public GameletMountChecker(IRemoteCommand remoteCommand, IDialogUtil dialogUtil, CancelableTask.Factory cancelableTaskFactory) { _remoteCommand = remoteCommand; _dialogUtil = dialogUtil; _cancelableTaskFactory = cancelableTaskFactory; }
private void ExecuteRemoteCommand(IRemoteCommand command) { Analyzer.Serial.SendPacket(command.GetBytes()); timer.Restart(); bool commandExecuted = false; while (!commandExecuted) { if (timer.ElapsedMilliseconds >= timeToWaitResponse) { //Logger.Info("[Command executor] - Слишком долгое ожидание ответа от устройства."); Analyzer.Serial.SendPacket(command.GetBytes()); timer.Restart(); } if (Protocol.CommandTypes.SIMPLE_COMMAND == command.GetType()) { commandExecuted = CheckCommandStatus(command, CommandStateResponse.CommandStates.COMMAND_EXECUTE_STARTED); } else if (Protocol.CommandTypes.WAITING_COMMAND == command.GetType()) { commandExecuted = CheckCommandStatus(command, CommandStateResponse.CommandStates.COMMAND_EXECUTE_FINISHED); } } timer.Stop(); }
/// <summary> /// Performs the actions on a certain queue item. /// </summary> /// <param name="item"></param> /// <param name="doc"></param> private void ProcessQueueItem(RevitQueueItem item, Document doc) { string dllLocation = item.DllLocation; string className = item.ClassName; //foreach of those. //load the dll with reflection Type type = LoadDllWithReflection(dllLocation, className); IRemoteCommand command = GetCommandFromType(type); //Check for transaction attribute, start one if automatic Transaction transaction = StartAutomaticTransaction(type, doc); //run the execute method Result result = command.RunRemotely(doc); //close the transaction if (transaction != null && result == Result.Succeeded) { transaction.Commit(); } if (transaction != null && (result == Result.Cancelled || result == Result.Failed)) { transaction.RollBack(); } item.MarkComplete(); }
/// <summary> /// Builds an HTTP request based on the specified remote Command /// </summary> /// <param name="command">the command we'll send to the server</param> /// <returns>an HTTP request, which will perform this command</returns> public virtual WebRequest CreateWebRequest(IRemoteCommand command) { WebRequest request = WebRequest.Create(BuildCommandString(command.CommandString)); request.Timeout = Timeout.Infinite; return(request); }
public void DetachClient(IRemoteCommand iClient) { if (iClient == null) { return; } try { lock (lockObject) { if (dicClients.ContainsKey(iClient.Sender)) { dicClients.Remove(iClient.Sender); } } if (UserLogout != null) { UserLogout(iClient.Sender); } } catch (Exception ex) { log.Info(iClient.Sender + "DetachError" + ex.Message); } finally { } }
public RemoteDeploy(IRemoteCommand remoteCommand, IRemoteFile remoteFile, ManagedProcess.Factory managedProcessFactory, IFileSystem fileSystem) { _remoteCommand = remoteCommand; _remoteFile = remoteFile; _managedProcessFactory = managedProcessFactory; _fileSystem = fileSystem; }
/// <summary> /// /// </summary> protected void FinishCurrentCommand() { var temp = m_currentCommand; // we delay the remove so we see small file downloads, otherwise it would be dropped instantly (download too fast) Dispatcher.DelayInvoke(TimeSpan.FromMilliseconds(2000), () => ViewModelCommands.RemoveItem(temp)); m_currentCommand = null; ExecuteNextCommandIfPossible(); }
public SshManager(IGameletClientFactory gameletClientFactory, ICloudRunner cloudRunner, ISshKeyLoader sshKeyLoader, ISshKnownHostsWriter sshKnownHostsWriter, IRemoteCommand remoteCommand) { this.gameletClientFactory = gameletClientFactory; this.cloudRunner = cloudRunner; this.sshKeyLoader = sshKeyLoader; this.sshKnownHostsWriter = sshKnownHostsWriter; this.remoteCommand = remoteCommand; }
public bool TryMerge(IRemoteCommand other, out IRemoteCommand?mergedCommand) { if (other is CreatureTemplateReloadRemoteCommand remoteCommand) { var merged = entries.Union(remoteCommand.entries).ToArray(); mergedCommand = new CreatureTemplateReloadRemoteCommand(merged); return(true); } mergedCommand = null; return(false); }
public void Register(IRemoteCommand command) { if (this.State != CommunicationState.Opened) { Debug.WriteLine("Can not regisger command, Remote Command Communication Error!", "Error"); return; } commandManager.Add(command); Channel.Register(command.ID, command.UIType, command.UIData); //ThreadPool.QueueUserWorkItem((o)=>Channel.Register(command.ID, command.UIType, command.UIData)); }
/// <summary> /// Gets the command from type /// </summary> /// <param name="type"></param> /// <returns></returns> private IRemoteCommand GetCommandFromType(Type type) { IRemoteCommand command = Activator.CreateInstance(type) as IRemoteCommand; if (command == null) { throw new Exception("Could not get Remote Command"); } return(command); }
public async Task <string> ExecuteCommand(IRemoteCommand command) { if (trinitySoapClient == null) { return(""); } var response = await trinitySoapClient.ExecuteCommand(command.GenerateCommand()); return(response.Message); }
public bool TryMerge(IRemoteCommand other, out IRemoteCommand?mergedCommand) { mergedCommand = null; if (other is ReloadRemoteCommand same && same.remoteCommand == remoteCommand) { mergedCommand = other; return(true); } return(false); }
public bool TryMerge(IRemoteCommand other, out IRemoteCommand mergedCommand) { mergedCommand = null; if (other is MergableCommand mergableCommand) { mergedCommand = new MergableCommand(cmd + mergableCommand.cmd); return(true); } return(false); }
public void SetUp() { gameletClient = Substitute.For <IGameletClient>(); gameletClientFactory = Substitute.For <GameletClient.Factory>(); gameletClientFactory.Create(Arg.Any <ICloudRunner>()).Returns(gameletClient); cloudRunner = Substitute.For <ICloudRunner>(); sshKeyLoader = Substitute.For <ISshKeyLoader>(); sshKnownHostsWriter = Substitute.For <ISshKnownHostsWriter>(); remoteCommand = Substitute.For <IRemoteCommand>(); sshManager = new SshManager(gameletClientFactory, cloudRunner, sshKeyLoader, sshKnownHostsWriter, remoteCommand); }
private ContextMenuStrip GetContextMenuStrip() { var notifyContextMenu = new ContextMenuStrip(); bool hasConfiguredCommands = false; IRemoteCommand previous = null; foreach (IRemoteCommand command in _commandsManager.Cast <IRemoteCommand>().OrderBy(c => c.GetType().ToString())) { if (command.Configured) { if (previous != null && !string.Equals(previous.GetType().ToString(), command.GetType().ToString())) { notifyContextMenu.Items.Add("-"); } var commandButton = new ToolStripMenuItem(command.CommandTitle) { Image = command.TrayIcon }; commandButton.Click += (s, e) => command.RunCommand(); notifyContextMenu.Items.Add(commandButton); hasConfiguredCommands = true; previous = command; } } if (hasConfiguredCommands) { notifyContextMenu.Items.Add("-"); } var settings = new ToolStripMenuItem("Settings") { Image = Resources.Settings.ToBitmap() }; settings.Click += SettingsClick; notifyContextMenu.Items.Add(settings); notifyContextMenu.Items.Add("-"); var exit = new ToolStripMenuItem("Exit") { Image = Resources.Exit.ToBitmap() }; exit.Click += Exit; notifyContextMenu.Items.Add(exit); return(notifyContextMenu); }
/// <summary> /// Builds an HTTP request based on the specified remote Command /// </summary> /// <param name="command">the command we'll send to the server</param> /// <returns>an HTTP request, which will perform this command</returns> public virtual WebRequest CreateWebRequest(IRemoteCommand command) { byte[] data = BuildCommandPostData(command.CommandString); HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url); request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded; charset=utf-8"; request.Timeout = Timeout.Infinite; Stream rs = request.GetRequestStream(); rs.Write(data, 0, data.Length); rs.Close(); return(request); }
public DateTime Ping(IRemoteCommand iClient) { if (iClient == null) { return(DateTime.MinValue); } string s = iClient.Sender; if (s != null) { return(DateTime.Now); } else { return(DateTime.MinValue); } }
public GameletSelectorLegacyFlow( IDialogUtil dialogUtil, ICloudRunner runner, InstanceSelectionWindow.Factory gameletSelectionWindowFactory, CancelableTask.Factory cancelableTaskFactory, IGameletClientFactory gameletClientFactory, ISshManager sshManager, IRemoteCommand remoteCommand, ActionRecorder actionRecorder) { _dialogUtil = dialogUtil; _runner = runner; _gameletSelectionWindowFactory = gameletSelectionWindowFactory; _cancelableTaskFactory = cancelableTaskFactory; _gameletClientFactory = gameletClientFactory; _sshManager = sshManager; _remoteCommand = remoteCommand; _mountChecker = new GameletMountChecker(remoteCommand, dialogUtil, cancelableTaskFactory); _actionRecorder = actionRecorder; }
public GameletSelectorFactory(IDialogUtil dialogUtil, ICloudRunner runner, InstanceSelectionWindow.Factory gameletSelectionWindowFactory, CancelableTask.Factory cancelableTaskFactory, IGameletClientFactory gameletClientFactory, ISshManager sshManager, IRemoteCommand remoteCommand, IGameLaunchBeHelper gameLaunchBeHelper, JoinableTaskContext taskContext) { _dialogUtil = dialogUtil; _runner = runner; _gameletSelectionWindowFactory = gameletSelectionWindowFactory; _cancelableTaskFactory = cancelableTaskFactory; _gameletClientFactory = gameletClientFactory; _sshManager = sshManager; _remoteCommand = remoteCommand; _gameLaunchBeHelper = gameLaunchBeHelper; _taskContext = taskContext; }
public GameletSelector(IDialogUtil dialogUtil, ICloudRunner runner, InstanceSelectionWindow.Factory gameletSelectionWindowFactory, CancelableTask.Factory cancelableTaskFactory, IGameletClientFactory gameletClientFactory, ISshManager sshManager, IRemoteCommand remoteCommand, IGameLaunchBeHelper gameLaunchBeHelper, JoinableTaskContext taskContext, ActionRecorder actionRecorder) { _dialogUtil = dialogUtil; _runner = runner; _gameletSelectionWindowFactory = gameletSelectionWindowFactory; _cancelableTaskFactory = cancelableTaskFactory; _gameletClientFactory = gameletClientFactory; _sshManager = sshManager; _remoteCommand = remoteCommand; _mountChecker = new GameletMountChecker(remoteCommand, dialogUtil, cancelableTaskFactory); _gameLaunchBeHelper = gameLaunchBeHelper; _taskContext = taskContext; _actionRecorder = actionRecorder; }
public bool AttachClient(IRemoteCommand iClient) { if (iClient == null) { return(false); } IRemoteCommand iPreviousClient = null; try { lock (lockObject) { if (dicClients.ContainsKey(iClient.Sender)) { iPreviousClient = dicClients[iClient.Sender]; dicClients.Remove(iClient.Sender); } dicClients.Add(iClient.Sender, iClient); } if (UserLogin != null) { UserLogin(iClient.Sender); } } catch (Exception ex) { log.Info(iClient.Sender + "登录时发生错误", ex); return(false); } try { if (iPreviousClient != null) { iPreviousClient.LogOff(); } } catch { } return(true); }
public RemoteMuxCommandBuilder(String Command, IList <TunerController> tunerController) : base(Command) { IRemoteCommand myCommand = null; if (String.IsNullOrEmpty(Command)) { throw new ArgumentNullException("Command is null"); } var parts = Command.Split(' '); if (parts.Length < 3) { throw new ArgumentException("Invalid number of arguments!"); } var cmd = new MuxControlCommand(); // Parse MUX id args... int muxId; if (!int.TryParse(parts[1], out muxId)) { throw new ArgumentException($"Unexpected MuxId value '{parts[1]}'!"); } cmd.MuxId = muxId; // Parse action arg... try { cmd.Action = (MuxControlCommand.Mux_action)Enum.Parse(typeof(MuxControlCommand.Mux_action), parts[2], true); } catch (Exception) { throw new ArgumentException($"Unexpected ACTION value '{parts[2]}'!"); } cmd.TunnerController = tunerController; myCommand = cmd; this.Command = myCommand; }
/// <summary> /// commands are special job that contains a single task and cab be run only by administrators /// A command job is not scheduled (it runs immediately) /// </summary> /// <param name="commandLine">the command to execute</param> /// <param name="info">provides additional property values used by command. if no additional property values, set to null</param> /// <param name="nodes">indentify the nodes on which the command will run.</param> /// <param name="userName">the name of the runas user, in the form domain\username</param> /// <param name="password">the password for the runas user</param> public void CreateCommand(string commandLine, ICommandInfo info, IStringCollection nodes, string userName, string password) { if (UserPrivilege.Admin != _scheduler.GetUserPrivilege()) { return; } manualReset.Reset(); //create the command IRemoteCommand command = _scheduler.CreateCommand(commandLine, info, nodes); //subscribe to one or more events before starting the command command.OnCommandJobState += OnJobStateCallback; command.OnCommandTaskState += OnCommandTaskStateCallback; command.OnCommandOutput += OnCommandOutputCallback; command.OnCommandRawOutput += OnCommandRawOutputCallback; command.StartWithCredentials(userName, password); manualReset.WaitOne(); }
/// <summary> /// /// </summary> protected void ExecuteNextCommandIfPossible() { if (m_currentCommand != null) { return; } if (m_pendingCommands.Count == 0) { return; } m_currentCommand = m_pendingCommands.Dequeue(); if (IsCommandCancelled(m_currentCommand.Id)) { m_currentCommand = null; ExecuteNextCommandIfPossible(); } else { m_currentCommand.DoExecute(); } }
public void SetUp() { _remoteCommand = Substitute.For <IRemoteCommand>(); _dialogUtil.ShowYesNo(Arg.Any <string>(), Arg.Any <string>()).Returns(false); _actionRecorder = new ActionRecorder(Substitute.For <IMetrics>()); }
internal void Add(IRemoteCommand command) { _commands.Add(command.ID, command); }
/// <summary> /// Builds an HTTP request based on the specified remote Command /// </summary> /// <param name="command">the command we'll send to the server</param> /// <returns>an HTTP request, which will perform this command</returns> public virtual WebRequest CreateWebRequest(IRemoteCommand command) { WebRequest request = WebRequest.Create(BuildCommandString(command.CommandString)); request.Timeout = Timeout.Infinite; return request; }
/// <summary> /// /// </summary> /// <param name="command"></param> protected void AddCommand(IRemoteCommand command) { m_pendingCommands.Enqueue(command); ViewModelCommands.AddItem(command); ExecuteNextCommandIfPossible(); }
/// <summary> /// Builds an HTTP request based on the specified remote Command /// </summary> /// <param name="command">the command we'll send to the server</param> /// <returns>an HTTP request, which will perform this command</returns> public virtual WebRequest CreateWebRequest(IRemoteCommand command) { byte[] data = BuildCommandPostData(command.CommandString); HttpWebRequest request = (HttpWebRequest) WebRequest.Create(url); request.Method = "POST"; request.ContentType = "application/x-www-form-urlencoded; charset=utf-8"; request.Timeout = Timeout.Infinite; Stream rs = request.GetRequestStream(); rs.Write(data, 0, data.Length); rs.Close(); return request; }
public bool TryMerge(IRemoteCommand other, out IRemoteCommand?mergedCommand) { mergedCommand = Singleton; return(true); }
public Fjärrkontroll(IRemoteCommand upp, IRemoteCommand ner) { this.upp = upp; this.ner = ner; }
private bool CheckCommandStatus(IRemoteCommand command, CommandStateResponse.CommandStates expectedState) { return(ExecutedCommandId == command.GetId() && ExecutedCommandState == expectedState); }