public static TaskResults Run(Coaster coaster)
{
TaskResults taskResults = TaskResults.Successful;
taskResults = BuildToYaw.Run(
coaster,
new List <float>()
{
MathHelper.KeepBetween360Degrees(coaster.Tracks[Rules.lastCollsionIndex].Yaw),
MathHelper.KeepBetween360Degrees(coaster.Tracks[Rules.lastCollsionIndex].Yaw + 180),
MathHelper.KeepBetween360Degrees(Builder.lastRuleIssueTrack.Yaw + 180)
});
return(taskResults);
//if(taskResults == TaskResults.Successful)
//{
// return taskResults;
//}
////Go To XYZ
//float x = coaster.LastTrack.X;
//float y = coaster.LastTrack.Y;
//float z = coaster.LastTrack.Z;
////Determine
//x = x + (float)(Math.Cos(MathHelper.ToRadians(coaster.LastTrack.Yaw)) * Math.Cos(MathHelper.ToRadians(coaster.LastTrack.Pitch)) * Globals.TRACK_LENGTH * 10);
//y = y + (float)(Math.Sin(MathHelper.ToRadians(coaster.LastTrack.Yaw)) * Math.Cos(MathHelper.ToRadians(coaster.LastTrack.Pitch)) * Globals.TRACK_LENGTH * 10);
//z = z + (float)(Math.Sin(MathHelper.ToRadians(coaster.LastTrack.Pitch)) * Globals.TRACK_LENGTH * 10);
////Check if there in bonunds and that there is no track at that location
////Try To Build To them
////If Fail return fail.
}
/// <summary>
/// Istanzia un nuovo oggetto della classe TaskExecutionCompletedEventArgs con i parametri specificati.
/// </summary>
/// <param name="cancelled">un valore che indica se il task è stato annullato</param>
/// <param name="error">l'eventuale errore verificatosi durante la comunicazione col servizio</param>
/// <param name="result">gli eventuali risultati scaricati dal server di elaborazione</param>
/// <param name="id">l'identificativo del task assegnato dal servizio di elaborazione</param>
/// <remarks>
/// Se non si è verificato alcun errore durante la comunicazione col servizio, il patametro corrispondente
/// va impostato a null. In modo analogo, se i risultati dell'elaborazione di un task non sono disponibili
/// a causa di un errore o perché l'operazione è stata annullata, il parametro corrispondente dovrà essere
/// impostato a null.
/// </remarks>
public TaskExecutionCompletedEventArgs(bool cancelled, Exception error, TaskResults result, string id)
{
Cancelled = cancelled;
Error = error;
Result = result;
Id = id;
}
/// <summary>
/// Permette il trasferimento dei risultati relativi ad un task già elaborato e specificato dal proprio
/// identificativo, impostando l'oggetto che dovrà contenere queste informazioni.
/// </summary>
/// <param name="id">l'identificativo precedentemente associato alla richiesta di elaborazione</param>
/// <param name="results">i risultati relativi al task di cui è stata completata l'elaborazione</param>
public void GetResults(string id, out TaskResults results)
{
m_Container.WriteToLog("GetResults: task request id = {0}.", id);
ServiceFault fault = null;
// Ottiene la copia dei metadati relativi al task.
TaskMetadata tm;
if (!m_Container.TryGetUserTask(id, out tm, out fault))
{
throw new FaultException<ServiceFault>(fault);
}
m_Container.WriteToLog("GetResults: sending results from file {0}.", tm.PathToTargetFile);
// Prepara e invia il risultato.
try
{
results = new TaskResults()
{
ElapsedTime = m_Container.GetProcessingTime(tm),
EncounteredErrors = tm.Errors,
Contents = File.ReadAllText(tm.PathToTargetFile)
};
}
catch (Exception e)
{
m_Container.HandleError(e.ToString(), ServiceFaultCode.SendTaskResultsFailed, out fault);
throw new FaultException<ServiceFault>(fault);
}
}
/// <summary>
/// Istanzia un nuovo oggetto della classe TaskExecutionCompletedEventArgs con i parametri specificati.
/// </summary>
/// <param name="cancelled">un valore che indica se il task è stato annullato</param>
/// <param name="error">l'eventuale errore verificatosi durante la comunicazione col servizio</param>
/// <param name="result">gli eventuali risultati scaricati dal server di elaborazione</param>
/// <param name="id">l'identificativo del task assegnato dal servizio di elaborazione</param>
/// <remarks>
/// Se non si è verificato alcun errore durante la comunicazione col servizio, il patametro corrispondente
/// va impostato a null. In modo analogo, se i risultati dell'elaborazione di un task non sono disponibili
/// a causa di un errore o perché l'operazione è stata annullata, il parametro corrispondente dovrà essere
/// impostato a null.
/// </remarks>
public TaskExecutionCompletedEventArgs(bool cancelled, Exception error, TaskResults result, string id)
{
Cancelled = cancelled;
Error = error;
Result = result;
Id = id;
}
public static TaskResults Run(Coaster coaster, List <float> angles)
{
List <BuildAction> buildActions = new List <BuildAction>();
TaskResults results = TaskResults.Fail;
buildActions.Clear();
for (int i = 0; i < 15; i++)
{
float startPitch = coaster.LastTrack.Pitch;
foreach (float angle in angles)
{
results = Builder.BuildTracks(DetermineActions(angle, i, startPitch), coaster);
if (results == TaskResults.Successful)
{
return(results);
}
else
{
coaster.Reset();
}
}
}
return(results);
}
private static void te_OnTaskExecutionCompleted(object sender, TaskExecutionCompletedEventArgs e)
{
string result = string.Empty;
string report = string.Empty;
if (e.Cancelled)
{
report = string.Format("Annullato (task id = {0}).", e.Id);
}
else if (e.Error != null)
{
report = string.Format("Errore (task id = {0}).", e.Id) + e.Error.Message;
}
else
{
TaskResults tr = e.Result;
report = string.Format("Completato (task id = {0}) in {1} con {2} errori.",
e.Id, tr.ElapsedTime, tr.EncounteredErrors.Length);
result = string.Format("Risultati (task id = {0}).", e.Id) + Environment.NewLine + tr.Contents;
}
Console.WriteLine(report);
Console.WriteLine("result: " + result);
mre.Set();
}
/// <summary>
/// Permette il trasferimento dei risultati relativi ad un task già elaborato e specificato dal proprio
/// identificativo, impostando l'oggetto che dovrà contenere queste informazioni.
/// </summary>
/// <param name="id">l'identificativo precedentemente associato alla richiesta di elaborazione</param>
/// <param name="results">i risultati relativi al task di cui è stata completata l'elaborazione</param>
public void GetResults(string id, out TaskResults results)
{
m_Container.WriteToLog("GetResults: task request id = {0}.", id);
ServiceFault fault = null;
// Ottiene la copia dei metadati relativi al task.
TaskMetadata tm;
if (!m_Container.TryGetUserTask(id, out tm, out fault))
{
throw new FaultException <ServiceFault>(fault);
}
m_Container.WriteToLog("GetResults: sending results from file {0}.", tm.PathToTargetFile);
// Prepara e invia il risultato.
try
{
results = new TaskResults()
{
ElapsedTime = m_Container.GetProcessingTime(tm),
EncounteredErrors = tm.Errors,
Contents = File.ReadAllText(tm.PathToTargetFile)
};
}
catch (Exception e)
{
m_Container.HandleError(e.ToString(), ServiceFaultCode.SendTaskResultsFailed, out fault);
throw new FaultException <ServiceFault>(fault);
}
}
public BuildTask(BuildTaskManager manager)
{
Manager = manager;
_importers = new Dictionary <string, ImporterInstance>();
_processors = new Dictionary <string, ProcessorInstance>();
Results = new TaskResults();
}
public TaskResults Run(Coaster coaster)
{
TaskResults results = RCLibrary.Support.BuildToXY.Run(
coaster,
Globals.FINSH_AREA_X,
Globals.FINSH_AREA_Y,
Globals.FINSH_AREA_X_RANGE,
Globals.FINSH_AREA_Y_RANGE);
return(results);
}
/// <summary>
/// Genera un nuovo evento per notificare il completamento della richiesta di elaborazione del task.
/// </summary>
/// <param name="cancelled">un valore che indica se il task è stato annullato</param>
/// <param name="error">l'eventuale errore verificatosi durante la comunicazione col servizio</param>
/// <param name="result">gli eventuali risultati scaricati dal server di elaborazione</param>
/// <remarks>
/// Se non si è verificato alcun errore durante la comunicazione col servizio, il patametro corrispondente
/// va impostato a null. In modo analogo, se i risultati dell'elaborazione di un task non sono disponibili
/// a causa di un errore o perché l'operazione è stata annullata, il parametro corrispondente dovrà essere
/// impostato a null.
/// </remarks>
private void RaiseTaskExecutionCompleted(bool cancelled, Exception error, TaskResults result)
{
TaskExecutionCompletedHandler handler = OnTaskExecutionCompleted;
if (handler != null)
{
TaskExecutionCompletedEventArgs args =
new TaskExecutionCompletedEventArgs(cancelled, error, result, m_TaskRequestId);
OnTaskExecutionCompleted(this, args);
}
}
public void BuildToX(float x, float withInX)
{
if (coaster.TracksStarted == false)
{
return;
}
TaskResults results = RCLibrary.Support.BuildToX.Run(coaster, x, withInX);
builder.ProcessAfterBuildAttempt(coaster, results);
}
public void BuildToPitch(List <float> pitch)
{
if (coaster.TracksStarted == false)
{
return;
}
TaskResults results = RCLibrary.Support.BuildToPitch.Run(coaster, pitch);
builder.ProcessAfterBuildAttempt(coaster, results);
}
/// <summary>
/// Determina l'avvio della procedura che permette di inviare il task specificato al servizio di elaborazione,
/// di verificarne periodicamente il completamento e di eseguire alla fine il download dei relativi risultati
/// eventualmente prodotti.
/// </summary>
/// <remarks>
/// Prima di invocare questo metodo, è necessario utilizzare il metodo SetTaskData per poter impostare i dati
/// relativi al task da elaborare.
/// Inoltre, questo metodo non dovrebbe essere invocato sul thread della UI, in quanto la verifica periodica
/// del completamento dell'elaborazione blocca tale thread per l'intervallo di polling specificato.
/// </remarks>
public void Start()
{
if (m_Proxy == null)
{
try
{
RaiseTaskExecutionProgress(TaskRequestState.InitializingProxy, null);
m_Proxy = new ProcessingServiceClient(m_Binding, m_Endpoint);
m_Proxy.Open();
RaiseTaskExecutionProgress(TaskRequestState.ProxyInitialized, null);
RaiseTaskExecutionProgress(TaskRequestState.SendingRequest, null);
m_TaskRequestId = m_Proxy.SubmitData(m_TaskData);
RaiseTaskExecutionProgress(TaskRequestState.RequestSent, null);
bool completed = false;
while (!completed)
{
m_PollingWaitHandle.WaitOne(m_PollingInterval);
TaskState ts = m_Proxy.GetState(m_TaskRequestId);
switch (ts)
{
case TaskState.Completed:
RaiseTaskExecutionProgress(TaskRequestState.DownloadingResults, null);
m_TaskResults = m_Proxy.GetResults(m_TaskRequestId);
RaiseTaskExecutionProgress(TaskRequestState.ResultsDownloaded, null);
RaiseTaskExecutionCompleted(false, null, m_TaskResults);
completed = true;
break;
case TaskState.None:
completed = true;
break;
default:
completed = false;
break;
}
}
RaiseTaskExecutionProgress(TaskRequestState.DisposingProxy, null);
m_Proxy.Close();
RaiseTaskExecutionProgress(TaskRequestState.ProxyDisposed, null);
}
catch (Exception ex)
{
HandleError(ex);
}
}
}
private static TaskResults GoToZ(Coaster coaster, float z, float withIn)
{
List <BuildAction> buildActions = new List <BuildAction>();
TaskResults results = TaskResults.Successful;
float pitchGoal = 0;
float lastDistance = Math.Abs(coaster.LastTrack.Z - z);
if (z > coaster.LastTrack.Z)
{
pitchGoal = 90;
}
else
{
pitchGoal = 270;
}
results = BuildToPitch.Run(coaster, new List <float>()
{
pitchGoal
});
if (results != TaskResults.Successful)
{
return(results);
}
while (!((coaster.LastTrack.Z < z + (withIn / 2) && coaster.LastTrack.Z > z - (withIn / 2))) && results == TaskResults.Successful)
{
buildActions.Add(new BuildAction(TrackType.Stright));
results = Builder.BuildTracks(buildActions, coaster);
buildActions.Clear();
float distance = Math.Abs(coaster.LastTrack.Z - z);
if (distance >= lastDistance)
{
return(TaskResults.Fail);
}
lastDistance = distance;
}
if (coaster.LastTrack.Z < z + (withIn / 2) && coaster.LastTrack.Z > z - (withIn / 2))
{
return(TaskResults.Successful);
}
else
{
return(TaskResults.Fail);
}
}
public bool ProcessBuildAction(Coaster coaster, BuilderTask task)
{
if (coaster.TracksStarted == false || (lastBuildActionFail && task.GetType() == lastBuildTask.GetType()))
{
return(false);
}
TaskResults results = task.Run(coaster);
initialTaskResults = results;
initialTaskResults = results;
lastBuildTask = task;
return(ProcessAfterBuildAttempt(coaster, results));
}
public IterationResult(SymuEnvironment environment)
{
Environment = environment ?? throw new ArgumentNullException(nameof(environment));
OrganizationFlexibility = new OrganizationFlexibility(Environment);
KnowledgeAndBeliefResults = new KnowledgeAndBeliefResults(Environment);
Blockers = new BlockerResults(Environment);
Tasks = new TaskResults(Environment);
Messages = new MessageResults(Environment);
Results.Add(OrganizationFlexibility);
Results.Add(KnowledgeAndBeliefResults);
Results.Add(Blockers);
Results.Add(Tasks);
Results.Add(Messages);
Results.Add(KeyFrames);
}
/// <summary>
/// Istanzia un nuovo oggetto della classe TaskExecution con i parametri specificati.
/// </summary>
/// <param name="serviceUri">indirizzo del servizio di elaborazione del task</param>
/// <param name="pollingInterval">tempo di attesa nella verifica di completamento del task</param>
/// <exception cref="UriFormatException">
/// Se si specifica un URI non valido come indirizzo del servizio di elaborazione.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Se si specifica il valore null come indirizzo del servizio di elaborazione.
/// </exception>
public TaskExecution(string serviceUri, TimeSpan pollingInterval)
{
m_PollingInterval = pollingInterval;
m_PollingWaitHandle = new ManualResetEvent(false);
m_Binding = new BasicHttpBinding();
m_Endpoint = new EndpointAddress(serviceUri);
m_Proxy = null;
m_CommunicationErrorsMapping = new Dictionary<Type, TaskExecutionState>()
{
{ typeof(TimeoutException), TaskExecutionState.TimeoutError },
{ typeof(EndpointNotFoundException), TaskExecutionState.ServiceNotFoundError },
{ typeof(CommunicationException), TaskExecutionState.CommunicationError }
};
m_TaskRequestId = string.Empty;
m_TaskData = new TaskData() { Name = string.Empty, Contents = string.Empty };
m_TaskResults = null;
}
public TaskResults Run(Coaster coaster)
{
List <Command> commands = new List <Command>();
List <BuildAction> buildActions = new List <BuildAction>();
TaskResults result = TaskResults.Fail;
bool loopDetected = true;
for (int i = coaster.TrackCount - 42; i < coaster.TrackCount; i++)
{
if (coaster.Tracks[i].TrackType != TrackType.Up)
{
loopDetected = false;
}
}
if (loopDetected)
{
for (int i = 0; i < 42; i++)
{
buildActions.Add(new BuildAction(true));
}
result = Builder.BuildTracks(buildActions, coaster);
if (result != TaskResults.Fail)
{
return((new BuildLoop()).Run(coaster));
}
else
{
return(result);
}
}
else
{
buildActions.Add(new BuildAction(TrackType.Up));
buildActions.Add(new BuildAction(TrackType.Up));
buildActions.Add(new BuildAction(TrackType.Up));
return(Builder.BuildTracks(buildActions, coaster));
}
}
/// <summary>
/// Istanzia un nuovo oggetto della classe TaskExecution con i parametri specificati.
/// </summary>
/// <param name="serviceUri">indirizzo del servizio di elaborazione del task</param>
/// <param name="pollingInterval">tempo di attesa nella verifica di completamento del task</param>
/// <exception cref="UriFormatException">
/// Se si specifica un URI non valido come indirizzo del servizio di elaborazione.
/// </exception>
/// <exception cref="ArgumentNullException">
/// Se si specifica il valore null come indirizzo del servizio di elaborazione.
/// </exception>
public TaskExecution(string serviceUri, TimeSpan pollingInterval)
{
m_PollingInterval = pollingInterval;
m_PollingWaitHandle = new ManualResetEvent(false);
m_Binding = new BasicHttpBinding();
m_Endpoint = new EndpointAddress(serviceUri);
m_Proxy = null;
m_CommunicationErrorsMapping = new Dictionary <Type, TaskRequestState>()
{
{ typeof(TimeoutException), TaskRequestState.TimeoutError },
{ typeof(EndpointNotFoundException), TaskRequestState.ServiceNotFoundError },
{ typeof(CommunicationException), TaskRequestState.CommunicationError }
};
m_TaskRequestId = string.Empty;
m_TaskData = new TaskData()
{
Name = string.Empty, Contents = string.Empty
};
m_TaskResults = null;
}
public static TaskResults BuildTracks(List <BuildAction> buildActions, Coaster coaster, bool removeChunk = false)
{
//Check If Coater Finshed
TaskResults result = TaskResults.Successful;
foreach (BuildAction buildAction in buildActions)
{
if (buildAction.RemoveTrack == false)
{
result = BuildTrack(coaster, buildAction);
}
else
{
result = RemoveTrack(coaster, removeChunk);
}
if (result != TaskResults.Successful)
{
break;
}
}
return(result);
}
public TaskResults Run(Coaster coaster)
{
TaskResults results = TaskResults.Fail;
List <BuildAction> buildActions = new List <BuildAction>();
if (coaster.LastTrack.Pitch == 0)
{
buildActions.Add(new BuildAction(TrackType.Custom));
for (int i = 0; i < 3; i++)
{
buildActions.Add(new BuildAction(TrackType.Custom));
}
results = Builder.BuildTracks(buildActions, coaster);
}
else
{
results = BuildToPitch.Run(coaster, new List <float>()
{
0
});
}
return(results);
}
public void BadGeneric()
{
Assert.ThrowsException <NullReferenceException>(() => TaskResults.BadGeneric <object>());
}
static void MainPrimes(string[] args)
{
DateTime tS = DateTime.UtcNow;
const int numJobs = 100;
const int numCores = 1;
// TODO - implement config class!
HPCUtilities.Init(HPCEnvironment.KubernetesAWS);
JobData jd;
SharedJobData sjd;
List <TaskData> tasks;
JobDataUtilities.CreateJobDataPrimes(
numJobs,
numCores,
out jd,
out sjd,
out tasks);
byte[] sharedDataBlob = HPCUtilities.Serialize(sjd);
List <byte[]> taskBlobs = new List <byte[]>();
foreach (var task in tasks)
{
taskBlobs.Add(HPCUtilities.Serialize(task));
}
// TODO - send shared data blob to cluster
// TODO - send task blobs to cluster
// TODO - collect results
// TODO - where should we output the data?
//string outputFolder = @"c:\temp\";
string dataDirectoryPath = null;
// send input file and task blobs to cluster, collect results
TaskSender taskSender = new TaskSender(Orchestrator.Docker);
List <byte[]> results = taskSender.Send(taskBlobs);
// DK - temp output results
Console.WriteLine("processing complete");
foreach (var result in results)
{
TaskResults taskResults = HPCUtilities.Deserialize <TaskResults>(result);
DataEntry[] data = taskResults.Results;
Console.Write("number: " + BitConverter.ToInt32(data[0].Data) + ", factors: ");
for (int i = 1; i < data.Length - 1; i++)
{
Console.Write(BitConverter.ToInt32(data[i].Data) + " ");
}
Console.WriteLine();
}
// DK- following code not quite hooked up yet with k8s
/*
*
* string[] resultFiles = new string[] { };
* List<ZOSResult> processedResults = new List<ZOSResult>();
* int numProcessed = 0;
* int numFail = 0;
* foreach (string resultFile in resultFiles)
* {
* var tr = HPCUtilities.Deserialize<TaskResults>(System.IO.File.ReadAllBytes(resultFile));
* ZOSResult result;
* JobDataUtilities.ProcessZOSResult(tr, out result);
* if (result != null)
* {
* JobDataUtilities.StoreZOSResult(jd.JobType, result, outputFolder, numProcessed);
* }
* else
* {
++numFail;
* }
++numProcessed;
* }
*
* int numSucceed;
* var stats = JobDataUtilities.GetZOSStats(
* jd.JobType,
* tS,
* outputFolder,
* out numSucceed,
* ref numFail);
*
* foreach (var stat in stats)
* {
* Console.WriteLine(stat.ToString());
* }
*
*/
Console.WriteLine();
Console.WriteLine("Press any key to exit");
Console.ReadKey();
}
/// <summary>
/// Genera un nuovo evento per notificare il completamento della richiesta di elaborazione del task.
/// </summary>
/// <param name="cancelled">un valore che indica se il task è stato annullato</param>
/// <param name="error">l'eventuale errore verificatosi durante la comunicazione col servizio</param>
/// <param name="result">gli eventuali risultati scaricati dal server di elaborazione</param>
/// <remarks>
/// Se non si è verificato alcun errore durante la comunicazione col servizio, il patametro corrispondente
/// va impostato a null. In modo analogo, se i risultati dell'elaborazione di un task non sono disponibili
/// a causa di un errore o perché l'operazione è stata annullata, il parametro corrispondente dovrà essere
/// impostato a null.
/// </remarks>
private void RaiseTaskExecutionCompleted(bool cancelled, Exception error, TaskResults result)
{
TaskExecutionCompletedHandler handler = OnTaskExecutionCompleted;
if (handler != null)
{
TaskExecutionCompletedEventArgs args =
new TaskExecutionCompletedEventArgs(cancelled, error, result, m_TaskRequestId);
OnTaskExecutionCompleted(this, args);
}
}
/// <summary>
/// There are no comments for TaskResults in the schema.
/// </summary>
public void AddToTaskResults(TaskResults taskResults)
{
base.AddObject("TaskResults", taskResults);
}
/// <summary>
/// Create a new TaskResults object.
/// </summary>
/// <param name="taskId">Initial value of TaskId.</param>
public static TaskResults CreateTaskResults(int taskId)
{
TaskResults taskResults = new TaskResults();
taskResults.TaskId = taskId;
return taskResults;
}
public void AddToTaskResults(int index)
{
GraphicsDataSet gds = null;
DataSet ds = null;
TaskResultNode tr = null;
string dsName = "No Name Found";
if (m_taskResults == null)
m_taskResults = FindControlRecursive(Page, m_taskResultsId) as TaskResults;
if (m_taskResults != null)
{
DataTable[] tbList =
System.Web.HttpContext.Current.Session["WebAppIdentifyDataTables"] as DataTable[];
DataTable tb = tbList[index];
if ( tb.ExtendedProperties.Contains("displayName") )
dsName = tb.ExtendedProperties["displayName"].ToString();
if(tb is GraphicsLayer)
{
gds = new GraphicsDataSet();
gds.DataSetName = dsName;
gds.Tables.Add(tb);
tr = m_taskResults.CreateTaskResultNode(null, null, null, gds, false, true);
}
else
{
ds = new DataSet();
ds.DataSetName = dsName;
ds.Tables.Add(tb);
tr = m_taskResults.CreateTaskResultNode(null, null, null, ds, false, true);
}
tr.Expanded = true;
m_taskResults.DisplayResults(null, null, null, tr);
this.CallbackResults.CopyFrom(m_taskResults.CallbackResults);
}
}
public Task GoodReferenceValueAsync()
{
return(TaskResults.GoodReferenceValueAsync().AsTask());
}
public Task GoodReferenceAsync()
{
return(TaskResults.GoodReferenceAsync());
}
/// <summary>
/// Determina l'avvio della procedura che permette di inviare il task specificato al servizio di elaborazione,
/// di verificarne periodicamente il completamento e di eseguire alla fine il download dei relativi risultati
/// eventualmente prodotti.
/// </summary>
/// <remarks>
/// Prima di invocare questo metodo, è necessario utilizzare il metodo SetTaskData per poter impostare i dati
/// relativi al task da elaborare.
/// Inoltre, questo metodo non dovrebbe essere invocato sul thread della UI, in quanto la verifica periodica
/// del completamento dell'elaborazione blocca tale thread per l'intervallo di polling specificato.
/// </remarks>
public void Start()
{
if (m_Proxy == null)
{
try
{
RaiseTaskExecutionProgress(TaskExecutionState.InitializingProxy, null);
m_Proxy = new ProcessingServiceClient(m_Binding, m_Endpoint);
m_Proxy.Open();
RaiseTaskExecutionProgress(TaskExecutionState.ProxyInitialized, null);
RaiseTaskExecutionProgress(TaskExecutionState.SendingRequest, null);
m_TaskRequestId = m_Proxy.SubmitData(m_TaskData);
RaiseTaskExecutionProgress(TaskExecutionState.RequestSent, null);
bool completed = false;
while (!completed)
{
m_PollingWaitHandle.WaitOne(m_PollingInterval);
TaskState ts = m_Proxy.GetState(m_TaskRequestId);
switch (ts)
{
case TaskState.Completed:
RaiseTaskExecutionProgress(TaskExecutionState.DownloadingResults, null);
m_TaskResults = m_Proxy.GetResults(m_TaskRequestId);
RaiseTaskExecutionProgress(TaskExecutionState.ResultsDownloaded, null);
completed = true;
break;
case TaskState.None:
completed = true;
break;
default:
completed = false;
break;
}
}
RaiseTaskExecutionProgress(TaskExecutionState.DisposingProxy, null);
m_Proxy.Close();
RaiseTaskExecutionProgress(TaskExecutionState.ProxyDisposed, null);
RaiseTaskExecutionCompleted(false, null, m_TaskResults);
}
catch (Exception ex)
{
HandleError(ex);
}
}
}
public async Task DefaultValueType()
{
Assert.AreEqual(false, await TaskResults.DefaultValueType());
}
public Task BadGenericNotNullConstraintAsync()
{
return(Assert.ThrowsExceptionAsync <NullReferenceException>(() => TaskResults.BadGenericAsync <object>()));
}
public Task GoodGenericNotNullConstraintAsync()
{
return(TaskResults.GoodGenericAsync <object>());
}
/// <summary>
/// Constructs an instance from the execution results of an
/// <see cref="AnsiblePlayer"/> play operation.
/// </summary>
/// <param name="rawResults">The execution results.</param>
internal AnsiblePlayResults(ExecuteResult rawResults)
{
Covenant.Requires <ArgumentNullException>(rawResults != null);
RawResults = rawResults;
if (rawResults.ExitCode != 0 && rawResults.ExitCode != 2)
{
// Must be a command line argument or playbook syntax error
// as opposed to a valid playbook that had one or more failed
// tasks.
throw new Exception(rawResults.ErrorText);
}
using (var reader = new StringReader(rawResults.OutputText))
{
string line;
// Skip over all lines until we see the first task line.
for (line = reader.ReadLine(); line != null; line = reader.ReadLine())
{
if (line.StartsWith("TASK [") && line.EndsWith("**********"))
{
break;
}
}
var sbTask = new StringBuilder();
var lastTask = false;
while (!lastTask)
{
// Capture the current line and any subsequent lines up to but not
// including the next task marker or the PLAY RECAP line and then
// use this to create the next task result.
sbTask.AppendLine(line);
for (line = reader.ReadLine(); line != null; line = reader.ReadLine())
{
if (line.StartsWith("TASK [") && line.EndsWith("**********"))
{
break;
}
else if (line.StartsWith("PLAY RECAP **********") && line.EndsWith("**********"))
{
lastTask = true;
break;
}
sbTask.AppendLine(line);
}
var taskResult = new AnsibleTaskResult(sbTask.ToString());
if (taskResult.HasStatus)
{
TaskResults.Add(taskResult);
}
if (!lastTask)
{
sbTask.Clear();
sbTask.AppendLine(line); // This is the first line of the next task
}
}
}
}
/// <summary>
/// Questo metodo viene invocato nel momento in cui gli eventuali risultati dell'elaborazione sono stati
/// ricevuti: in tal caso viene segnalato il completamento dell'elaborazione e richiesta la chiusura del
/// canale di comunicazione.
/// </summary>
/// <param name="sender">l'oggetto che ha generato l'evento</param>
/// <param name="args">informazioni aggiuntive sull'evento</param>
private void Proxy_GetResultsCompleted(object sender, GetResultsCompletedEventArgs args)
{
if (HandleCancellationIfRequired(args.Cancelled)) return;
if (HandleErrorIfRequired(args.Error)) return;
RaiseTaskExecutionProgress(TaskExecutionState.ResultsDownloaded, null);
m_TaskResults = args.Result;
RaiseTaskExecutionCompleted(false, null, m_TaskResults);
BeginCloseProxy();
}
protected override void OnPreRender(EventArgs e)
{
base.OnPreRender(e);
m_id = this.ClientID;
// find the map, task results and map resource manager controls
m_map = Page.FindControl(m_mapBuddyId) as Map;
m_taskResults = FindControlRecursive(Page, m_taskResultsId) as TaskResults;
m_resourceManger = m_map.MapResourceManagerInstance;
#region Register script for creating script object
ScriptManager sm = ScriptManager.GetCurrent(this.Page);
if (sm != null) sm.RegisterAsyncPostBackControl(this);
string create = String.Format("\nSys.Application.add_init(function() {{\n\t$create(ESRI.ADF.UI.MapIdentifyTool,{{\"id\":\"{3}\",\"uniqueID\":\"{0}\",\"callbackFunctionString\":\"{1}\",\"identifyIcon\":\"{4}\",\"waitIcon\":\"{5}\"}},null,{{\"map\":\"{2}\"}});\n\tMapIdentifyTool = function() {{ $find('{3}').startIdentify(); }};\n }});\n",
this.UniqueID, this.CallbackFunctionString, m_map.ClientID, this.ClientID, m_identifyIconUrl, m_waitIconUrl);
Page.ClientScript.RegisterStartupScript(this.GetType(), this.Id + "_startup", create, true);
#endregion
}
public Task GoodReferenceValueAsyncWithoutAwait()
{
return(TaskResults.GoodReferenceValueAsyncWithoutAwait().AsTask());
}
public Task BadReferenceAsync()
{
return(Assert.ThrowsExceptionAsync <NullReferenceException>(() => TaskResults.BadReferenceAsync()));
}
private static TaskResults GoToY(Coaster coaster, float y, float withIn, TrackType type)
{
List <BuildAction> buildActions = new List <BuildAction>();
TaskResults results = TaskResults.Successful;
float yawGoal = 0;
if (y > coaster.LastTrack.Y)
{
yawGoal = 0;
}
else
{
yawGoal = 180;
}
bool firstStrightTrack = true;
float lastY = 0;
float lastDiffernce = 0;
results = BuildToPitch.Run(coaster, new List <float>()
{
0
});
if (results != TaskResults.Successful)
{
return(results);
}
while (!((coaster.LastTrack.Y < y + (withIn / 2) && coaster.LastTrack.Y > y - (withIn / 2))) && results == TaskResults.Successful)
{
if (coaster.LastTrack.Yaw == yawGoal)
{
buildActions.Add(new BuildAction(TrackType.Stright));
results = Builder.BuildTracks(buildActions, coaster);
if (results != TaskResults.Successful)
{
return(results);
}
buildActions.Clear();
float differnce = Math.Abs(coaster.LastTrack.Y - lastY);
if (!firstStrightTrack)
{
//This Means You Passed The Goal Point, This could have been done by turning, Or After the Fact. But You Are now going the wrong way.
if (differnce > lastDiffernce)
{
return(TaskResults.Fail);
}
}
else
{
firstStrightTrack = true;
}
lastY = coaster.LastTrack.Y;
lastDiffernce = differnce;
}
else
{
buildActions.Add(new BuildAction(type));
results = Builder.BuildTracks(buildActions, coaster);
buildActions.Clear();
}
}
if (coaster.LastTrack.Y < y + (withIn / 2) && coaster.LastTrack.Y > y - (withIn / 2))
{
return(TaskResults.Successful);
}
else
{
return(TaskResults.Fail);
}
}
public Task BadReferenceAsyncValueWithoutAwait()
{
return(Assert.ThrowsExceptionAsync <NullReferenceException>(() => TaskResults.BadReferenceAsyncValueWithoutAwait().AsTask()));
}
