/// <summary> /// Creates a new relay connection from a caller to a callee using a specific application service. /// </summary> /// <param name="Caller">Network client of the caller.</param> /// <param name="Callee">Network client of the callee.</param> /// <param name="ServiceName">Name of the application service of the callee that is being used for the call.</param> /// <param name="RequestMessage">CallIdentityApplicationServiceRequest message that the caller send in order to initiate the call.</param> public RelayConnection(Client Caller, Client Callee, string ServiceName, Message RequestMessage) { lockObject = new SemaphoreSlim(1); id = Guid.NewGuid(); string logPrefix = string.Format("[{0}:{1}] ", id, ServiceName); string logName = "HomeNet.Network.ClientList"; log = new PrefixLogger(logName, logPrefix); log.Trace("(Caller.Id:0x{0:X16},Callee.Id:0x{1:X16},ServiceName:'{2}')", Caller.Id, Callee.Id, ServiceName); serviceName = ServiceName; caller = Caller; callee = Callee; pendingMessage = RequestMessage; callerToken = Guid.NewGuid(); calleeToken = Guid.NewGuid(); log.Trace("Caller token is '{0}'.", callerToken); log.Trace("Callee token is '{0}'.", calleeToken); status = RelayConnectionStatus.WaitingForCalleeResponse; // Relay is created by caller's request, it will expire if the callee does not reply within reasonable time. timeoutTimer = new Timer(TimeoutCallback, status, CalleeResponseCallNotificationDelayMaxSeconds * 1000, Timeout.Infinite); log.Trace("(-)"); }
/// <summary>Initializes the class logger.</summary> public ApplicationServices(string LogPrefix) { string logName = "ProfileServer.Network.ApplicationServices"; log = new PrefixLogger(logName, LogPrefix); log.Trace("()"); log.Trace("(-)"); }
/// <summary> /// Creates the instance for a new outgoing TCP client. /// </summary> /// <param name="RemoteEndPoint">Target IP address and port this client will be connected to.</param> /// <param name="UseTls">true if TLS should be used for this TCP client, false otherwise.</param> /// <param name="ShutdownCancellationToken">Cancellation token of the parent component.</param> public OutgoingClient(IPEndPoint RemoteEndPoint, bool UseTls, CancellationToken ShutdownCancellationToken) : base(RemoteEndPoint, UseTls) { string logPrefix = string.Format("[=>{0}] ", RemoteEndPoint); log = new PrefixLogger("ProfileServer.Network.OutgoingClient", logPrefix); log.Trace("()"); shutdownCancellationToken = ShutdownCancellationToken; log.Trace("(-)"); }
public SocketConnection(Uri uri, ConnectionSettings connectionSettings, BufferSettings bufferSettings, ILogger logger = null) { _idPrefix = $"conn-{uri.Host}:{uri.Port}-"; _id = $"{_idPrefix}{UniqueIdGenerator.GetId()}"; _logger = new PrefixLogger(logger, FormatPrefix(_id)); _client = new SocketClient(uri, connectionSettings.SocketSettings, bufferSettings, _logger); _authToken = connectionSettings.AuthToken; _userAgent = connectionSettings.UserAgent; Server = new ServerInfo(uri); _responsePipeline = new ResponsePipeline(_logger); }
public SocketConnection(Uri uri, ConnectionSettings connectionSettings, BufferSettings bufferSettings, IConnectionListener metricsListener = null, IDriverLogger logger = null) { _id = $"conn-{UniqueIdGenerator.GetId()}"; _logger = new PrefixLogger(logger, FormatPrefix(_id)); _client = new SocketClient(uri, connectionSettings.SocketSettings, bufferSettings, metricsListener, _logger); _authToken = connectionSettings.AuthToken; _userAgent = connectionSettings.UserAgent; Server = new ServerInfo(uri); _responseHandler = new MessageResponseHandler(_logger); }
// for test only internal SocketConnection(ISocketClient socketClient, IAuthToken authToken, string userAgent, ILogger logger, IServerInfo server, IResponsePipeline responsePipeline = null) { Throw.ArgumentNullException.IfNull(socketClient, nameof(socketClient)); Throw.ArgumentNullException.IfNull(authToken, nameof(authToken)); Throw.ArgumentNullException.IfNull(userAgent, nameof(userAgent)); Throw.ArgumentNullException.IfNull(server, nameof(server)); _client = socketClient; _authToken = authToken; _userAgent = userAgent; Server = server; _id = $"{_idPrefix}{UniqueIdGenerator.GetId()}"; _logger = new PrefixLogger(logger, FormatPrefix(_id)); _responsePipeline = responsePipeline ?? new ResponsePipeline(logger); }
// for test only internal SocketConnection(ISocketClient socketClient, IAuthToken authToken, string userAgent, IDriverLogger logger, IServerInfo server, IMessageResponseHandler messageResponseHandler = null) { Throw.ArgumentNullException.IfNull(socketClient, nameof(socketClient)); Throw.ArgumentNullException.IfNull(authToken, nameof(authToken)); Throw.ArgumentNullException.IfNull(userAgent, nameof(userAgent)); Throw.ArgumentNullException.IfNull(server, nameof(server)); _client = socketClient; _authToken = authToken; _userAgent = userAgent; Server = server; _id = $"conn-{UniqueIdGenerator.GetId()}"; _logger = new PrefixLogger(logger, FormatPrefix(_id)); _responseHandler = messageResponseHandler ?? new MessageResponseHandler(logger); }
// const int DataSize = 4096; static void Main([NotNull][ItemNotNull] string[] args) { if (args.Length != 2) { PrintUsage(); return; } string source = args[0]; string destination = args[1]; if (!File.Exists(source)) { Console.WriteLine("Source file does not exist"); return; } var initialLogger = new PrefixLogger("[Initial] "); var infoLogger = new PrefixLogger("[Sorter] "); IDataManager manager = new FileDataManager(source, destination); string[] environmentArgs = new string[0]; using (new Environment(ref environmentArgs)) { var world = Communicator.world; initialLogger.Assert(world != null, "Could not retrieve world"); int processors = world.Size; initialLogger.Assert(processors.IsPowerOfTwo(), "Number of processors should be power of two"); int[] batch = GetDataBatch(world, initialLogger, manager, processors); var sorter = new Sorter(batch, world, infoLogger); int numberOfSteps = world.Size.IntegralBinaryLogarithm(); for (int step = numberOfSteps - 1; step >= 0; step -= 1) { sorter.Exchange(step); } var gathered = world.Gather(sorter.Sort(), 0); if (gathered != null) { manager.SinkResult(gathered); } } }
/// <summary> /// Asynchronous read and processing function for each client that connects to the TCP server. /// </summary> /// <param name="Client">Client that is connected to TCP server.</param> /// <remarks>The client is being handled in the processing loop until the connection to it /// is terminated by either side. This function implements reading the message from the network stream, /// which includes reading the message length prefix followed by the entire message.</remarks> private async void ClientHandlerAsync(Client Client) { this.log.Info("(Client.RemoteEndPoint:{0})", Client.RemoteEndPoint); string prefix = string.Format("{0}[{1}] ", this.logPrefix, Client.RemoteEndPoint); PrefixLogger log = new PrefixLogger(this.logName, prefix); clientList.AddNetworkPeer(Client); log.Debug("Client ID set to 0x{0:X16}.", Client.Id); await Client.ReceiveMessageLoop(); // Free resources used by the client. clientList.RemoveNetworkPeer(Client); await Client.HandleDisconnect(); Client.Dispose(); log.Info("(-)"); }
/// <summary> /// Creates the encapsulation for a new TCP server client. /// </summary> /// <param name="Server">Role server that the client connected to.</param> /// <param name="TcpClient">TCP client class that holds the connection and allows communication with the client.</param> /// <param name="Id">Unique identifier of the client's connection.</param> /// <param name="UseTls">true if the client is connected to the TLS port, false otherwise.</param> /// <param name="KeepAliveIntervalSeconds">Number of seconds for the connection to this client to be without any message until the node can close it for inactivity.</param> public Client(TcpRoleServer Server, TcpClient TcpClient, ulong Id, bool UseTls, int KeepAliveIntervalSeconds) { this.TcpClient = TcpClient; this.Id = Id; RemoteEndPoint = this.TcpClient.Client.RemoteEndPoint; server = Server; string logPrefix = string.Format("[{0}<=>{1}|0x{2:X16}] ", server.EndPoint, RemoteEndPoint, Id); string logName = "HomeNet.Network.Client"; this.log = new PrefixLogger(logName, logPrefix); log.Trace("(UseTls:{0},KeepAliveIntervalSeconds:{1})", UseTls, KeepAliveIntervalSeconds); messageProcessor = new MessageProcessor(server, logPrefix); this.KeepAliveIntervalSeconds = KeepAliveIntervalSeconds; NextKeepAliveTime = DateTime.UtcNow.AddSeconds(this.KeepAliveIntervalSeconds); this.TcpClient.LingerState = new LingerOption(true, 0); this.TcpClient.NoDelay = true; this.UseTls = UseTls; Stream = this.TcpClient.GetStream(); if (this.UseTls) { Stream = new SslStream(Stream, false, PeerCertificateValidationCallback); } MessageBuilder = new MessageBuilder(server.IdBase, new List <byte[]>() { new byte[] { 1, 0, 0 } }, Base.Configuration.Keys); ConversationStatus = ClientConversationStatus.NoConversation; IsOurCheckedInClient = false; ApplicationServices = new ApplicationServices(logPrefix); log.Trace("(-)"); }
/// <summary> /// Creates a new TCP server to listen on specific IP endpoint. /// </summary> /// <param name="EndPoint">Specification of the interface and TCP port on which the TCP server should listen. IPAddress.Any is a valid value for the interface.</param> /// <param name="UseTls">Indication of whether to use TLS for this TCP server.</param> /// <param name="Roles">One or more roles of this server.</param> public TcpRoleServer(IPEndPoint EndPoint, bool UseTls, ServerRole Roles) { logPrefix = string.Format("[{0}/tcp{1}] ", EndPoint.Port, UseTls ? "_tls" : ""); logName = "HomeNet.Network.RoleServer"; log = new PrefixLogger(logName, logPrefix); this.UseTls = UseTls; this.Roles = Roles; this.EndPoint = EndPoint; ShutdownSignaling = new ComponentShutdown(Base.Components.GlobalShutdown); serverComponent = (Server)Base.ComponentDictionary["Network.Server"]; clientList = serverComponent.GetClientList(); IsRunning = false; Listener = new TcpListener(this.EndPoint); Listener.Server.LingerState = new LingerOption(true, 0); Listener.Server.NoDelay = true; // We want to determine what types of clients do connect to this server. // This information is stored in ServerRoleForNodes dictionary. // If ServerRoleForNodes[R] is true for a role R, it means that that role is intended for nodes. // Thus if this server roles only consist of roles, for which ServerRoleForNodes[x] is false, // it means that the server is intended for clients use. IsServingClientsOnly = true; foreach (ServerRole role in Enum.GetValues(typeof(ServerRole))) { if (this.Roles.HasFlag(role) && ServerRoleForNodes[role]) { this.IsServingClientsOnly = false; break; } } IdBase = ((uint)Roles << 24); }
/// <summary> /// Creates the instance for a new TCP server client. /// </summary> /// <param name="Server">Role server that the client connected to.</param> /// <param name="TcpClient">TCP client class that holds the connection and allows communication with the client.</param> /// <param name="Id">Unique identifier of the client's connection.</param> /// <param name="UseTls">true if the client is connected to the TLS port, false otherwise.</param> /// <param name="KeepAliveIntervalSeconds">Number of seconds for the connection to this client to be without any message until the profile server can close it for inactivity.</param> public IncomingClient(TcpRoleServer Server, TcpClient TcpClient, ulong Id, bool UseTls, int KeepAliveIntervalSeconds) : base(TcpClient, UseTls, Server.IdBase) { this.Id = Id; server = Server; string logPrefix = string.Format("[{0}<=>{1}|{2}] ", server.EndPoint, RemoteEndPoint, Id.ToHex()); string logName = "ProfileServer.Network.IncomingClient"; log = new PrefixLogger(logName, logPrefix); log.Trace("(UseTls:{0},KeepAliveIntervalSeconds:{1})", UseTls, KeepAliveIntervalSeconds); messageProcessor = new MessageProcessor(server, logPrefix); this.KeepAliveIntervalSeconds = KeepAliveIntervalSeconds; NextKeepAliveTime = DateTime.UtcNow.AddSeconds(this.KeepAliveIntervalSeconds); ConversationStatus = ClientConversationStatus.NoConversation; IsOurCheckedInClient = false; ApplicationServices = new ApplicationServices(logPrefix); log.Trace("(-)"); }
public PrefixLoggerTest() { innerLogger = Substitute.For <IBasicLogger>(); logger = new PrefixLogger("MyMod", innerLogger); }
public PrefixLoggerTest() { logger = new PrefixLogger("MyMod", innerLogger); }