bool UpdateRegisterInfo(School school, DuplexMessage commandMessage) { var registerOk = false; var registerInfo = commandMessage.GetContent <RegisterInfo>(); if (registerInfo != null) { school.ClientPubKey = registerInfo.ClientPubKey; school.UniqueToken = registerInfo.ClientMacAddr; metaRepository.AddOrUpdateSchool(school, (updateOk) => { DuplexMessage resultMessage; if (updateOk) { resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage); } else { resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, ErrorCode.RegisterFailed); } Return(resultMessage); }); registerOk = true; } return(registerOk); }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { DuplexMessage resultMessage = null; var school = metaRepository .GetAllSchools() .ByIdentifier(commandMessage.Header.Identifier); if (school != null) { if (UpdateRegisterInfo(school, commandMessage)) { resultMessage = DuplexMessage.CreateAckMessage(commandMessage); } else { resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, ErrorCode.RegisterFailed); } } else { resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, ErrorCode.RegisterFailed); } return(resultMessage); }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { Log.Error(ErrorCode.BadProtocalVersion, new Exception("error")); var content = commandMessage.GetContent <Customer>(); return(DuplexMessage.CreateCallbackMessage(commandMessage, content)); }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { return(DuplexMessage.CreateAckMessage(commandMessage, commandMessage.Header.ErrorCode == ErrorCode.NoError ? ErrorCode.BadRequest : commandMessage.Header.ErrorCode)); }
void IUniversalDuplexContract.SendToService(DuplexMessage msg) { //We get here when we receive a message from a client IUniversalDuplexCallbackContract ch = OperationContext.Current.GetCallbackChannel <IUniversalDuplexCallbackContract>(); string session = OperationContext.Current.Channel.SessionId; //Any message from a client we haven't seen before causes the new client to be added to our list //(Basically, treated as a "Connect" message) lock (syncRoot) { if (!clients.ContainsKey(session)) { clients.Add(session, ch); OperationContext.Current.Channel.Closing += new EventHandler(Channel_Closing); OperationContext.Current.Channel.Faulted += new EventHandler(Channel_Faulted); OnConnected(session); } } //If it's a Disconnect message, treat as disconnection if (msg is DisconnectMessage) { ClientDisconnected(session); } //Otherwise, if it's a payload-carrying message (and not just a simple "Connect"), process it else if (!(msg is ConnectMessage)) { OnMessage(session, msg); } }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { return DuplexMessage.CreateAckMessage(commandMessage, commandMessage.Header.ErrorCode == ErrorCode.NoError ? ErrorCode.BadRequest : commandMessage.Header.ErrorCode); }
/// <summary> /// Pushes a message to all connected clients /// </summary> /// <param name="message">The message to push</param> protected void PushToAllClients(DuplexMessage message) { lock (syncRoot) { foreach (string session in clients.Keys) { PushMessageToClient(session, message); } } }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { var instruction = BuildInstruction(commandMessage); if (instruction != null) { instructionProducer.Produce(instruction); return DuplexMessage.CreateAckMessage(commandMessage); } else return DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.InstructionBuildFailed); }
public override DuplexMessage Run(int timeout = AbstractAsyncCommand.BLOCK_UNTIL_TIMEOUT_AFTER_SECONDS * 1000) { DisableRetry(); RunAsync(); if (!semaphore.Wait(timeout)) { result = DuplexMessage.CreateAckMessage(ID, Version, CommandCode, ErrorCode.CommandRunTimeout); semaphore.Dispose(); } return(result); }
public override DuplexMessage Run(int timeout = AbstractAsyncCommand.BLOCK_UNTIL_TIMEOUT_AFTER_SECONDS * 1000) { DisableRetry(); RunAsync(); if (!semaphore.Wait(timeout)) { result = DuplexMessage.CreateAckMessage(ID, Version, CommandCode, ErrorCode.CommandRunTimeout); semaphore.Dispose(); } return result; }
protected override IInstruction BuildInstruction(DuplexMessage commandMessage) { var instrSet = new InstructionSet(this); using (var scope = ObjectHost.Host.BeginLifetimeScope()) { instrSet.AddInstruction(scope.Resolve<CheckInQueryInstruction>( new NamedParameter("command", this), new NamedParameter("parameter", commandMessage.GetContent<object>()))); instrSet.AddInstruction(scope.Resolve<CheckInReplyInstruction>( new NamedParameter("parameter", commandMessage.GetContent<object>()))); } return instrSet; }
/// <summary> /// Pushes a message to one specific client /// </summary> /// <param name="clientSessionId">Session ID of the client that should receive the message</param> /// <param name="message">The message to push</param> protected void PushMessageToClient(string clientSessionId, DuplexMessage message) { if (clients != null && clients.ContainsKey(clientSessionId)) { IUniversalDuplexCallbackContract ch = clients[clientSessionId]; IAsyncResult iar = ch.BeginSendToClient(message, new AsyncCallback(OnPushMessageComplete), new PushMessageState(ch, clientSessionId)); if (iar.CompletedSynchronously) { CompletePushMessage(iar); } } }
protected override IInstruction BuildInstruction(DuplexMessage commandMessage) { var instrSet = new InstructionSet(this); using (var scope = ObjectHost.Host.BeginLifetimeScope()) { instrSet.AddInstruction(scope.Resolve <CheckInQueryInstruction>( new NamedParameter("command", this), new NamedParameter("parameter", commandMessage.GetContent <object>()))); instrSet.AddInstruction(scope.Resolve <CheckInReplyInstruction>( new NamedParameter("parameter", commandMessage.GetContent <object>()))); } return(instrSet); }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { var instruction = BuildInstruction(commandMessage); if (instruction != null) { instructionProducer.Produce(instruction); return(DuplexMessage.CreateAckMessage(commandMessage)); } else { return(DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.InstructionBuildFailed)); } }
/// <summary> /// Pushes a message to one specific client /// </summary> /// <param name="clientSessionId">Session ID of the client that should receive the message</param> /// <param name="message">The message to push</param> protected void PushMessageToClient(string clientSessionId, DuplexMessage message) { try //try to send message to client if it is still connected. Otherwise dont worry about it. { IUniversalDuplexCallbackContract ch = (clients[clientSessionId]).Channel; IAsyncResult iar = ch.BeginSendToClient(message, new AsyncCallback(OnPushMessageComplete), new PushMessageState(ch, clientSessionId)); if (iar.CompletedSynchronously) { CompletePushMessage(iar); } } catch { } }
protected void PushServiceStatusToClients(string nodeID, DuplexMessage message) { Dictionary <string, Client> clientsList; lock (clients) { clientsList = new Dictionary <string, Client>(clients); // we will take a copy of the global collection locally to avoid locking of the resource. } foreach (string session in clientsList.Keys) { if (clientsList[session].CurrentDisplayType == DisplayType.ServiceClient && clientsList[session].NodeID == nodeID) { PushMessageToClient(session, message); } } }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { DuplexMessage resultMessage = null; var school = metaRepository .GetAllSchools() .ByIdentifier(commandMessage.Header.Identifier); if (school != null) { if (UpdateRegisterInfo(school, commandMessage)) resultMessage = DuplexMessage.CreateAckMessage(commandMessage); else resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, ErrorCode.RegisterFailed); } else resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, ErrorCode.RegisterFailed); return resultMessage; }
public void Execute() { new Task(() => { while (true) { foreach (var hardware in hardwareRepository .GetHardwares(LOCAL_SCHOOL_ID)) { base.Execute(null, DuplexMessage.CreateCommandMessage( string.Empty, MessageVersion.V1, CommandCode.Test, Rpc.Net.Message.Filter.MessageFilterType.None, new byte[0], Rpc.Net.Message.Serializer.SerializeMode.None, new { DestinationAddr = hardware.Address })); are.WaitOne(500); } } }).Start(); }
bool UpdateRegisterInfo(School school, DuplexMessage commandMessage) { var registerOk = false; var registerInfo = commandMessage.GetContent<RegisterInfo>(); if (registerInfo != null) { school.ClientPubKey = registerInfo.ClientPubKey; school.UniqueToken = registerInfo.ClientMacAddr; metaRepository.AddOrUpdateSchool(school, (updateOk) => { DuplexMessage resultMessage; if (updateOk) resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage); else resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, ErrorCode.RegisterFailed); Return(resultMessage); }); registerOk = true; } return registerOk; }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { IoSession session = null; DuplexMessage resultMessage = null; if (identifierManager.TryGetSessonIdByIdentifier(commandMessage.Header.Identifier, out session)) { var connectors = session.Service .ManagedSessions .Values .Where(s => s.Id != session.Id) .Select(s => s.GetAttribute<string>(KeyName.SESSION_IDENTIFIER)) .ToList(); resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, connectors); resultMessage.Header.FilterType |= MessageFilterType.Crypto; resultMessage.Header.SerializeMode = Rpc.Net.Message.Serializer.SerializeMode.Json; } else { resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage); } return resultMessage; }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { IoSession session = null; DuplexMessage resultMessage = null; if (identifierManager.TryGetSessonIdByIdentifier(commandMessage.Header.Identifier, out session)) { var connectors = session.Service .ManagedSessions .Values .Where(s => s.Id != session.Id) .Select(s => s.GetAttribute <string>(KeyName.SESSION_IDENTIFIER)) .ToList(); resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage, connectors); resultMessage.Header.FilterType |= MessageFilterType.Crypto; resultMessage.Header.SerializeMode = Rpc.Net.Message.Serializer.SerializeMode.Json; } else { resultMessage = DuplexMessage.CreateCallbackMessage(commandMessage); } return(resultMessage); }
public object GetRequest(IoSession session) { return(DuplexMessage.CreateHeartbeat()); }
void BlockCommand_Callback(object sender, CommandEventArgs<DuplexMessage> e) { result = e.Message; semaphore.Release(); }
static CheckInQueryCommand() { message = DuplexMessage.CreateCommandMessage(string.Empty, MessageVersion.V1, CommandCode.Test); }
protected void PushServiceStatusToClients(string nodeID, DuplexMessage message) { Dictionary<string, Client> clientsList; lock (clients) { clientsList = new Dictionary<string, Client>(clients); // we will take a copy of the global collection locally to avoid locking of the resource. } foreach (string session in clientsList.Keys) { if (clientsList[session].CurrentDisplayType == DisplayType.ServiceClient && clientsList[session].NodeID == nodeID) PushMessageToClient(session, message); } }
void SendToService(DuplexMessage message) { m_duplexClient.SendToServiceAsync(message); }
protected abstract IInstruction BuildInstruction(DuplexMessage commandMessage);
public void SendToService(DuplexMessage msg) { //We get here when we receive a message from a client IUniversalDuplexCallbackContract ch = OperationContext.Current.GetCallbackChannel<IUniversalDuplexCallbackContract>(); string session = OperationContext.Current.Channel.SessionId; if (msg is ConnectMessage) { //lock (syncRoot) lock (clients) { if (!clients.ContainsKey(session)) // new client { System.Diagnostics.Debug.WriteLine("New client connected: "); System.Diagnostics.Debug.WriteLine(" " + (msg as ConnectMessage).NodeID); System.Diagnostics.Debug.WriteLine(" " + (msg as ConnectMessage).TimeSeriesDataRootUrl); System.Diagnostics.Debug.WriteLine(" " + (msg as ConnectMessage).CurrentDisplayType.ToString()); Client client = new Client(); client.Channel = ch; client.NodeID = (msg as ConnectMessage).NodeID; client.TimeSeriesDataRootUrl = (msg as ConnectMessage).TimeSeriesDataRootUrl; client.RealTimeStatisticRootUrl = (msg as ConnectMessage).RealTimeStatisticRootUrl; client.DataPointID = (msg as ConnectMessage).DataPointID; client.CurrentDisplayType = (msg as ConnectMessage).CurrentDisplayType; clients.Add(session, client); OperationContext.Current.Channel.Closing += Channel_Closing; OperationContext.Current.Channel.Faulted += Channel_Faulted; OnConnected(session); } else //existing connected client. Just trying to update its settings. { clients[session] = new Client() { Channel = ch, NodeID = (msg as ConnectMessage).NodeID, DataPointID = (msg as ConnectMessage).DataPointID, TimeSeriesDataRootUrl = (msg as ConnectMessage).TimeSeriesDataRootUrl, RealTimeStatisticRootUrl = (msg as ConnectMessage).RealTimeStatisticRootUrl, CurrentDisplayType = (msg as ConnectMessage).CurrentDisplayType }; } } Client currentClient = clients[session]; // Initially when client is connected, we will send them data only if client is connected from home page of the openPDCManager. if (currentClient.CurrentDisplayType == DisplayType.Home) { PushMessageToClient(session, new LivePhasorDataMessage() { //PmuDistributionList = CommonFunctions.GetPmuDistribution(), DeviceDistributionList = CommonFunctions.GetVendorDeviceDistribution(null, currentClient.NodeID), InterconnectionStatusList = CommonFunctions.GetInterconnectionStatus(null, currentClient.NodeID) } ); PushMessageToClient(session, new TimeSeriesDataMessage() { TimeSeriesData = CommonFunctions.GetTimeSeriesData(currentClient.TimeSeriesDataRootUrl + "/timeseriesdata/read/historic/" + currentClient.DataPointID.ToString() + "/*-30S/*/XML") //TimeSeriesData = CommonFunctions.GetTimeSeriesData(currentClient.TimeSeriesDataRootUrl + "current/" + currentClient.DataPointID.ToString() + "/XML") } ); } else if (currentClient.CurrentDisplayType == DisplayType.ServiceClient) { if (serviceClientList.ContainsKey(currentClient.NodeID)) { System.Diagnostics.Debug.WriteLine("Sending Cached Status to Client Connected on System Monitor Page."); PushMessageToClient(session, new ServiceUpdateMessage() { ServiceUpdateType = UpdateType.Information, ServiceUpdate = serviceClientList[currentClient.NodeID].CachedStatus }); } else { System.Diagnostics.Debug.WriteLine("Sending Empty Message to Client Connected on System Monitor Page."); PushMessageToClient(session, new ServiceUpdateMessage()); } } else if (currentClient.CurrentDisplayType == DisplayType.DeviceMeasurements) { KeyValuePair<int, int> minMaxPointID = minMaxPointIDsPerNode[currentClient.NodeID]; if (!string.IsNullOrEmpty(currentClient.TimeSeriesDataRootUrl)) // if TimeSeriesDataRootUrl is defined for the node, then only try to send data to client upon connection. { System.Diagnostics.Debug.WriteLine("Sending Measurements to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage() { TimeTaggedMeasurements = CommonFunctions.GetTimeTaggedMeasurements(currentClient.TimeSeriesDataRootUrl + "/timeseriesdata/read/current/" + minMaxPointID.Key.ToString() + "-" + minMaxPointID.Value.ToString() + "/XML") }); } else { System.Diagnostics.Debug.WriteLine("Sending Empty Message to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage()); } } else if (currentClient.CurrentDisplayType == DisplayType.RealTimeStatistics) { KeyValuePair<int, int> minMaxPointID = minMaxPointIDsPerNode[currentClient.NodeID]; if (!string.IsNullOrEmpty(currentClient.TimeSeriesDataRootUrl)) // if TimeSeriesDataRootUrl is defined for the node, then only try to send data to client upon connection. { System.Diagnostics.Debug.WriteLine("Sending Measurements to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage() { TimeTaggedMeasurements = CommonFunctions.GetStatisticMeasurements(currentClient.RealTimeStatisticRootUrl + "/timeseriesdata/read/current/" + minMaxPointID.Key.ToString() + "-" + minMaxPointID.Value.ToString() + "/XML", currentClient.NodeID) }); } else { System.Diagnostics.Debug.WriteLine("Sending Empty Message to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage()); } } } else if (msg is ServiceRequestMessage) { SendServiceRequest(clients[session].NodeID, (msg as ServiceRequestMessage).Request); } else if (msg is DisconnectMessage) //If it's a Disconnect message, treat as disconnection { ClientDisconnected(session); } else //if (!(msg is ConnectMessage)) //Otherwise, if it's a payload-carrying message (and not just a simple "Connect"), process it { OnMessage(session, msg); } }
/// <summary> /// This will be called when a message is received from a client /// </summary> /// <param name="sessionId">Session ID of the client sending the message</param> /// <param name="message">The message that was received</param> protected virtual void OnMessage(string sessionId, DuplexMessage message) { }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { commandMessage.Header.MessageType = MessageType.Heartbeat; return(commandMessage); }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { Log.Error(ErrorCode.BadProtocalVersion, new Exception("error")); var content = commandMessage.GetContent<Customer>(); return DuplexMessage.CreateCallbackMessage(commandMessage, content); }
protected override DuplexMessage DoExecute(DuplexMessage commandMessage) { commandMessage.Header.MessageType = MessageType.Heartbeat; return commandMessage; }
public void SendToService(DuplexMessage msg) { //We get here when we receive a message from a client IUniversalDuplexCallbackContract ch = OperationContext.Current.GetCallbackChannel <IUniversalDuplexCallbackContract>(); string session = OperationContext.Current.Channel.SessionId; if (msg is ConnectMessage) { //lock (syncRoot) lock (clients) { if (!clients.ContainsKey(session)) // new client { System.Diagnostics.Debug.WriteLine("New client connected: "); System.Diagnostics.Debug.WriteLine(" " + (msg as ConnectMessage).NodeID); System.Diagnostics.Debug.WriteLine(" " + (msg as ConnectMessage).TimeSeriesDataRootUrl); System.Diagnostics.Debug.WriteLine(" " + (msg as ConnectMessage).CurrentDisplayType.ToString()); Client client = new Client(); client.Channel = ch; client.NodeID = (msg as ConnectMessage).NodeID; client.TimeSeriesDataRootUrl = (msg as ConnectMessage).TimeSeriesDataRootUrl; client.RealTimeStatisticRootUrl = (msg as ConnectMessage).RealTimeStatisticRootUrl; client.DataPointID = (msg as ConnectMessage).DataPointID; client.CurrentDisplayType = (msg as ConnectMessage).CurrentDisplayType; clients.Add(session, client); OperationContext.Current.Channel.Closing += Channel_Closing; OperationContext.Current.Channel.Faulted += Channel_Faulted; OnConnected(session); } else //existing connected client. Just trying to update its settings. { clients[session] = new Client() { Channel = ch, NodeID = (msg as ConnectMessage).NodeID, DataPointID = (msg as ConnectMessage).DataPointID, TimeSeriesDataRootUrl = (msg as ConnectMessage).TimeSeriesDataRootUrl, RealTimeStatisticRootUrl = (msg as ConnectMessage).RealTimeStatisticRootUrl, CurrentDisplayType = (msg as ConnectMessage).CurrentDisplayType }; } } Client currentClient = clients[session]; // Initially when client is connected, we will send them data only if client is connected from home page of the openPDCManager. if (currentClient.CurrentDisplayType == DisplayType.Home) { PushMessageToClient(session, new LivePhasorDataMessage() { //PmuDistributionList = CommonFunctions.GetPmuDistribution(), DeviceDistributionList = CommonFunctions.GetVendorDeviceDistribution(null, currentClient.NodeID), InterconnectionStatusList = CommonFunctions.GetInterconnectionStatus(null, currentClient.NodeID) } ); PushMessageToClient(session, new TimeSeriesDataMessage() { TimeSeriesData = CommonFunctions.GetTimeSeriesData(currentClient.TimeSeriesDataRootUrl + "/timeseriesdata/read/historic/" + currentClient.DataPointID.ToString() + "/*-30S/*/XML") //TimeSeriesData = CommonFunctions.GetTimeSeriesData(currentClient.TimeSeriesDataRootUrl + "current/" + currentClient.DataPointID.ToString() + "/XML") } ); } else if (currentClient.CurrentDisplayType == DisplayType.ServiceClient) { if (serviceClientList.ContainsKey(currentClient.NodeID)) { System.Diagnostics.Debug.WriteLine("Sending Cached Status to Client Connected on System Monitor Page."); PushMessageToClient(session, new ServiceUpdateMessage() { ServiceUpdateType = UpdateType.Information, ServiceUpdate = serviceClientList[currentClient.NodeID].CachedStatus }); } else { System.Diagnostics.Debug.WriteLine("Sending Empty Message to Client Connected on System Monitor Page."); PushMessageToClient(session, new ServiceUpdateMessage()); } } else if (currentClient.CurrentDisplayType == DisplayType.DeviceMeasurements) { KeyValuePair <int, int> minMaxPointID = minMaxPointIDsPerNode[currentClient.NodeID]; if (!string.IsNullOrEmpty(currentClient.TimeSeriesDataRootUrl)) // if TimeSeriesDataRootUrl is defined for the node, then only try to send data to client upon connection. { System.Diagnostics.Debug.WriteLine("Sending Measurements to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage() { TimeTaggedMeasurements = CommonFunctions.GetTimeTaggedMeasurements(currentClient.TimeSeriesDataRootUrl + "/timeseriesdata/read/current/" + minMaxPointID.Key.ToString() + "-" + minMaxPointID.Value.ToString() + "/XML") }); } else { System.Diagnostics.Debug.WriteLine("Sending Empty Message to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage()); } } else if (currentClient.CurrentDisplayType == DisplayType.RealTimeStatistics) { KeyValuePair <int, int> minMaxPointID = minMaxPointIDsPerNode[currentClient.NodeID]; if (!string.IsNullOrEmpty(currentClient.TimeSeriesDataRootUrl)) // if TimeSeriesDataRootUrl is defined for the node, then only try to send data to client upon connection. { System.Diagnostics.Debug.WriteLine("Sending Measurements to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage() { TimeTaggedMeasurements = CommonFunctions.GetStatisticMeasurements(currentClient.RealTimeStatisticRootUrl + "/timeseriesdata/read/current/" + minMaxPointID.Key.ToString() + "-" + minMaxPointID.Value.ToString() + "/XML", currentClient.NodeID) }); } else { System.Diagnostics.Debug.WriteLine("Sending Empty Message to Client Connected on Device Measurements Page."); PushMessageToClient(session, new TimeTaggedDataMessage()); } } } else if (msg is ServiceRequestMessage) { SendServiceRequest(clients[session].NodeID, (msg as ServiceRequestMessage).Request); } else if (msg is DisconnectMessage) //If it's a Disconnect message, treat as disconnection { ClientDisconnected(session); } else //if (!(msg is ConnectMessage)) //Otherwise, if it's a payload-carrying message (and not just a simple "Connect"), process it { OnMessage(session, msg); } }
public override void MessageReceived(INextFilter nextFilter, IoSession session, object message) { using (var scope = ObjectHost.Host.BeginLifetimeScope()) { var commandMessage = message as DuplexMessage; if (commandMessage != null) { if (commandMessage.Header.CommandCode == CommandCode.Authentication) { var school = metaRepository .GetAllSchools() .ByIdentifier(commandMessage.Header.Identifier); if (school != null && school.UniqueToken.Equals( commandMessage.GetContent <AuthInfo>().Mac, StringComparison.OrdinalIgnoreCase)) { session.SetAttributeIfAbsent(KeyName.SESSION_IDENTIFIER, commandMessage.Header.Identifier); identifierManager.SetSessonIdentifier(commandMessage.Header.Identifier, session); nextFilter.FilterWrite(session, new DefaultWriteRequest( DuplexMessage.CreateCallbackMessage(commandMessage))); } else { nextFilter.FilterWrite(session, new DefaultWriteRequest( DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.AuthenticationFailed))); } } else if ( commandMessage.Header.CommandCode == CommandCode.Register || commandMessage.Header.CommandCode == CommandCode.Heartbeat) { nextFilter.MessageReceived(session, message); } else { if (!session.ContainsAttribute(KeyName.SESSION_IDENTIFIER)) { nextFilter.FilterWrite(session, new DefaultWriteRequest( DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.UnauthorizedCommand))); } else { var identifier = session.GetAttribute <string>(KeyName.SESSION_IDENTIFIER); if (identifier.Equals(commandMessage.Header.Identifier)) { nextFilter.MessageReceived(session, message); } else { nextFilter.FilterWrite(session, new DefaultWriteRequest( DuplexMessage.CreateAckMessage(commandMessage, ErrorCode.UnauthorizedCommand))); } } } } else { nextFilter.FilterWrite(session, new DefaultWriteRequest( DuplexMessage.CreateAckMessage( Guid.NewGuid().ToByteArray().ToBase64(), MessageVersion.V1, CommandCode.UnAssigned, ErrorCode.IllegalCommandRequest))); } } }
void BlockCommand_Callback(object sender, CommandEventArgs <DuplexMessage> e) { result = e.Message; semaphore.Release(); }