private bool WaitForTurn()
{
bool completeSelf;
var success = false;
this.instanceOperation = new InstanceOperation {
RequiresInitialized = false
};
try
{
if (this.application.WaitForTurnAsync(this.instanceOperation, this.timeoutHelper.RemainingTime(), waitCompleteCallback, this))
{
completeSelf = this.ValidateState();
}
else
{
completeSelf = false;
}
success = true;
}
finally
{
if (!success)
{
this.NotifyOperationComplete();
}
}
return(completeSelf);
}
private bool ProcessResumption()
{
var stillSync = true;
this.resumptionResult = this.instance.ResumeBookmarkCore(this.bookmark, this.value);
if (this.resumptionResult == BookmarkResumptionResult.Success)
{
if (this.instance.Controller.HasPendingTrackingRecords)
{
var result = this.instance.Controller.BeginFlushTrackingRecords(this.timeoutHelper.RemainingTime(), this.PrepareAsyncCompletion(trackingCompleteCallback), this);
if (result.CompletedSynchronously)
{
stillSync = OnTrackingComplete(result);
}
else
{
stillSync = false;
}
}
}
else if (this.resumptionResult == BookmarkResumptionResult.NotReady)
{
this.NotifyOperationComplete();
this.currentOperation = new DeferredRequiresIdleOperation();
}
return(stillSync);
}
private void NotifyOperationComplete()
{
var lastOperation = this.currentOperation;
this.currentOperation = null;
this.instance.NotifyOperationComplete(lastOperation);
}
protected void Run(TimeSpan timeout)
{
this.timeoutHelper = new TimeoutHelper(timeout);
var operation = new InstanceOperation();
var completeSelf = true;
try
{
completeSelf = this.instance.WaitForTurnAsync(operation, this.timeoutHelper.RemainingTime(), waitCompleteCallback, this);
if (completeSelf)
{
this.ValidateState();
completeSelf = this.PerformOperationAndTrack();
}
}
finally
{
if (completeSelf)
{
this.instance.NotifyOperationComplete(operation);
}
}
if (completeSelf)
{
this.Complete(true);
}
}
private void NotifyOperationComplete()
{
if (this.application != null)
{
var localInstanceOperation = this.instanceOperation;
this.instanceOperation = null;
this.application.NotifyOperationComplete(localInstanceOperation);
}
}
private string ConvertInstanceOperation(InstanceOperation instOp)
{
switch (instOp)
{
case (InstanceOperation.Suspend):
return("suspend");
case (InstanceOperation.Terminate):
return("terminate");
case (InstanceOperation.Resume):
return("resume");
}
return("Error");
}
private void PrintStateTransitionStatus(InstanceOperation instOp, CompletionStatus operationStatus)
{
string operationType = ConvertInstanceOperation(instOp);
switch (operationStatus)
{
case (CompletionStatus.Succeeded):
Console.WriteLine("The " + operationType + " operation succeeded.");
return;
case (CompletionStatus.Failed):
Console.WriteLine("The " + operationType + " operation failed.");
return;
case (CompletionStatus.Pending):
Console.WriteLine("The " + operationType + " operation is pending or was skipped.");
return;
}
}
public void OperateOnInstance(InstanceOperation operation, Guid instanceID)
{
CompletionStatus operationStatus;
try
{
switch (operation)
{
case (InstanceOperation.Suspend):
PrintSampleName("SuspendInstance");
operationStatus = _operations.SuspendInstance(instanceID);
PrintStateTransitionStatus(InstanceOperation.Suspend, operationStatus);
return;
case (InstanceOperation.Terminate):
PrintSampleName("TerminateInstance");
operationStatus = _operations.TerminateInstance(instanceID);
PrintStateTransitionStatus(InstanceOperation.Terminate, operationStatus);
return;
case (InstanceOperation.Resume):
PrintSampleName("ResumeInstance");
operationStatus = _operations.ResumeInstance(instanceID);
PrintStateTransitionStatus(InstanceOperation.Resume, operationStatus);
return;
}
}
catch (ArgumentException ae)
{
Console.WriteLine("An argument exception occurred. It is possible that the input guid is an empty guid.");
Console.WriteLine("Specific details are: " + ae.Message);
}
catch (SqlException se)
{
Console.WriteLine("A SQL exception occurred. It is possible that one of the databases is down or that the SQL service isn't running.");
Console.WriteLine("Specific details are: " + se.Message);
}
}
public void send_instanceOperation(List<string> instances, InstanceOperation operations, Session session)
#endif
{
oprot_.WriteMessageBegin(new TMessage("instanceOperation", TMessageType.Call, seqid_));
instanceOperation_args args = new instanceOperation_args();
args.Instances = instances;
args.Operations = operations;
args.Session = session;
args.Write(oprot_);
oprot_.WriteMessageEnd();
#if SILVERLIGHT
return oprot_.Transport.BeginFlush(callback, state);
#else
oprot_.Transport.Flush();
#endif
}
public IAsyncResult send_instanceOperation(AsyncCallback callback, object state, List<string> instances, InstanceOperation operations, Session session)
public void instanceOperation(List<string> instances, InstanceOperation operations, Session session)
{
#if !SILVERLIGHT
send_instanceOperation(instances, operations, session);
recv_instanceOperation();
#else
var asyncResult = Begin_instanceOperation(null, null, instances, operations, session);
End_instanceOperation(asyncResult);
#endif
}
public IAsyncResult Begin_instanceOperation(AsyncCallback callback, object state, List<string> instances, InstanceOperation operations, Session session)
{
return send_instanceOperation(callback, state, instances, operations, session);
}
private bool StartResumptionLoop()
{
this.currentOperation = new RequiresIdleOperation(this.isFromExtension);
return(this.WaitOnCurrentOperation());
}
public WaitForTurnData(Action <object, TimeoutException> callback, object state, InstanceOperation operation, WorkflowApplication instance)
{
this.Callback = callback;
this.State = state;
this.Operation = operation;
this.Instance = instance;
}
