/// <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;
}
