void OnGUI_AsyncJob()
{
if (m_CurrentJob == null)
{
if (m_AutoRefreshRegistered)
{
EditorApplication.update -= Repaint;
m_AutoRefreshRegistered = false;
}
return;
}
if (!m_AutoRefreshRegistered)
{
m_AutoRefreshRegistered = true;
EditorApplication.update += Repaint;
}
#if !UNITY_2020_1_OR_NEWER
GUILayout.BeginHorizontal(EditorStyles.toolbar, GUILayout.Height(EditorGUIUtility.singleLineHeight));
var progressRect = GUILayoutUtility.GetRect(0, float.MaxValue, EditorGUIUtility.singleLineHeight, float.MaxValue);
EditorGUI.ProgressBar(progressRect, m_CurrentJob.progress, m_CurrentJob.message);
if (GUILayout.Button(UIUtils.Text("Cancel"), EditorStyles.toolbarButton))
{
m_CurrentJob.Cancel();
}
GUILayout.EndVertical();
#endif
if (m_CurrentJob.IsComplete())
{
m_CurrentJob = null;
}
}
void AsyncWrite(IAsyncJob job)
{
if (this._QueueItems.Count == 0)
{
return;
}
List <LogItem> items = new List <LogItem>(this._QueueItems.Count);
LogItem item;
while (this._QueueItems.TryDequeue(out item))
{
items.Add(item);
}
try
{
this.OnWrite(items.ToArray());
}
catch (Exception ex)
{
GA.WriteUnhandledException("日志线程崩溃了：{0}", ex);
job.Cancel();
}
}
public AsyncJob(IAsyncJob job)
{
this.Job = job;
Status = new MarkdownFileHandler.JobStatus();
Status.State = JobState.NotStarted;
JobTracker.QueueJob(this.Status);
}
/// <summary>
/// Schedule a fire-and-forget background job in the future.
/// </summary>
public static string Schedule <TParameters>(
this IAsyncJob <TParameters> job,
TimeSpan delay,
TParameters parameters)
where TParameters : class => BackgroundJob.Schedule(
() => job.HandleAsync(null, parameters, CancellationToken.None),
delay
);
private async Task <TResult> ExecuteRequestCoreAsync <TResult>(
string operationName,
IAsyncJob <TResult> request,
string requestName,
CancellationToken cancellationToken)
where TResult : ICallbackMsg
{
await requestSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
try
{
EnsureConnectedAndLoggedOn();
var telemetry = new DependencyTelemetry {
Name = operationName
};
telemetry.Type = "Steam3";
telemetry.Target = steamClient.RemoteIP?.ToString();
telemetry.Data = requestName;
telemetry.Timestamp = DateTimeOffset.UtcNow;
var timer = Stopwatch.StartNew();
try
{
request.Timeout = Timeout;
// A fallback timeout is used in case SteamKit deadlocks.
var response = await timeoutPolicy
.ExecuteAsync(request.ToTask, continueOnCapturedContext : false)
.ConfigureAwait(false);
telemetry.Success = true;
return(response);
}
catch (TaskCanceledException ex)
{
telemetry.Success = false;
throw new SteamClientApiException("Request timed out.", ex);
}
catch (Exception) when(telemetry.MarkAsUnsuccessful())
{
// Unreachable
throw;
}
finally
{
timer.Stop();
telemetry.Duration = timer.Elapsed;
telemetryClient.TrackDependency(telemetry);
}
}
finally
{
requestSemaphore.Release();
}
}
void OnGUI_Execute(List <GUIAction> actions)
{
foreach (var action in actions)
{
switch (action.kind)
{
case GUIActionKind.OpenSelectedAsset:
OpenAsset(m_SelectedAsset);
break;
case GUIActionKind.LoadAssetMetaData:
m_AssetMetadata = ShaderAnalysisUtils.LoadAssetMetadatasFor(m_CurrentPlatform);
break;
case GUIActionKind.LoadAssetReferenceMetaData:
m_AssetMetadataReference =
ShaderAnalysisUtils.LoadAssetMetadatasFor(m_CurrentPlatform, referenceFolder);
break;
case GUIActionKind.BuildReportJob:
{
m_CurrentJob = action.jobBuilder();
if (m_CurrentJob != null)
{
m_JobAssets[m_CurrentJob] = action.asset;
m_CurrentJob.OnComplete(OnBuildReportJobComplete);
}
break;
}
case GUIActionKind.ExportReport:
{
var assetGUID = ShaderAnalysisUtils.CalculateGUIDFor(action.asset);
var report = m_AssetMetadata.GetReport(assetGUID);
var tempReportFile = ShaderAnalysisUtils.GetTemporaryReportFile(action.asset, m_CurrentPlatform);
var tempReportFileName = ExporterUtilities.ChangeExtensionFor(m_ReportExporterIndex, tempReportFile.FullName);
ExporterUtilities.Export(m_ReportExporterIndex, report, tempReportFileName);
Application.OpenURL(tempReportFileName);
break;
}
case GUIActionKind.SetAsReference:
SetAsReference(m_CurrentPlatform, action.assetGUID, action.report);
break;
case GUIActionKind.ExportDiffReport:
{
var diff = ShaderAnalysisUtils.DiffReports(action.report, action.reportReference);
var exportFile = ShaderAnalysisUtils.GetTemporaryDiffFile(action.assetGUID, m_CurrentPlatform);
var exportReportFileName = ExporterUtilities.ChangeExtensionFor(m_ReportExporterIndex, exportFile.FullName);
ExporterUtilities.ExportDiff(m_ReportDiffExporterIndex, diff, exportReportFileName);
Application.OpenURL(exportReportFileName);
break;
}
}
}
}
/// <summary>
/// Recur a background job.
/// </summary>
public static void Recur(
this IAsyncJob job,
string name,
string cron,
TimeZoneInfo timeZone = null) => RecurringJob.AddOrUpdate(
name,
() => job.HandleAsync(null, CancellationToken.None),
cron,
timeZone
);
public virtual async Task <InvocationResult> Dispatch(InvocationContext context)
{
JobDescription jobdef;
if (!_jobMap.TryGetValue(context.Invocation.Job, out jobdef))
{
throw new UnknownJobException(context.Invocation.Job);
}
_currentJob = jobdef;
ILifetimeScope scope = null;
using (scope = _container.BeginLifetimeScope(b =>
{
b.RegisterType(jobdef.Implementation).As(jobdef.Implementation);
b.RegisterInstance(context).As <InvocationContext>();
b.Register(ctx => scope)
.As <ILifetimeScope>();
}))
{
var job = (JobHandlerBase)scope.Resolve(jobdef.Implementation);
Func <Task <InvocationResult> > invocationThunk = () => job.Invoke(context);
if (context.Invocation.IsContinuation)
{
IAsyncJob asyncJob = job as IAsyncJob;
if (asyncJob == null)
{
// Just going to be caught below, but that's what we want :).
throw new InvalidOperationException(String.Format(
CultureInfo.CurrentCulture,
Strings.JobDispatcher_AsyncContinuationOfNonAsyncJob,
jobdef.Name));
}
invocationThunk = () => asyncJob.InvokeContinuation(context);
}
InvocationEventSource.Log.Invoking(jobdef);
InvocationResult result = null;
try
{
context.SetJob(jobdef, job);
result = await invocationThunk();
}
catch (Exception ex)
{
result = InvocationResult.Faulted(ex);
}
_currentJob = null;
_lastJob = jobdef;
return(result);
}
}
/// <summary>
/// Recur a background job.
/// </summary>
public static void Recur <TParameters>(
this IAsyncJob <TParameters> job,
string name,
string cron,
TimeZoneInfo timeZone = null,
TParameters parameters = null)
where TParameters : class => RecurringJob.AddOrUpdate(
() => job.HandleAsync(null, parameters, CancellationToken.None),
cron,
timeZone
);
void AsyncWrite(IAsyncJob job)
{
if(this._QueueItems.Count == 0) return;
List<LogItem> items = new List<LogItem>(this._QueueItems.Count);
LogItem item;
while(this._QueueItems.TryDequeue(out item)) items.Add(item);
try
{
this.OnWrite(items.ToArray());
}
catch(Exception ex)
{
GA.WriteUnhandledException("日志线程崩溃了：{0}", ex);
job.Cancel();
}
}
private async Task <TResult> ExecuteRequestAsync <TResult>(
string operationName,
IAsyncJob <TResult> request,
string requestName,
CancellationToken cancellationToken)
where TResult : ICallbackMsg
{
using (var operation = telemetryClient.StartOperation <DependencyTelemetry>(operationName))
{
var telemetry = operation.Telemetry;
telemetry.Type = "Steam3";
telemetry.Target = steamClient.RemoteIP?.ToString();
telemetry.Data = requestName;
try
{
if (Log.IsDebugEnabled)
{
Log.Debug($"Start download {operationName} {requestName}");
}
var response = await retryPolicy
.ExecuteAsync(cancellation => ExecuteRequestCoreAsync(operationName, request, requestName, cancellation), cancellationToken)
.ConfigureAwait(false);
if (Log.IsDebugEnabled)
{
Log.Debug($"End download {operationName} {requestName}");
}
telemetry.Success = true;
return(response);
}
catch (Exception) when(operation.Telemetry.MarkAsUnsuccessful())
{
// Unreachable
throw;
}
}
}
void OnBuildReportJobComplete(IAsyncJob obj)
{
var asset = m_JobAssets[obj];
m_JobAssets.Remove(obj);
var job = obj as AsyncBuildReportJob;
Assert.IsNotNull(job);
ShaderBuildReport report = null;
if (job.IsComplete() &&
job.hasReport &&
(report = job.builtReport) != null)
{
var metadata = ShaderAnalysisUtils.LoadAssetMetadatasFor(job.target);
var assetGUID = ShaderAnalysisUtils.CalculateGUIDFor(asset);
metadata.SetReport(assetGUID, report);
ShaderAnalysisUtils.SaveAssetMetadata(metadata);
}
}
/// <summary>
/// Schedule a fire-and-forget background job in the future.
/// </summary>
public static string Schedule(
this IAsyncJob job,
TimeSpan delay) => BackgroundJob.Schedule(
() => job.HandleAsync(null, CancellationToken.None),
delay
);
public AsyncJobService(int dueTime, int period, Func <TJob> createJob) : base(dueTime, period)
{
_job = createJob();
}
/// <summary>
/// Enqueue a fire-and-forget background job immediately.
/// </summary>
public static string Enqueue <TParameters>(
this IAsyncJob <TParameters> job,
TParameters parameters) => BackgroundJob.Enqueue(
() => job.HandleAsync(null, parameters, CancellationToken.None)
);
/// <summary>
/// Enqueue a fire-and-forget background job immediately.
/// </summary>
public static string Enqueue(
this IAsyncJob job) => BackgroundJob.Enqueue(
() => job.HandleAsync(null, CancellationToken.None)
);
public static void ExecuteAsyncJob(ImageShrinkerViewModel context, IBackgroundWorkerUi uiResponder, IAsyncJob job)
{
var backgroundWorker = new BackgroundWorker();
backgroundWorker.DoWork += job.BackgroundWorkerOnDoWork;
backgroundWorker.WorkerSupportsCancellation = true;
backgroundWorker.RunWorkerCompleted += (s, e) =>
{
uiResponder.OnWorkerCompleted();
AsyncJobRunning = false;
};
uiResponder.Worker = backgroundWorker;
job.Prepare(context, uiResponder);
AsyncJobRunning = true;
backgroundWorker.RunWorkerAsync();
uiResponder.AfterAsyncStart();
}
/// <summary>Whether this job has completed.</summary> /// <param name="job">The job to check.</param> /// <returns><c>true</c> when the job has completed, <c>false</c> otherwise.</returns> public static bool IsComplete(this IAsyncJob job) => job.progress >= 1;
/// <summary>
/// Creates a Task object from an IAsyncJob instance
/// </summary>
/// <param name="job"></param>
public static Task CreateTaskFromJob(IAsyncJob job)
{
// job.Task.ConfigureAwait(false).GetAwaiter();
Awaiter.Instance.Jobs.Add(job);
return job.Task;
}
public Task StartJobAsync(IAsyncJob <TParameter> job, string jobId, string cronExpression, TParameter parameter)
{
_recurringJobClient.AddOrUpdate(jobId, () => job.ExecuteAsync(parameter), cronExpression);
return(Task.CompletedTask);
}
public Task <string> StartJobAsync(IAsyncJob <TParameter> job, TimeSpan delay, TParameter parameter)
{
return(Task.FromResult(_backgroundJobClient.Schedule(() => job.ExecuteAsync(parameter), delay)));
}
/// <summary>
/// 初始化一个 <see cref="LoggerBase"/> 类的新实例。
/// </summary>
public LoggerBase()
{
this._ajob = Ajob.Loop(AsyncWrite, TimeSpan.FromSeconds(1));
}
public Task <string> StartJobAsync(IAsyncJob <TParameter> job, TParameter parameter)
{
return(Task.FromResult(_backgroundJobClient.Enqueue(() => job.ExecuteAsync(parameter))));
}
/// <summary>
/// Creates a Task object from an IAsyncJob instance
/// </summary>
/// <param name="job"></param>
public static Task CreateTaskFromJob(IAsyncJob job)
{
// job.Task.ConfigureAwait(false).GetAwaiter();
Awaiter.Instance.Jobs.Add(job);
return(job.Task);
}
public static void ExecuteAsyncJobWithDialog(ImageShrinkerViewModel context, IBackgroundWorkerUi uiResponder, IAsyncJob job)
{
ExecuteAsyncJob(context, uiResponder, job);
ShowDialog((ViewModel)uiResponder);
}
/// <summary>
/// 初始化一个 <see cref="LoggerBase"/> 类的新实例。
/// </summary>
public LoggerBase()
{
this._ajob = Ajob.Loop(AsyncWrite, TimeSpan.FromSeconds(1));
}
