/// <summary> /// Initializes a new instance of the <see cref="WSNetworkConnector"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="tcpClient">The tcp client.</param> /// <param name="protocol">The protocol. e.g: /{protocol} websocket endpoint.</param> public WSNetworkConnector(IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, TcpClient tcpClient, string protocol) : base(messageTypeCache, messageSerializer, messageProcessor) { _protocol = protocol; _tcpClient = tcpClient; _tcpClient.Client.NoDelay = true; _networkStream = _tcpClient.GetStream(); }
public void CreateProtobufConnection_ShouldCreateWithProperDependencies( [Frozen] IProtobufFieldNumberCache cache, [Frozen] IProtobufStreamSerializer protobuf, [Frozen] IMessageSerializer serializer, [Frozen] IMessageTypeCache messageTypeCache, [Frozen] IMessageMetadataFactory metadataFactory, Stream stream, ProtobufConnectionFactory sut) { var connection = sut.CreateProtobufConnection(stream); Assert.IsType <MessageSerializerConnection>(connection); Assert.Equal(serializer, GetPrivateField(connection, "_serializer")); Assert.Equal(messageTypeCache, GetPrivateField(connection, "_messageTypeCache")); Assert.Equal(metadataFactory, GetPrivateField(connection, "_metadataFactory")); var rawConnection = GetPrivateField(connection, "_connection") !; Assert.NotNull(rawConnection); Assert.IsType <ProtobufConnection>(rawConnection); Assert.Equal(cache, GetPrivateField(rawConnection, "_fieldNumberCache")); Assert.Equal(stream, GetPrivateField(rawConnection, "_stream")); Assert.Equal(protobuf, GetPrivateField(rawConnection, "_protobuf")); }
/// <summary> /// Initializes a new instance of the <see cref="RegistryService"/> class. /// </summary> /// <param name="registryConfigurationOptions">The registry configuration options.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="serviceMessageProcessor">The service message processor.</param> /// <param name="messageToServiceMapper">The message to service mapper.</param> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="accessTokenService">The access token service.</param> /// <param name="registryServiceLogger">The registry service logger.</param> /// <param name="tcpNetworkConnectorLogger">The tcp network connector logger.</param> /// <param name="registryServiceMessageProcessorLogger">The registry service message processor logger.</param> /// <param name="httpNetworkConnectorLogger">The http network connector logger.</param> public RegistryService( IOptions <RegistryConfiguration> registryConfigurationOptions, IMessageSerializer messageSerializer, IServiceMessageProcessor serviceMessageProcessor, IMessageToServiceMapper messageToServiceMapper, IRegistryServiceMessageTypeCache messageTypeCache, IAccessTokenService accessTokenService, ILogger <RegistryService> registryServiceLogger, ILogger <TcpNetworkConnector> tcpNetworkConnectorLogger, ILogger <RegistryServiceMessageProcessor> registryServiceMessageProcessorLogger, ILogger <HttpNetworkConnector> httpNetworkConnectorLogger) { _messageSerializer = messageSerializer; _serviceMessageProcessor = serviceMessageProcessor; _registryServiceMessageProcessor = new RegistryServiceMessageProcessor(this, registryServiceMessageProcessorLogger); _messageToServiceMapper = messageToServiceMapper; RegistryConfiguration registryConfiguration = registryConfigurationOptions.Value; _tcpListener = new TcpListener(IPAddress.Any, registryConfiguration.Port); _messageTypeCache = messageTypeCache; _accessTokenService = accessTokenService; _registryServiceLogger = registryServiceLogger; _tcpNetworkConnectorLogger = tcpNetworkConnectorLogger; _httpNetworkConnectorLogger = httpNetworkConnectorLogger; }
/// <summary> /// Initializes an instance of the <see cref="TcpNetworkConnector"/> class as client. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="host">The host string.</param> /// <param name="port">The port.</param> public TcpNetworkConnector(IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, string host, int port) : base(messageTypeCache, messageSerializer, messageProcessor) { _host = host; _port = port; _tcpClient = new TcpClient { Client = { NoDelay = true } }; }
/// <summary> /// Initializes an instance of the <see cref="SslTcpNetworkConnector"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="logger">The logger.</param> /// <param name="host">The host string.</param> /// <param name="port">The port.</param> public SslTcpNetworkConnector( IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, ILogger <SslTcpNetworkConnector> logger, string host, int port) : base(messageTypeCache, messageSerializer, messageProcessor, logger, host, port) { }
/// <summary> /// Initializes an instance of the <see cref="SslTcpNetworkConnector"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="logger">The logger.</param> /// <param name="tcpClient">The tcp client.</param> public SslTcpNetworkConnector( IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, ILogger <SslTcpNetworkConnector> logger, TcpClient tcpClient) : base(messageTypeCache, messageSerializer, messageProcessor, logger, tcpClient) { Stream = new SslStream(tcpClient.GetStream(), false); }
public SignalRConnectionFactory( IMessageSerializer messageSerializer, IMessageTypeCache messageTypeCache, IMessageMetadataFactory clientToServerMessageMetadataFactory) { _messageSerializer = messageSerializer; _messageTypeCache = messageTypeCache; _messageMetadataFactory = clientToServerMessageMetadataFactory; }
public void ShouldSetMessageTypeCache( [Frozen] IMessageTypeCache cache, IConnection connection, JsonConnectionFactory sut) { var result = sut.CreateJsonConnection(connection); Assert.Equal(cache, GetPrivateField(result, "_messageTypes")); }
/// <summary> /// Initializes a new instance of the <see cref="WSNetworkConnector"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="logger">The logger.</param> /// <param name="wsHandshakeHandler">The websocket handshake handler.</param> /// <param name="tcpClient">The tcp client.</param> public WSNetworkConnector( IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, ILogger <WSNetworkConnector> logger, IWSHandshakeHandler wsHandshakeHandler, TcpClient tcpClient) : base(messageTypeCache, messageSerializer, messageProcessor, logger, tcpClient) { _wsHandshakeHandler = wsHandshakeHandler; }
/// <summary> /// Initializes a new instance of the <see cref="WSNetworkConnector"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="logger">The logger.</param> /// <param name="wsHandshakeHandler">The websocket handshake handler.</param> /// <param name="host">The host string.</param> /// <param name="port">The port.</param> public WSNetworkConnector( IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, ILogger <WSNetworkConnector> logger, IWSHandshakeHandler wsHandshakeHandler, string host, int port) : base(messageTypeCache, messageSerializer, messageProcessor, logger, host, port) { _wsHandshakeHandler = wsHandshakeHandler; }
/// <summary> /// Initializes an instance of the <see cref="TcpNetworkConnector"/> class as server. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="logger">The logger.</param> /// <param name="tcpClient">The tcp client.</param> public TcpNetworkConnector( IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, ILogger <TcpNetworkConnector> logger, TcpClient tcpClient) : base(messageTypeCache, messageSerializer, messageProcessor, logger) { TcpClient = tcpClient; TcpClient.Client.NoDelay = true; Stream = TcpClient.GetStream(); }
/// <summary> /// Initializes a new instance of <see cref="BaseNetworkConnector"/> class. /// </summary> /// <remarks> /// Also loads the <see cref="MessageTypeCache"/> on the first <see cref="BaseNetworkConnector"/> instance creation. /// </remarks> /// <exception cref="ArgumentNullException">If the messageProcessor is null; an argument exception is thrown.</exception> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="logger">The logger.</param> protected BaseNetworkConnector( IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, ILogger <BaseNetworkConnector> logger) { _messageConstructor = new MessageConstructor(messageSerializer); _messageProcessor = messageProcessor ?? throw new ArgumentNullException(nameof(messageProcessor)); _messageTypeCache = messageTypeCache ?? throw new ArgumentNullException(nameof(messageTypeCache)); Logger = logger; }
public MessageSerializerConnection( IConnection connection, IMessageSerializer serializer, IMessageTypeCache messageTypeCache, IMessageMetadataFactory metadataFactory) { _connection = connection; _serializer = serializer; _messageTypeCache = messageTypeCache; _metadataFactory = metadataFactory; }
public ProtobufFieldNumberCache(IMessageTypeCache messageTypes) { _fieldNumberToType = messageTypes.GetAllTypes() .Select((type, index) => new { FieldNumber = index + 1, Type = type.Value }) .ToDictionary(x => x.FieldNumber, x => x.Type); _typeToFieldNumber = _fieldNumberToType.ToDictionary(x => x.Value, x => x.Key); }
public JsonConnection( IConnection connection, IMessageTypeCache messageTypes) { _connection = connection; _messageTypes = messageTypes; _options = new JsonSerializerOptions { PropertyNamingPolicy = JsonNamingPolicy.CamelCase }; _options.Converters.Add(new JsonStringEnumConverter()); }
/// <summary> /// Converts received <see cref="MessageData"/> objects to the actual messages, /// and converts actual messages to <see cref="MessageData"/> before sending. /// Attaches required metadata to objects before sending. /// </summary> public static IConnection AddCoreMessageSerialization( this IConnection connection, IMessageSerializer messageSerializer, IMessageTypeCache messageTypeCache, IMessageMetadataFactory messageMetadataFactory) { return(new MessageSerializerConnection( connection, messageSerializer, messageTypeCache, messageMetadataFactory)); }
/// <summary> /// Initializes a new instance of the <see cref="RegistryService"/> class. /// </summary> /// <param name="serviceRepository">The service repository.</param> /// <param name="mapper">The mapper.</param> /// <param name="neuralmConfigurationOptions">The neuralm configuration options.</param> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="tcpNetworkConnectorLogger">The tcp network connector logger.</param> public RegistryService( IRepository <Service> serviceRepository, IMapper mapper, IOptions <NeuralmConfiguration> neuralmConfigurationOptions, IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, ILogger <TcpNetworkConnector> tcpNetworkConnectorLogger) : base(serviceRepository, mapper) { _serviceRepository = serviceRepository; NeuralmConfiguration neuralmConfiguration = neuralmConfigurationOptions.Value; _networkConnector = new TcpNetworkConnector(messageTypeCache, messageSerializer, messageProcessor, tcpNetworkConnectorLogger, neuralmConfiguration.Host, neuralmConfiguration.Port); }
public ProtobufConnectionFactory( IProtobufFieldNumberCache fieldNumberCache, IProtobufStreamSerializer protobuf, IMessageSerializer messageSerializer, IMessageTypeCache messageTypeCache, IMessageMetadataFactory messageMetadataFactory) { _fieldNumberCache = fieldNumberCache; _protobuf = protobuf; _messageSerializer = messageSerializer; _messageTypeCache = messageTypeCache; _messageMetadataFactory = messageMetadataFactory; }
public void ShouldWrapConnectionInMessageSerializerConnection( IConnection connection, IMessageSerializer messageSerializer, IMessageTypeCache messageTypeCache, IMessageMetadataFactory messageMetadataFactory) { var sut = connection.AddCoreMessageSerialization( messageSerializer, messageTypeCache, messageMetadataFactory); Assert.IsType <MessageSerializerConnection>(sut); Assert.Equal(connection, GetPrivateField(sut, "_connection")); Assert.Equal(messageSerializer, GetPrivateField(sut, "_serializer")); Assert.Equal(messageTypeCache, GetPrivateField(sut, "_messageTypeCache")); Assert.Equal(messageMetadataFactory, GetPrivateField(sut, "_metadataFactory")); }
public MessageProcessor( ILogger <MessageProcessor> logger, IClientConnectionFactory connectionFactory, IMessageDispatcher dispatcher, IProfileTokenProvider profileTokenProvider, IMessageMetadataFactory metadataFactory, IMessageTypeCache messageTypeCache, IAuthenticationService authenticationService) { _logger = logger; _connectionFactory = connectionFactory; _dispatcher = dispatcher; _profileTokenProvider = profileTokenProvider; _metadataFactory = metadataFactory; _messageTypeCache = messageTypeCache; _authenticationService = authenticationService; }
public ConnectionHandler( ILogger <ConnectionHandler> logger, IConnectionInitializer connectionInitializer, IConnectedClientStore connectedClients, IMessageDispatcher messageDispatcher, IQueryDispatcher queryDispatcher, IUpdateDetector updateDetector, IMessageTypeCache messageTypeCache, IEnumerable <IConnectedClientInitializer> connectedClientInitializers, IUpdater updater) { _logger = logger; _connectionInitializer = connectionInitializer; _connectedClients = connectedClients; _messageDispatcher = messageDispatcher; _queryDispatcher = queryDispatcher; _updateDetector = updateDetector; _messageTypeCache = messageTypeCache; _connectedClientInitializers = connectedClientInitializers; _updater = updater; }
/// <summary> /// Adds services from the <see cref="Application"/> assembly into the <see cref="serviceCollection"/>. /// </summary> /// <param name="serviceCollection">The service collection.</param> /// <returns>Returns the service collection to chain further upon.</returns> public static IServiceCollection AddApplicationServices(this IServiceCollection serviceCollection) { serviceCollection.AddAutoMapper(Assembly.GetAssembly(typeof(MessageQueueStartupExtensions))); serviceCollection.AddLogging(p => p.AddConsole()); serviceCollection.AddSingleton <IFactory <IMessageTypeCache, IEnumerable <Type> >, MessageTypeCacheFactory>(); serviceCollection.AddSingleton <IClientMessageTypeCache, ClientMessageTypeCache>(serviceCollection => { List <Type> types = new List <Type> { typeof(RegisterRequest), typeof(CreateTrainingRoomRequest), typeof(ServiceHealthCheckRequest) }; IMessageTypeCache messageTypeCache = serviceCollection.GetService <IFactory <IMessageTypeCache, IEnumerable <Type> > >().Create(types); return(new ClientMessageTypeCache(messageTypeCache)); }); serviceCollection.AddSingleton <IRegistryServiceMessageTypeCache, RegistryServiceMessageTypeCache>(serviceCollection => { List <Type> types = new List <Type> { typeof(AddServiceCommand) }; IMessageTypeCache messageTypeCache = serviceCollection.GetService <IFactory <IMessageTypeCache, IEnumerable <Type> > >().Create(types); return(new RegistryServiceMessageTypeCache(messageTypeCache)); }); serviceCollection.AddSingleton <IMessageSerializer, JsonMessageSerializer>(); serviceCollection.AddSingleton <IAccessTokenService, JwtAccessTokenService>(); serviceCollection.AddSingleton <IMessageToServiceMapper, MessageToServiceMapper>(); serviceCollection.AddSingleton <IServiceMessageProcessor, ServiceMessageProcessor>(); serviceCollection.AddSingleton <IClientMessageProcessor, ClientMessageProcessor>(); #region Services serviceCollection.AddSingleton <Application.Interfaces.IRegistryService, Infrastructure.Services.RegistryService>(); #endregion Services return(serviceCollection); }
/// <summary> /// Initializes an instance of the <see cref="SslTcpNetworkConnector"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="tcpClient">The tcp client.</param> public SslTcpNetworkConnector(IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, TcpClient tcpClient) : base(messageTypeCache, messageSerializer, messageProcessor) { _tcpClient = tcpClient; _sslStream = new SslStream(_tcpClient.GetStream(), false); }
/// <summary> /// Initializes an instance of the <see cref="SslTcpNetworkConnector"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="host">The host string.</param> /// <param name="port">The port.</param> public SslTcpNetworkConnector(IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, string host, int port) : base(messageTypeCache, messageSerializer, messageProcessor) { _tcpClient = new TcpClient(); _host = host; _port = port; }
/// <summary> /// Initializes an instance of the <see cref="TcpNetworkConnector"/> class as server. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> /// <param name="messageSerializer">The message serializer.</param> /// <param name="messageProcessor">The message processor.</param> /// <param name="tcpClient">The tcp client.</param> public TcpNetworkConnector(IMessageTypeCache messageTypeCache, IMessageSerializer messageSerializer, IMessageProcessor messageProcessor, TcpClient tcpClient) : base(messageTypeCache, messageSerializer, messageProcessor) { _tcpClient = tcpClient; _tcpClient.Client.NoDelay = true; _networkStream = _tcpClient.GetStream(); }
public JsonConnectionFactory(IMessageTypeCache messageTypes) { _messageTypes = messageTypes; }
/// <summary> /// Initializes a new instance of the <see cref="RegistryServiceMessageTypeCache"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> public RegistryServiceMessageTypeCache(IMessageTypeCache messageTypeCache) { _messageTypeCache = messageTypeCache; }
/// <summary> /// Initializes a new instance of the <see cref="ClientMessageTypeCache"/> class. /// </summary> /// <param name="messageTypeCache">The message type cache.</param> public ClientMessageTypeCache(IMessageTypeCache messageTypeCache) { _messageTypeCache = messageTypeCache; }