public void NotifyAll()
{
AsyncMessage m = new AsyncMessage(MessageType.Notification);
m.Data = "Hello!";
Longpool.Instance.PushMessage(m);
}
private AsyncMessage convertToFlexMessage(IMessage message, String clientId)
{
AsyncMessage asyncMessage = new AsyncMessage();
if (message is ActiveMQObjectMessage)
{
ActiveMQObjectMessage objectMessage = ((ActiveMQObjectMessage)message);
asyncMessage.body = objectMessage.Body;
}
else if (message is ActiveMQTextMessage)
{
asyncMessage.body = ((ActiveMQTextMessage)message).Text;
}
try
{
asyncMessage.destination = this.DestinationDefinition.Id;
asyncMessage.clientId = clientId;
asyncMessage.messageId = message.NMSMessageId;
asyncMessage.timestamp = message.NMSTimestamp.Ticks;
asyncMessage.correlationId = message.NMSCorrelationID;
foreach (String key in message.Properties.Keys)
{
asyncMessage.headers.Add(key, message.Properties[key]);
}
}
catch (Exception ex)
{
log.Error("Error while converting to Flex Message", ex);
}
return(asyncMessage);
}
private AsyncMessage ConvertMsmqMessage(Message message)
{
AsyncMessage asyncMessage = new AsyncMessage();
asyncMessage.body = message.Body;
asyncMessage.destination = DestinationDefinition.Id;
asyncMessage.clientId = Guid.NewGuid().ToString("D");
asyncMessage.messageId = Guid.NewGuid().ToString("D");
asyncMessage.timestamp = Environment.TickCount;
asyncMessage.headers["MSMQId"] = message.Id;
asyncMessage.headers["MSMQLabel"] = message.Label;
//asyncMessage.headers["MSMQBody"] = message.Body;
if (message.Body != null)
{
PropertyInfo[] propertyInfos = message.Body.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo pi in propertyInfos)
{
if (pi.GetGetMethod() != null && pi.GetGetMethod().GetParameters().Length == 0)
{
asyncMessage.headers[pi.Name] = pi.GetValue(message.Body, null);
}
}
FieldInfo[] fieldInfos = message.Body.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
foreach (FieldInfo fi in fieldInfos)
{
asyncMessage.headers[fi.Name] = fi.GetValue(message.Body);
}
}
return(asyncMessage);
}
private AsyncMessage ConvertMsmqMessage(Message message)
{
AsyncMessage message2 = null;
message2 = new AsyncMessage {
body = message.Body,
destination = base.DestinationSettings.Id,
clientId = Guid.NewGuid().ToString("D"),
messageId = Guid.NewGuid().ToString("D"),
timestamp = Environment.TickCount
};
message2.headers["MSMQId"] = message.Id;
message2.headers["MSMQLabel"] = message.Label;
if (message.Body != null)
{
PropertyInfo[] properties = message.Body.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance);
foreach (PropertyInfo info in properties)
{
if ((info.GetGetMethod() != null) && (info.GetGetMethod().GetParameters().Length == 0))
{
message2.headers[info.Name] = info.GetValue(message.Body, null);
}
}
FieldInfo[] fields = message.Body.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance);
foreach (FieldInfo info2 in fields)
{
message2.headers[info2.Name] = info2.GetValue(message.Body);
}
}
return(message2);
}
public void AsyncActorResult_IsAddedToMessageCompletionQueue()
{
try
{
actorHost.AssignActor(new EchoActor());
var delay = AsyncOp;
var asyncMessage = new AsyncMessage {
Delay = delay
};
var messageIn = Message.CreateFlowStartMessage(asyncMessage);
receivingSocket.SetupMessageReceived(messageIn);
//
StartActorHost(actorHost);
//
(AsyncOpCompletionDelay + AsyncOp).Sleep();
asyncQueue.Verify(m => m.Enqueue(It.IsAny <AsyncMessageContext>(), It.IsAny <CancellationToken>()),
Times.Once);
asyncQueue.Verify(m => m.GetConsumingEnumerable(It.IsAny <CancellationToken>()), Times.Once);
}
finally
{
actorHost.Stop();
}
}
/// <summary>
/// Send AsyncMessage.<br/>
/// Important!!: If not found receiver then freeze.
/// </summary>
/// <typeparam name="TMessage">wrapped message type</typeparam>
/// <param name="self"></param>
/// <param name="message">wrapped message</param>
/// <returns></returns>
public static Task SendAsync <TMessage>(this IMessenger self, TMessage message)
where TMessage : MessageBase
{
var asyncMessage = new AsyncMessage <TMessage>(message);
self.Send(asyncMessage);
return(asyncMessage.Task);
}
/// <summary>
/// Send AsyncMessage.<br/>
/// Important!!: If not found receiver then freeze.
/// </summary>
/// <typeparam name="TMessage">wrapped message type</typeparam>
/// <typeparam name="TResult">return type</typeparam>
/// <param name="self"></param>
/// <param name="message">wrapped message</param>
/// <returns></returns>
public static async Task <TResult> SendAsync <TMessage, TResult>(this IMessenger self, TMessage message)
where TMessage : MessageBase
{
var asyncMessage = new AsyncMessage <TMessage>(message);
self.Send(asyncMessage);
return((TResult)await asyncMessage.Task);
}
protected void ReceivedMessage(AsyncMessage message)
{
object responder = GetResponder(message.clientId.ToString());
if (responder != null && responder is ISubscribeResponder)
{
((ISubscribeResponder)responder).ResponseHandler(message);
}
}
public new void ResponseHandler(AsyncMessage asyncMessage)
{
IAdaptingType[] bodys = asyncMessage.GetBody();
foreach (IAdaptingType adaptingType in bodys)
{
object message = adaptingType.defaultAdapt();
base.ResponseHandler(message);
}
return;
}
public void SendMessageToPlayers(AsyncMessage message, bool exceptCreator = false)
{
foreach (Player player in Players)
{
if (!exceptCreator || (exceptCreator && player.UserId != Creator.UserId))
{
Longpool.Longpool.Instance.PushMessageToUser(player.UserId, message);
}
}
}
public Task <string> Get(int input)
{
var message = new AsyncMessage <int, string>(input);
if (!_asyncProcessor.Post(message))
{
throw new OperationCanceledException();
}
return(message.Completion);
}
public void Publish(Object message, Dictionary <object, object> headers, String subtopic, PublishingResponder responder, string destination)
{
AsyncMessage asyncMessage;
if (message is AsyncMessage)
{
asyncMessage = (AsyncMessage)message;
}
else
{
asyncMessage = new AsyncMessage();
asyncMessage._body = new BodyHolder();
asyncMessage._body.body = message;
}
asyncMessage.destination = destination;
asyncMessage.headers = asyncMessage.headers ?? new Dictionary <object, object>();
if (headers != null)
{
foreach (KeyValuePair <object, object> keyValuePair in headers)
{
if (asyncMessage.headers.Contains(keyValuePair.Key))
{
asyncMessage.headers[keyValuePair.Key] = keyValuePair.Value;
}
else
{
asyncMessage.headers.Add(keyValuePair.Key, keyValuePair.Value);
}
}
}
asyncMessage.messageId = Guid.NewGuid().ToString();
//
// asyncMessage.clientId = IdInfo.ClientId;
if (subtopic != null)
{
asyncMessage.headers["DSSubtopic"] = subtopic;
}
if (IdInfo.DsId != null)
{
asyncMessage.headers["DSId"] = IdInfo.DsId;
}
if (responder == null)
{
responder = new PublishingResponder(PublishResponseHandler, PublishErrorHandler);
}
_engine.SendRequest(asyncMessage, responder);
}
public void Push(AsyncMessage message)
{
if (IsCompleted)
{
Messages.Add(message);
}
else
{
CurrentContext.Response.Write(message.ToString());
CompleteRequest();
}
}
private void OnReceiveCompleted(object sender, ReceiveCompletedEventArgs e)
{
Message message = ((MessageQueue)e.AsyncResult.AsyncState).EndReceive(e.AsyncResult);
log.Debug(__Res.GetString("Msmq_Receive", new object[] { message.Label, message.Id }));
try
{
AsyncMessage message2 = this.ConvertMsmqMessage(message);
(base.Destination.Service as MessageService).PushMessageToClients(message2);
}
catch (SerializationException exception)
{
log.Error(__Res.GetString("Msmq_Poison"), exception);
}
IAsyncResult result = ((MessageQueue)e.AsyncResult.AsyncState).BeginReceive(new TimeSpan(1, 0, 0), (MessageQueue)e.AsyncResult.AsyncState);
}
public virtual void onMessage(String clientId, String subscriptionId, IMessage message)
{
try
{
log.Debug(string.Format("Recieved new Message for Client ID: {0}", clientId));
ArrayList list = new ArrayList();
list.Add(subscriptionId);
AsyncMessage asyncMessage = convertToFlexMessage(message, clientId);
MessageService messageService = this.Destination.Service as MessageService;
messageService.PushMessageToClients(list, asyncMessage);
}
catch (Exception ex)
{
log.Error("Error while handling incoming message", ex);
}
}
public new void ResponseHandler(AsyncMessage asyncMessage)
{
IAdaptingType[] bodys = asyncMessage.GetBody();
foreach (IAdaptingType adaptingType in bodys)
{
object message = adaptingType.defaultAdapt();
base.ResponseHandler(message);
}
return;
#if !(FULL_BUILD)
IAdaptingType body = (IAdaptingType)asyncMessage.body;
#else
IAdaptingType body = (IAdaptingType)((object[])(asyncMessage.body.body))[0];
#endif
object adaptedMessage = body.defaultAdapt();
base.ResponseHandler(adaptedMessage);
}
void OnReceiveCompleted(object sender, ReceiveCompletedEventArgs e)
{
Message message = ((MessageQueue)e.AsyncResult.AsyncState).EndReceive(e.AsyncResult);
log.Debug(__Res.GetString(__Res.Msmq_Receive, message.Label, message.Id));
try {
AsyncMessage asyncMessage = ConvertMsmqMessage(message);
MessageService messageService = Destination.Service as MessageService;
if (messageService != null)
{
messageService.PushMessageToClients(asyncMessage);
}
//msgBroker.RouteMessage(msg);
} catch (System.Runtime.Serialization.SerializationException ex) {
log.Error(__Res.GetString(__Res.Msmq_Poison), ex);
}
// start looking for the next message
IAsyncResult asyncResult = ((MessageQueue)e.AsyncResult.AsyncState).BeginReceive(new TimeSpan(1, 0, 0), ((MessageQueue)e.AsyncResult.AsyncState));
}
public void CallbackReceiverIdentities_AreCopiedFromIncomingMessageProcessedAsync()
{
try
{
actorHost = new ActorHost(actorHandlersMap,
new AsyncQueue <AsyncMessageContext>(),
new AsyncQueue <ActorRegistration>(),
securityProvider.Object,
localRouterSocket.Object,
internalRegistrationSender.Object,
localSocketFactory.Object,
logger.Object);
actorHost.AssignActor(new EchoActor());
var asyncMessage = new AsyncMessage {
Delay = AsyncOp
};
var messageIn = Message.CreateFlowStartMessage(asyncMessage).As <Message>();
var callbackReceiver = Guid.NewGuid().ToByteArray();
var callbackReceiverNode = Guid.NewGuid().ToByteArray();
messageIn.RegisterCallbackPoint(callbackReceiverNode,
callbackReceiver,
MessageIdentifier.Create <SimpleMessage>(),
Randomizer.Int32());
receivingSocket.SetupMessageReceived(messageIn);
//
StartActorHost(actorHost);
//
localRouterSocket.WaitUntilMessageSent(AssertCallbackPropertiesCopied);
bool AssertCallbackPropertiesCopied(Message messageOut)
=> messageIn.CallbackPoint.SequenceEqual(messageOut.CallbackPoint) &&
Unsafe.ArraysEqual(messageIn.CallbackReceiverIdentity, messageOut.CallbackReceiverIdentity) &&
Unsafe.ArraysEqual(messageIn.CallbackReceiverNodeIdentity, messageOut.CallbackReceiverNodeIdentity);
}
finally
{
actorHost.Stop();
}
}
protected override MessageBase CopyImpl(MessageBase clone)
{
// Instantiate the clone, if a derived type hasn't already.
if (clone == null) clone = new AsyncMessage();
// Allow base type(s) to copy their state into the new clone.
base.CopyImpl(clone);
// Copy our state into the clone.
((AsyncMessage)clone)._correlationId = _correlationId;
return clone;
}
public override object ServiceMessage(IMessage message)
{
CommandMessage message2 = message as CommandMessage;
if (message2 != null)
{
return(base.ServiceMessage(message2));
}
AsyncMessage message3 = null;
DataMessage message4 = message as DataMessage;
DataDestination destination = base.GetDestination(message4) as DataDestination;
if (destination.SubscriptionManager.GetSubscriber(message4.clientId as string) == null)
{
CommandMessage message5 = new CommandMessage {
destination = destination.Id,
operation = 0,
clientId = message4.clientId as string
};
string header = message4.GetHeader("DSEndpoint") as string;
message5.headers["DSEndpoint"] = header;
string str2 = message4.GetHeader("DSId") as string;
if (str2 != null)
{
message5.headers["DSId"] = str2;
}
base.GetMessageBroker().GetEndpoint(header).ServiceMessage(message5);
}
switch (message4.operation)
{
case 1:
message3 = this.ExecuteFillOperation(message);
break;
case 2:
message3 = this.ExecuteGetOperation(message);
break;
case 5:
case 6:
case 7:
message3 = this.ExecuteMultiBatchOperation(message);
break;
case 8:
message3 = this.ExecutePageOperation(message);
break;
case 12:
message3 = this.ExecuteGetSequenceIdOperation(message);
break;
case 0x12:
message3 = this.ExecuteReleaseCollectionOperation(message);
break;
case 0x13:
message3 = this.ExecuteReleaseItemOperation(message);
break;
case 20:
message3 = this.ExecutePageItemsOperation(message);
break;
default:
if (log.get_IsErrorEnabled())
{
log.Error(__Res.GetString("DataService_Unknown", new object[] { message4.operation }));
}
message3 = new AcknowledgeMessage();
break;
}
message3.clientId = message.clientId;
message3.correlationId = message.messageId;
return(message3);
}
public override object ServiceMessage(IMessage message)
{
CommandMessage commandMessage = message as CommandMessage;
if (commandMessage != null)
{
//Sub/unsub handled by base class
return(base.ServiceMessage(commandMessage));
}
else
{
AsyncMessage responseMessage = null;
DataMessage dataMessage = message as DataMessage;
DataDestination dataDestination = this.GetDestination(dataMessage) as DataDestination;
if (dataDestination.SubscriptionManager.GetSubscriber(dataMessage.clientId as string) == null)
{
//Subscribe here as DS doesn't send a separate subscribe command
CommandMessage commandMessageSubscribe = new CommandMessage();
commandMessageSubscribe.destination = dataDestination.Id;
commandMessageSubscribe.operation = CommandMessage.SubscribeOperation;
commandMessageSubscribe.clientId = dataMessage.clientId as string;
string endpointId = dataMessage.GetHeader(MessageBase.EndpointHeader) as string;
commandMessageSubscribe.headers[MessageBase.EndpointHeader] = endpointId;
string flexClientIdHeader = dataMessage.GetHeader(MessageBase.FlexClientIdHeader) as string;
if (flexClientIdHeader != null)
{
commandMessageSubscribe.headers[MessageBase.FlexClientIdHeader] = flexClientIdHeader;
}
IEndpoint endpoint = GetMessageBroker().GetEndpoint(endpointId);
endpoint.ServiceMessage(commandMessageSubscribe);//route through the endpoint again
//base.ServiceMessage(commandMessageSubscribe);
}
switch (dataMessage.operation)
{
case DataMessage.FillOperation:
responseMessage = ExecuteFillOperation(message);
break;
case DataMessage.GetOperation:
responseMessage = ExecuteGetOperation(message);
break;
case DataMessage.BatchedOperation:
case DataMessage.MultiBatchOperation:
case DataMessage.TransactedOperation:
responseMessage = ExecuteMultiBatchOperation(message);
break;
case DataMessage.PageItemsOperation:
responseMessage = ExecutePageItemsOperation(message);
break;
case DataMessage.PageOperation:
responseMessage = ExecutePageOperation(message);
break;
case DataMessage.ReleaseCollectionOperation:
responseMessage = ExecuteReleaseCollectionOperation(message);
break;
case DataMessage.GetSequenceIdOperation:
responseMessage = ExecuteGetSequenceIdOperation(message);
break;
case DataMessage.ReleaseItemOperation:
responseMessage = ExecuteReleaseItemOperation(message);
break;
default:
if (log.IsErrorEnabled)
{
log.Error(__Res.GetString(__Res.DataService_Unknown, dataMessage.operation));
}
responseMessage = new AcknowledgeMessage();
break;
}
responseMessage.clientId = message.clientId;
responseMessage.correlationId = message.messageId;
//Dump();
return(responseMessage);
}
}
public bool AddToPool(AsyncMessage message)
{
return(Messages.Add(message));
}
public void Enqueue(AsyncMessage message)
{
_messageConcurrentQueue.Enqueue(message);
}
