/*
* 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));
}
