private void ProcessNextCommand() { _processingCommand = true; PendingCommand pendingCommand = _pendingCommands.Dequeue(); ICommand command = _commandFactory.Create(pendingCommand.commandType, pendingCommand.dataType, pendingCommand.data); if (command == null) { _logger.LogError(LoggedFeature.CommandSystem, "Command is not bound. Have you installed a separate Installer via CommandsInstaller.Install?"); return; } IObservable <Unit> observable = command.Run(); IObserver <Unit> observer = Observer.Create <Unit>(HandleCommandSuccess, HandleCommandError); observable.Subscribe(observer); // Notify listeners CommandSnapshot commandSnapshot = new CommandSnapshot(command, pendingCommand.data, _clock.Now, pendingCommand.source); foreach (var commandQueueListener in _listeners) { commandQueueListener.HandleCommandQueued(commandSnapshot); } }
void AddCommand(Id id, PendingCommand command) { if (!_commandsById.TryAdd(id, command)) { throw new Exception($"Cannot reuse command identifier {id}"); } }
private bool TextCommandCallback(ServerPlayer player, MsgMessage message) { if (player == null || message.MessageText == string.Empty || message.To != BZFlag.Data.Players.PlayerConstants.AllPlayersID || message.MessageType == MsgMessage.MessageTypes.ActionMessage) { return(false); } if (message.MessageText[0] == '/') { if (player.Allowances.AllowCommands) { PendingCommand cmd = new PendingCommand(); cmd.Text = message.MessageText; cmd.Player = player; lock (PendingCommands) { PendingCommands.Add(cmd); if (Worker == null) { Worker = new Thread(new ThreadStart(ProcessCommands)); Worker.Start(); } } } return(true); } return(false); }
internal void RegisterPending(PendingCommand sender) { if (!ImmutableInterlocked.TryAdd(ref _pendingCommands, sender.Id, sender)) { throw new InvalidOperationException($"Invalid command ID '{sender.Id}'. ID is already present."); } }
// POST: api/PendingApp public async Task <IActionResult> PostAsync([FromBody] PendingCommand pendingCommand) { _context.Add(pendingCommand); await _context.SaveChangesAsync(); return(Ok()); }
/// <summary> /// Sends a command to the controller over serial, /// and waits for execution. /// </summary> /// <param name="command">The command to execute, including parameters.</param> /// <returns>The result.</returns> public async Task <bool> SendCommand(string command, bool waitForConfirmation = true) { logger.LogDebug(String.Format("Sending a command to the FMC serial interface: \"{0}\"", command)); string commandGuid = Guid.NewGuid().ToString(); await serialController.TryWriteString(command); serialController.CommandInProgress = true; if (!waitForConfirmation) { return(true); } pendingCommands.Add(commandGuid, new PendingCommand(commandGuid, command, DateTime.Now)); while (true) { PendingCommand pendingCommand = pendingCommands[commandGuid]; if (DateTime.Now >= pendingCommand.TimeSent.AddSeconds(30)) { // Command execution timed out pendingCommands.Remove(commandGuid); serialController.CommandInProgress = false; logger.LogError("An command intended to run on the FMC timed out. This indicates an internal fault. The command was: " + pendingCommand.Command); return(false); } if (pendingCommand.Confirmed = true && pendingCommand.Status != null) { pendingCommands.Remove(commandGuid); serialController.CommandInProgress = false; if (pendingCommand.Status == "success") { logger.LogInformation("An command sent to the FMC succeeded. The command was: " + pendingCommand.Command); return(true); } else if (pendingCommand.Status == "failure") { logger.LogError("The FMC reported command failure. The command was: " + pendingCommand.Command); return(false); } else { throw new Exception("Malformed command status."); } } } }
protected PendingCommand PopCommand() { lock (PendingCommands) { if (PendingCommands.Count == 0) { return(null); } PendingCommand cmd = PendingCommands[0]; PendingCommands.RemoveAt(0); return(cmd); } }
async Task <TResponse> WaitForResponse <TResponse>(Id id, IEnumerable <ICommandWhen <TResponse> > whens) { var command = new PendingCommand <TResponse>(whens); AddCommand(id, command); try { return(await command.Task); } finally { RemoveCommand(id); } }
public async Task <PendingCommand> Send <TCommand>(TCommand command, CancellationToken ct) where TCommand : HomeAssistantCommand { if (await _state.FirstOrDefaultAsync(state => state == State.Connected) != State.Connected) { throw new InvalidOperationException("Connection failed"); } using (await _sendGate.LockAsync(ct)) using (var id = _commandIdProvider.GetNext()) { var sender = new PendingCommand(command, this, id, ct); var payload = JsonSerializer.SerializeToUtf8Bytes(command, JsonWriteOpts); await _client.SendAsync(new ArraySegment <byte>(payload), WebSocketMessageType.Text, true, ct); return(sender); } }
public void HandleCommand(PendingCommand Command) { try { var matchedCommand = Parser.ParseCommand(Command); if (matchedCommand != null) { Core.ProcessPlayerCommand(matchedCommand.Command, matchedCommand.Matches[0], Command.Actor); } else { MudObject.SendMessage(Command.Actor, "I do not understand."); } } catch (Exception e) { Core.ClearPendingMessages(); MudObject.SendMessage(Command.Actor, e.Message); } }
protected virtual void ProcessCommands() { PendingCommand cmd = PopCommand(); while (cmd != null) { string[] parts = cmd.Text.Split(" ".ToCharArray(), 2); string command = parts[0].Substring(1); string args = string.Empty; if (parts.Length == 2) { args = parts[1]; } Commands.CallHandler(command, args, cmd.Player); cmd = PopCommand(); } lock (PendingCommands) Worker = null; }
internal void UnRegisterPending(PendingCommand sender) { ImmutableInterlocked.TryRemove(ref _pendingCommands, sender.Id, out _); }
public void HandleCommand(PendingCommand Command) { Command.Actor.CommandHandler = ParentHandler; AuthenticatingCommand(Command.Actor, UserName, Command.RawCommand); }
/// <summary> /// Called when this CMC recieves a serial message. /// </summary> private Task SerialController_SerialRecieved(string text) { string[] split = text.Split("\n\r".ToCharArray(), StringSplitOptions.RemoveEmptyEntries); IList <IDictionary <string, dynamic> > statusResults = new List <IDictionary <string, dynamic> >(); IList <PendingCommand> commandResults = new List <PendingCommand>(); foreach (string line in split) { // Handle malformed serial output by the Arduino string _line = line; if (line == "{,\"command\":\"syncStatus\"}") { continue; } string[] firstSplit = _line.Split("{\"status\":"); if (firstSplit.Count() == 2) { _line = "{\"status\":" + firstSplit[1]; } IDictionary <string, dynamic> result = null; try { result = JsonConvert.DeserializeObject <IDictionary <string, dynamic> >(_line); } catch (Exception e) { logger.LogError(String.Format("Could not parse JSON from line with content \"{0}\". Content was malformed from the Arduino. The line will be ignored.", _line), e); continue; } if (result.ContainsKey("status") && result.ContainsKey("command")) { // Command result IEnumerable <PendingCommand> pending = pendingCommands.Select(i => i.Value).Where(p => p.Command == result["command"]).OrderBy(p => p.TimeSent); if (pending.Count() > 0) { PendingCommand command = pending.First(); if (command != null) { commandResults.Add(command); pendingCommands[command.Guid].Confirmed = true; pendingCommands[command.Guid].Status = result["status"]; } } } else if (result.ContainsKey("status")) { statusResults.Add(result); switch (result["status"]) { case "system_ready": FmcReady = true; Task.Run(async() => { await FmcReadyEvent.Invoke(this); }); break; case "tamper_detection_tripped": break; case "sensor_triggered": break; case "sensor_untriggered": break; case "alarm_activated_not_armed": break; case "alert": Alarmed = true; break; case "syncStatus": // Got a sync request-response from the FMC if (result.ContainsKey("statusValues")) { IList <string> statusValues = ((JArray)result["statusValues"]).ToObject <IList <string> >(); foreach (string value in statusValues) { switch (value) { case "alarmed": Alarmed = true; break; case "silenced": Alarmed = false; break; case "armed": Armed = true; break; case "disarmed": Armed = false; break; case "override": Override = true; break; case "no_override": Override = false; break; } } } break; } } } return(Task.CompletedTask); }