file
function     FStormSyncTransportClientSocket::FStormSyncTransportClientSocket

{
	Settings = GetDefault<UStormSyncTransportSettings>();
	ConnectionRetryDelay = Settings->GetConnectionRetryDelay();
}

FStormSyncTransportClientSocket::~FStormSyncTransportClientSocket()
{
	UE_LOG(LogStormSyncClient, Display, TEXT("FStormSyncTransportClientSocket::~FStormSyncTransportClientSocket Destructor Closing socket and runnable to '%s'"), *RemoteEndpoint.ToString());
	

file
function     uint32 FStormSyncTransportClientSocket::Run

		);

		if (!bListenerIsRunning && GetConnectionState() == State_Closed && ConnectionRetryDelay > 0)
		{
			bListenerIsRunning = TryReconnect();
		}

		if (!bListenerIsRunning)
		{

file
function     bool FStormSyncTransportClientSocket::TryReconnect

		}
    
		FPlatformProcess::Sleep(ConnectionRetryDelay);

		bReconnectPending = Connect();
		if (bReconnectPending)
		{
			ConnectionState = State_DisconnectReconnectPending;
		}

file
class        class FStormSyncTransportClientSocket : public FRunnable, public TSharedFromThis<FStormSyncTransportClientSocket>

	/** Delay before re-establishing connection if it drops, 0 disables */
	uint32 ConnectionRetryDelay;

	/** Delegate trigger when underlying socket is closed */
	FStormSyncOnConnectionClosed ConnectionClosedDelegate;
	
	/** Connection state changed delegate */
	FStormSyncOnConnectionStateChanged ConnectionStateChangedDelegate;

file
function     uint32 UStormSyncTransportSettings::GetConnectionRetryDelay

uint32 UStormSyncTransportSettings::GetConnectionRetryDelay() const
{
	return ConnectionRetryDelay;
}

bool UStormSyncTransportSettings::HasConnectionRetryDelay() const
{
	return ConnectionRetryDelay > 0;
}

FString UStormSyncTransportSettings::GetServerName() const
{
	return ServerName;
}

file
class        class UStormSyncTransportSettings : public UDeveloperSettings

	 */
	UPROPERTY(config, EditAnywhere, Category = "Client")
	uint32 ConnectionRetryDelay = 0;

	/** The refresh frequency of the heartbeat event */
	UPROPERTY(config, EditAnywhere, AdvancedDisplay, Category = "Service Discovery", meta=(ClampMin = "0.1", ConfigRestartRequired=true, ForceUnits=s))
	float MessageBusHeartbeatPeriod = 1.f;

	/** How long we should wait before checking for message bus sources activity */

file
class        class UTcpMessagingSettings : public UObject

	 */
	UPROPERTY(config, EditAnywhere, Category = Transport)
	int32 ConnectionRetryDelay;

	/**
	 * Period time during which attempts to re-establish outgoing connections that become disconnected or fail to connect
	 * 0 means it will be retried only once
	 */
	UPROPERTY(config, EditAnywhere, Category = Transport)

file
function     int32 UTcpMessagingSettings::GetConnectionRetryDelay

int32 UTcpMessagingSettings::GetConnectionRetryDelay() const
{
	return ConnectionRetryDelay;
}

int32 UTcpMessagingSettings::GetConnectionRetryPeriod() const
{
	return ConnectionRetryPeriod;
}

file
function     FTcpMessageTransport::FTcpMessageTransport

	: ListenEndpoint(InListenEndpoint)
	, ConnectToEndpoints(InConnectToEndpoints)
	, ConnectionRetryDelay(InConnectionRetryDelay)
	, ConnectionRetryPeriod(InConnectionRetryPeriod)
	, bStopping(false)
	, SocketSubsystem(ISocketSubsystem::Get(PLATFORM_SOCKETSUBSYSTEM))
	, Listener(nullptr)
	, TransportHandler(nullptr)
{

file
function     void FTcpMessageTransport::AddOutgoingConnection

	else
	{
		PendingConnections.Enqueue(MakeShareable(new FTcpMessageTransportConnection(Socket, Endpoint, ConnectionRetryDelay, ConnectionRetryPeriod)));
	}
}

void FTcpMessageTransport::RemoveOutgoingConnection(const FIPv4Endpoint& Endpoint)
{
	ConnectionEndpointsToRemove.Enqueue(Endpoint);

file
class        class FTcpMessageTransport : FRunnable , public IMessageTransport

	FIPv4Endpoint ListenEndpoint;
	TArray<FIPv4Endpoint> ConnectToEndpoints;
	int32 ConnectionRetryDelay;
	int32 ConnectionRetryPeriod;

	/** For the thread */
	bool bStopping;
	
	/** Holds a pointer to the socket sub-system. */

file
function     FTcpMessageTransportConnection::FTcpMessageTransportConnection

	, TotalBytesSent(0)
	, bRun(false)
	, ConnectionRetryDelay(InConnectionRetryDelay)
	, ConnectionRetryPeriod(InConnectionRetryPeriod)
	, RecvMessageDataRemaining(0)
{
	int32 NewSize = 0;
	Socket->SetReceiveBufferSize(TCP_MESSAGING_RECEIVE_BUFFER_SIZE, NewSize);
	Socket->SetSendBufferSize(TCP_MESSAGING_SEND_BUFFER_SIZE, NewSize);

file
function     uint32 FTcpMessageTransportConnection::Run

		{
			// Disconnected. Reconnect if requested.
			const float Delay = ConnectionRetryDelay;
			if (Delay > 0)
			{
				bool bReconnectPending = false;
				{
				    // Wait for any sending before we close the socket
				    FScopeLock SendLock(&SendCriticalSection);

file
function     uint32 FTcpMessageTransportConnection::Run

					{
						UE_LOG(LogTcpMessaging, Verbose, TEXT("Connection to '%s' failed, retrying..."), *RemoteEndpoint.ToString());
						FPlatformProcess::Sleep(ConnectionRetryDelay);

						Socket = FTcpSocketBuilder(TEXT("FTcpMessageTransport.RemoteConnection"))
							.WithSendBufferSize(TCP_MESSAGING_SEND_BUFFER_SIZE)
							.WithReceiveBufferSize(TCP_MESSAGING_RECEIVE_BUFFER_SIZE);

						if (Socket && Socket->Connect(RemoteEndpoint.ToInternetAddr().Get()))

file
class        class FTcpMessageTransportConnection : public FRunnable , public TSharedFromThis<FTcpMessageTransportConnection>

	/** Delay before re-establishing connection if it drops, 0 disables */
	int32 ConnectionRetryDelay;

	/** Period during which re-establishing connection if it drops, 0 means it will retry only once */
	int32 ConnectionRetryPeriod;

	/** Message data we're currently in the process of receiving, if any */
	TSharedPtr<FArrayReader, ESPMode::ThreadSafe> RecvMessageData;