private void Init(NameValueCollection props)
{
if (props == null)
{
props = new NameValueCollection();
}
if (String.IsNullOrWhiteSpace(props.Get(StdSchedulerFactory.PropertySchedulerInstanceName)))
{
props.Set(StdSchedulerFactory.PropertySchedulerInstanceName, Guid.NewGuid().ToString());
}
ActorTaskScheduler.RunTask(async() =>
{
if (props == null)
{
Scheduler = await new StdSchedulerFactory().GetScheduler();
}
else
{
Scheduler = await new StdSchedulerFactory(props).GetScheduler();
}
await Scheduler.Start();
OnSchedulerCreated(Scheduler);
});
}
protected override bool Receive(object message) => message.Match()
.With <Request>(request =>
{
ActorTaskScheduler.RunTask(GetAsync);
})
.With <Cancel>(cancel => OnCompleteThenStop())
.WasHandled;
protected virtual void CreateJobCommand(CreateJob createJob)
{
ActorTaskScheduler.RunTask(async() =>
{
if (createJob.To == null)
{
Context.Sender.Tell(new CreateJobFail(null, null, new ArgumentNullException(nameof(createJob.To))));
}
if (createJob.Trigger == null)
{
Context.Sender.Tell(new CreateJobFail(null, null, new ArgumentNullException(nameof(createJob.Trigger))));
}
else
{
try
{
var job =
QuartzJob.CreateBuilderWithData(createJob.To, createJob.Message)
.WithIdentity(createJob.Trigger.JobKey)
.Build();
await Scheduler.ScheduleJob(job, createJob.Trigger);
Context.Sender.Tell(new JobCreated(createJob.Trigger.JobKey, createJob.Trigger.Key));
}
catch (Exception ex)
{
Context.Sender.Tell(new CreateJobFail(createJob.Trigger.JobKey, createJob.Trigger.Key, ex));
}
}
});
}
protected override void PostStop()
{
if (!_externallySupplied)
{
ActorTaskScheduler.RunTask(() => Scheduler.Shutdown());
}
base.PostStop();
}
private Action <T> WrapAsyncHandler <T>(Func <T, Task> asyncHandler)
{
return(m =>
{
Func <Task> wrap = () => asyncHandler(m);
ActorTaskScheduler.RunTask(wrap);
});
}
protected override bool Receive(object message) => message.Match()
.With <Request>(request =>
{
//Console.WriteLine("---");
ActorTaskScheduler.RunTask(() => QueryAsync(request.Count));
})
.With <Cancel>(cancel => OnCompleteThenStop())
.WasHandled;
protected override void PreStart()
{
ColorConsole.WriteLine($"{BrowserActorName} PreStart", ConsoleColor.Green);
ActorTaskScheduler.RunTask(async() =>
{
await PrepareBrowserInstance();
Become(Ready);
});
}
protected void Receive <T>(Func <T, Task> handler)
{
EnsureMayConfigureMessageHandlers();
_matchHandlerBuilders.Peek().Match <T>(m =>
{
Func <Task> wrap = () => handler(m);
ActorTaskScheduler.RunTask(wrap);
});
}
private static Action <T> WrapAsyncHandler <T>(Func <T, Task> asyncHandler)
{
return(m =>
{
Task Wrap() => asyncHandler(m);
ActorTaskScheduler.RunTask(Wrap);
});
}
public PageActor(string webSocket, XpathConfigurationForPuppeteer configuration)
{
PageActorName = Self.Path.Name;
WebSocket = webSocket;
Configuration = configuration;
ActorTaskScheduler.RunTask(async() =>
{
await PreparePage();
});
}
protected override void PostStop()
{
ActorTaskScheduler.RunTask(async() =>
{
if (Page != null)
{
await Page.DisposeAsync();
}
});
ColorConsole.WriteLine($"{PageActorName} PostStop", ConsoleColor.Magenta);
}
protected override void PostStop()
{
ActorTaskScheduler.RunTask(async() =>
{
if (Browser != null)
{
await Browser.DisposeAsync();
}
});
ColorConsole.WriteLine($"{BrowserActorName} PostStop", ConsoleColor.Green);
}
/// <summary>
/// Causes the actor to await until the task is completed to process new messages.
/// If the task is completed, works synchronously without any overhead
/// </summary>
public static void Await(Func <Task> func)
{
var task = func();
// if task is null, treat as synchronous execution
if (task == null)
{
return;
}
if (task.IsFaulted)
{
ExceptionDispatchInfo.Capture(task.Exception.InnerException).Throw();
}
// if task is completed, return synchronously
if (task.IsCompleted)
{
return;
}
// dispatch to actor scheduler only if needed
ActorTaskScheduler.RunTask(() => task);
}
protected virtual void RemoveJobCommand(RemoveJob removeJob)
{
var sender = Context.Sender;
ActorTaskScheduler.RunTask(async() =>
{
try
{
var deleted = await Scheduler.DeleteJob(removeJob.JobKey);
if (deleted)
{
sender.Tell(new JobRemoved(removeJob.JobKey, removeJob.TriggerKey));
}
else
{
sender.Tell(new RemoveJobFail(removeJob.JobKey, removeJob.TriggerKey, new JobNotFoundException()));
}
}
catch (Exception ex)
{
sender.Tell(new RemoveJobFail(removeJob.JobKey, removeJob.TriggerKey, ex));
}
});
}
/// <summary>
/// Initializes a new instance of the <see cref="ActorTaskSchedulerMessage" /> class.
/// </summary>
/// <param name="scheduler">TBD</param>
/// <param name="task">TBD</param>
/// <param name="message">TBD</param>
public ActorTaskSchedulerMessage(ActorTaskScheduler scheduler, Task task, object message)
{
_scheduler = scheduler;
_task = task;
Message = message;
}
public ActorTaskSchedulerTests()
{
_scheduler = new ActorTaskScheduler(_actorId);
_actorTaskFactory = new ActorTaskFactory(_scheduler);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActorTaskSchedulerMessage" /> class.
/// </summary>
/// <param name="scheduler">TBD</param>
/// <param name="task">TBD</param>
/// <param name="message">TBD</param>
public ActorTaskSchedulerMessage(ActorTaskScheduler scheduler, Task task, object message)
{
_scheduler = scheduler ?? throw new ArgumentNullException(nameof(scheduler));
_task = task ?? throw new ArgumentNullException(nameof(task));
Message = message;
}
/// <summary>
/// Initializes a new instance of the <see cref="ActorTaskSchedulerMessage" /> class.
/// </summary>
public ActorTaskSchedulerMessage(ActorTaskScheduler scheduler, Task task)
{
_scheduler = scheduler;
_task = task;
}
/// <summary>
/// Constructor.
/// </summary>
public Actor()
{
_taskScheduler = new ActorTaskScheduler(Id);
_actorTaskFactory = new ActorTaskFactory(_taskScheduler);
_startTask = _startTaskCompletionSource.Task;
}
/// <summary>
/// TBD
/// </summary>
/// <param name="action">TBD</param>
protected void RunTask(Action action)
{
ActorTaskScheduler.RunTask(action);
}
/// <summary>
/// Initializes a new instance of the <see cref="ActorTaskSchedulerMessage" /> class.
/// </summary>
public ActorTaskSchedulerMessage(ActorTaskScheduler scheduler, Task task, object message)
{
_scheduler = scheduler;
_task = task;
Message = message;
}
protected void RunTask(AsyncBehavior behavior, Func <Task> action)
{
ActorTaskScheduler.RunTask(behavior, action);
}
/// <summary>
/// TBD
/// </summary>
/// <param name="action">TBD</param>
protected void RunTask(Func <Task> action)
{
ActorTaskScheduler.RunTask(action);
}
public ActorSynchronizationContext(ActorTaskScheduler scheduler)
{
_scheduler = new TaskFactory(scheduler);
}
