/// <summary> /// Poll an message from a queue. /// </summary> /// <param name="queueName">Queue name (e.g. "/queue/foo").</param> /// <param name="timeout">Time, in miliseconds, before the agent stops waiting for a message, if the timeout is bigger than 0. If timeout is reached a TimeoutException is thrown. If the value is zero, than the agent will wait forever. A negative value means that the client doesn't want to wait if there are no messages is local agent's queue.</param> /// <param name="reserveTime">Message reserve time, in milliseconds. Polled messages are reserved, by default, for 15 minutes. If clients prefer a different reserve time, bigger or small, they can specify it.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> /// <returns>A NetNotification instance. In case of connection fail or if there are no messages in local agent's queue when timeout is negative null is returned.</returns> public NetNotification Poll(String queueName, long timeout, long reserveTime, AcceptRequest acceptRequest) { if (IsClosed()) { return(null); } NetPoll poll = new NetPoll(queueName, timeout); NetAction action = new NetAction(NetAction.ActionType.POLL); action.PollMessage = poll; NetMessage netMessage = new NetMessage(action); if (reserveTime != -1) { netMessage.Headers.Add("RESERVE_TIME", reserveTime.ToString()); } protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); NetNotification notification = protocolHandler.GetSyncMessage(queueName, netMessage); if (notification == BrokerProtocolHandler.UnblockNotification) { throw new TimeoutException(); } if (notification == BrokerProtocolHandler.NoMessageNotification) { return(null); } return(notification); }
private static NetAction getAction(Atom atom) { NetAction.ActionType actionType = translate(atom.Action.Action_type); NetAction action = new NetAction(actionType); switch (actionType) { case NetAction.ActionType.ACCEPTED: action.AcceptedMessage = getAcceptedMessage(atom); break; case NetAction.ActionType.NOTIFICATION: action.NotificationMessage = getNotificationMessage(atom); break; case NetAction.ActionType.FAULT: action.FaultMessage = getFaultMessage(atom); break; case NetAction.ActionType.PONG: action.PongMessage = getPongMessage(atom); break; default: throw new Exception("Unexpected ActionType while unmarshalling message " + actionType.ToString()); } return(action); }
private static NetAction getAction(Atom atom) { NetAction.ActionType actionType = translate(atom.Action.Action_type); NetAction action = new NetAction( actionType ); switch(actionType) { case NetAction.ActionType.ACCEPTED: action.AcceptedMessage =getAcceptedMessage(atom) ; break; case NetAction.ActionType.NOTIFICATION: action.NotificationMessage = getNotificationMessage(atom) ; break; case NetAction.ActionType.FAULT: action.FaultMessage = getFaultMessage(atom) ; break; case NetAction.ActionType.PONG: action.PongMessage = getPongMessage(atom); break; default: throw new Exception("Unexpected ActionType while unmarshalling message " + actionType.ToString() ); } return action; }
public NotificationHandler(BrokerClient client, NetAction.DestinationType actionType, int expectedMessages) { this.client = client; this.actionType = actionType; this.expectedMessages = expectedMessages; this.Notifications = new List<NetNotification>(); this.ManualResetEvent = new ManualResetEvent(false); }
public static NetMessage translate(Atom message) { NetAction action = getAction(message); IDictionary <string, string> headers = getHeaders(message); NetMessage netMessage = new NetMessage(action, headers); return(netMessage); }
public static NetMessage buildNetFaultMessage(string code, string message) { NetFault fault = new NetFault(code, message); NetAction action = new NetAction(NetAction.ActionType.FAULT); action.FaultMessage = fault; NetMessage msg = new NetMessage(action); return(msg); }
/// <summary> /// Get a NetMessage containing a NetSubscribe object that represents this subscription request. This is meant to be used by the messaging framework. /// </summary> /// <returns>A NetMessage instance.</returns> public NetMessage ToNetMessage() { NetSubscribe netSubscribe = new NetSubscribe(this.destinationPattern, this.destinationType); NetAction netAction = new NetAction(NetAction.ActionType.SUBSCRIBE); netAction.SubscribeMessage = netSubscribe; NetMessage netMessage = new NetMessage(netAction, this.Headers); return(netMessage); }
/// <summary> /// Enqueue a message over UDP. /// </summary> /// <param name="message">Message content.</param> /// <param name="destination">Message destination.</param> /// <param name="hostInfo">Agent information.</param> /// <param name="messageSerializer">Serialization type.</param> public static void EnqueueMessageOverUdp(NetBrokerMessage message, string destination, HostInfo hostInfo, IMessageSerializer messageSerializer) { NetPublish publish = new NetPublish(destination, NetAction.DestinationType.QUEUE, message); NetAction action = new NetAction(NetAction.ActionType.PUBLISH); action.PublishMessage = publish; NetMessage netMessage = new NetMessage(action, message.Headers); BrokerProtocolHandler.SendMessageOverUdp(netMessage, hostInfo, messageSerializer); }
public NetMessage(NetAction action, IDictionary <string, string> headers) { this.action = action; if (headers != null) { this.headers = headers; } else { this.headers = new Dictionary <string, string>(); } }
/// <summary> /// Acknowledge a queue message. /// </summary> /// <param name="quequeName">Queue name (e.g. "/queue/foo" or "myQueue@/topic/foo").</param> /// <param name="messageId">The received message identifier.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Acknowledge(string quequeName, string messageId, AcceptRequest acceptRequest) { if (IsClosed()) { return; } NetAcknowledge netAck = new NetAcknowledge(quequeName, messageId); NetAction action = new NetAction(NetAction.ActionType.ACKNOWLEDGE); action.AcknowledgeMessage = netAck; NetMessage netMessage = new NetMessage(action); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); }
public static NetMessage getMessageFaultWithDetail(NetMessage message, string detail) { NetFault fault = message.Action.FaultMessage; NetFault newFault = new NetFault(fault.Code, fault.Message); newFault.ActionId = fault.ActionId; newFault.Detail = detail; NetAction action = new NetAction(NetAction.ActionType.FAULT); action.FaultMessage = newFault; return(new NetMessage(action, message.Headers)); }
/// <summary> /// Cancel a previous subscription. /// </summary> /// <param name="subscription">A Subscription instance.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Unsubscribe(Subscription subscription, AcceptRequest acceptRequest) { if (IsClosed()) { return; } NetUnsubscribe netUnsubscribe = new NetUnsubscribe(subscription.DestinationPattern, subscription.DestinationType); NetAction action = new NetAction(NetAction.ActionType.UNSUBSCRIBE); action.UnsbuscribeMessage = netUnsubscribe; NetMessage netMessage = new NetMessage(action, subscription.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); protocolHandler.RemoveSubscription(subscription); }
/// <summary> /// Publish a message (to a topic). /// </summary> /// <param name="message">A broker message</param> /// <param name="destination">A destination (e.g. "/topic/foo")</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Publish(NetBrokerMessage message, string destination, AcceptRequest acceptRequest) { if (IsClosed()) { return; } NetPublish publish = new NetPublish(destination, NetAction.DestinationType.TOPIC, message); NetAction action = new NetAction(NetAction.ActionType.PUBLISH); action.PublishMessage = publish; NetMessage netMessage = new NetMessage(action, message.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); }
private static void PublishMessages(BrokerClient brokerClient, string destination, int numberOfMessages, NetAction.DestinationType destinationType) { //string message = "Hello, how are you?"; int i = 0; while ((numberOfMessages--) != 0) { System.Console.WriteLine("Publishing message"); NetBrokerMessage brokerMessage = new NetBrokerMessage(System.Text.Encoding.UTF8.GetBytes((i++).ToString())); if (destinationType == NetAction.DestinationType.TOPIC) { brokerClient.Publish(brokerMessage, destination); } else { brokerClient.Enqueue(brokerMessage, destination); } System.Threading.Thread.Sleep(50); } }
/// <summary> /// Subscribe to a destination. /// </summary> /// <param name="subscription">A Subscription instance.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Subscribe(Subscription subscription, AcceptRequest acceptRequest) { if (IsClosed()) { return; } subscription.BrokerClient = this; NetSubscribe netSubscribe = new NetSubscribe(subscription.DestinationPattern, subscription.DestinationType); NetAction action = new NetAction(NetAction.ActionType.SUBSCRIBE); action.SubscribeMessage = netSubscribe; NetMessage netMessage = new NetMessage(action, subscription.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); protocolHandler.AddSubscription(subscription); }
/// <summary> /// Send a Ping message to determine agent liveness. /// </summary> /// <returns>A Pong message or null if conection failed.</returns> public NetPong Ping() { if (IsClosed()) { return(null); } NetPong localNetPong = null; string actionId = Guid.NewGuid().ToString(); NetPing ping = new NetPing(actionId); NetAction action = new NetAction(NetAction.ActionType.PING); action.PingMessage = ping; NetMessage netMessage = new NetMessage(action); ManualResetEvent mrEvent = new ManualResetEvent(false); PongHandler handler = delegate(NetPong pong) { if (pong.ActionId.Equals(actionId)) { localNetPong = pong; mrEvent.Set(); } }; protocolHandler.OnPong += handler; protocolHandler.HandleOutgoingMessage(netMessage, null); mrEvent.WaitOne(2 * 1000, false); protocolHandler.OnPong -= handler; return(localNetPong); }
/// <summary> /// Publish a message (to a topic). /// </summary> /// <param name="message">A broker message</param> /// <param name="destination">A destination (e.g. "/topic/foo")</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Publish(NetBrokerMessage message, string destination, AcceptRequest acceptRequest) { if (IsClosed()) return; NetPublish publish = new NetPublish(destination, NetAction.DestinationType.TOPIC, message); NetAction action = new NetAction(NetAction.ActionType.PUBLISH); action.PublishMessage = publish; NetMessage netMessage = new NetMessage(action, message.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); }
/// <summary> /// Poll an message from a queue. /// </summary> /// <param name="queueName">Queue name (e.g. "/queue/foo").</param> /// <param name="timeout">Time, in miliseconds, before the agent stops waiting for a message, if the timeout is bigger than 0. If timeout is reached a TimeoutException is thrown. If the value is zero, than the agent will wait forever. A negative value means that the client doesn't want to wait if there are no messages is local agent's queue.</param> /// <param name="reserveTime">Message reserve time, in milliseconds. Polled messages are reserved, by default, for 15 minutes. If clients prefer a different reserve time, bigger or small, they can specify it.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> /// <returns>A NetNotification instance. In case of connection fail or if there are no messages in local agent's queue when timeout is negative null is returned.</returns> public NetNotification Poll(String queueName, long timeout, long reserveTime,AcceptRequest acceptRequest) { if (IsClosed()) return null; NetPoll poll = new NetPoll(queueName, timeout); NetAction action = new NetAction(NetAction.ActionType.POLL); action.PollMessage = poll; NetMessage netMessage = new NetMessage(action); if (reserveTime != -1) { netMessage.Headers.Add("RESERVE_TIME", reserveTime.ToString()); } protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); NetNotification notification = protocolHandler.GetSyncMessage(queueName, netMessage); if (notification == BrokerProtocolHandler.UnblockNotification) throw new TimeoutException(); if (notification == BrokerProtocolHandler.NoMessageNotification) return null; return notification; }
/// <summary> /// Send a Ping message to determine agent liveness. /// </summary> /// <returns>A Pong message or null if conection failed.</returns> public NetPong Ping() { if (IsClosed()) return null; NetPong localNetPong = null; string actionId = Guid.NewGuid().ToString(); NetPing ping = new NetPing(actionId); NetAction action = new NetAction(NetAction.ActionType.PING); action.PingMessage = ping; NetMessage netMessage = new NetMessage(action); ManualResetEvent mrEvent = new ManualResetEvent(false); PongHandler handler = delegate(NetPong pong) { if (pong.ActionId.Equals(actionId)) { localNetPong = pong; mrEvent.Set(); } }; protocolHandler.OnPong += handler; protocolHandler.HandleOutgoingMessage(netMessage, null); mrEvent.WaitOne(2 * 1000, false); protocolHandler.OnPong -= handler; return localNetPong; }
/// <summary> /// Acknowledge a queue message. /// </summary> /// <param name="quequeName">Queue name (e.g. "/queue/foo" or "myQueue@/topic/foo").</param> /// <param name="messageId">The received message identifier.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Acknowledge(string quequeName, string messageId, AcceptRequest acceptRequest) { if (IsClosed()) return; NetAcknowledge netAck = new NetAcknowledge(quequeName, messageId); NetAction action = new NetAction(NetAction.ActionType.ACKNOWLEDGE); action.AcknowledgeMessage = netAck; NetMessage netMessage = new NetMessage(action); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); }
/// <summary> /// Publish a message over UDP. /// </summary> /// <param name="message">Message content.</param> /// <param name="destination">Message destination.</param> /// <param name="hostInfo">Agent information.</param> /// <param name="messageSerializer">Serialization type.</param> public static void PublishMessageOverUdp(NetBrokerMessage message, string destination, HostInfo hostInfo, IMessageSerializer messageSerializer) { NetPublish publish = new NetPublish(destination, NetAction.DestinationType.TOPIC, message); NetAction action = new NetAction(NetAction.ActionType.PUBLISH); action.PublishMessage = publish; NetMessage netMessage = new NetMessage(action, message.Headers); BrokerProtocolHandler.SendMessageOverUdp(netMessage, hostInfo, messageSerializer); }
private static DestinationType translate(NetAction.DestinationType destination) { switch(destination) { case NetAction.DestinationType.QUEUE: return DestinationType.QUEUE; case NetAction.DestinationType.TOPIC: return DestinationType.TOPIC; case NetAction.DestinationType.VIRTUAL_QUEUE: return DestinationType.VIRTUAL_QUEUE; } throw new Exception("Unexpected DestinationType while marshalling message " + destination.ToString() ); }
public Subscription(string destinationPattern, NetAction.DestinationType destinationType) { this.destinationPattern = destinationPattern; this.destinationType = destinationType; }
public bool Authenticate(ICredentialsProvider provider) { log.Info("Authenticating"); if (provider == null) { throw new ArgumentNullException("AuthenticationInfo can not be null in order to authenticate."); } AuthenticationInfo authInfoToUse = null; try { authInfoToUse = provider.GetCredentials(); if (authInfoToUse == null) throw new InvalidCredentialsException("Credential provider returned null"); } catch (InvalidCredentialsException ice) { log.Error("Failed to obtain credentials.", ice); return false; } // save important information lock (this) { this.provider = provider; this.clientAuthInfo = authInfoToUse; this.usingAuth = true; } // build NetMessage string actionId = System.Guid.NewGuid().ToString(); NetAuthentication netAuth = new NetAuthentication(authInfoToUse.Token, authInfoToUse.UserAuthenticationType); if ((authInfoToUse.Roles != null) && (authInfoToUse.Roles.Count != 0)) netAuth.Roles = authInfoToUse.Roles; if (authInfoToUse.UserId != null) { netAuth.UserId = authInfoToUse.UserId; } netAuth.ActionId = actionId; NetAction netAction = new NetAction(NetAction.ActionType.AUTH); netAction.AuthenticationMessage = netAuth; NetMessage msg = new NetMessage(netAction); // build waitable object WaitMessageAccepted waitMsgAccepted = new WaitMessageAccepted(); AcceptRequest acceptRequest = new AcceptRequest(actionId, waitMsgAccepted, 7000); //send message HandleOutgoingMessage(msg, acceptRequest); // wait for response lock (waitMsgAccepted.SyncObject) { Monitor.Wait(waitMsgAccepted.SyncObject); } if (waitMsgAccepted.WaitResult != WaitMessageAccepted.Result.Accepted) { log.Error("Authenticatation failed. Reason: " + waitMsgAccepted.WaitResult); return false; } log.Info("Authenticated"); return true; }
private static ActionType translate( NetAction.ActionType actionType) { switch(actionType) { case NetAction.ActionType.PUBLISH: return ActionType.PUBLISH; case NetAction.ActionType.POLL: return ActionType.POLL; case NetAction.ActionType.ACKNOWLEDGE: return ActionType.ACKNOWLEDGE; case NetAction.ActionType.SUBSCRIBE: return ActionType.SUBSCRIBE; case NetAction.ActionType.UNSUBSCRIBE: return ActionType.UNSUBSCRIBE; case NetAction.ActionType.PING: return ActionType.PING; case NetAction.ActionType.AUTH: return ActionType.AUTH; } throw new Exception("Unexpected ActionType while marshalling message " + actionType.ToString() ); }
public static NetMessage getMessageFaultWithDetail(NetMessage message, string detail) { NetFault fault = message.Action.FaultMessage; NetFault newFault = new NetFault(fault.Code, fault.Message); newFault.ActionId = fault.ActionId; newFault.Detail = detail; NetAction action = new NetAction(NetAction.ActionType.FAULT); action.FaultMessage = newFault; return new NetMessage(action, message.Headers); }
public static NetMessage buildNetFaultMessage(string code, string message) { NetFault fault = new NetFault(code, message); NetAction action = new NetAction(NetAction.ActionType.FAULT); action.FaultMessage = fault; NetMessage msg = new NetMessage(action); return msg; }
/// <summary> /// Subscribe to a destination. /// </summary> /// <param name="subscription">A Subscription instance.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Subscribe(Subscription subscription, AcceptRequest acceptRequest) { if (IsClosed()) return; subscription.BrokerClient = this; NetSubscribe netSubscribe = new NetSubscribe(subscription.DestinationPattern, subscription.DestinationType); NetAction action = new NetAction(NetAction.ActionType.SUBSCRIBE); action.SubscribeMessage = netSubscribe; NetMessage netMessage = new NetMessage(action, subscription.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); protocolHandler.AddSubscription(subscription); }
/// <summary> /// Cancel a previous subscription. /// </summary> /// <param name="subscription">A Subscription instance.</param> /// <param name="acceptRequest">An AcceptRequest instance.</param> public void Unsubscribe(Subscription subscription, AcceptRequest acceptRequest) { if (IsClosed()) return; NetUnsubscribe netUnsubscribe = new NetUnsubscribe(subscription.DestinationPattern, subscription.DestinationType); NetAction action = new NetAction(NetAction.ActionType.UNSUBSCRIBE); action.UnsbuscribeMessage = netUnsubscribe; NetMessage netMessage = new NetMessage(action, subscription.Headers); protocolHandler.HandleOutgoingMessage(netMessage, acceptRequest); protocolHandler.RemoveSubscription(subscription); }
public NetUnsubscribe(string destination, NetAction.DestinationType destinationType) { this.destination = destination; this.destinationType = destinationType; }
/// <summary> /// Get a NetMessage containing a NetSubscribe object that represents this subscription request. This is meant to be used by the messaging framework. /// </summary> /// <returns>A NetMessage instance.</returns> public NetMessage ToNetMessage() { NetSubscribe netSubscribe = new NetSubscribe(this.destinationPattern, this.destinationType); NetAction netAction = new NetAction(NetAction.ActionType.SUBSCRIBE); netAction.SubscribeMessage = netSubscribe; NetMessage netMessage = new NetMessage(netAction, this.Headers); return netMessage; }
internal NetNotification(string destination, NetAction.DestinationType destinationType, NetBrokerMessage message, string subscription, IDictionary<string, string> headers) { this.destination = destination; this.destinationType = destinationType; this.message = message; if (subscription == null) this.subscription = ""; else this.subscription = subscription; this.headers = headers; }
public NetMessage(NetAction action) : this(action, null) { }
public NetPublish(string destination, NetAction.DestinationType destinationType, NetBrokerMessage message) { this.destinationType = destinationType; this.destination = destination; this.message = message; }
public NetMessage(NetAction action, IDictionary<string, string> headers) { this.action = action; if (headers != null) this.headers = headers; else this.headers = new Dictionary<string, string>(); }