private void TransactionExpired(IGammaClientTransaction trx)
{
lock (locker)
{
gamma_transactions.Remove(trx);
}
}
/*
* 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);
}
private void AddTransaction(IGammaClientTransaction trx, ulong task_id)
{
lock (locker)
{
trx.TX_ID = task_id;
gamma_transactions.Add(trx);
}
}
/*
* return the task that run the command on the node.
* and also bind the task with the transaction here.
*/
private Task <string> StartTransactions(IGammaClientTransaction trx, IMachineInfo machine, string[] commands)
{
trx.TransactionStarted();
var task = ProxyFacadeCmdExecutor.ExecuteCmdsSeqByNodeAsync(machine, commands);
BindCmdTaskWithTranscation(task, trx);
return(task);
}
private void AddTransaction(IGammaClientTransaction trx)
{
lock (locker)
{
trx.TX_ID = seq;
seq += 1;
gamma_transactions.Add(trx);
}
}
/*
* Bind the task with the transaction, so that when the task is finished, it will set the trasaction's status
* And rasie the event to update the UI.
*/
private void BindCmdTaskWithTranscation(Task <string> task, IGammaClientTransaction trx)
{
task.GetAwaiter().OnCompleted(() => {//code here are still run by the thread who started the task.
if (task.IsCompleted)
{
trx.TX_RESULT = task.Result;
if (task.Result.ToString().ToLower().Contains(TX_RESULT_FAIL))
{
trx.TX_RESULT_CODE = GammaTransactionRC.FAIL;
trx.TransactionFailed();
}
else
{
trx.TX_RESULT_CODE = GammaTransactionRC.SUCCEED;
trx.TransactionCompleted();
}
}
else if (task.IsFaulted)
{
trx.TX_RESULT_CODE = GammaTransactionRC.UNKNOWN;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("[Task Faulted: Task Status is ] {0}", task.Status);
sb.AppendLine();
if (task.Exception != null)
{
task.Exception.Handle((x) => {
sb.AppendFormat("[Task Faulted Error: Exception ] {0}", x.Message);
sb.AppendLine();
return(true);
});
}
trx.TX_RESULT = sb.ToString();
trx.TransactionFailed();
}
else if (task.IsCanceled)
{
trx.TX_RESULT_CODE = GammaTransactionRC.UNKNOWN;
trx.TX_RESULT = "Task is canceled";
trx.TransactionFailed();
}
else
{
trx.TX_RESULT_CODE = GammaTransactionRC.UNKNOWN;
StringBuilder sb = new StringBuilder();
sb.AppendFormat("[Task Faulted: Task Status is ] {0}", task.Status);
sb.AppendLine();
trx.TX_RESULT = sb.ToString();
trx.TransactionFailed();
}
//Notify UI update//
ResultComesBack(trx);
});
}
private void ResultComesBack(IGammaClientTransaction transaction)
{
var handler = OnResultComesBack;
if (handler != null)
{
handler(this, new GammaUIUpdateArgs()
{
TRANSACTION = transaction
});
}
TransactionExpired(transaction);
}
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);
}
private void ClientTrx_OnTransactionStarted(object sender, EventArgs e)
{
IGammaClientTransaction trx = sender as IGammaClientTransaction;
StringBuilder sb = new StringBuilder();
if (trx != null)
{
sb.AppendFormat("{0} : {1} : {2} : {3} : {4} : {5}",
(DateTime.Now).ToString("yyyyMMddHHmmssffff"),
trx.TX_ID,
trx.TX_TYPE,
trx.TX_RESULT_CODE,
trx.Machine,
trx.TX_CONTENT.Trim());
sb.AppendLine();
LogInformation(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);
}
public void RegisterTransaction(IGammaClientTransaction clientTrx)
{
clientTrx.OnTransactionStarted += ClientTrx_OnTransactionStarted;
clientTrx.OnTransactionCompleted += ClientTrx_OnTransactionCompleted;
clientTrx.OnTransactionFailed += ClientTrx_OnTransactionFailed;
}
