/// <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>();
}
public NetMessage(NetAction action)
: this(action, null)
{
}
