public async Task ProcessAsync(IMessageProtocol messageProtocol)
{
if (Equals(messageProtocol.Header, MessageType.Message))
{
var message = messageProtocol.GetDataAs <Message>();
try
{
var meseClient = _clientsPool.FindClient(message.To.Id);
if (meseClient != null)
{
await MessageCommunicator.WriteAsync(meseClient.TcpClient, messageProtocol);
}
else
{
Logger.Error($"Client {message.To.Name} not found. ");
}
}
catch (Exception ex)
{
Logger.Error($"Exception: {ex}.");
}
return;
}
await _innerProcessor.ProcessAsync(messageProtocol);
}
public static ConnectionContext CreateConnectionContext(IMessageProtocol protocol, params KeyValuePair <string, object>[] items)
{
var context = new ConnectionContext();
context.Features.Set(protocol);
items.ForEach(x => context.Items.Add(x.Key, x.Value));
return(context);
}
/// <summary>
/// Initializes a new instance of the <see cref="MqConsumer{TRequest, TResponse}" /> class.
/// </summary>
/// <param name="publisher">message publisher</param>
/// <param name="acknowledger">message acknowledger</param>
/// <param name="protocol">protocol to decode the messages</param>
/// <param name="consumerImpl">injected consumer implementation</param>
/// <param name="logger">injected logger</param>
protected MqConsumer(IMessagePublisher <TResponse> publisher, IAmqpAcknowledger acknowledger, IMessageProtocol <TRequest> protocol, IBasicConsumer consumerImpl, ILogger logger)
: base(acknowledger, consumerImpl, logger)
{
this.publisher = Arguments.EnsureNotNull(publisher, nameof(publisher));
this.AcknowledgementManager = Arguments.EnsureNotNull(acknowledger, nameof(acknowledger));
this.protocol = Arguments.EnsureNotNull(protocol, nameof(protocol));
Arguments.NotNull(consumerImpl, nameof(protocol));
}
public TcpConnection(Socket clientSocket, IMessageProtocol protocol)
{
observers = new ConcurrentList <IObserver <BasicMessage> >();
this.clientSocket = clientSocket;
this.protocol = protocol;
closed = false;
buffer = new byte[maxBufferSize];
clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, BytesRecieved, this);
}
public TcpConnection(Socket clientSocket, IMessageProtocol protocol)
{
observers = new ConcurrentList<IObserver<BasicMessage>>();
this.clientSocket = clientSocket;
this.protocol = protocol;
closed = false;
buffer = new byte[maxBufferSize];
clientSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, BytesRecieved, this);
}
public static async Task BroadcastAsync(TcpClient[] clients, IMessageProtocol messageProtocol)
{
var bytes = MessageCoder.Encode(messageProtocol);
foreach (var client in clients)
{
await WriteAsync(client, bytes);
}
}
public SimpleConsole()
{
var options = new PipeOptions(useSynchronizationContext: false);
var pipe = new Pipe(options);
_lengthProtocol = new LengthProtocol();
_pipeWriter = pipe.Writer;
_pipeReader = pipe.Reader;
}
/// <summary>
/// Initializes a new instance of the <see cref="MqConsumer{TMessage}" /> class.
/// </summary>
/// <param name="acknowledger">message acknowledger</param>
/// <param name="protocol">protocol to decode the messages</param>
/// <param name="consumer">injected consumer implementation</param>
/// <param name="logger">injected logger</param>
protected MqConsumer(IBasicAcknowledger acknowledger, IMessageProtocol <TMessage> protocol, IBasicConsumer consumer, ILogger logger)
: base(acknowledger, consumer, logger)
{
Arguments.NotNull(acknowledger, nameof(acknowledger));
Arguments.NotNull(protocol, nameof(protocol));
Arguments.NotNull(consumer, nameof(consumer));
Arguments.NotNull(logger, nameof(logger));
this.protocol = protocol;
}
/// <summary>
/// Initializes a new instance of the <see cref="Retriever{TMessage}"/> class.
/// </summary>
/// <param name="source">name of the queue to retrieve from</param>
/// <param name="channel">handle to the connection with retreival features</param>
/// <param name="protocol">protocol to encode message with</param>
/// <param name="logger">injected logger</param>
public Retriever(string source, IBasicRetriever channel, IMessageProtocol <TMessage> protocol, ILogger logger)
: base(logger)
{
Arguments.NotNull(source, nameof(source));
Arguments.NotNull(channel, nameof(channel));
Arguments.NotNull(protocol, nameof(protocol));
Arguments.NotNull(logger, nameof(logger));
this.Source = source;
this.Channel = channel;
this.protocol = protocol;
}
public ConsoleChatClient(ILogger <ConsoleChatClient> logger,
IOptions <ClientConfig> clientConfig,
IChatClientFactory clientFactory,
IMessageProtocol messageProtocol,
IConsoleClient consoleClient)
{
this.logger = logger;
this.clientFactory = clientFactory;
this.messageProtocol = messageProtocol;
this.consoleClient = consoleClient;
this.remoteUrl = clientConfig.Value.Server.Url;
}
/// <summary>
/// Initializes a new instance of the <see cref="Publisher{TMessage}" /> class.
/// </summary>
/// <param name="destination">Name of publishing destination</param>
/// <param name="channel">handle to the connection with publishing features</param>
/// <param name="protocol">protocol to encode message with</param>
/// <param name="logger">injected logger</param>
public Publisher(string destination, IBasicPublisher channel, IMessageProtocol <TMessage> protocol, ILogger logger)
: base(logger)
{
Arguments.NotNull(destination, nameof(destination));
Arguments.NotNull(channel, nameof(channel));
Arguments.NotNull(protocol, nameof(protocol));
Arguments.NotNull(logger, nameof(logger));
this.protocol = protocol;
this.Destination = destination;
this.Channel = channel;
}
public static byte[] Encode(IMessageProtocol messageProtocol)
{
var bytes = new List <byte>();
var header = BitConverter.GetBytes(messageProtocol.Header.Type);
var payload = ObjectToByteArray(messageProtocol.Data);
bytes.AddRange(header);
bytes.AddRange(payload);
return(bytes.ToArray());
}
public ChatServer(ILogger <ChatServer> logger,
IChatUserIdentityProvider identityProvider,
IMessageProtocol messageProtocol,
IChatServer chatServer,
IRoomRegistry roomRegistry)
{
this.logger = logger;
this.messageProtocol = messageProtocol;
this.chatServer = chatServer;
this.roomRegistry = roomRegistry;
this.identityProvider = identityProvider;
}
public override async Task ProcessAsync(IMessageProtocol messageProtocol)
{
if (messageProtocol.Header.Equals(MessageType.ClientDisconnected))
{
var user = messageProtocol.GetDataAs <User>();
Notifier.OnUserDisconnected(this, new NotifierEventArgs <User>(user));
return;
}
await _innerProcessor.ProcessAsync(messageProtocol);
}
public override async Task ProcessAsync(IMessageProtocol messageProtocol)
{
if (messageProtocol != null && Equals(messageProtocol.Header, MessageType.ClientConnectedSelf))
{
var connectionEstablished = messageProtocol.GetDataAs <ConnectionEstablished>();
Notifier.OnConnectedToServer(this, new NotifierEventArgs <ConnectionEstablished>(connectionEstablished));
return;
}
await _innerProcessor.ProcessAsync(messageProtocol);
}
public override async Task ProcessAsync(IMessageProtocol messageProtocol)
{
if (messageProtocol != null && Equals(messageProtocol.Header, MessageType.Message))
{
var message = messageProtocol.GetDataAs <Message>();
Notifier.OnMessageReceived(this, new NotifierEventArgs <Message>(message));
return;
}
await _innerProcessor.ProcessAsync(messageProtocol);
}
public async Task ProcessAsync(IMessageProtocol messageProtocol)
{
if (messageProtocol != null && Equals(messageProtocol.Header, MessageType.ClientDisconnected))
{
var user = messageProtocol.GetDataAs <User>();
Logger.Info($"Client disconnected. {user}");
await BroadcastClientDisconnectedAsync(user);
return;
}
await _innerProcessor.ProcessAsync(messageProtocol);
}
public ConsoleChatClient(ILogger <ConsoleChatClient> logger,
IOptions <ClientConfig> clientConfig,
IChatClientFactory clientFactory,
IMessageProtocol messageProtocol,
IConsoleClient consoleClient)
{
this.logger = logger;
this.clientFactory = clientFactory;
this.messageProtocol = messageProtocol;
this.consoleClient = consoleClient;
this.client = new TcpClient();
var serverConfig = clientConfig.Value.Server;
this.serverAddress = IPAddress.Parse(serverConfig.Host);
this.serverPort = serverConfig.Port;
}
public TraceDataCollector(IMessageProtocol messageProtocol,
BufferService bufferService,
ClassIdentifier classIdentifier,
MethodIdentifier methodIdentifier,
IErrorHandler errorHandler,
ILog logger)
{
_messageProtocol = messageProtocol ?? throw new ArgumentNullException(nameof(messageProtocol));
_bufferService = bufferService ?? throw new ArgumentNullException(nameof(bufferService));
_classIdentifier = classIdentifier ?? throw new ArgumentNullException(nameof(classIdentifier));
_methodIdentifier = methodIdentifier ?? throw new ArgumentNullException(nameof(methodIdentifier));
_errorHandler = errorHandler ?? throw new ArgumentNullException(nameof(errorHandler));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
_methodIdAdapter = new MethodIdAdapter(this);
_task = Task.Run(() => ReadTraceMessages());
}
public ChatServer(ILogger <ChatServer> logger,
IOptions <ServerConfig> serverConfig,
IChatUserIdentityProvider identityProvider,
IMessageProtocol messageProtocol,
IChatServer chatServer,
IRoomRegistry roomRegistry)
{
this.logger = logger;
this.messageProtocol = messageProtocol;
this.chatServer = chatServer;
this.roomRegistry = roomRegistry;
this.identityProvider = identityProvider;
var listeningConfig = serverConfig.Value.Listening;
var listeningHost = IPAddress.Parse(listeningConfig.Host);
var listeningPort = listeningConfig.Port;
this.listener = new TcpListener(listeningHost, listeningPort);
this.tracker = new TaskTracker();
}
public static async Task <int> WriteAsync(TcpClient client, IMessageProtocol messageProtocol)
{
if (client.Connected)
{
var ns = client.GetStream();
if (ns.CanWrite)
{
var bytes = MessageCoder.Encode(messageProtocol);
await ns.WriteAsync(bytes, 0, bytes.Length);
await ns.FlushAsync();
return(bytes.Length);
}
}
return(0);
}
public WebSocketChatTransport(WebSocket webSocket, IMessageProtocol protocol)
{
this.webSocket = webSocket;
this.protocol = protocol;
this.arrayPool = ArrayPool <byte> .Shared;
}
public ControlConnectionHandshake(IMessageProtocol messageProtocol, IConfigurationReader configurationReader)
{
_messageProtocol = messageProtocol ?? throw new ArgumentNullException(nameof(messageProtocol));
_configurationReader = configurationReader ?? throw new ArgumentNullException(nameof(configurationReader));
}
public DoSomethingWithEachClient(IMessageProtocol messageProtocol)
{
_messageProtocol = messageProtocol;
}
public TcpChatTransport(TcpClient client, IMessageProtocol protocol)
{
this.client = client;
this.protocol = protocol;
}
public SimpleConsole(Pipe pipe, IMessageProtocol messageProtocol)
{
_pipeReader = pipe.Reader;
_pipeWriter = pipe.Writer;
_lengthProtocol = messageProtocol;
}
public abstract Task ProcessAsync(IMessageProtocol messageProtocol);
public StreamMessage(IMessageProtocol MessageProtocol)
{
this.MessageProtocol = MessageProtocol ?? throw new ArgumentNullException(nameof(MessageProtocol));
}
public MessageProtocolReceivedEventArgs(IMessageProtocol messageProtocol)
{
MessageProtocol = messageProtocol;
}
public Task ProcessAsync(IMessageProtocol messageProtocol)
{
return(Task.CompletedTask);
}
public Application(PipeWriter writer, PipeReader reader, IMessageProtocol messageProtocol)
{
_messageProtocol = messageProtocol;
_pipeWriter = writer;
_pipeReader = reader;
}