/* * Run Commands on machine in sequence, one after another. * And the result will be returned when all of them are finished. */ public Task <string> StartCmdInSeqTransaction(IMachineInfo machine, string[] commands) { return(Task.Run(() => { var trx = GammaClientTXFactory.GetCmdExecTX(machine, commands); AddTransaction(trx); return StartTransactions(trx, machine, commands); })); }
public MachineInfoInflux(IMachineInfo machine) { IPAddress = machine.IPAddress; MAC = machine.MAC; Line = machine.Line; Name = machine.Name; Department = machine.Department; }
public static Task <string> ExecuteCmdAsync(IMachineInfo machine, string single_command) { string filename = GetFileNameFromCmd(single_command); string args = GetArgsFromCmd(single_command); ProxyCmdExecutor client = GammaProxyFactory.GetCmdExecutorProxy(machine); return(client.ShellExecutorAsync(filename, args)); }
/* * Same as StartTransaction*S*, but single command. */ private Task <string> StartTransaction(IGammaClientTransaction trx, IMachineInfo machine, string command) { trx.TransactionStarted(); var task = ProxyFacadeCmdExecutor.ExecuteCmdAsync(machine, command); BindCmdTaskWithTranscation(task, trx); return(task); }
public Source(Guid sourceId, string sourceName, ISourceType sourceType, ISystemProcess process, IMachineInfo machineInfo) { SourceId = sourceId; SourceName = sourceName; MachineInfo = machineInfo; Process = process; SourceType = sourceType; }
/* * Clear environment transactions */ public Task <string> StartClearEnvTransaction(IMachineInfo machine, GammaTXClearEnv clear_step) { return(Task.Run(() => { var trx = GammaClientTXFactory.GetClearEnvTX(machine, clear_step); AddTransaction(trx); return StartTransactions(trx, machine, clear_step); })); }
/* * return the task that run the command on the node with seq# not changed. * if the command are considered as in the same group, they should use this to start the transaction. */ private Task <string> StartCmdGroupTransaction(IMachineInfo machine, string command) { return(Task.Run(() => { var trx = GammaClientTXFactory.GetCmdExecTX(machine, command); GammaClientTXLogger.GetInstance().RegisterTransaction(trx); AddTransaction(trx, seq); return StartTransaction(trx, machine, command); })); }
/* * QA tools transactions */ public Task <string> StartQAToolsTransaction(IMachineInfo machine, GammaTXQATools tool, object qatoolArgs = null) { return(Task.Run(() => { var trx = GammaClientTXFactory.GetQAToolsTX(machine, tool); AddTransaction(trx); return StartTransactions(trx, machine, tool, qatoolArgs); })); }
internal static List <GammaClientTransaction> GetCmdParallelExecTX(IMachineInfo machine, string[] commands) { var transactions = new List <GammaClientTransaction>(); foreach (var cmd in commands) { transactions.Add(GetCmdExecTX(machine, commands)); } return(transactions); }
/* * if the command is being run as parallel, all the nodes' transaction will share the same seq#, * so that later we can notice that they are submitted as parallel run on all nodes. */ public List <Task <string> > StartCmdInParallelTransaction(IMachineInfo machine, string[] commands) { List <Task <string> > tasks = new List <Task <string> >(); //all cmds are run together and share the same seq# foreach (string cmd in commands) { tasks.Add(StartCmdGroupTransaction(machine, cmd)); } return(tasks); }
public SystemMonitorController(IAtlassRequest atlassRequest) { RequestHelper = atlassRequest; if (Runtime.Windows) { _machineInfo = new WindowsMachineInfo(); } else { _machineInfo = new LinuxMachineInfo(); } }
internal static GammaClientTransaction GetCmdExecTX(IMachineInfo machine, string command) { var trx = new GammaClientTransaction() { Machine = machine.MachineName, TX_TYPE = GammaTransactionType.COMMAND, TX_CONTENT = command, TX_RESULT = string.Empty, TX_RESULT_CODE = GammaTransactionRC.RUNNING, }; GammaClientTXLogger.GetInstance().RegisterTransaction(trx); return(trx); }
private Task <string> StartTransactions(IGammaClientTransaction trx, IMachineInfo machine, GammaTXClearEnv clear_step) { trx.TransactionStarted(); Task <string> task; if (clear_step != GammaTXClearEnv.REBOOT) { switch (clear_step) { case GammaTXClearEnv.REG: task = GammaProxyFactory.GetCrsCleanerProxy(machine).RemoveOraKeysAsync(); break; case GammaTXClearEnv.GROUP: task = GammaProxyFactory.GetCrsCleanerProxy(machine).RmOraGroupAsync(); break; case GammaTXClearEnv.FILE: task = GammaProxyFactory.GetCrsCleanerProxy(machine).RemoveOraFilesAsync(); break; case GammaTXClearEnv.DISK: task = GammaProxyFactory.GetCrsCleanerProxy(machine).CleanDiskAsync(); break; case GammaTXClearEnv.DRIVER: task = GammaProxyFactory.GetCrsCleanerProxy(machine).RemoveDrvLtrAsync(); break; default: task = GenerateCompletedTask(TX_RESULT_SUC); break; } BindCmdTaskWithTranscation(task, trx); } else { /* * reboot node transaction no need to Bind, as it will always fails by its mean. */ var tmp = GammaProxyFactory.GetCrsCleanerProxy(machine).RestartComputerAsync(); task = tmp.ContinueWith <string>((t) => { trx.TransactionCompleted(); return(TX_RESULT_SUC); }); } return(task); }
internal static GammaClientTransaction GetClearEnvTX(IMachineInfo machine, GammaTXClearEnv op_code) { var trx = new GammaClientTransaction() { Machine = machine.MachineName, TX_TYPE = GammaTransactionType.CLEARENV, TX_SUB_TYPE = (int)op_code, TX_CONTENT = string.Empty, TX_RESULT = string.Empty, TX_RESULT_CODE = GammaTransactionRC.RUNNING, }; GammaClientTXLogger.GetInstance().RegisterTransaction(trx); return(trx); }
private ObservableCollection <IOraDB> GetDBnames(IMachineInfo machine) { var proxy = GammaProxyFactory.GetCrsEnvProxy(machine); var rs = proxy.GetDBNames(); var dbnames = rs.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).ToList(); int count = 0; var rs_list = new ObservableCollection <IOraDB>(); foreach (var db in dbnames) { var dbhome = proxy.GetDBHOMEByName(db); rs_list.Add(OraDBFactory.GetOraDB(count, db, dbhome)); count++; } return(rs_list); }
public async static Task <string> ExecuteCmdsSeqByNodeAsync(IMachineInfo machine, string[] multi_cmd) { if (multi_cmd.Count() == 1) { return(ExecuteCmdSync(machine, multi_cmd[0])); } StringBuilder sb = new StringBuilder(); foreach (string cmd in multi_cmd) { string tmp = await ExecuteCmdAsync(machine, cmd); sb.AppendFormat("cmd: {0}, result: {1}", cmd, tmp); sb.AppendLine(); } return(sb.ToString()); }
private Task <string> StartTransactions(IGammaClientTransaction trx, IMachineInfo machine, GammaTXQATools tool, object qatoolArgs = null) { trx.TransactionStarted(); Task <string> task; switch (tool) { case GammaTXQATools.GETLOG: if (qatoolArgs != null) { bool tmp = (bool)qatoolArgs; task = GammaProxyFactory.GetQAToolsProxy(machine).GetLogAsync(tmp); } else { throw new Exception("Unexpected error when try to get operation option."); } break; case GammaTXQATools.CLEARLOG: task = GammaProxyFactory.GetQAToolsProxy(machine).ClearLogAsync(); break; case GammaTXQATools.UPLOAD: if (qatoolArgs != null) { GammaServiceLib.UploadRecord tmp = qatoolArgs as GammaServiceLib.UploadRecord; task = GammaProxyFactory.GetQAToolsProxy(machine).UploadLogAsync(tmp); } else { throw new Exception("Unexpected error when try to get upload information."); } break; default: task = GenerateCompletedTask(TX_RESULT_SUC); break; } BindCmdTaskWithTranscation(task, trx); return(task); }
internal static GammaClientTransaction GetCmdExecTX(IMachineInfo machine, string[] command) { var sb = new StringBuilder(); foreach (var cmd in command) { sb.AppendFormat("{0};", cmd); } var trx = new GammaClientTransaction() { Machine = machine.MachineName, TX_TYPE = GammaTransactionType.COMMAND, TX_CONTENT = sb.ToString(), TX_RESULT = string.Empty, TX_RESULT_CODE = GammaTransactionRC.RUNNING, }; GammaClientTXLogger.GetInstance().RegisterTransaction(trx); return(trx); }
//Notified update of node status private void Ping_Complete(object sender, PingCompletedEventArgs k) { PingReply reply = k.Reply; IMachineInfo machine = k.UserState as IMachineInfo; try { if (reply.Status == IPStatus.Success) { machine.Alive = (NodeState.Online); } else { machine.Alive = (NodeState.Offline); } } catch (NullReferenceException e) { machine.Alive = (NodeState.Unknown); } }
public DateTime AddStatusBegin(IMachineInfo machine, bool IsCycling) { return(_statusAddDoer.Invoke(machine, IsCycling)); }
public SystemMessage(IMachineInfo machineInfo, ISystemSource source) { Source = source; MessageDateTime = DateTime.Now; MachineInfo = machineInfo; }
public MachineIsRunningInflux(IMachineInfo machine) : base(machine) { }
public void AddConnectionStatusBegin(IMachineInfo machine, bool IsConnected) { _connectionAddDoer.Invoke(machine, IsConnected); }
public LicenseManager(IMachineInfo machineInfo) { this.machineInfo = machineInfo; }
public static ProxyQATools GetQAToolsProxy(IMachineInfo machine) { string uri = string.Format("http://{0}:{1}/GammaService/QATools", machine.NetworkCompent.GetWorkingNic(), machine.NetworkCompent.GetWorkingServicePort()); return(new ProxyQATools(uri)); }
public SystemMonitorController(IAtlassRequest atlassRequest, IMachineInfo machineInfo) { RequestHelper = atlassRequest; _machineInfo = machineInfo; }
public ServerHealthService(IMachineInfo machineInfo) { Hostname = machineInfo.GetHostname(); }
public MachineStatusInflux(IMachineInfo machineInfo) : base(machineInfo) { }
public static ProxyCrsEnv GetCrsEnvProxy(IMachineInfo machine) { string uri = string.Format("http://{0}:{1}/GammaService/CrsEnv", machine.NetworkCompent.GetWorkingNic(), machine.NetworkCompent.GetWorkingServicePort()); return(new ProxyCrsEnv(uri)); }
public static ProxyDBWorkload GetDBWorkloadProxy(IMachineInfo machine) { string uri = string.Format("http://{0}:{1}/GammaService/DBWorkload", machine.NetworkCompent.GetWorkingNic(), machine.NetworkCompent.GetWorkingServicePort()); return(new ProxyDBWorkload(uri)); }