private static Action getAction(NetMessage message) { Action action = new Action(); ActionType actionType = translate( message.Action.Action ); action.Action_type = actionType; switch(actionType) { case ActionType.PUBLISH: action.Publish = getPublishMessage(message); break; case ActionType.POLL: action.Poll = getPollMessage(message); break; case ActionType.ACKNOWLEDGE: action.Ack_message = getAcknowledgeMessage(message); break; case ActionType.SUBSCRIBE: action.Subscribe = getSubscribeMessage(message); break; case ActionType.UNSUBSCRIBE: action.Unsubscribe = getUnsubscribeMessage(message); break; case ActionType.PING: action.Ping = getPingMessage(message); break; case ActionType.AUTH: action.Auth = getAuthMessage(message); break; default: throw new Exception("Unexpected ActionType while marshalling message " + actionType.ToString() ); } return action; }
public static NetMessage translate(Atom message) { NetAction action = getAction(message); IDictionary<string, string> headers = getHeaders(message); NetMessage netMessage = new NetMessage(action, headers); return netMessage; }
private static Acknowledge getAcknowledgeMessage(NetMessage message) { NetAcknowledge netAck = message.Action.AcknowledgeMessage; Acknowledge ack = new Acknowledge(); ack.Action_id = netAck.ActionId; ack.Destination = netAck.Destination; ack.Message_id = netAck.MessageId; return ack; }
public static Atom translate(NetMessage message) { Atom atom = new Atom(); Action action = getAction(message); Header header = getHeaders(message); atom.Action = action; atom.Header = header; return atom; }
/// <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; }
private static Header getHeaders(NetMessage message) { Header headers = new Header(); headers.Parameters = new Dictionary<string, string>(message.Headers); return headers; }
private void HandlePongMessage(NetMessage message) { PongHandler handler = OnPong; if (handler != null) OnPong(message.Action.PongMessage); }
private void HandleFault(NetMessage message) { string msgDest = message.Action.FaultMessage.Detail; if( message.Action.FaultMessage.Code.Equals( NetFault.PollTimeoutErrorMessage.Action.FaultMessage.Code ) || message.Action.FaultMessage.Code.Equals(NetFault.NoMessageInQueueErrorMessage.Action.FaultMessage.Code) ) { lock (this.syncSubscriptions) { if (syncSubscriptions.ContainsKey(msgDest)) { PollRequest request = syncSubscriptions[msgDest]; if( message.Action.FaultMessage.Code.Equals( NetFault.PollTimeoutErrorMessage.Action.FaultMessage.Code ) ) { request.Handover.Offer(UnblockNotification); } else { request.Handover.Offer(NoMessageNotification); } } return; } } message.Action.FaultMessage.Headers = message.Headers; if (!PendingAcceptRequestsManager.MessageFailed(message.Action.FaultMessage)) { FaultHandler handler = OnFault; if (handler != null) OnFault(message.Action.FaultMessage); } }
//syncSubscriptions internal NetNotification GetSyncMessage(string queueName, NetMessage message) { NetNotification receivedMessage = null; HandoverSyncObject<NetNotification> synObj = null; lock (syncSubscriptions) { if (syncSubscriptions.ContainsKey(queueName)) throw new ArgumentException("Queue " + queueName + " has already a poll runnig."); PollRequest pr = new PollRequest(); pr.Subscription = message; pr.Handover = synObj = new HandoverSyncObject<NetNotification>(); syncSubscriptions.Add(queueName, pr); } receivedMessage = synObj.Get(); lock (syncSubscriptions) { syncSubscriptions.Remove(queueName); } return receivedMessage; }
public void HandleIncommingMessage(NetMessage message) { try{ switch( message.Action.Action ) { case NetAction.ActionType.ACCEPTED: PendingAcceptRequestsManager.MessageReceived(message.Action.AcceptedMessage.ActionId); break; case NetAction.ActionType.FAULT: HandleFault(message); break; case NetAction.ActionType.NOTIFICATION: HandleNotification(message); break; case NetAction.ActionType.PONG: HandlePongMessage(message); break; default: DealWithException( new Exception(String.Format("Unexpected incoming message type: {0}", message.Action.Action))); break; } } catch(Exception ex) { DealWithException( new Exception("Error handling incomming message.", ex)); } }
public static void SendMessageOverUdp(NetMessage message, HostInfo hostInfo, IMessageSerializer messageSerializer) { byte[] encodedData = messageSerializer.Marshall(message); UdpNetworkHandler.SendMessage(encodedData, hostInfo, messageSerializer); }
/// <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); }
private static Unsubscribe getUnsubscribeMessage(NetMessage message) { NetUnsubscribe netUnsub = message.Action.UnsbuscribeMessage; Unsubscribe unsubscribe = new Unsubscribe(); unsubscribe.Action_id = netUnsub.ActionId; unsubscribe.Destination = netUnsub.Destination; unsubscribe.Destination_type = translate ( netUnsub.DestinationType ); return unsubscribe; }
private static Subscribe getSubscribeMessage(NetMessage message) { NetSubscribe netSubs = message.Action.SubscribeMessage; Subscribe subs = new Subscribe(); subs.Action_id = netSubs.ActionId; subs.Destination = netSubs.Destination; subs.Destination_type = translate(netSubs.DestinationType); return subs; }
private static Publish getPublishMessage(NetMessage message) { NetPublish netPublish = message.Action.PublishMessage; Publish publish = new Publish(); publish.Action_id = netPublish.ActionId; publish.Destination = netPublish.Destination; publish.Destination_type = translate( netPublish.DestinationType ); publish.Message = getBrokerMessage( netPublish.Message ); return publish; }
private static Poll getPollMessage(NetMessage message) { NetPoll netPoll = message.Action.PollMessage; Poll poll = new Poll(); poll.Action_id = netPoll.ActionId; poll.Destination = netPoll.Destination; poll.Timeout = netPoll.Timeout; return poll; }
private static Ping getPingMessage(NetMessage message) { NetPing netPing = message.Action.PingMessage; Ping ping = new Ping(); ping.Action_id = netPing.ActionId; return ping; }
/// <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); }
static NetFault() { InvalidMessageSizeErrorMessage = buildNetFaultMessage("1101", "Invalid message size"); UnknownEncodingProtocolMessage = buildNetFaultMessage("1102", "Unknown encoding protocol"); UnknownEncodingVersionMessage = buildNetFaultMessage("1103", "Unknown encoding version"); InvalidMessageFormatErrorMessage = buildNetFaultMessage("1201", "Invalid message format"); UnexpectedMessageTypeErrorMessage = buildNetFaultMessage("1202", "Unexpected message type"); InvalidDestinationNameErrorMessage = buildNetFaultMessage("2001", "Invalid destination name"); InvalidMessageDestinationTypeErrorMessage = buildNetFaultMessage("2002", "Invalid destination type"); MaximumNrQueuesReachedMessage = buildNetFaultMessage("2003", "Maximum number of queues reached"); MaximumDistinctSubscriptionsReachedMessage = buildNetFaultMessage("2004", "Maximum distinct subscriptions reached"); PollTimeoutErrorMessage = buildNetFaultMessage("2005", "Message poll timeout"); NoMessageInQueueErrorMessage = buildNetFaultMessage("2006", "No message in local agent queue."); AuthenticationFailedErrorMessage = buildNetFaultMessage("3101", "Authentication failed"); UnknownAuthenticationTypeMessage = buildNetFaultMessage("3102", "Unknown authentication type"); InvalidAuthenticationChannelType = buildNetFaultMessage("3103", "Invalid authentication channel type"); AccessDeniedErrorMessage = buildNetFaultMessage("3201", "Access denied"); }
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; }
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; }
public bool HandleOutgoingMessage(NetMessage message, AcceptRequest acceptRequest) { if( acceptRequest != null) { PendingAcceptRequestsManager.AddAcceptRequest(acceptRequest); } // transform and Marshall message byte[] encodedData = EncodeMessage(message); return SendMessage(encodedData); }
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); }
private byte[] EncodeMessage(NetMessage message) { return messageSerializer.Marshall(message); }
/// <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 void HandleNotification(NetMessage message) { string subscription = message.Action.NotificationMessage.Subscription; NetAction.DestinationType destType = message.Action.NotificationMessage.DestinationType; if (destType != NetAction.DestinationType.TOPIC) { lock (this.syncSubscriptions) { string subs = message.Action.NotificationMessage.Subscription; if (syncSubscriptions.ContainsKey(subscription)) { PollRequest request = syncSubscriptions[subs]; request.Handover.Offer(message.Action.NotificationMessage); return; } } } lock (subscriptions) { IDictionary<string, Subscription> destSubscriptions = subscriptions[destType == NetAction.DestinationType.TOPIC ? NetAction.DestinationType.TOPIC : NetAction.DestinationType.QUEUE]; if (destSubscriptions.ContainsKey(subscription)) { destSubscriptions[subscription].FireOnMessage(message.Action.NotificationMessage); } else { DealWithException(new UnexpectedMessageException("No registered subscribers for received message.", message)); } } }
/// <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> /// 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> /// 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; }