public static Task <string> ExecuteCmdAsync(IGammaMachineInfo machine, string single_command)
{
string filename = GetFileNameFromCmd(single_command);
string args = GetArgsFromCmd(single_command);
CmdExecutorProxy client = GammaProxyFactory.GetCmdExecutorProxy(machine);
return(client.ShellExecutorAsync(filename, args));
}
/*
* 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(IGammaMachineInfo machine, string[] commands)
{
return(Task.Run(() => {
var trx = GammaClientTXFactory.GetCmdExecTX(machine, commands);
AddTransaction(trx);
return StartTransactions(trx, machine, commands);
}));
}
/*
* Same as StartTransaction*S*, but single command.
*/
private Task <string> StartTransaction(IGammaClientTransaction trx, IGammaMachineInfo machine, string command)
{
trx.TransactionStarted();
var task = GammaCmdExecutorServiceFacade.ExecuteCmdAsync(machine, command);
BindCmdTaskWithTranscation(task, trx);
return(task);
}
/*
* QA tools transactions
*/
public Task <string> StartQAToolsTransaction(IGammaMachineInfo machine, GammaTXQATools tool, object qatoolArgs = null)
{
return(Task.Run(() =>
{
var trx = GammaClientTXFactory.GetQAToolsTX(machine, tool);
AddTransaction(trx);
return StartTransactions(trx, machine, tool, qatoolArgs);
}));
}
/*
* Clear environment transactions
*/
public Task <string> StartClearEnvTransaction(IGammaMachineInfo 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(IGammaMachineInfo machine, string command)
{
return(Task.Run(() => {
var trx = GammaClientTXFactory.GetCmdExecTX(machine, command);
GammaClientTXLogger.GetInstance().RegisterTransaction(trx);
AddTransaction(trx, seq);
return StartTransaction(trx, machine, command);
}));
}
internal static List <GammaClientTransaction> GetCmdParallelExecTX(IGammaMachineInfo 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(IGammaMachineInfo 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);
}
/*
* return the task based on the enum code.
* and also bind the task with the transaction here.
*/
private Task <string> StartTransactions(IGammaClientTransaction trx, IGammaMachineInfo 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 GetCmdExecTX(IGammaMachineInfo 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,
};
//init event handler
GammaClientTXLogger.GetInstance().RegisterTransaction(trx);
return(trx);
}
internal static GammaClientTransaction GetClearEnvTX(IGammaMachineInfo 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);
}
internal static GammaClientTransaction GetQAToolsTX(IGammaMachineInfo machine, GammaTXQATools op_code)
{
var trx = new GammaClientTransaction()
{
Machine = machine.MachineName,
TX_TYPE = GammaTransactionType.QATOOLS,
TX_SUB_TYPE = (int)op_code,
TX_CONTENT = string.Empty,
TX_RESULT = string.Empty,
TX_RESULT_CODE = GammaTransactionRC.RUNNING,
};
//init event handler
GammaClientTXLogger.GetInstance().RegisterTransaction(trx);
return(trx);
}
public async static Task <string> ExecuteCmdsSeqByNodeAsync(IGammaMachineInfo 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());
}
/*
* return the task based on the enum code.
* and also bind the task with the transaction here.
*/
private Task <string> StartTransactions(IGammaClientTransaction trx, IGammaMachineInfo 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);
}
//Notified update of node status
private void Ping_Complete(object sender, PingCompletedEventArgs k)
{
PingReply reply = k.Reply;
IGammaMachineInfo machine = k.UserState as IGammaMachineInfo;
try
{
if (reply.Status == IPStatus.Success)
{
machine.UpdateNotifiableProperties(NodeState.Online);
}
else
{
machine.UpdateNotifiableProperties(NodeState.Offline);
}
}
catch (NullReferenceException e)
{
machine.UpdateNotifiableProperties(NodeState.Unknown);
}
}
internal static GammaClientTransaction GetCmdExecTX(IGammaMachineInfo 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,
};
//init event handler
GammaClientTXLogger.GetInstance().RegisterTransaction(trx);
return(trx);
}
public static CrsCleanerProxy GetCrsCleanerProxy(IGammaMachineInfo machine)
{
string uri = string.Format("http://{0}:{1}/GammaService/CrsCleaner", machine.NetworkCompent.GetWorkingNic(), machine.NetworkCompent.GetWorkingServicePort());
return(new CrsCleanerProxy(uri));
}
public static DBWorkloadProxy GetDBWorkloadProxy(IGammaMachineInfo machine)
{
string uri = string.Format("http://{0}:{1}/GammaService/DBWorkload", machine.NetworkCompent.GetWorkingNic(), machine.NetworkCompent.GetWorkingServicePort());
return(new DBWorkloadProxy(uri));
}
