public async Task PutsServiceInDequeingStateUntilQueueReturnsMessage()
{
// Arrange
var runner = new TestableJobRunner(TimeSpan.FromSeconds(5), skipDispatch: true);
var cts = new CancellationTokenSource();
var dequeueTcs = runner.MockQueue
.Setup(q => q.Dequeue(JobRunner.DefaultInvisibilityPeriod, cts.Token))
.WaitsForSignal();
RunnerStatus statusAtHeartBeat = RunnerStatus.Working;
runner.Heartbeat += (_, __) => statusAtHeartBeat = runner.Status;
// Act
var task = runner.Run(cts.Token);
// Assert
Assert.Equal(RunnerStatus.Dequeuing, runner.Status);
Assert.Equal(RunnerStatus.Dequeuing, statusAtHeartBeat);
// Abort the waiting threads
dequeueTcs.SetException(new OperationCanceledException());
cts.Cancel();
try
{
await task;
}
catch (TaskCanceledException) { }
}
public HorizonRunnerForm()
{
InitializeComponent();
Status = RunnerStatus.Stopped;
OnSuccess = new CallbackDelegate(DoNothing);
OnFailure = new CallbackDelegate(DoNothing);
}
public async Task PutsServiceIntoSleepingStateWhenDequeueReturnsNoMessage()
{
// Arrange
var cts = new CancellationTokenSource();
var runner = new TestableJobRunner(TimeSpan.FromSeconds(5), skipDispatch: true);
var dequeueTcs = runner.MockQueue
.Setup(q => q.Dequeue(JobRunner.DefaultInvisibilityPeriod, cts.Token))
.WaitsForSignal();
RunnerStatus statusAtLastHeartBeat = RunnerStatus.Working;
runner.Heartbeat += (_, __) => statusAtLastHeartBeat = runner.Status;
dequeueTcs.SetResult(null);
// Act, run the task to the sleep
var task = runner.Run(cts.Token);
// Assert
Assert.Equal(RunnerStatus.Sleeping, runner.Status);
Assert.Equal(RunnerStatus.Sleeping, statusAtLastHeartBeat);
// Abort the waiting threads
runner.VirtualClock.Advance(TimeSpan.FromMinutes(10));
cts.Cancel();
try
{
await task;
}
catch (TaskCanceledException) { }
}
private void SetStatus(RunnerStatus runnerStatus)
{
lock (_lock)
{
_runnerStatus = runnerStatus;
}
}
public void Pause()
{
if (Status == RunnerStatus.Play)
{
Status = RunnerStatus.Pause;
}
}
private void backgroundWorker1_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
// Update labels and call proper delegates
if (!this.cancelled && textBox1.Text.Contains("DONE!"))
{
this.taskLabel.Text = "Horizon Simulation Complete!";
OnSuccess();
}
else if (this.cancelled)
{
this.taskLabel.Text = "Simulation Terminated per User Request!";
OnFailure();
}
else
{
this.taskLabel.Text = "Simulation Failed";
OnFailure();
}
// Disable buttons
this.cancelButton.Enabled = false;
this.continueButton.Enabled = true;
// Update status
Status = RunnerStatus.FinishedSuccess;
}
public void Stop()
{
if (_run)
{
_runnerStatus = RunnerStatus.Stopped;
_cts.Cancel();
}
}
void Awake()
{
m_runnerController = GetComponent <RunnerController>();
m_runnerInput = GetComponent <RunnerInput>();
m_status = GetComponent <RunnerStatus>();
m_runnerSkill = GetComponent <RunnerSkill>();
m_animatorManeger = new AnimatorManager(GetComponentsInChildren <Animator>(true));
}
protected void FireOnResult(int id, int SI, string firstName, string lastName, string club, string Class, int start, int time, RunnerStatus status, List<ResultStruct> results)
{
ResultDelegate dlg = OnResult;
if (dlg != null)
{
dlg(id, SI, firstName, lastName, club, Class, start, time, status, results);
}
}
private void ChangeStatus(RunnerStatus runnerStatus)
{
lock (_lock)
{
_runnerStatus = runnerStatus;
}
_uiControl.ChangeConfigUiStatus(this);
}
private void cancelButton_Click(object sender, EventArgs e)
{
this.backgroundWorker1.CancelAsync();
this.cancelButton.Enabled = false;
this.taskLabel.Text = "Terminating Simulation...";
this.progressBar1.Value = 100;
Status = RunnerStatus.FinishedCancelled;
}
private void Awake()
{
m_uIController = GameObject.Find("UIController").GetComponent <UIController>();;
m_runnerInput = GetComponent <RunnerInput>();
m_runnerStatus = GetComponent <RunnerStatus>();
m_runnerSkill = GetComponent <RunnerSkill>();
m_rigidbody = GetComponent <Rigidbody>();
m_animaton = GetComponent <PlayerAnimator>();
}
public WorkServiceStatus(RunnerStatus runnerStatus, Guid currentInvocationId, Guid lastInvocationId, JobDescription currentJob, JobDescription lastJob, Exception error)
{
RunnerStatus = runnerStatus;
CurrentInvocationId = currentInvocationId;
LastInvocationId = lastInvocationId;
CurrentJob = currentJob;
LastJob = lastJob;
Error = error;
}
private void HorizonRunnerForm_Load(object sender, EventArgs e)
{
this.textBox1.Text = "Launching Horizon. Please stand by..." + Environment.NewLine;
this.continueButton.Enabled = false;
this.cancelButton.Enabled = true;
this.backgroundWorker1.RunWorkerAsync();
Status = RunnerStatus.Stopped;
}
public WorkServiceStatus(RunnerStatus runnerStatus, Guid currentInvocationId, Guid lastInvocationId, JobDescription currentJob, JobDescription lastJob, Exception error)
{
RunnerStatus = runnerStatus;
CurrentInvocationId = currentInvocationId;
LastInvocationId = lastInvocationId;
CurrentJob = currentJob;
LastJob = lastJob;
Error = error;
}
public ConfigRunner(SkylineBatchConfig config, ISkylineBatchLogger logger, IMainUiControl uiControl = null)
{
_runnerStatus = RunnerStatus.Stopped;
Config = config;
_uiControl = uiControl;
_logger = logger;
}
void Start()
{
m_runnerStatus = GetComponent <RunnerStatus>();
m_runnerInput = GetComponent <RunnerInput>();
m_runnerMove = GetComponent <RunnerMove>();
m_runnerController = GetComponent <RunnerController>();
m_uIController = GameObject.Find("UIController").GetComponent <UIController>();;
m_runnerAnimator = GetComponent <PlayerAnimator>();
m_playerNum = m_runnerController.m_playerNum;
}
public ConfigRunner(AutoQcConfig config, IMainUiControl uiControl)
{
_runnerStatus = RunnerStatus.Stopped;
Config = config;
_uiControl = uiControl;
CreateLogger();
}
/// <summary>
/// Write the status of the service to the watch directory.
/// </summary>
private void SetStatus()
{
RunnerStatus status = new RunnerStatus {
Timestamp = DateTime.Now,
//LogFilePath = Log.LogFilePath,
RevitVersion = mApplication?.ControlledApplication?.VersionName
};
JsonHelper.ToFile(FileNames.RunnerStatusFilePath, status);
}
public void Start(int bot)
{
if (!_run)
{
if (_wordlist == null)
{
throw new Exception("Wordlist is null.");
}
if (!_wordlist.HasNext)
{
throw new Exception("Wordlist is null.");
}
_theEnd = false;
_run = true;
_threadList.Clear();
_bot = bot;
if (_bot > _wordlist.Count - _position)
{
_bot = _wordlist.Count - _position;
}
_runnerStatus = RunnerStatus.Started;
try { OnStarted?.Invoke(this, new StartEventArgs()
{
Bot = _bot
}); } catch (Exception ex) { OnException?.Invoke(this, new ExceptionEventArgs()
{
Location = "OnStarted", Exception = ex, Log = _log
}); }
_stopwatch.Restart();
_stopwatch.Start();
_cts = new CancellationTokenSource();
for (int i = 0; i < _bot; i++)
{
int num = i;
Thread thread = new Thread(() => { Config(num, _cts.Token); })
{
IsBackground = true, Name = $"ID{num}"
};
thread.Start();
_threadList.Add(thread);
}
new Thread(() => { CompletedTask(); })
{
IsBackground = true
}.Start();
}
}
/// <summary>
/// Start loop of observing the watch directory.
/// </summary>
public void StartRunnerStatusWatcher(Action <RunnerStatus> aCallback, CancellationToken aCancellationToken)
{
while (!aCancellationToken.IsCancellationRequested)
{
RunnerStatus status = CheckStatus();
Task.Delay(1000, aCancellationToken);
aCallback(status);
}
}
public void ChangeStatus(RunnerStatus runnerStatus)
{
lock (_lock) // TODO: not required?
{
if (_runnerStatus == runnerStatus)
{
return;
}
_runnerStatus = runnerStatus;
}
_uiControl.ChangeConfigUiStatus(this);
}
/// <summary>
/// Get service status file from watch directory.
/// </summary>
private RunnerStatus CheckStatus()
{
RunnerStatus status = null;
try {
status = JsonHelper.FromFile <RunnerStatus>(FileNames.RunnerStatusFilePath);
}
catch {
// do nothing
}
return(status);
}
private void Awake()
{
m_runnerInput = GetComponent <RunnerInput>();
m_ChaserMove = GetComponent <ChaserMove>();
m_runnerStatus = GetComponent <RunnerStatus>();
m_rigidBody = GetComponent <Rigidbody>();
m_chaserColor = GetComponentInChildren <SkinnedMeshRenderer>().material.color;
m_playerAnimator = GetComponent <PlayerAnimator>();
m_uIController = GameObject.Find("UIController").GetComponent <UIController>();
//m_uIController = GetComponent<UIController>();
StatusInit();
m_chaserState = ChaserState.normal;
}
public void ChangeStatus(RunnerStatus runnerStatus)
{
lock (_lock)
{
if (_runnerStatus == runnerStatus)
{
return;
}
_runnerStatus = runnerStatus;
}
if (_uiControl != null)
{
_uiControl.UpdateUiConfigurations();
}
}
private static Runner CreateRunner(int id, string firstName, string lastName, string club, string Class, int start, int time, RunnerStatus status, List<ResultStruct> splits)
{
Runner r = new Runner()
{
ID = id,
FirstName = firstName,
LastName = lastName,
ClassName = Class,
ClubName = club,
Time = time,
Status = status,
StartTime = start,
RadioTimes = splits == null ? null : splits.ToDictionary(x => x.ControlCode, x => x.Time)
};
return r;
}
public async Task SleepsForPollIntervalWhenDequeueReturnsNoMessage()
{
// Arrange
var cts = new CancellationTokenSource();
var runner = new TestableJobRunner(TimeSpan.FromSeconds(5), skipDispatch: true);
var dequeueTcs = new TaskCompletionSource <InvocationState>();
runner.MockQueue
.Setup(q => q.Dequeue(JobRunner.DefaultInvisibilityPeriod, cts.Token))
.Returns(async() =>
{
var result = await dequeueTcs.Task;
dequeueTcs = new TaskCompletionSource <InvocationState>();
return(result);
});
RunnerStatus statusAtLastHeartBeat = RunnerStatus.Working;
runner.Heartbeat += (_, __) => statusAtLastHeartBeat = runner.Status;
dequeueTcs.SetResult(null);
runner.DispatchTCS.TrySetResult(null);
// Run to the sleep
var task = runner.Run(cts.Token);
runner.DispatchTCS = new TaskCompletionSource <object>();
// Act
runner.VirtualClock.Advance(TimeSpan.FromSeconds(5));
// Assert
Assert.Equal(RunnerStatus.Dequeuing, runner.Status);
Assert.Equal(RunnerStatus.Dequeuing, statusAtLastHeartBeat);
// Abort the waiting threads
runner.DispatchTCS.SetResult(null);
dequeueTcs.SetResult(null);
cts.Cancel();
try
{
await task;
}
catch (TaskCanceledException) { }
}
private void CompletedTask()
{
while (_run)
{
try
{
var activeThread = Active;
if (activeThread == 0 && _runnerStatus == RunnerStatus.Stopped)
{
_run = false;
_stopwatch.Stop();
_datapool.Clear();
_cts.Dispose();
try { OnStopped?.Invoke(this, new StopEventArgs()
{
WordList = _wordlist, Save = _save, Log = _log
}); } catch (Exception ex) { OnException?.Invoke(this, new ExceptionEventArgs()
{
Location = "OnStopped", Exception = ex, Log = _log
}); }
}
else if (activeThread == 0)
{
_run = false;
_stopwatch.Stop();
_datapool.Clear();
_cts.Dispose();
_runnerStatus = RunnerStatus.Completed;
try { OnCompleted?.Invoke(this, new EventArgs()); } catch (Exception ex) { OnException?.Invoke(this, new ExceptionEventArgs()
{
Location = "OnCompleted", Exception = ex, Log = _log
}); }
}
}
catch
{
}
Thread.Sleep(100);
}
}
void Awake()
{
m_rigidBody = GetComponent <Rigidbody>();
m_runnerInput = GetComponent <RunnerInput>();
m_runnerMove = GetComponent <RunnerMove>();
m_runnerStatus = GetComponent <RunnerStatus>();
m_runnerSkill = GetComponent <RunnerSkill>();
m_rigidBody = GetComponent <Rigidbody>();
m_runnerAnimator = GetComponent <PlayerAnimator>();
//初期ステータス
m_runnerStatus.firstSpeed = 2;
m_runnerStatus.maxSpeed = 3;
m_runnerStatus.health = 5;
m_runnerStatus.maxHealth = 5;
m_runnerStatus.isState = true;
m_runnerStatus.ishave = false;
m_runnerStatus.animator = GetComponent <Animator>();
if (ChaserFlag == false)
{
m_runnerStatus.animator.runtimeAnimatorController = Resources.Load <RuntimeAnimatorController>("Runner");
}
}
public void Stop()
{
if (_runnerStatus == RunnerStatus.Stopped)
{
return;
}
Task.Run(() =>
{
if (_fileWatcher != null)
{
_fileWatcher.Stop();
}
_totalImportCount = 0;
if (_worker != null && _worker.IsBusy)
{
_runnerStatus = RunnerStatus.Stopping;
CancelAsync();
}
else if (_runnerStatus != RunnerStatus.Error)
{
_runnerStatus = RunnerStatus.Stopped;
}
if (_runnerStatus == RunnerStatus.Stopped && _panoramaUploadError)
{
_runnerStatus = RunnerStatus.Error;
}
_uiControl.ChangeConfigUiStatus(this);
if (_panoramaPinger != null)
{
_panoramaPinger.Stop();
}
});
}
public async Task PutsServiceInDispatchingStateWhenQueueReturnsMessage()
{
// Arrange
var cts = new CancellationTokenSource();
var runner = new TestableJobRunner(TimeSpan.FromSeconds(5), skipDispatch: true);
var dequeueTcs = new TaskCompletionSource <InvocationState>();
runner.MockQueue
.Setup(q => q.Dequeue(JobRunner.DefaultInvisibilityPeriod, cts.Token))
.Returns(async() =>
{
var result = await dequeueTcs.Task;
dequeueTcs = new TaskCompletionSource <InvocationState>();
return(result);
});
RunnerStatus statusAtHeartBeat = RunnerStatus.Working;
runner.Heartbeat += (_, __) => statusAtHeartBeat = runner.Status;
// Act
var task = runner.Run(cts.Token);
dequeueTcs.SetResult(TestHelpers.CreateInvocation(Guid.NewGuid(), "test", "test", new Dictionary <string, string>()));
// Assert
Assert.Equal(RunnerStatus.Dispatching, runner.Status);
Assert.Equal(RunnerStatus.Dispatching, statusAtHeartBeat);
// Abort the waiting threads
cts.Cancel();
runner.DispatchTCS.TrySetResult(null);
dequeueTcs.SetResult(null);
try
{
await task;
}
catch (TaskCanceledException) { }
}
private void backgroundWorker1_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
int s = 0;
int l = 0;
String text = e.UserState as String;
Status = RunnerStatus.Running;
if (text.Contains("Integrator State:"))
{
this.taskLabel.Text = "Propagating Assets...";
s = "Integrator State:".Length;
l = text.IndexOf("%") - s;
this.progressBar1.Value = (int)Convert.ToDouble(text.Substring(s, l));
}
else if (text.Contains("Inserting Accesses:"))
{
this.taskLabel.Text = "Inserting Asset Tasks...";
s = "Inserting Accesses:".Length;
l = text.IndexOf("%") - s;
this.progressBar1.Value = (int)Convert.ToDouble(text.Substring(s, l));
}
else if (text.Contains("Scheduler Status:"))
{
this.taskLabel.Text = "Scheduling Tasks...";
s = "Scheduler Status:".Length;
l = text.IndexOf("%") - s;
this.progressBar1.Value = (int)Convert.ToDouble(text.Substring(s, l));
}
else if (text.Contains("DONE!"))
{
this.taskLabel.Text += " Complete!";
}
else
{
this.textBox1.AppendText(text + Environment.NewLine);
}
}
public void Run(IAlgorithm algorithm, IDictionary<string, string> parameters)
{
status = RunnerStatus.Running;
algorithm.AlgorithmRunner = this;
new Thread(() =>
{
try
{
Console.WriteLine("Worker thread running algorithm...");
var result = algorithm.Run(parameters);
workerPool.FinishComputation(Id, true, result);
}
catch (Exception ex)
{
Console.WriteLine("Error in thread running algorithm: " + ex.Message);
workerPool.FinishComputation(Id, false);
}
finally
{
status = RunnerStatus.Idle;
}
}).Start();
}
public bool Run()
{
if (this.gameObject == null || !this.gameObject.activeInHierarchy)
{
#if UNITY_EDITOR
UnityEngine.Debug.LogWarning(string.Format("Coroutine couldn't be started because game object '{0}:{1}' is inactive!", gameObject.name, gameObject.GetInstanceID()));
#endif
return(false);
}
if (EntryContainer.RootEntry == null)
{
#if UNITY_EDITOR
UnityEngine.Debug.Log("<color=green>No Root Entry found, 'Run' action cancelled.</color>");
#endif
return(false);
}
if (Status == RunnerStatus.Pause)
{
Status = RunnerStatus.Play;
return(true);
}
if (Status == RunnerStatus.Stop)
{
// コメントアウト理由：UIScalableButtonなど当初想定しなかった使い方に合わせるのために。UISystemではコメントアウトしない予定 by Lx
// ResetRunner();
numOfFinishedActionEntry = 0;
Status = RunnerStatus.Play;
PrepareEntry(EntryContainer.RootEntry);
StartCoroutine(Step(EntryContainer.RootEntry));
}
return(true);
}
void m_Parser_OnResult(int id, int SI, string firstName, string lastName, string club, string Class, int start, int time, RunnerStatus status, List<ResultStruct> splits)
{
if (!m_ModelEvent.Classes.ContainsKey(Class))
{
//New Class!
EventClass ec = new EventClass() { ClassName = Class, Runners = new Dictionary<int, Runner>(), Upload = true };
m_ModelEvent.Classes.Add(Class, ec);
m_ModelEvent.FireClassChanged(ec);
m_Logger("[" + Class + "] added");
Runner r = CreateRunner(id, firstName, lastName, club, Class, start, time, status, splits);
ec.Runners.Add(id, r);
m_ModelEvent.FireRunnerChanged(r);
}
else
{
if (!m_ModelEvent.Classes[Class].Runners.ContainsKey(id))
{
//new runner
Runner r = CreateRunner(id, firstName, lastName, club, Class, start, time, status, splits);
if (time == -2) //split updated
{
r.Time = -1;
r.Status = RunnerStatus.STARTED;
}
m_ModelEvent.Classes[Class].Runners.Add(id,r);
m_ModelEvent.FireRunnerChanged(r);
m_Logger("[" + Class + "] Runner " + r.FirstName + " " + r.LastName + " added..");
}
else
{
Runner r = m_ModelEvent.Classes[Class].Runners[id];
Dictionary<int, int> radioTimes = null;
if (splits != null)
{
radioTimes = splits.ToDictionary(x => x.ControlCode, x => x.Time);
}
if (time != -2)
{
if (r.MergeNewValues(start, time, status, r.RadioTimes))
{
m_ModelEvent.FireRunnerChanged(r);
m_Logger("[" + Class + "] Runner " + r.FirstName + " " + r.LastName + " changed..");
}
}
else
{
if (radioTimes != null)
{
bool haveChange = false;
foreach (var kvp in radioTimes)
{
if (r.RadioTimes.ContainsKey(kvp.Key))
{
if (r.RadioTimes[kvp.Key] != kvp.Value)
{
r.RadioTimes[kvp.Key] = kvp.Value;
haveChange = true;
}
}
else
{
r.RadioTimes.Add(kvp.Key, kvp.Value);
haveChange = true;
}
}
if (haveChange)
{
m_ModelEvent.FireRunnerChanged(r);
m_Logger("[" + Class + "] Runner " + r.FirstName + " " + r.LastName + " splittimechanged..");
}
}
}
}
}
}
public bool MergeNewValues(int startTime, int time, RunnerStatus status, Dictionary<int, int> radioTimes)
{
bool haveChanged = false;
if (startTime != StartTime)
{
StartTime = startTime;
haveChanged = true;
}
if (time != -2 && time != Time)
{
Time = time;
haveChanged = true;
}
if (time != -2 && status != Status)
{
Status = status;
haveChanged = true;
}
if (radioTimes != null)
{
foreach (var kvp in radioTimes)
{
if (!RadioTimes.ContainsKey(kvp.Key))
{
RadioTimes.Add(kvp.Key, kvp.Value);
haveChanged = true;
}
else if (RadioTimes[kvp.Key] != kvp.Value)
{
RadioTimes[kvp.Key] = kvp.Value;
haveChanged = true;
}
}
List<int> toDelete = new List<int>();
foreach (var kvp in RadioTimes)
{
if (!radioTimes.ContainsKey(kvp.Key))
{
toDelete.Add(kvp.Key);
haveChanged = true;
}
}
foreach (int i in toDelete)
{
RadioTimes.Remove(i);
}
}
return haveChanged;
}
protected JobRunner(TimeSpan pollInterval)
{
_status = RunnerStatus.Working;
_pollInterval = pollInterval;
}
public virtual async Task Run(CancellationToken cancelToken)
{
WorkServiceEventSource.Log.ReinitializingInvocationState(Queue.InstanceName);
await Queue.ReinitializeInvocationState();
WorkServiceEventSource.Log.ReinitializedInvocationState();
WorkServiceEventSource.Log.DispatchLoopStarted();
try
{
while (!cancelToken.IsCancellationRequested)
{
InvocationState invocation = null;
try
{
Status = RunnerStatus.Dequeuing;
invocation = await Queue.Dequeue(DefaultInvisibilityPeriod, cancelToken);
Status = RunnerStatus.Working;
}
catch (Exception ex)
{
WorkServiceEventSource.Log.ErrorRetrievingInvocation(ex);
}
// Check Cancellation
if (cancelToken.IsCancellationRequested)
{
break;
}
if (invocation == null)
{
Status = RunnerStatus.Sleeping;
WorkServiceEventSource.Log.DispatchLoopWaiting(_pollInterval);
await Clock.Delay(_pollInterval, cancelToken);
WorkServiceEventSource.Log.DispatchLoopResumed();
Status = RunnerStatus.Working;
}
else if (invocation.Status == InvocationStatus.Cancelled)
{
// Job was cancelled by the user, so just continue.
WorkServiceEventSource.Log.Cancelled(invocation);
}
else
{
Status = RunnerStatus.Dispatching;
_currentInvocationId = invocation.Id.ToByteArray();
Exception dispatchError = null;
try
{
await Dispatch(invocation, cancelToken);
}
catch (Exception ex)
{
dispatchError = ex;
}
if (dispatchError != null)
{
await Queue.Complete(
invocation,
ExecutionResult.Crashed,
dispatchError.ToString(),
null);
}
_currentInvocationId = null;
_lastInvocationId = invocation.Id.ToByteArray();
Status = RunnerStatus.Working;
}
}
Status = RunnerStatus.Stopping;
}
catch (Exception ex)
{
WorkServiceEventSource.Log.DispatchLoopError(ex);
Status = RunnerStatus.Error;
_error = ex;
throw;
}
WorkServiceEventSource.Log.DispatchLoopEnded();
}
