/// <summary> /// Processes the client message which has multiple receivers (message by name or type) /// </summary> private async Task ProcessMultipleReceiverClientMessage(MqClient sender, List <MqClient> receivers, HorseMessage message) { if (receivers.Count < 1) { await sender.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } foreach (MqClient receiver in receivers) { //check sending message authority foreach (IClientAuthorization authorization in _server.Authorizations) { bool grant = await authorization.CanDirectMessage(sender, message, receiver); if (!grant) { await sender.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); return; } } //send the message await receiver.SendAsync(message); } }
/// <summary> /// Processes the client message which has single receiver (message by unique id) /// </summary> private async Task ProcessSingleReceiverClientMessage(MqClient client, HorseMessage message) { //find the receiver MqClient other = _server.FindClient(message.Target); if (other == null) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } //check sending message authority foreach (IClientAuthorization authorization in _server.Authorizations) { bool grant = await authorization.CanDirectMessage(client, message, other); if (!grant) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); return; } } //send the message await other.SendAsync(message); }
/// <summary> /// Creates new router /// </summary> private async Task CreateRouter(MqClient client, HorseMessage message) { IRouter found = _server.FindRouter(message.Target); if (found != null) { await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); return; } string methodHeader = message.FindHeader(HorseHeaders.ROUTE_METHOD); RouteMethod method = RouteMethod.Distribute; if (!string.IsNullOrEmpty(methodHeader)) { method = (RouteMethod)Convert.ToInt32(methodHeader); } //check create queue access foreach (IClientAuthorization authorization in _server.Authorizations) { bool grant = await authorization.CanCreateRouter(client, message.Target, method); if (!grant) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); return; } } _server.AddRouter(message.Target, method); await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); }
/// <summary> /// Removes a router with it's bindings /// </summary> private async Task RemoveRouter(MqClient client, HorseMessage message) { IRouter found = _server.FindRouter(message.Target); if (found == null) { await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); return; } //check create queue access foreach (IClientAuthorization authorization in _server.Authorizations) { bool grant = await authorization.CanRemoveRouter(client, found); if (!grant) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); return; } } _server.RemoveRouter(found); await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); }
/// <summary> /// Removes a channel with it's queues /// </summary> private async Task RemoveChannel(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } Channel channel = _server.FindChannel(message.Target); if (channel == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } bool grant = await _server.AdminAuthorization.CanRemoveChannel(client, _server, channel); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } await _server.RemoveChannel(channel); }
/// <summary> /// Handles pushing a message into a queue /// </summary> private async Task HandlePush(MqClient client, TmqMessage message, ChannelQueue queue) { //check authority if (_server.Authorization != null) { bool grant = await _server.Authorization.CanMessageToQueue(client, queue, message); if (!grant) { if (!string.IsNullOrEmpty(message.MessageId)) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } } //prepare the message QueueMessage queueMessage = new QueueMessage(message); queueMessage.Source = client; //push the message PushResult result = await queue.Push(queueMessage, client); if (result == PushResult.StatusNotSupported) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unacceptable)); } else if (result == PushResult.LimitExceeded) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.LimitExceeded)); } }
/// <summary> /// Removes a queue from a server /// </summary> private async Task RemoveQueue(MqClient client, HorseMessage message) { HorseQueue queue = _server.FindQueue(message.Target); if (queue == null) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); } return; } foreach (IAdminAuthorization authorization in _server.AdminAuthorizations) { bool grant = await authorization.CanRemoveQueue(client, queue); if (!grant) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); } return; } } await _server.RemoveQueue(queue); if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); } }
/// <summary> /// Processes the client message which has multiple receivers (message by name or type) /// </summary> private async Task ProcessMultipleReceiverClientMessage(MqClient sender, List <MqClient> receivers, TmqMessage message) { if (receivers.Count < 1) { await sender.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } foreach (MqClient receiver in receivers) { //check sending message authority if (_server.Authorization != null) { bool grant = await _server.Authorization.CanMessageToPeer(sender, message, receiver); if (!grant) { await sender.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); return; } } //send the message await receiver.SendAsync(message); } }
/// <summary> /// Processes the client message which has single receiver (message by unique id) /// </summary> private async Task ProcessSingleReceiverClientMessage(MqClient client, TmqMessage message) { //find the receiver MqClient other = _server.FindClient(message.Target); if (other == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } //check sending message authority if (_server.Authorization != null) { bool grant = await _server.Authorization.CanMessageToPeer(client, message, other); if (!grant) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); return; } } //send the message await other.SendAsync(message); }
/// <summary> /// Gets connected instance list /// </summary> private async Task GetInstanceList(MqClient client, HorseMessage message) { foreach (IAdminAuthorization authorization in _server.AdminAuthorizations) { bool grant = await authorization.CanManageInstances(client, message); if (!grant) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); } return; } } List <NodeInformation> list = new List <NodeInformation>(); //slave instances List <MqClient> slaves = _server.NodeManager.Clients.GetAsClone(); foreach (MqClient slave in slaves) { list.Add(new NodeInformation { IsSlave = true, Host = slave.RemoteHost, IsConnected = slave.IsConnected, Id = slave.UniqueId, Name = slave.Name, Lifetime = slave.ConnectedDate.LifetimeMilliseconds() }); } //master instances foreach (HmqStickyConnector connector in _server.NodeManager.Connectors) { NodeOptions options = connector.Tag as NodeOptions; HorseClient c = connector.GetClient(); list.Add(new NodeInformation { IsSlave = false, Host = options?.Host, IsConnected = connector.IsConnected, Id = c.ClientId, Name = options?.Name, Lifetime = Convert.ToInt64(connector.Lifetime.TotalMilliseconds) }); } HorseMessage response = message.CreateResponse(HorseResultCode.Ok); message.ContentType = KnownContentTypes.InstanceList; response.Serialize(list, _server.MessageContentSerializer); await client.SendAsync(response); }
/// <summary> /// Finds the channel and sends the information /// </summary> private async Task GetChannelInformation(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } Channel channel = _server.FindChannel(message.Target); if (channel == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } bool grant = await _server.AdminAuthorization.CanReceiveChannelInfo(client, channel); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } ChannelInformation information = new ChannelInformation { Name = channel.Name, Queues = channel.QueuesClone.Select(x => x.Id).ToArray(), AllowMultipleQueues = channel.Options.AllowMultipleQueues, AllowedQueues = channel.Options.AllowedQueues, OnlyFirstAcquirer = channel.Options.SendOnlyFirstAcquirer, RequestAcknowledge = channel.Options.RequestAcknowledge, AcknowledgeTimeout = Convert.ToInt32(channel.Options.AcknowledgeTimeout.TotalMilliseconds), MessageTimeout = Convert.ToInt32(channel.Options.MessageTimeout.TotalMilliseconds), WaitForAcknowledge = channel.Options.WaitForAcknowledge, HideClientNames = channel.Options.HideClientNames, QueueLimit = channel.Options.QueueLimit, ClientLimit = channel.Options.ClientLimit, DestroyWhenEmpty = channel.Options.DestroyWhenEmpty, ActiveClients = channel.ClientsCount() }; TmqMessage response = message.CreateResponse(); message.ContentType = KnownContentTypes.ChannelInformation; await response.SetJsonContent(information); await client.SendAsync(response); }
/// <summary> /// Finds and subscribes to the queue and sends response /// </summary> private async Task Subscribe(MqClient client, HorseMessage message) { HorseQueue queue = _server.FindQueue(message.Target); //if auto creation active, try to create queue if (queue == null && _server.Options.AutoQueueCreation) { QueueOptions options = QueueOptions.CloneFrom(_server.Options); queue = await _server.CreateQueue(message.Target, options, message, _server.DeliveryHandlerFactory, true, true); } if (queue == null) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); } return; } QueueClient found = queue.FindClient(client.UniqueId); if (found != null) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); } return; } QueueSubscriptionResult result = await queue.AddClient(client); if (message.WaitResponse) { switch (result) { case QueueSubscriptionResult.Success: await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); break; case QueueSubscriptionResult.Unauthorized: await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); break; case QueueSubscriptionResult.Full: await client.SendAsync(message.CreateResponse(HorseResultCode.LimitExceeded)); break; } } }
/// <summary> /// Finds and joins to channel and sends response /// </summary> private async Task JoinChannel(MqClient client, TmqMessage message) { Channel channel = _server.FindChannel(message.Target); //if auto creation active, try to create channel if (channel == null && _server.Options.AutoChannelCreation) { channel = _server.FindOrCreateChannel(message.Target); } if (channel == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } return; } ChannelClient found = channel.FindClient(client.UniqueId); if (found != null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Ok)); } return; } ClientJoinResult result = await channel.AddClient(client); if (message.ResponseRequired) { switch (result) { case ClientJoinResult.Success: await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Ok)); break; case ClientJoinResult.Unauthorized: await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); break; case ClientJoinResult.Full: await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.LimitExceeded)); break; } } }
/// <summary> /// Removes a queue from a channel /// </summary> private async Task RemoveQueue(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } Channel channel = _server.FindChannel(message.Target); if (channel == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } byte[] bytes = new byte[2]; await message.Content.ReadAsync(bytes); ushort contentType = BitConverter.ToUInt16(bytes); ChannelQueue queue = channel.FindQueue(contentType); if (queue == null) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); return; } bool grant = await _server.AdminAuthorization.CanRemoveQueue(client, queue); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } await channel.RemoveQueue(queue); if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Ok)); } }
/// <summary> /// Clears messages in a queue /// </summary> private async Task ClearMessages(MqClient client, HorseMessage message) { HorseQueue queue = _server.FindQueue(message.Target); if (queue == null) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); } return; } string prio = message.FindHeader(HorseHeaders.PRIORITY_MESSAGES); string msgs = message.FindHeader(HorseHeaders.MESSAGES); bool clearPrio = !string.IsNullOrEmpty(prio) && prio.Equals("yes", StringComparison.InvariantCultureIgnoreCase); bool clearMsgs = !string.IsNullOrEmpty(msgs) && msgs.Equals("yes", StringComparison.InvariantCultureIgnoreCase); foreach (IAdminAuthorization authorization in _server.AdminAuthorizations) { bool grant = await authorization.CanClearQueueMessages(client, queue, clearPrio, clearMsgs); if (!grant) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); } return; } } if (clearPrio && clearMsgs) { queue.ClearAllMessages(); } else if (clearPrio) { queue.ClearHighPriorityMessages(); } else if (clearMsgs) { queue.ClearRegularMessages(); } //if creation successful, sends response if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); } }
/// <summary> /// Gets all connected clients /// </summary> public async Task GetClients(MqClient client, HorseMessage message) { foreach (IAdminAuthorization authorization in _server.AdminAuthorizations) { bool grant = await authorization.CanReceiveClients(client); if (!grant) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); } return; } } List <ClientInformation> list = new List <ClientInformation>(); string filter = null; if (!string.IsNullOrEmpty(message.Target)) { filter = message.Target; } foreach (MqClient mc in _server.Clients) { if (!string.IsNullOrEmpty(filter)) { if (string.IsNullOrEmpty(mc.Type) || !Filter.CheckMatch(mc.Type, filter)) { continue; } } list.Add(new ClientInformation { Id = mc.UniqueId, Name = mc.Name, Type = mc.Type, IsAuthenticated = mc.IsAuthenticated, Online = mc.ConnectedDate.LifetimeMilliseconds(), }); } HorseMessage response = message.CreateResponse(HorseResultCode.Ok); message.ContentType = KnownContentTypes.ClientList; response.Serialize(list, _server.MessageContentSerializer); await client.SendAsync(response); }
/// <summary> /// Sends all bindings of a router /// </summary> private async Task ListRouterBindings(MqClient client, HorseMessage message) { IRouter router = _server.FindRouter(message.Target); if (router == null) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } List <BindingInformation> items = new List <BindingInformation>(); foreach (Binding binding in router.GetBindings()) { BindingInformation info = new BindingInformation { Name = binding.Name, Target = binding.Target, Priority = binding.Priority, ContentType = binding.ContentType, Interaction = binding.Interaction }; if (binding is QueueBinding) { info.BindingType = BindingType.Queue; } else if (binding is DirectBinding directBinding) { info.Method = directBinding.RouteMethod; info.BindingType = BindingType.Direct; } else if (binding is TopicBinding topicBinding) { info.Method = topicBinding.RouteMethod; info.BindingType = BindingType.Topic; } else if (binding is HttpBinding) { info.BindingType = BindingType.Http; } items.Add(info); } HorseMessage response = message.CreateResponse(HorseResultCode.Ok); response.Serialize(items, new NewtonsoftContentSerializer()); await client.SendAsync(response); }
public async Task Handle(MqClient client, TmqMessage message) { if (string.IsNullOrEmpty(message.Target)) { return; } if (message.Target.StartsWith("@name:")) { List <MqClient> receivers = _server.FindClientByName(message.Target.Substring(6)); if (receivers.Count > 0) { if (message.FirstAcquirer) { MqClient first = receivers.FirstOrDefault(); receivers.Clear(); receivers.Add(first); } await ProcessMultipleReceiverClientMessage(client, receivers, message); } else if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } } else if (message.Target.StartsWith("@type:")) { List <MqClient> receivers = _server.FindClientByType(message.Target.Substring(6)); if (receivers.Count > 0) { if (message.FirstAcquirer) { MqClient first = receivers.FirstOrDefault(); receivers.Clear(); receivers.Add(first); } await ProcessMultipleReceiverClientMessage(client, receivers, message); } else if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } } else { await ProcessSingleReceiverClientMessage(client, message); } }
public async Task Handle(MqClient client, TmqMessage message) { //find channel and queue Channel channel = _server.FindChannel(message.Target); //if auto creation active, try to create channel if (channel == null && _server.Options.AutoChannelCreation) { channel = _server.FindOrCreateChannel(message.Target); } if (channel == null) { if (!string.IsNullOrEmpty(message.MessageId)) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } return; } ChannelQueue queue = channel.FindQueue(message.ContentType); //if auto creation active, try to create queue if (queue == null && _server.Options.AutoQueueCreation) { queue = await channel.FindOrCreateQueue(message.ContentType); } if (queue == null) { if (!string.IsNullOrEmpty(message.MessageId)) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.NotFound)); } return; } //consumer is trying to pull from the queue //in false cases, we won't send any response, cuz client is pending only queue messages, not response messages if (message.Length == 0 && message.ResponseRequired) { await HandlePullRequest(client, message, channel, queue); } //message have a content, this is the real message from producer to the queue else { await HandlePush(client, message, queue); } }
public async Task Handle(MqClient client, HorseMessage message, bool fromNode) { if (string.IsNullOrEmpty(message.Target)) { return; } if (message.Target.StartsWith("@name:")) { List <MqClient> receivers = _server.FindClientByName(message.Target.Substring(6)); if (receivers.Count > 0) { if (message.HighPriority && receivers.Count > 1) { MqClient first = receivers.FirstOrDefault(); receivers.Clear(); receivers.Add(first); } await ProcessMultipleReceiverClientMessage(client, receivers, message); } else if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); } } else if (message.Target.StartsWith("@type:")) { List <MqClient> receivers = _server.FindClientByType(message.Target.Substring(6)); if (receivers.Count > 0) { if (message.HighPriority) { MqClient first = receivers.FirstOrDefault(); receivers.Clear(); receivers.Add(first); } await ProcessMultipleReceiverClientMessage(client, receivers, message); } else if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); } } else { await ProcessSingleReceiverClientMessage(client, message); } }
public Task Handle(MqClient client, HorseMessage message, bool fromNode) { try { return(HandleUnsafe(client, message)); } catch (OperationCanceledException) { return(client.SendAsync(message.CreateResponse(HorseResultCode.LimitExceeded))); } catch (DuplicateNameException) { return(client.SendAsync(message.CreateResponse(HorseResultCode.Duplicate))); } }
public async Task Handle(MqClient client, TmqMessage message) { try { await HandleUnsafe(client, message); } catch (OperationCanceledException) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.LimitExceeded)); } catch (DuplicateNameException) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Duplicate)); } }
/// <summary> /// Routes message to it's type handler /// </summary> private async Task RouteToHandler(MqClient mc, TmqMessage message, IConnectionInfo info) { switch (message.Type) { //client sends a queue message in a channel case MessageType.Channel: await _instanceHandler.Handle(mc, message); await _channelHandler.Handle(mc, message); break; //clients sends a message to another client case MessageType.Client: await _instanceHandler.Handle(mc, message); await _clientHandler.Handle(mc, message); break; //client sends an acknowledge message of a message case MessageType.Acknowledge: await _instanceHandler.Handle(mc, message); await _acknowledgeHandler.Handle(mc, message); break; //client sends a response message for a message case MessageType.Response: await _instanceHandler.Handle(mc, message); await _responseHandler.Handle(mc, message); break; //client sends a message to the server //this message may be join, header, info, some another server message case MessageType.Server: await _serverHandler.Handle(mc, message); break; //if client sends a ping message, response with pong case MessageType.Ping: await mc.SendAsync(PredefinedMessages.PONG); break; //client sends PONG message case MessageType.Pong: mc.KeepAlive(); break; //close the client's connection case MessageType.Terminate: mc.Disconnect(); break; } }
public async Task Handle(MqClient client, HorseMessage message, bool fromNode) { try { HorseQueue queue = _server.FindQueue(message.Target); //if auto creation active, try to create queue if (queue == null && _server.Options.AutoQueueCreation) { QueueOptions options = QueueOptions.CloneFrom(_server.Options); queue = await _server.CreateQueue(message.Target, options, message, _server.DeliveryHandlerFactory, true, true); } if (queue == null) { if (!string.IsNullOrEmpty(message.MessageId)) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); } return; } await HandlePullRequest(client, message, queue); } catch (Exception e) { _server.SendError("PULL_REQUEST", e, $"QueueName:{message.Target}"); } }
/// <summary> /// Sends all routers /// </summary> private async Task ListRouters(MqClient client, HorseMessage message) { List <RouterInformation> items = new List <RouterInformation>(); foreach (IRouter router in _server.Routers) { RouterInformation info = new RouterInformation { Name = router.Name, IsEnabled = router.IsEnabled }; if (router is Router r) { info.Method = r.Method; } items.Add(info); } HorseMessage response = message.CreateResponse(HorseResultCode.Ok); response.Serialize(items, new NewtonsoftContentSerializer()); await client.SendAsync(response); }
/// <summary> /// Creates new binding for a router /// </summary> private async Task CreateRouterBinding(MqClient client, HorseMessage message) { IRouter router = _server.FindRouter(message.Target); if (router == null) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } BindingInformation info = message.Deserialize <BindingInformation>(new NewtonsoftContentSerializer()); //check create queue access foreach (IClientAuthorization authorization in _server.Authorizations) { bool grant = await authorization.CanCreateBinding(client, router, info); if (!grant) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); return; } } switch (info.BindingType) { case BindingType.Direct: router.AddBinding(new DirectBinding(info.Name, info.Target, info.ContentType, info.Priority, info.Interaction, info.Method)); break; case BindingType.Queue: router.AddBinding(new QueueBinding(info.Name, info.Target, info.Priority, info.Interaction)); break; case BindingType.Http: router.AddBinding(new HttpBinding(info.Name, info.Target, (HttpBindingMethod)(info.ContentType ?? 0), info.Priority, info.Interaction)); break; case BindingType.Topic: router.AddBinding(new TopicBinding(info.Name, info.Target, info.ContentType ?? 0, info.Priority, info.Interaction, info.Method)); break; } await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); }
private static async Task SendResponse(MqClient client, HorseMessage message, bool successful) { ushort contentType = successful ? (ushort)HorseResultCode.Ok : (ushort)HorseResultCode.Failed; HorseMessage response = new HorseMessage(MessageType.Response, client.UniqueId, contentType); response.SetMessageId(message.MessageId); await client.SendAsync(response); }
/// <summary> /// Gets active consumers of the queue /// </summary> public async Task GetQueueConsumers(MqClient client, HorseMessage message) { HorseQueue queue = _server.FindQueue(message.Target); if (queue == null) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } foreach (IAdminAuthorization authorization in _server.AdminAuthorizations) { bool grant = await authorization.CanReceiveQueueConsumers(client, queue); if (!grant) { if (message.WaitResponse) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); } return; } } List <ClientInformation> list = new List <ClientInformation>(); foreach (QueueClient cc in queue.ClientsClone) { list.Add(new ClientInformation { Id = cc.Client.UniqueId, Name = cc.Client.Name, Type = cc.Client.Type, IsAuthenticated = cc.Client.IsAuthenticated, Online = cc.JoinDate.LifetimeMilliseconds(), }); } HorseMessage response = message.CreateResponse(HorseResultCode.Ok); message.ContentType = KnownContentTypes.QueueConsumers; response.Serialize(list, _server.MessageContentSerializer); await client.SendAsync(response); }
/// <summary> /// Removes a router with it's bindings /// </summary> private async Task RemoveRouterBinding(MqClient client, HorseMessage message) { IRouter router = _server.FindRouter(message.Target); if (router == null) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } string name = message.FindHeader(HorseHeaders.BINDING_NAME); if (string.IsNullOrEmpty(name)) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } Binding[] bindings = router.GetBindings(); Binding binding = bindings.FirstOrDefault(x => x.Name == name); if (binding == null) { await client.SendAsync(message.CreateResponse(HorseResultCode.NotFound)); return; } //check create queue access foreach (IClientAuthorization authorization in _server.Authorizations) { bool grant = await authorization.CanRemoveBinding(client, binding); if (!grant) { await client.SendAsync(message.CreateResponse(HorseResultCode.Unauthorized)); return; } } router.RemoveBinding(binding); await client.SendAsync(message.CreateResponse(HorseResultCode.Ok)); }
/// <summary> /// Gets all connected clients /// </summary> public async Task GetClients(MqClient client, TmqMessage message) { if (_server.AdminAuthorization == null) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } bool grant = await _server.AdminAuthorization.CanReceiveClients(client); if (!grant) { if (message.ResponseRequired) { await client.SendAsync(MessageBuilder.ResponseStatus(message, KnownContentTypes.Unauthorized)); } return; } List <ClientInformation> list = new List <ClientInformation>(); foreach (MqClient mc in _server.Clients) { list.Add(new ClientInformation { Id = mc.UniqueId, Name = mc.Name, Type = mc.Type, IsAuthenticated = mc.IsAuthenticated, Online = mc.ConnectedDate.LifetimeMilliseconds(), }); } TmqMessage response = message.CreateResponse(); message.ContentType = KnownContentTypes.ClientList; await response.SetJsonContent(list); await client.SendAsync(response); }