public FindNextSystemCommand(ICommunicator communicator, INavigator navigator, IGalaxyMap galaxyMap, FindNextSystemPhrases phrases) { _communicator = communicator; _navigator = navigator; _galaxyMap = galaxyMap; _phraseBook = PhraseBook.Ingest(phrases.Phrases); }
/// <summary> /// Adds a TCPCommunicator object to _communicators list. /// </summary> /// <param name="communicator">TCPCommunicator to be added</param> private void AddToCommunicators(ICommunicator communicator) { lock (_communicators) { _communicators[communicator.ComminicatorId] = communicator; } }
public AbstractLockstep(float deltaTime, ICommunicator communicator, IPhysicsManagerBase physicsManager, int syncWindow, int panicWindow, int rollbackWindow, TrueSyncEventCallback OnGameStarted, TrueSyncEventCallback OnGamePaused, TrueSyncEventCallback OnGameUnPaused, TrueSyncEventCallback OnGameEnded, TrueSyncPlayerDisconnectionCallback OnPlayerDisconnection, TrueSyncUpdateCallback OnStepUpdate, TrueSyncInputDataProvider InputDataProvider) { AbstractLockstep.instance = this; this.deltaTime = deltaTime; this.syncWindow = syncWindow; this.panicWindow = panicWindow; this.rollbackWindow = rollbackWindow; this.totalWindow = syncWindow + rollbackWindow; this.StepUpdate = OnStepUpdate; this.OnGameStarted = OnGameStarted; this.OnGamePaused = OnGamePaused; this.OnGameUnPaused = OnGameUnPaused; this.OnGameEnded = OnGameEnded; this.OnPlayerDisconnection = OnPlayerDisconnection; this.InputDataProvider = InputDataProvider; this.ticks = 0; this.players = new Dictionary <byte, TSPlayer>(4); this.activePlayers = new List <TSPlayer>(4); this.auxPlayersSyncedData = new List <SyncedData>(4); this.auxPlayersInputData = new List <InputDataBase>(4); this.communicator = communicator; this.physicsManager = physicsManager; this.compoundStats = new CompoundStats(); this.bufferSyncedInfo = new GenericBufferWindow <SyncedInfo>(3); this.checksumOk = true; this.simulationState = AbstractLockstep.SimulationState.NOT_STARTED; this.bodiesToDestroy = new Dictionary <int, List <IBody> >(); this.playersDisconnect = new Dictionary <int, List <byte> >(); this.ReplayMode = ReplayRecord.replayMode; }
public void ProcessMessage(BotUser user, ICommunicator communicator, string message) { try { var command = _commandFactory.GetCommand(message, user); if (command.HasValue) { ProcessCommandMessage(user, communicator, command.Value); } else { ProcessSimpleMessage(user, communicator, message); } } catch (UnauthorizedException exception) { communicator.SendMessage("У вас нет прав для выполнения этой команды"); _logger.Error(exception); } catch (InvalidOperationException e) { communicator.SendMessage(e.Message); _logger.Error(e); } catch (Exception e) { _logger.Error(e); } }
public void TestCreateCommunicator() { ICommunicator communicatorInterface = Factory.CreateCommunicator(DICT, API_KEY_ID, SECRET_API_KEY); Assert.IsInstanceOf <Communicator>(communicatorInterface); Communicator communicator = (Communicator)communicatorInterface; Assert.AreSame(DefaultMarshaller.Instance, communicator.Marshaller); IConnection connection = communicator.Connection; Assert.True(connection is DefaultConnection); IAuthenticator authenticator = communicator.Authenticator; Assert.True(authenticator is DefaultAuthenticator); Assert.AreEqual(AuthorizationType.V1HMAC, GetInstanceField(typeof(DefaultAuthenticator), authenticator, "_authorizationType")); Assert.AreEqual(API_KEY_ID, GetInstanceField(typeof(DefaultAuthenticator), authenticator, "_apiKeyId")); Assert.AreEqual(SECRET_API_KEY, GetInstanceField(typeof(DefaultAuthenticator), authenticator, "_secretApiKey")); MetaDataProvider metaDataProvider = communicator.MetaDataProvider; Assert.AreEqual(typeof(MetaDataProvider), metaDataProvider.GetType()); IEnumerable <RequestHeader> requestHeaders = metaDataProvider.ServerMetaDataHeaders; Assert.AreEqual(1, requestHeaders.Count()); RequestHeader requestHeader = requestHeaders.ElementAt(0); Assert.AreEqual("X-GCS-ServerMetaInfo", requestHeader.Name); }
/// <summary> /// Constructor /// </summary> /// <param name="Communicator">Communicator used to create the message</param> public EmailMessage(ICommunicator Communicator) : base(Communicator) { Attachments = new List <Attachment>(); EmbeddedResources = new List <LinkedResource>(); Priority = MailPriority.Normal; }
/// <summary> /// Creates a new ReceiverCommunicator object. /// </summary> /// <param name="communicator">The communicator</param> public ConnectedCommunicator(ICommunicator communicator) { IsSuspended = false; SuspendExpireDate = DateTime.MinValue; ProcessingMessageExpireDate = DateTime.MaxValue; Communicator = communicator; }
static bool SendFile(ICommunicator service, string file) { long blockSize = 1024;//can be bigger try { FileStream fs = File.Open(file, FileMode.Open, FileAccess.Read);//open local string filename = Path.GetFileName(file); service.OpenFileForWrite(filename);//open remote int bytesRead = 0; while (true) { long remainder = (int)(fs.Length - fs.Position); if (remainder == 0) break; long size = Math.Min(blockSize, remainder); byte[] block = new byte[size]; bytesRead = fs.Read(block, 0, block.Length); service.WriteFileBlock(block);//write remote } fs.Close(); service.CloseFile();//close remote return true; } catch (Exception ex) { Console.Write("\n can't open {0} for writing - {1}", file, ex.Message); return false; } }
/// <summary> /// This method is called by ProcessDataTransferMessage when a message must be sent to an adjacent server of this server. /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="senderCommunicator">Sender communicator</param> /// <param name="message">Message</param> private void SentToAdjacentServer(NGRIDRemoteApplication senderApplication, ICommunicator senderCommunicator, NGRIDDataTransferMessage message) { /* On one of these conditions, message is stored: * - TransmitRule = StoreAndForward * - (TransmitRule = StoreOnSource OR StoreOnEndPoints) AND (This server is the source server) */ if (message.TransmitRule == MessageTransmitRules.StoreAndForward || message.TransmitRule == MessageTransmitRules.NonPersistent) { EnqueueMessage( senderApplication, senderCommunicator, _serverGraph.AdjacentServers[message.DestinationServerName], message ); } /* Else, message is not stored in these conditions: * - TransmitRule = DirectlySend OR StoreOnDestination (this server can not be destination because message is being sent to another server right now) * - All Other conditions */ else { SendMessageDirectly( senderApplication, senderCommunicator, _serverGraph.AdjacentServers[message.DestinationServerName], message ); } }
public GameLoadCommand(ICommunicator communicator, IPlayerStatus playerStatus, GameLoadPhrases phrases) { _communicator = communicator; _playerStatus = playerStatus; _genericPhrases = PhraseBook.Ingest(phrases.Generic); }
protected ApiResource(ICommunicator communicator, string clientMetaInfo, IDictionary <string, string> pathContext) { _parent = null; _pathContext = pathContext; _communicator = communicator ?? throw new ArgumentException("communicator is required"); _clientMetaInfo = clientMetaInfo; }
public void ProcessMessage(string message, ICommunicator communicator) { DoAction(message, new List <ICommunicator>() { communicator }); }
protected ApiResource(ApiResource parent, IDictionary <string, string> pathContext) { _parent = parent ?? throw new ArgumentException("parent is required"); _pathContext = pathContext; _communicator = parent._communicator; _clientMetaInfo = parent._clientMetaInfo; }
public MessageSender(ICommunicator communicator, ILogger <MessageSender> logger, IApplicationLifetime applicationLifetime) { _communicator = communicator; _logger = logger; _cancellationToken = applicationLifetime.ApplicationStopping; _messageTypes = new List <ISender>(); }
public Bootstrapper(ICommunicator communicator, IContestEntry contestEntry) { this.communicator = communicator; this.contestEntry = contestEntry; ScanWholeContestantAssembly = false; }
public PollModule(ISettingsService settings, ICommunicator communicator, IFrameworkReflector frameworkReflector, HelpBuilder helpBuilder) { _settings = settings; _communicator = communicator; _frameworkReflector = frameworkReflector; _helpBuilder = helpBuilder; }
public static async ValueTask <ATResult <OkResult> > SendSmsAsync( this ICommunicator <string> comm, ResponseFormat responseFormat, PhoneNumber phoneNumber, string message, CancellationToken cancellationToken = default) { if (message.Length > 160) { throw new ArgumentOutOfRangeException($"Message exceeded maximum length of 160"); } await comm.Write($"AT+CMGS=\"{phoneNumber}\"\r", cancellationToken); Thread.Sleep(100); var response = await comm.ReadSingleMessageAsync((byte)'>', cancellationToken); await comm.Write($"{message}\r{0x1A}"); Thread.Sleep(2000); response = await comm.ReadSingleMessageAsync((byte)'\r', cancellationToken); var result = OkParser.TryParse(response, responseFormat, out _); return(default);
private ICommunicator CreateCommunicator(CommunicatorType type, string user, string env, string application, bool isFromApplicatonProcess = false) { var key = string.Format(KEY_FORMAT, user, env, application, isFromApplicatonProcess ? "_App" : ""); ICommunicator comm = null; switch (type) { case CommunicatorType.MappedFileType: comm = new MemoryMappedFileCommunicator(user, env, application, isFromApplicatonProcess); break; default: break; } if (comm != null) { lock (lockObj) { commList.Add(key, comm); } comm.StartReader(); } //logger.DebugFormat("CreateCommunicator, Key = {0}", key); return(comm); }
/// <summary> /// Add a generic peer to the recording /// </summary> /// <param name="commLink">ICommunicator to record</param> /// <param name="dumpToFile">True if packets for this peer should be written to individual file</param> /// <param name="dumpFileExtension">Extension for the individual dump file</param> public bool AddPeer(ICommunicator commLink, bool dumpToFile, string dumpFileExtension = ".dump") { if (CurrentState == State.Recording) { return(false); } if (!socketListeners.ContainsKey(commLink.ID)) { commLink.DataReadySyncEvent += DataReadyEventCallback; commLink.DataRateEvent += OnDataRate; RecPeerInfo p = new RecPeerInfo() { ID = commLink.ID, DumpToFile = dumpToFile, DumpFileExtension = dumpFileExtension, commsLink = commLink, IP = commLink.CommsUri.IP, Port = commLink.CommsUri.LocalPort }; bool doneRight = socketListeners.TryAdd(commLink.ID, p) && _dataRate.TryAdd(commLink.ID, 0); return(doneRight); } return(false); }
/// <summary> /// Raises CommunicatorConnected event. /// </summary> /// <param name="communicator">Communicator</param> protected void OnCommunicatorConnected(ICommunicator communicator) { if (CommunicatorConnected != null) { CommunicatorConnected(this, new CommunicatorConnectedEventArgs {Communicator = communicator}); } }
public FSDTargetCommand(IDetourPlanner detourPlanner, INavigator navigator, ICommunicator communicator, ILogger logger) { _detourPlanner = detourPlanner; _navigator = navigator; _communicator = communicator; _logger = logger; }
public Do Run( string input, AlchemyController controller, ICommunicator communicator ) { string elementname = input.TrimStart( '*' ); if( controller.ElementExists( elementname ) ) controller.ForeachNonterminalElement( ( e ) => controller.ReportChangedRule( new Rule( new[] { elementname, e.Name } ) ) ); return Do.AnotherRule; }
/// <summary> /// Processes UpdateServerGraphMessage. /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="controlMessage">The message to be processed</param> /// <param name="controllerMessage">NGRIDControllerMessage object that includes controlMessage</param> private void ProcessUpdateServerGraphMessage(ICommunicator communicator, UpdateServerGraphMessage controlMessage, NGRIDControllerMessage controllerMessage) { try { var newSettings = new NGRIDSettings(Path.Combine(GeneralHelper.GetCurrentDirectory(), "NGRIDSettings.xml")); //var newDesignSettings = new NGRIDDesignSettings(Path.Combine(GeneralHelper.GetCurrentDirectory(), "NGRIDSettings.design.xml")); //Clear existing server lists newSettings.Servers.Clear(); //newDesignSettings.Servers.Clear(); //Add servers from UpdateServerGraphMessage newSettings.ThisServerName = controlMessage.ServerGraph.ThisServerName; foreach (var server in controlMessage.ServerGraph.Servers) { //Settings newSettings.Servers.Add( new ServerInfoItem { Name = server.Name, IpAddress = server.IpAddress, Port = server.Port, Adjacents = server.Adjacents }); /*Design settings * newDesignSettings.Servers.Add( * new ServerDesignItem * { * Name = server.Name, * Location = server.Location * });*/ } //Save settings newSettings.SaveToXml(); //newDesignSettings.SaveToXml(); } catch (Exception ex) { //Send fail message ReplyMessageToCommunicator( communicator, new OperationResultMessage { Success = false, ResultMessage = ex.Message }, controllerMessage ); return; } //Send success message ReplyMessageToCommunicator( communicator, new OperationResultMessage { Success = true, ResultMessage = "Success" }, controllerMessage ); }
/// <summary> /// Processes GetApplicationListMessage. /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="controllerMessage">MDSControllerMessage object that includes controlMessage</param> private void ProcessGetApplicationListMessage(ICommunicator communicator, MDSControllerMessage controllerMessage) { //Get all client applications var applicationList = OrganizationLayer.GetClientApplications(); //Create ClientApplicationInfo array var clientApplications = new GetApplicationListResponseMessage.ClientApplicationInfo[applicationList.Length]; for (var i = 0; i < applicationList.Length; i++) { clientApplications[i] = new GetApplicationListResponseMessage.ClientApplicationInfo { Name = applicationList[i].Name, CommunicatorCount = applicationList[i].ConnectedCommunicatorCount }; } //Send response message ReplyMessageToCommunicator( communicator, new GetApplicationListResponseMessage { ClientApplications = clientApplications }, controllerMessage ); }
public LocalEndPoint(ICommunicator communicator) { _communicator = communicator; _communicator.RegisterReceiver(this); _root = new RootResource(); AddResource(new DiscoveryResource(_root)); }
public DeviceDetailPageModel(ICommunicator communicator, IEventAggregator eventAggregator) { _communicator = communicator; _eventAggregator = eventAggregator; SaveDeviceCommand = new DelegateCommand <object, object>(OnSaveDevice); DeleteDeviceCommand = new DelegateCommand <object, object>(OnDeleteDevice); }
protected ObjectOverviewPageModelBase(ICommunicator communicator, IEventAggregator eventAggregator) { _communicator = communicator; _eventAggregator = eventAggregator; NewObjectCommand = new DelegateCommand <object, object>(OnNewObjectAsync); NavigateToObjectCommand = new DelegateCommand <object, object>(OnNavigateToObjectAsync); }
/// <summary> /// Initializes the environment, configures it and initialized the Academy. /// </summary> void InitializeEnvironment() { EnableAutomaticStepping(); var floatProperties = new FloatPropertiesChannel(); FloatProperties = floatProperties; // Try to launch the communicator by using the arguments passed at launch var port = ReadPortFromArgs(); if (port > 0) { Communicator = new RpcCommunicator( new CommunicatorInitParameters { port = port } ); } if (Communicator != null) { Communicator.RegisterSideChannel(new EngineConfigurationChannel()); Communicator.RegisterSideChannel(floatProperties); // We try to exchange the first message with Python. If this fails, it means // no Python Process is ready to train the environment. In this case, the //environment must use Inference. try { var unityRlInitParameters = Communicator.Initialize( new CommunicatorInitParameters { version = k_ApiVersion, name = "AcademySingleton", }); UnityEngine.Random.InitState(unityRlInitParameters.seed); } catch { Debug.Log($"" + $"Couldn't connect to trainer on port {port} using API version {k_ApiVersion}. " + "Will perform inference instead." ); Communicator = null; } if (Communicator != null) { Communicator.QuitCommandReceived += OnQuitCommandReceived; Communicator.ResetCommandReceived += OnResetCommand; } } // If a communicator is enabled/provided, then we assume we are in // training mode. In the absence of a communicator, we assume we are // in inference mode. ResetActions(); }
public static async ValueTask <ATResult <PinStatusResult> > GetPinStatusAsync( this ICommunicator <string> comm, ResponseFormat responseFormat, CancellationToken cancellationToken = default) { await comm.Write($"AT+CPIN?\r", cancellationToken); var message = await comm.ReadSingleMessageAsync(Constants.BYTE_LF, cancellationToken); if (PinStatusParser.TryParse(message, responseFormat, out ATResult <PinStatusResult> pinResult)) { message = await comm.ReadSingleMessageAsync(Constants.BYTE_LF, cancellationToken); if (OkParser.TryParse(message, responseFormat, out ATResult <OkResult> _)) { return(pinResult); } else if (ErrorParser.TryParse(message, responseFormat, out ATResult <ErrorResult> errorResult)) { return(ATResult.Error <PinStatusResult>(errorResult.ErrorMessage)); } } else if (ErrorParser.TryParse(message, responseFormat, out ATResult <ErrorResult> errorResult)) { return(ATResult.Error <PinStatusResult>(errorResult.ErrorMessage)); } return(ATResult.Error <PinStatusResult>(Constants.PARSING_FAILED)); }
void _HandleConnectionBroken(ICommunicator ptr, string broken_info) { BrokenInfo info = new BrokenInfo(); info.Commer = ptr; info.Info = broken_info; lock (m_BrokenClient) m_BrokenClient.Add(info); //bool isclient = false; //int count = 0; //lock (m_ClientCommunicators) //{ // isclient = m_ClientCommunicators.Remove(id); // count = m_ClientCommunicators.Count; //} //lock (m_ClientActiveCounter) // m_ClientActiveCounter.Remove(id); //if (isclient) //{ // MSGTYPE command = new MSGTYPE(); // command.TK_CommandType = Constants.TK_CommandType.UNREGISTERCLIENT; // command.SetValue("ClientID", id); // command.SeqID = CommandProcessor.AllocateID(); // CommandProcessor.instance().DispatchCommand(command); // SendLog("客户端: " + clientinfo + " 已经从" + Name + "断开."); // SendLog(Name + "当前客户端的数量:" + count); //} }
/// <summary> /// Shut down the Academy. /// </summary> public void Dispose() { DisableAutomaticStepping(); // Signal to listeners that the academy is being destroyed now DestroyAction?.Invoke(); Communicator?.Dispose(); Communicator = null; if (m_ModelRunners != null) { foreach (var mr in m_ModelRunners) { mr.Dispose(); } m_ModelRunners = null; } // Clear out the actions so we're not keeping references to any old objects ResetActions(); // TODO - Pass worker ID or some other identifier, // so that multiple envs won't overwrite each others stats. TimerStack.Instance.SaveJsonTimers(); FloatProperties = null; m_Initialized = false; // Reset the Lazy instance s_Lazy = new Lazy <Academy>(() => new Academy()); }
public static T MultiplyAll <T>(ICommunicator comm, T value) where T : ICloneable, SettableToProduct <T> { string key = StringUtil.TypeToString(typeof(T)); TimingInfo timingInfo; lock (MultiplyAllTimingInfos) { if (!MultiplyAllTimingInfos.TryGetValue(key, out timingInfo)) { timingInfo = new TimingInfo(); MultiplyAllTimingInfos.Add(key, timingInfo); } } timingInfo.watch.Start(); var reduced = comm.Allreduce(value, (a, b) => { T result = (T)a.Clone(); result.SetToProduct(a, b); return(result); }); timingInfo.watch.Stop(); timingInfo.ItemsTransmitted++; return(reduced); }
/// <summary> /// Constructor /// </summary> /// <param name="Communicator">Communicator used to create the message</param> public EmailMessage(ICommunicator Communicator) : base(Communicator) { Attachments = new List<Attachment>(); EmbeddedResources = new List<LinkedResource>(); Priority = MailPriority.Normal; }
public void Send(ICommunicator communicator) { //Kontakt holen (public Key des Empfaengers) //Message zu Xml serialisieren //Xml verschluesseln //Verschluesseltes Xml verschicken throw new NotImplementedException(); }
public void Recieve(ICommunicator communicator) { //Nach neuen Nachrichten suchen //Nachrichten herunterladen //Nachrichten entschluesseln //Nachrichten zurückliefern throw new NotImplementedException(); }
public async Task Start(ICommunicator communicator) { this.communicator = communicator; await OnStart(); Task.Factory.StartNew(async () => { while (true) { var message = await communicator.GetNextMessage(); await OnMessageReceived(message.Sender, message.Content); } }); }
public SafeHouseUserControl(string baseUri, SafeHouseNode node, ICommunicator communicator) { InitializeComponent(); Loaded += new RoutedEventHandler(SafeHouseUserControl_Loaded); _safeHouseNode = node; _baseUri = baseUri; _communicator = communicator; if (_safeHouseIcon == null) { string uri = String.Concat(_baseUri, "Content/", "images/", "safehouse.png"); _safeHouseIcon = new BitmapImage(new Uri(uri)); } }
public ZombiePackUserControl(string baseUri, Node node, ICommunicator communicator) { InitializeComponent(); Loaded += new RoutedEventHandler(HotZoneUserControl_Loaded); _hotZone = node; _baseUri = baseUri; _communicator = communicator; if (_zombiePackIcon == null) { string uri = String.Concat(_baseUri, "Content/", "images/", "zombie.png"); _zombiePackIcon = new BitmapImage(new Uri(uri)); } }
public UserNodeUserControl(string baseUri, UserNode userNode, ICommunicator communicator) { InitializeComponent(); _baseUri = baseUri; _userNode = userNode; _communicator = communicator; Loaded += new RoutedEventHandler(UserNodeUserControl_Loaded); if (_moveIcon == null) { string uri = String.Concat(_baseUri, "Content/", "images/", "move.png"); _moveIcon = new BitmapImage(new Uri(uri)); } }
public HotZoneUserControl(string baseUri, HotZoneNode node, ICommunicator communicator) { InitializeComponent(); Loaded += new RoutedEventHandler(HotZoneUserControl_Loaded); _hotZone = node; _baseUri = baseUri; _communicator = communicator; if (_hotZoneIcon == null) { string uri = String.Concat(_baseUri, "Content/", "images/", "hotzone.png"); _hotZoneIcon = new BitmapImage(new Uri(uri)); } if (_clearedHotZoneIcon == null) { string uri = String.Concat(_baseUri, "Content/", "images/", "information.png"); _clearedHotZoneIcon = new BitmapImage(new Uri(uri)); } }
public Do Run( string input, AlchemyController controller, ICommunicator communicator ) { var splitinput = input.TrimStart( ' ', '#' ).Split( ':' ); if( splitinput.Length < 2 ) return Do.AnotherRule; var ingredients = splitinput[0].Split( ',' ); foreach( var ingredient in ingredients ) { if( !controller.ElementExists( ingredient ) ) { communicator.Display( "Bad data, element named '" + ingredient + "' isnt in list of known elements. If this isnt a typo, please add element using '>element', or, if possible, add rule that creates element" ); return Do.AnotherRule; } } var rule = new Rule( ingredients ); rule.SetResult( splitinput[1] ); controller.ReportChangedRule( rule, true ); return Do.AnotherRule; }
/// <summary> /// Sends message directly to application (not stores) and waits ACK. /// This method adds message to queue by MDSPersistentRemoteApplicationBase.AddMessageToHeadOfQueue method /// and waits a signal/pulse from RemoteApplication_MessageReceived method to get ACK/Reject. /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="senderCommunicator">Sender communicator</param> /// <param name="destApplication">Destination application/server</param> /// <param name="message">Message</param> private void SendMessageDirectly(MDSRemoteApplication senderApplication, ICommunicator senderCommunicator, MDSPersistentRemoteApplicationBase destApplication, MDSDataTransferMessage message) { //Create a WaitingMessage to wait and get ACK/Reject message and add it to waiting messages var waitingMessage = new WaitingMessage(); lock (_waitingMessages) { _waitingMessages[message.MessageId] = waitingMessage; } try { //Add message to head of queue of remote application destApplication.AddMessageToHeadOfQueue(message); //Wait until thread is signalled by another thread to get response (Signalled by RemoteApplication_MessageReceived method) waitingMessage.WaitEvent.WaitOne((int) (_settings.MessageResponseTimeout*1.2)); //Evaluate response if (waitingMessage.ResponseMessage.Success) { SendOperationResultMessage(senderApplication, senderCommunicator, message, true, "Success."); } else { SendOperationResultMessage(senderApplication, senderCommunicator, message, false, "Message is not acknowledged. Reason: " + waitingMessage.ResponseMessage.ResultText); } } finally { //Remove message from waiting messages lock (_waitingMessages) { _waitingMessages.Remove(message.MessageId); } } }
/// <summary> /// This method is called by ProcessDataTransferMessage when a message must be sent to a server /// that is not an adjacent of this server. Message is forwarded to next server. /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="senderCommunicator">Sender communicator</param> /// <param name="message">Message</param> private void SendToNextServer(MDSRemoteApplication senderApplication, ICommunicator senderCommunicator, MDSDataTransferMessage message) { //If there is a path from this server to destination server... if (_serverGraph.ThisServerNode.BestPathsToServers.ContainsKey(message.DestinationServerName)) { //Find best path to destination server var bestPath = _serverGraph.ThisServerNode.BestPathsToServers[message.DestinationServerName]; //If path is regular (a path must consist of 2 nodes at least)... if (bestPath.Count > 1) { //Next server var nextServerName = bestPath[1].Name; /* On one of these conditions, message is stored: * - TransmitRule = StoreAndForward * - (TransmitRule = StoreOnSource OR StoreOnEndPoints) AND (This server is the source server) */ if (message.TransmitRule == MessageTransmitRules.StoreAndForward || message.TransmitRule == MessageTransmitRules.NonPersistent) { EnqueueMessage( senderApplication, senderCommunicator, _serverGraph.AdjacentServers[nextServerName], message ); } /* Else, message is not stored in these conditions: * - TransmitRule = DirectlySend OR StoreOnDestination (this server can not be destination because message is being sent to another server right now) * - All Other conditions */ else { SendMessageDirectly( senderApplication, senderCommunicator, _serverGraph.AdjacentServers[nextServerName], message ); } } //Server graph may be wrong (this is just for checking case, normally this situation must not become) else { SendOperationResultMessage(senderApplication, senderCommunicator, message, false, "Server graph is wrong."); } } //No path from this server to destination server else { SendOperationResultMessage(senderApplication, senderCommunicator, message, false, "There is no path from this server to destination."); } }
/// <summary> /// This method is called by ProcessDataTransferMessage when a message must be sent to an adjacent server of this server. /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="senderCommunicator">Sender communicator</param> /// <param name="message">Message</param> private void SentToAdjacentServer(MDSRemoteApplication senderApplication, ICommunicator senderCommunicator, MDSDataTransferMessage message) { /* On one of these conditions, message is stored: * - TransmitRule = StoreAndForward * - (TransmitRule = StoreOnSource OR StoreOnEndPoints) AND (This server is the source server) */ if (message.TransmitRule == MessageTransmitRules.StoreAndForward || message.TransmitRule == MessageTransmitRules.NonPersistent) { EnqueueMessage( senderApplication, senderCommunicator, _serverGraph.AdjacentServers[message.DestinationServerName], message ); } /* Else, message is not stored in these conditions: * - TransmitRule = DirectlySend OR StoreOnDestination (this server can not be destination because message is being sent to another server right now) * - All Other conditions */ else { SendMessageDirectly( senderApplication, senderCommunicator, _serverGraph.AdjacentServers[message.DestinationServerName], message ); } }
/// <summary> /// This method is called by ProcessDataTransferMessage when a message must be sent to a aclient application /// that is running on this server. /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="senderCommunicator">Sender communicator</param> /// <param name="message">Message</param> private void SentToClientApplication(MDSRemoteApplication senderApplication, ICommunicator senderCommunicator, MDSDataTransferMessage message) { MDSClientApplication destinationApplication = null; //If application exists on this server, get it lock (_clientApplicationList.Applications) { if (_clientApplicationList.Applications.ContainsKey(message.DestinationApplicationName)) { destinationApplication = _clientApplicationList.Applications[message.DestinationApplicationName]; } } //If application doesn't exist on this server... if (destinationApplication == null) { SendOperationResultMessage(senderApplication, senderCommunicator, message, false, "Application does not exists on this server (" + _settings.ThisServerName + ")."); return; } //Send message according TransmitRule switch (message.TransmitRule) { case MessageTransmitRules.DirectlySend: SendMessageDirectly( senderApplication, senderCommunicator, destinationApplication, message ); break; default: // case MessageTransmitRules.StoreAndForward: // case MessageTransmitRules.NonPersistent: EnqueueMessage( senderApplication, senderCommunicator, destinationApplication, message ); break; } }
/// <summary> /// Checks a MDSDataTransferMessage and fills it's empty fields by default values. /// </summary> /// <param name="dataTransferMessage">Message</param> /// <param name="senderApplication">Sender application</param> /// <param name="communicator">Sender communicator of application</param> private void FillEmptyMessageFields(MDSDataTransferMessage dataTransferMessage, MDSRemoteApplication senderApplication, ICommunicator communicator) { //Default SourceApplicationName: Name of the sender application. if (string.IsNullOrEmpty(dataTransferMessage.SourceApplicationName)) { dataTransferMessage.SourceApplicationName = senderApplication.Name; } //Default SourceServerName: Name of this server. if (string.IsNullOrEmpty(dataTransferMessage.SourceServerName)) { dataTransferMessage.SourceServerName = _settings.ThisServerName; } //Default DestinationApplicationName: Name of the sender application. if (string.IsNullOrEmpty(dataTransferMessage.DestinationApplicationName)) { dataTransferMessage.DestinationApplicationName = senderApplication.Name; } //Default DestinationServerName: Name of this server. if (string.IsNullOrEmpty(dataTransferMessage.DestinationServerName)) { dataTransferMessage.DestinationServerName = _settings.ThisServerName; } if (dataTransferMessage.SourceServerName == _settings.ThisServerName) { //Sender communicator id is being set. dataTransferMessage.SourceCommunicatorId = communicator.ComminicatorId; } }
/// <summary> /// This method is used to process a MDSDataTransferMessage that is gotten from a mds server or client application. /// Message is sent to destination or next server in one of these three conditions: /// - Destination server is this server and application exists on this server /// - Destination server is an adjacent server of this server /// - Destination server in server graph and there is a path from this server to destination server /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="senderCommunicator">Sender communicator</param> /// <param name="message">Message</param> private void ProcessDataTransferMessage(MDSRemoteApplication senderApplication, ICommunicator senderCommunicator, MDSDataTransferMessage message) { //Check for duplicate messages if (senderApplication.LastAcknowledgedMessageId == message.MessageId) { SendOperationResultMessage(senderApplication, senderCommunicator, message, true, "Duplicate message."); return; } try { AddThisServerToPassedServerList(message); FillEmptyMessageFields(message, senderApplication, senderCommunicator); _routingTable.ApplyRouting(message); //If Destination server is this server then deliver message to the destination application if (message.DestinationServerName.Equals(_settings.ThisServerName, StringComparison.OrdinalIgnoreCase)) { SentToClientApplication(senderApplication, senderCommunicator, message); } //Else, if destination server is an adjacent of this server (so they can communicate directly) else if (_serverGraph.AdjacentServers.ContainsKey(message.DestinationServerName)) { SentToAdjacentServer(senderApplication, senderCommunicator, message); } //Else, if destination server is not adjacent but in server graph (so, send message to next server) else if (_serverGraph.ServerNodes.ContainsKey(message.DestinationServerName)) { SendToNextServer(senderApplication, senderCommunicator, message); } else { //return error to sender SendOperationResultMessage(senderApplication, senderCommunicator, message, false, "Destination does not exists."); } } catch (Exception ex) { SendOperationResultMessage(senderApplication, senderCommunicator, message, false, ex.Message); } }
/// <summary> /// Process GetWaitingMessagesOfApplicationMessage /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="message"></param> /// <param name="controllerMessage">MDSControllerMessage object that includes controlMessage</param> private void ProcessGetWaitingMessagesOfApplicationMessage(ICommunicator communicator, GetWaitingMessagesOfApplicationMessage message, MDSControllerMessage controllerMessage) { var messageList = OrganizationLayer.GetWaitingMessagesOfApplication(message.ApplicationName); //Send response message //ReplyMessageToCommunicator(communicator, new GetWaitingMessagesOfApplicationResponseMessage() { Messages = messageList }, controllerMessage ); SendMessageToAllReceivers(new GetWaitingMessagesOfApplicationResponseMessage() { Messages = messageList }); }
/// <summary> /// Adds message to destination's send queue. /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="senderCommunicator">Sender communicator</param> /// <param name="destApplication">Destination application/server</param> /// <param name="message">Message</param> private static void EnqueueMessage(MDSRemoteApplication senderApplication, ICommunicator senderCommunicator, MDSPersistentRemoteApplicationBase destApplication, MDSDataTransferMessage message) { destApplication.EnqueueMessage(message); SendOperationResultMessage(senderApplication, senderCommunicator, message, true, "Success."); }
private void ProcessUpdateApplicationWebServicesMessage(ICommunicator communicator, UpdateApplicationWebServicesMessage message, MDSControllerMessage controllerMessage) { try { //Find application ApplicationInfoItem application = null; foreach (var applicationInfoItem in _settings.Applications) { if (applicationInfoItem.Name == message.ApplicationName) { application = applicationInfoItem; } } if (application == null) { //Send message ReplyMessageToCommunicator( communicator, new OperationResultMessage() { Success = false, ResultMessage = "No application found with name '" + message.ApplicationName + "'." }, controllerMessage ); return; } //Delete old service list application.CommunicationChannels.Clear(); //Add new services if (message.WebServices != null && message.WebServices.Length > 0) { foreach (var webServiceInfo in message.WebServices) { var channelInfo = new ApplicationInfoItem.CommunicationChannelInfoItem { CommunicationType = "WebService" }; channelInfo.CommunicationSettings["Url"] = webServiceInfo.Url; application.CommunicationChannels.Add(channelInfo); } } try { //Save settings _settings.SaveToXml(); } catch (Exception ex) { Logger.Error(ex.Message, ex); ReplyMessageToCommunicator( communicator, new OperationResultMessage() { Success = false, ResultMessage = "Can not save XML configuration file (MDSSettings.xml)." }, controllerMessage ); return; } //Send success message ReplyMessageToCommunicator( communicator, new OperationResultMessage() { Success = true, ResultMessage = "Success." }, controllerMessage ); } catch (Exception ex) { Logger.Error(ex.Message, ex); ReplyMessageToCommunicator( communicator, new OperationResultMessage() { Success = false, ResultMessage = ex.Message }, controllerMessage ); return; } }
/// <summary> /// Sends a message to a spesific communicator as a reply to an incoming message. /// </summary> /// <param name="communicator">Communicator to send message</param> /// <param name="message">Message to send</param> /// <param name="incomingMessage">Incoming message which is being replied</param> private void ReplyMessageToCommunicator(ICommunicator communicator, ControlMessage message, MDSControllerMessage incomingMessage) { //Create MDSControllerMessage that includes serialized GetApplicationListResponseMessage message var outgoingMessage = new MDSControllerMessage { ControllerMessageTypeId = message.MessageTypeId, MessageData = MDSSerializationHelper.SerializeToByteArray(message), RepliedMessageId = incomingMessage.MessageId }; //Send message to communicator that sent to message SendMessage(outgoingMessage, communicator); }
private void ProcessGetApplicationWebServicesMessage(ICommunicator communicator, GetApplicationWebServicesMessage message, MDSControllerMessage controllerMessage) { try { //Find application ApplicationInfoItem application = null; foreach (var applicationInfoItem in _settings.Applications) { if(applicationInfoItem.Name == message.ApplicationName) { application = applicationInfoItem; } } if(application == null) { //Send message ReplyMessageToCommunicator( communicator, new GetApplicationWebServicesResponseMessage { WebServices = null, Success = false, ResultText = "No application found with name '" + message.ApplicationName + "'." }, controllerMessage ); return; } var webServiceList = new List<ApplicationWebServiceInfo>(); foreach (var channel in application.CommunicationChannels) { if ("WebService".Equals(channel.CommunicationType, StringComparison.OrdinalIgnoreCase)) { webServiceList.Add(new ApplicationWebServiceInfo {Url = channel.CommunicationSettings["Url"]}); } } //Send web service list ReplyMessageToCommunicator( communicator, new GetApplicationWebServicesResponseMessage { WebServices = webServiceList.ToArray(), Success = true, ResultText = "Success." }, controllerMessage ); } catch (Exception ex) { Logger.Error(ex.Message, ex); } }
/// <summary> /// Processes UpdateServerGraphMessage. /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="controlMessage">The message to be processed</param> /// <param name="controllerMessage">MDSControllerMessage object that includes controlMessage</param> private void ProcessUpdateServerGraphMessage(ICommunicator communicator, UpdateServerGraphMessage controlMessage, MDSControllerMessage controllerMessage) { try { var newSettings = new MDSSettings(Path.Combine(GeneralHelper.GetCurrentDirectory(), "MDSSettings.xml")); var newDesignSettings = new MDSDesignSettings(Path.Combine(GeneralHelper.GetCurrentDirectory(), "MDSSettings.design.xml")); //Clear existing server lists newSettings.Servers.Clear(); newDesignSettings.Servers.Clear(); //Add servers from UpdateServerGraphMessage newSettings.ThisServerName = controlMessage.ServerGraph.ThisServerName; foreach (var server in controlMessage.ServerGraph.Servers) { //Settings newSettings.Servers.Add( new ServerInfoItem { Name = server.Name, IpAddress = server.IpAddress, Port = server.Port, Adjacents = server.Adjacents }); //Design settings newDesignSettings.Servers.Add( new ServerDesignItem { Name = server.Name, Location = server.Location }); } //Save settings newSettings.SaveToXml(); newDesignSettings.SaveToXml(); } catch (Exception ex) { //Send fail message ReplyMessageToCommunicator( communicator, new OperationResultMessage {Success = false, ResultMessage = ex.Message}, controllerMessage ); return; } //Send success message ReplyMessageToCommunicator( communicator, new OperationResultMessage {Success = true, ResultMessage = "Success"}, controllerMessage ); }
/// <summary> /// Processes GetServerGraphMessage. /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="controllerMessage">MDSControllerMessage object that includes controlMessage</param> private void ProcessGetServerGraphMessage(ICommunicator communicator, MDSControllerMessage controllerMessage) { //Create response message var responseMessage = new GetServerGraphResponseMessage { ServerGraph = new ServerGraphInfo { ThisServerName = _settings.ThisServerName, Servers = new ServerGraphInfo.ServerOnGraph[_settings.Servers.Count] } }; //Fill server settings for (var i = 0; i < _settings.Servers.Count; i++) { responseMessage.ServerGraph.Servers[i] = new ServerGraphInfo.ServerOnGraph { Name = _settings.Servers[i].Name, IpAddress = _settings.Servers[i].IpAddress, Port = _settings.Servers[i].Port, Adjacents = _settings.Servers[i].Adjacents }; } //Fill server design settings for (var i = 0; i < responseMessage.ServerGraph.Servers.Length; i++) { foreach (var serverDesignItem in _designSettings.Servers) { if (responseMessage.ServerGraph.Servers[i].Name == serverDesignItem.Name) { responseMessage.ServerGraph.Servers[i].Location = serverDesignItem.Location; break; } } } //Send response message ReplyMessageToCommunicator( communicator, responseMessage, controllerMessage ); }
/// <summary> /// Processes RemoveApplicationMessage. /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="controlMessage">The message to be processed</param> /// <param name="controllerMessage">MDSControllerMessage object that includes controlMessage</param> private void ProcessRemoveApplicationMessage(ICommunicator communicator, RemoveApplicationMessage controlMessage, MDSControllerMessage controllerMessage) { try { var removedApplication = OrganizationLayer.RemoveApplication(controlMessage.ApplicationName); removedApplication.CommunicatorConnected -= ClientApplication_CommunicatorConnected; removedApplication.CommunicatorDisconnected -= ClientApplication_CommunicatorDisconnected; ReplyMessageToCommunicator( communicator, new RemoveApplicationResponseMessage { ApplicationName = controlMessage.ApplicationName, Removed = true, ResultMessage = "Success." }, controllerMessage ); SendMessageToAllReceivers( new ClientApplicationRemovedEventMessage { ApplicationName = removedApplication.Name }); } catch (Exception ex) { Logger.Warn(ex.Message, ex); ReplyMessageToCommunicator( communicator, new RemoveApplicationResponseMessage { ApplicationName = controlMessage.ApplicationName, Removed = false, ResultMessage = ex.Message }, controllerMessage ); } }
/// <summary> /// Processes GetApplicationListMessage. /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="controllerMessage">MDSControllerMessage object that includes controlMessage</param> private void ProcessGetApplicationListMessage(ICommunicator communicator, MDSControllerMessage controllerMessage) { //Get all client applications var applicationList = OrganizationLayer.GetClientApplications(); //Create ClientApplicationInfo array var clientApplications = new GetApplicationListResponseMessage.ClientApplicationInfo[applicationList.Length]; for (var i = 0; i < applicationList.Length; i++) { clientApplications[i] = new GetApplicationListResponseMessage.ClientApplicationInfo { Name = applicationList[i].Name, CommunicatorCount = applicationList[i].ConnectedCommunicatorCount, MessageCount = applicationList[i].GetWaitingMessages(0, applicationList[i].GetMaxWaitingMessageId() +1).Count }; } //Send response message ReplyMessageToCommunicator( communicator, new GetApplicationListResponseMessage { ClientApplications = clientApplications }, controllerMessage ); }
/// <summary> /// To send a MDSOperationResultMessage to remote application's spesific communicator. /// </summary> /// <param name="senderApplication">Sender application/server</param> /// <param name="communicator">Communicator to send message</param> /// <param name="repliedMessage">Replied Message</param> /// <param name="success">Operation result</param> /// <param name="resultText">Details</param> private static void SendOperationResultMessage(MDSRemoteApplication senderApplication, ICommunicator communicator, MDSDataTransferMessage repliedMessage, bool success, string resultText) { try { if (success) { //Save MessageId of acknowledged message to do not receive same message again senderApplication.LastAcknowledgedMessageId = repliedMessage.MessageId; } senderApplication.SendMessage(new MDSOperationResultMessage { RepliedMessageId = repliedMessage.MessageId, Success = success, ResultText = resultText }, communicator); } catch (Exception ex) { Logger.Warn(ex.Message, ex); } }
/// <summary> /// Sends a NGRIDOperationResultMessage message to a communicator. /// </summary> /// <param name="communicator">Communicator object</param> /// <param name="success">Operation result</param> /// <param name="resultText">Detailed result/error text</param> /// <param name="repliedMessageId">The message id of request message</param> private static void SendOperationResultMessage(ICommunicator communicator, bool success, string resultText, string repliedMessageId) { communicator.SendMessage( new NGRIDOperationResultMessage { Success = success, ResultText = resultText, RepliedMessageId = repliedMessageId }); }
/// <summary> /// This methods checks type of message (MessageTypeId) and calls appropriate method to process message. /// </summary> /// <param name="communicator">Communicator that sent message</param> /// <param name="controllerMessage">MDSControllerMessage object that includes controlMessage</param> /// <param name="controlMessage">The message to be processed</param> private void ProcessControllerMessage(ICommunicator communicator, MDSControllerMessage controllerMessage , ControlMessage controlMessage) { switch (controlMessage.MessageTypeId) { case ControlMessageFactory.MessageTypeIdGetApplicationListMessage: ProcessGetApplicationListMessage(communicator, controllerMessage); break; case ControlMessageFactory.MessageTypeIdGetWaitingMessagesOfApplicationMessage: ProcessGetWaitingMessagesOfApplicationMessage(communicator, controlMessage as GetWaitingMessagesOfApplicationMessage, controllerMessage); break; case ControlMessageFactory.MessageTypeIdAddNewApplicationMessage: ProcessAddNewApplicationMessage(controlMessage as AddNewApplicationMessage); break; case ControlMessageFactory.MessageTypeIdRemoveApplicationMessage: ProcessRemoveApplicationMessage(communicator, controlMessage as RemoveApplicationMessage, controllerMessage); break; case ControlMessageFactory.MessageTypeIdGetServerGraphMessage: ProcessGetServerGraphMessage(communicator, controllerMessage); break; case ControlMessageFactory.MessageTypeIdUpdateServerGraphMessage: ProcessUpdateServerGraphMessage(communicator, controlMessage as UpdateServerGraphMessage, controllerMessage); break; case ControlMessageFactory.MessageTypeIdGetApplicationWebServicesMessage: ProcessGetApplicationWebServicesMessage(communicator, controlMessage as GetApplicationWebServicesMessage, controllerMessage); break; case ControlMessageFactory.MessageTypeIdUpdateApplicationWebServicesMessage: ProcessUpdateApplicationWebServicesMessage(communicator, controlMessage as UpdateApplicationWebServicesMessage, controllerMessage); break; default: throw new MDSException("Undefined MessageTypeId for ControlMessage: " + controlMessage.MessageTypeId); } }