private void ProcessMessageInBuffer() { Console.WriteLine("Command received. Deserializing.."); // stop the timer m_rxTimeoutTimer.Change(Timeout.Infinite, Timeout.Infinite); // we've finished the packet TestCommand c = null; try { c = Serializer?.Deserialize(m_buffer); Console.WriteLine("done."); } catch (Exception ex) { Console.WriteLine($"Failed to deserialize: {ex.Message}"); } if (c != null) { CommandReceived?.Invoke(this, c); } m_buffer = null; m_header.Clear(); }
public void AddCommandListener <TR>(CommandReceived <TR> callback, IChannel channel) { IRTCallback rtCallback = new RTCallback <TR>(callback, result => { try { Command <TR> command = new Command <TR>(); UserInfo userInfo = new UserInfo(); command.UserInfo = userInfo; userInfo.ConnectionId = WeborbSerializationHelper.AsString(result, "connectionId"); userInfo.UserId = WeborbSerializationHelper.AsString(result, "userId"); command.Type = WeborbSerializationHelper.AsString(result, "type"); IAdaptingType data = WeborbSerializationHelper.AsAdaptingType(result, "data"); command.Data = (TR)data.adapt(typeof(TR)); callback(command); } catch (System.Exception e) { channel.ErrorHandler?.Invoke(RTErrorType.COMMAND, new BackendlessFault(e)); } }, fault => { channel.ErrorHandler?.Invoke(RTErrorType.COMMAND, fault); }); AddCommandListener(rtCallback); }
private async Task HandleCommand <TCommand>(CommandReceived <TCommand> commandHandler, IConsumeContext <TCommand> context) where TCommand : class, ICommand { CommandMessage <TCommand> message = _options.ContextManager.CreateCommandMessage(context); _logger.LogVerbose(new { commandType = typeof(TCommand).FullName, correlationId = message.CorrelationId, retryCount = context.RetryCount, command = message.Command.ToString() }, arg => $"Received command of type {arg.commandType} with correlationId {arg.correlationId}. (Try n. {arg.retryCount}). Command: {arg.command}"); try { await commandHandler.Invoke(message).ConfigureAwait(false); } catch (Exception ex) { _logger.LogError(new { commandType = typeof(TCommand).FullName, correlationId = message.CorrelationId, retryCount = context.RetryCount, command = context.Message.ToString() }, ex, (arg, e) => $"Error while processing event of type {arg.commandType} with correlationId {arg.correlationId}. (Try n. {arg.retryCount}). Command: {arg.command}. Error: {e.Message}"); var handled = await _options.CommandErrorStrategy.HandleError(context, ex).ConfigureAwait(false); if (!handled) { throw ExceptionManager.PrepareForRethrow(ex); } } }
private void Receive() { while (!closeConnection) { try { int b; while ((b = stream.ReadByte()) != -1 && !closeConnection) { char c = (char)b; if (c == '\n') { CommandReceived?.Invoke(new CommandReceivedEventArgs(pendingCommand.TrimEnd('\r'))); pendingCommand = string.Empty; } else { pendingCommand += c; } } } catch { if (!closeConnection) { throw; } } } }
private void DataReceive() { while (Tcp?.Connected ?? false) { try { byte message = Reader.ReadByte(); switch (message) { case READY_BYTE: Writer.Write(READY_BYTE); break; case COMMAND_BYTE: byte command = Reader.ReadByte(); byte processNumber = Reader.ReadByte(); CommandReceived?.Invoke(this, new Message <byte>(command, processNumber)); break; case TEXT_BYTE: string text = Reader.ReadString(); processNumber = Reader.ReadByte(); TextReceived?.Invoke(this, new Message <string>(text, processNumber)); break; } } catch { Connected = false; return; } } Connected = false; }
private async void Listen() { try { using (var serverStream = GetServerStream()) { await Task.Factory.FromAsync( (cb, state) => serverStream.BeginWaitForConnection(cb, state), ar => serverStream.EndWaitForConnection(ar), null); var command = ParseCommand(serverStream.ReadByte()); CommandReceived?.Invoke(this, new IpcEventArgs(command)); serverStream.Disconnect(); } Listen(); } catch (Exception ex) { Log.Error(ex, "Failed to listen for IPC commands"); } }
public void ProcessMessage(Message message) { if (message.Content.StartsWith("!")) { string[] arguments = message.Content.Substring(1).Split(' '); CommandReceived?.Invoke(this, new StreamCommand { Service = DiscordConstants.Service, Channel = Key, User = message.Author.Username, Command = arguments[0], Arguments = arguments.Skip(1).ToArray() }); } else { ChatMessage?.Invoke(this, new ChatMessage { Service = DiscordConstants.Service, Channel = Key, User = message.Author.Username, AvatarLink = message.Author.Avatar != null ? DataExtensions.GetAvatarURL(message.Author.ID, message.Author.Avatar) : null, Message = message.Content, Emotes = new ChatEmote[0], Attachements = ProcessAttachements(message.Attachments).ToArray(), IsWhisper = false, UserColor = Colors.White }); } }
public void Register() { if (++countModels == 2 && client.Connected) { Task t = new Task(() => { Mutex mut = new Mutex(); while (true) { string JCommand = reader.ReadString(); CommandRecievedEventArgs command = CommandRecievedEventArgs.FromJSON(JCommand); if (command.CommandID == (int)CommandEnum.CloseClientCommand) { client.Close(); break; } mut.WaitOne(); CommandReceived?.Invoke(this, command); mut.ReleaseMutex(); } } ); t.Start(); } }
private async void CloudToDeviceAsync() { while (true) { try { Message receivedMessage = await deviceClient.ReceiveAsync(); if (receivedMessage == null) { await Task.Delay(2000); continue; } await deviceClient.CompleteAsync(receivedMessage); string command = Encoding.ASCII.GetString(receivedMessage.GetBytes()); if (telemetry.SetSampleRateInSeconds(command)) { continue; } T cmd = (T)Convert.ChangeType(command, typeof(T)); CommandReceived?.Invoke(this, new CommandEventArgs <T>(cmd)); } catch { telemetry.Exceptions++; } } }
protected virtual void OnCommandReceived(SystemCommandModel theCmd) { SystemCommandEnum theEnum; Enum.TryParse(theCmd.Name, true, out theEnum); if (theEnum == SystemCommandEnum.None) { return; } var paramList = new List <KeyValuePair <string, object> >(); paramList.Add(new KeyValuePair <string, object>("targetId", theCmd.TargetId)); if (theCmd.NewPreference.HasValue) { paramList.Add(new KeyValuePair <string, object>("preference", theCmd.NewPreference)); } CommandReceived?.Invoke(this, new CommandReceivedEventArgs { Command = theEnum, Parameters = paramList }); }
protected virtual void OnCommandReceived(VoiceCommand command) { CommandReceived?.Invoke(this, new VoiceCommandControllerEventArgs() { Data = command }); }
private void ListenData(Connection connection) { while (true) { try { var data = connection.TransferProtocol.Read(); if (data.Type == TrasnsferDataType.Command) { _logger.LogMessage("Command received from " + connection.Id + " " + connection.Name); CommandReceived?.Invoke(connection.Id, (CommandTrasnsferData)data); } else if (data.Type == TrasnsferDataType.DataObject) { _logger.LogMessage("Data received from " + connection.Id + " " + connection.Name); DataReceived?.Invoke(connection.Id, (ObjectTrasnsferData)data); } else { _logger.LogMessage("File received from " + connection.Id + " " + connection.Name); FileReceived?.Invoke(connection.Id, (FileTransferData)data); } } catch (Exception ex) { _logger.LogError("Disconected: " + connection.Id + " " + connection.Name + " Error connection: " + ex.Message); Disconect(connection); return; } } }
private static async Task DiscordClient_MessageReceived(SocketMessage msg) { if (!msg.Content.StartsWith("!")) //Ignore message if it doesn't start with the command specifier "!" { return; } string[] splitmsg = msg.Content.Substring(1).Split(' '); if (splitmsg.Length == 0) //If the message is just an exclamation mark don't bother { return; } List <string> args = new List <string>(); for (int i = 1; i < splitmsg.Length; i++) { args.Add(splitmsg[i]); } CommandReceived?.Invoke(new CommandReceivedEventArgs() { Command = splitmsg[0], CommandArgs = args.ToArray(), Channel = msg.Channel, User = msg.Author }); }
protected virtual void OnCommandReceived(string commandName, string userName) { CommandReceived?.Invoke(this, new CommandReceivedEventArgs() { CommandName = commandName, Username = userName }); }
private async Task ReadLoop() { while (!_cancellationTokenSource.IsCancellationRequested && _pipe.IsConnected) { byte[] buffer = ArrayPool <byte> .Shared.Rent(_pipe.InBufferSize); int position = 0; do { position += await _pipe.ReadAsync(buffer.AsMemory(position), _cancellationTokenSource.Token); } while (!_pipe.IsMessageComplete); if (position == 0) { //I don't know why, but this happens when closing the pipe. //return the buffer to the pool and skip the rest ArrayPool <byte> .Shared.Return(buffer); continue; } var dataLength = (int)BitConverter.ToUInt32(buffer, 0); var actualData = buffer.AsMemory(4, dataLength - 4); CommandReceived?.Invoke(this, actualData); ArrayPool <byte> .Shared.Return(buffer); } await _pipe.DisposeAsync(); Disconnected?.Invoke(this, EventArgs.Empty); }
private void OnCommandReceived(byte value) { if (CommandReceived != null) { CommandReceived.Invoke(value); } }
protected virtual void OnCommandReceived(CommandEventArgs e) #endif { if (CommandReceived != null) { CommandReceived.Invoke(this, e); } }
public void SubscribeToCommand <TCommand>(CommandReceived <TCommand> commandReceived) where TCommand : class, ICommand { if (commandReceived == null) { throw new ArgumentNullException(nameof(commandReceived)); } _commandSubscriptions.Add(configurator => configurator.Handler <TCommand>(ctx => HandleCommand(commandReceived, ctx))); }
private async void ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { DebugHelper.LogInformation($"Connection received from {args.Socket.Information.RemoteAddress.DisplayName}:{args.Socket.Information.RemotePort}"); string passkey = SecretManager.EncryptionKey; //Passkey used for this session. try { using (var reader = new DataReader(args.Socket.InputStream)) { using (var writer = new DataWriter(args.Socket.OutputStream)) { reader.InputStreamOptions = InputStreamOptions.Partial; try { var networkCommand = await ReceiveCommand(reader, passkey); //if (networkCommand == null) break; if (networkCommand == null) { await SendResponse(Command.CreateErrorCommand($"The command was null."), writer, passkey); return; } CommandEventArgs commandArgs = new CommandEventArgs() { InputCommand = networkCommand }; //Send command await CommandReceived?.Invoke(commandArgs); //If output command retrieve, send it if (commandArgs.OutputCommand != null) { await SendResponse(commandArgs.OutputCommand, writer, passkey); } } catch (Exception loopException) { await SendResponse(Command.CreateErrorCommand($"Error handling request: {loopException.Message}"), writer, passkey); } DebugHelper.LogInformation($"Connection from {args.Socket.Information.RemoteAddress.DisplayName}:{args.Socket.Information.RemotePort} ended"); if (args.Socket != null) { args.Socket.Dispose(); DebugHelper.LogVerbose("Socket disposed."); } } } } catch (Exception e) { DebugHelper.LogError($"Error handling request: {e.Message}"); } }
private async Task <bool> RaiseCommandReceivedAsync(Command envelope) { var eventArgs = new EnvelopeEventArgs <Command>(envelope); CommandReceived?.RaiseEvent(this, eventArgs); await eventArgs.WaitForDeferralsAsync().ConfigureAwait(false); return(true); }
private async Task OnCommandReceived(object source, IrcCommandEventArgs args) { if (CommandReceived == null) { return; } await CommandReceived.Invoke(source, args); }
/// <summary> /// New API Request /// </summary> /// <param name="sender"></param> /// <param name="args"></param> private async void ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args) { DebugHelper.LogInformation($"Connection received from {args.Socket.Information.RemoteAddress.DisplayName}:{args.Socket.Information.RemotePort}"); try { using (var reader = new DataReader(args.Socket.InputStream)) { using (var writer = new DataWriter(args.Socket.OutputStream)) { reader.InputStreamOptions = InputStreamOptions.Partial; try { Tuple <Command, HttpStatusCode> commandAndStatus = await ReceiveCommand(reader); Command command = commandAndStatus.Item1; if (command == null) { await SendResponse(Command.CreateErrorCommand($"The command was null."), writer, false, HttpStatusCode.BadRequest); return; } if (command.BaseCommand == CommandsEnum.ResultError) { await SendResponse(command, writer, false, commandAndStatus.Item2); return; } //Send command CommandEventArgs commandArgs = new CommandEventArgs() { InputCommand = command }; await CommandReceived?.Invoke(commandArgs); //If output command retrieve, send it if (commandArgs.OutputCommand != null) { await SendResponse(commandArgs.OutputCommand, writer, SecretManager.IsEncryptionEnabled); } } catch (Exception loopException) { await SendResponse(Command.CreateErrorCommand($"Error handling request: {loopException.Message}"), writer, false, HttpStatusCode.InternalServerError); } DebugHelper.LogInformation($"Connection from {args.Socket.Information.RemoteAddress.DisplayName}:{args.Socket.Information.RemotePort} ended"); } } } catch (Exception e) { DebugHelper.LogError($"Error handling request: {e.Message}"); } }
private void Com_DataReceived(object sender, SerialDataReceivedEventArgs e) { var s = com.ReadLine(); CommandInfo c = new CommandInfo(); c.command = StringToEnum(s.Substring(0, 3)); c.p = Convert.ToInt32(s.Substring(3, 2)); c.v = s.Substring(5); CommandReceived?.Invoke(this, c); }
/// <summary> /// Invokes the CommandReceived event and passes the appropriate args to the subscribed Objects. /// </summary> /// <param name="id">CommandEnum the code for the specific command</param> /// <param name="args">List<String> the args used by the Command</param> /// <param name="path">String, the target directory/file path</param> public void SendCommand(CommandEnum id, List <String> args, string path) { CommandReceivedEventArgs cArgs = new CommandReceivedEventArgs(id, args, path); CommandReceived?.Invoke(this, cArgs); if (id == CommandEnum.CloseServerCommand) { OnCloseServer(); } }
private void SerialPortDataReceived(object sender, SerialDataReceivedEventArgs e) { while (_serialPort.BytesToRead > 0) { var command = _serialPort.ReadLine(); _logger.Information($"RCV: {command}"); command = command.Replace("\r", string.Empty); CommandReceived?.Invoke(command); } }
public override void HandleCommand(TestCommand command) { Console.WriteLine("[{0}] Command {1} received in {2} [ms]", Key, command.Id, (DateTime.UtcNow - command.CreatedAt).TotalMilliseconds); Interlocked.Increment(ref _receivedMessages); if (_receivedMessages == _expectedMessages) { CommandReceived.Complete(true); } }
/// Runs a command. /// <inheritdoc/> public override Dialogue.HandlerExecutionType RunCommand(Yarn.Command command, System.Action onCommandComplete) { // Dispatch this command via the 'On Command' handler. CommandReceived?.Invoke(command.Text); // Signal to the DialogueRunner that it should continue // executing. (This implementation of RunCommand always signals // that execution should continue, and never calls // onCommandComplete.) return(Dialogue.HandlerExecutionType.ContinueExecution); }
private void CommandExecutorService_MessageRecieved(object sender, CommandReceived commandReceived) { if (InvokeRequired) { Invoke((MethodInvoker)(() => CommandExecutorService_MessageRecieved(sender, commandReceived))); } else { dataTable.Rows.Add(DateTime.Now, commandReceived.Type, commandReceived.Message); dataGridView1.CurrentCell = dataGridView1.Rows[dataGridView1.Rows.Count - 1].Cells[0]; } }
private void HandleCommandEvent(TelloCommand command) { ICommandReader reader = commandReaders.SingleOrDefault(t => t.Id == command.Id); IEventCommand evt = reader?.Read(command); if (evt == null) { return; } CommandReceived?.Invoke(this, evt); }
public async Task HandleCommand <TCommand>(CommandMessage <TCommand> message) where TCommand : class, ICommand { Delegate @delegate; if (!_subscribedCommands.TryGetValue(typeof(TCommand), out @delegate)) { return; } CommandReceived <TCommand> commandReceivedDelegate = (CommandReceived <TCommand>)@delegate; await commandReceivedDelegate(message).ConfigureAwait(false); }
/// <summary> /// Occurs when the service is started /// </summary> protected override void OnStart(string[] args) { try { // hookup the command event eventReceivedCommand += new CommandReceived(IrcBotService_eventReceivedCommand); connect(); CreateThreads(1, workerFunc); } catch (Exception ex) { Console.WriteLine("Error when starting: " + ex.Message); } }
public void AddCommandListener(CommandReceived call) { OnCommandReceived += call; }