public void Run(BaseWorker worker)
{
WebMethod.Device device = null;
while (!worker.IsTerminated())
{
var info = WebMethod.GetDevice(configuration.information.clientId);
if (info == null)
{
Tracker.LogE("WebMethod: GetDevice fail");
Thread.Sleep(3000);
continue;
}
// 获取并检查设备信息
if (!info.Equals(device))
{
device = info;
EventEmitter.Instance.Publish(Constants.EVENT_SERVICE_START_STREAMING, new Dictionary <int, string>()
{
{ 1, device.pushUrl },
{ 2, device.irPushUrl }
});
}
// 更新设备状态
WebMethod.UpdateDeviceStatus(new WebMethod.DeviceParameter()
{
serialNumber = configuration.information.clientId,
status = "1"
});
Thread.Sleep(1000 * 60);
}
}
private void Load(BaseWorker baseWorker)
{
foreach (Question question in baseWorker.Questions())
{
userQuestions.Add(question.ToUserQuestion());
}
}
protected override void OnStart()
{
worker = new BaseWorker(this);
worker.Start();
base.OnStart();
}
public void Run(BaseWorker worker)
{
bool isOpen = false;
while (!worker.IsTerminated())
{
if (!isOpen)
{
try {
// 创建目录
var now = DateTime.Now;
var folder = $"{Global.gRecordingsFolder}/{now.Year}-{now.Month}-{now.Day}";
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
encoder.Stop();
encoder.Start($"{folder}/{now.ToString("yyyyMMddHHmmss")}.h264");
isOpen = true;
}
catch (Exception e) {
Tracker.LogE(e);
Thread.Sleep(3000);
continue;
}
}
try {
IntPtr addr = imageGCHandle.AddrOfPinnedObject();
encoder.Encode(addr, addr + imageSize, addr + imageSize + imageSize / 4);
}
catch (Exception e) {
Tracker.LogE(e);
encoder.Stop();
isOpen = false;
Thread.Sleep(3000);
continue;
}
Thread.Sleep(1000 / cell.mCell.mIRCameraVideoFrameRate);
}
try {
encoder.Encode(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
encoder.Stop();
}
catch (Exception e) {
Tracker.LogE(e);
}
}
public async Task <List <ScanResult> > ScanDns(WorkerInformation workerInformation)
{
var baseWorker = new BaseWorker();
var mxWorker = new MxWorker(baseWorker, this.LookupClient);
var dkimWorker = new DkimWorker(mxWorker, this.LookupClient, this.Settings);
var caaWorker = new CaaWorker(dkimWorker, this.LookupClient);
var spfWorker = new SpfWorker(caaWorker, this.LookupClient);
var dnssecWorker = new DnssecWorker(spfWorker, this.LookupClient);
var dmarcWorker = new DmarcWorker(dnssecWorker, this.LookupClient);
var scanResults = await dmarcWorker.Scan(workerInformation);
return(scanResults);
}
public static BaseWorker CreateBaseWorker(string personnelNumber, global::System.DateTimeOffset birthDate, global::System.DateTimeOffset disabledVerificationDate, global::System.DateTimeOffset deceasedDate, global::Microsoft.Dynamics.DataEntities.Person person)
{
BaseWorker baseWorker = new BaseWorker();
baseWorker.PersonnelNumber = personnelNumber;
baseWorker.BirthDate = birthDate;
baseWorker.DisabledVerificationDate = disabledVerificationDate;
baseWorker.DeceasedDate = deceasedDate;
if ((person == null))
{
throw new global::System.ArgumentNullException("person");
}
baseWorker.Person = person;
return(baseWorker);
}
public void Test_BaseWorker_Scan()
{
//Arrange
var workerInformation = MockWorkerInformation(hostname: "google.com");
var baseWorker = new BaseWorker();
//Act
var rawRecords = baseWorker.Scan(workerInformation);
rawRecords.Wait();
// Assert
var records = rawRecords.Result;
Assert.AreEqual(0, records.Count);
}
private static async Task ProcessJobs(List <ClientJob> allJobs)
{
Log($"ProcessJobs");
var whenLastJobCompleted = DateTime.MinValue;
for (int i = 0; i < allJobs.Count(); i++)
{
var job = allJobs[i];
Log($"jod ID: {job.Id}, State: {job.State}");
// TODO: to remove, only for debug
Log($"{job.State} {job.TransportType}");
if (job.State == ClientState.Waiting)
{
Log($"Starting SignalR worker");
job.State = ClientState.Starting;
try
{
BaseWorker worker = WorkerFactory.CreateWorker(job);
if (worker == null)
{
Log($"Error while creating the worker");
job.State = ClientState.Deleting;
whenLastJobCompleted = DateTime.UtcNow;
}
else
{
var processJobTask = worker.ProcessJobAsync();
Task.WaitAll(processJobTask);
Thread.Sleep(100);
}
}
catch (Exception e)
{
Log($"An unexpected error occured while starting the job {job.Id}");
Log(e.ToString());
}
}
}
}
/// <summary>
/// Launch workers
/// </summary>
private static void RunWorkers(IServiceProvider services)
{
var ct = _shutdownToken.Token;
var workers = new BaseWorker[] {
// notifications
new NotificationSender(BaseOptions.RunOnce(ct)),
// ethereum pool (contract)
new Workers.EthPoolFreezer.EventHarvester(_appConfig.Services.Ethereum.ConfirmationsRequired, BaseOptions.RunPeriod(ct, TimeSpan.FromMinutes(2))),
new Workers.EthPoolFreezer.EmissionRequestor(BaseOptions.RunMinutely(ct)),
new Workers.EthPoolFreezer.EmissionConfirmer(BaseOptions.RunOnce(ct)),
// processes gold buying requests
new Workers.GoldBuy.Eth.Eth2GoldDepositer(BaseOptions.RunOnce(ct)),
new Workers.GoldBuy.Withdraw.Confirmer(BaseOptions.RunOnce(ct)),
// processes gold selling requests
new Workers.GoldSell.Eth.RequestProcessor(BaseOptions.RunMinutely(ct)),
// eth sender
new Workers.EthSender.Sender(BaseOptions.RunMinutely(ct)),
new Workers.EthSender.Confirmer(_appConfig.Services.Ethereum.ConfirmationsRequired, BaseOptions.RunMinutely(ct)),
// mint deposit wallets
new Workers.SumusWallet.RefillListener(BaseOptions.RunOnce(ct)),
new Workers.SumusWallet.TrackRequestor(BaseOptions.RunMinutely(ct)),
};
foreach (var w in workers)
{
w.Init(services.CreateScope().ServiceProvider).Wait();
}
var tasks = new List <Task>();
foreach (var w in workers)
{
var t = Task.Factory.StartNew(w.Loop, TaskCreationOptions.LongRunning);
tasks.Add(t.Unwrap());
}
Task.WaitAll(tasks.ToArray());
}
private void Load(BaseWorker baseWorker)
{
foreach (Category category in baseWorker.Categoryes())
{
UserCategory userCategory = category.ToUserCategory();
userCategory.UserAttacks = new List<UserAttack>();
foreach (Attack attack in baseWorker.Attacks(userCategory))
{
UserAttack userAttack = attack.ToUserAttack();
userAttack.UserSigns = new List<UserSign>();
foreach (Sign sign in baseWorker.Signs(userAttack))
{
userAttack.UserSigns.Add(sign.ToUserSign());
}
userCategory.UserAttacks.Add(userAttack);
}
UserCategories.Add(userCategory);
}
}
public void Start <T>() where T : BaseWorker
{
if (_threadList != null)
{
throw new InvalidOperationException("WorkerPool already started");
}
_threadList = new List <Thread>();
for (int i = 0; i < WorkersCount; i++)
{
BaseWorker newWorker = (BaseWorker)Activator.CreateInstance(typeof(T));
Thread workerThread = new Thread(new ParameterizedThreadStart(newWorker.DoWork));
workerThread.IsBackground = true;
_threadList.Add(workerThread);
}
foreach (Thread workerThread in _threadList)
{
workerThread.Start(Tuple.Create <BlockQueue, BlockQueue>(_inQueue, _outQueue));
}
}
public bool ExecuteJob(string jobId)
{
var job = Provider.Database.Read <Job>("Id = {0}", jobId);
if (job == null)
{
throw new APIException("Job not found: " + jobId);
}
try
{
var worker = BaseWorker.GetWorker(job.Command);
if (worker == null)
{
throw new APIException("Worker not defined for " + job.Command);
}
worker.ExecuteInternal(job);
}
catch (Exception ex)
{
job.State = JobStates.TryAgain;
job.Save();
JobData jd = Provider.Database.Read <JobData>("JobId={0}", job.Id);
if (jd == null)
{
jd = new JobData()
{
JobId = job.Id
}
}
;
jd.Request = jd.Request ?? "";
jd.Response = ex.Message;
jd.Save();
}
return(true);
}
public void Run(BaseWorker worker)
{
try {
encoder.Stop();
encoder.Start($"rtmp://{Global.gCloudRtmpIP}:{Global.gCloudRtmpPort}/live/{streamId}");
}
catch (Exception e) {
Tracker.LogE(e);
OnFault();
return;
}
while (!worker.IsTerminated())
{
try {
IntPtr addr = imageGCHandle.AddrOfPinnedObject();
encoder.Encode(addr, addr + imageSize, addr + imageSize + imageSize / 4);
}
catch (Exception e) {
Tracker.LogE(e);
encoder.Stop();
OnFault();
return;
}
Thread.Sleep(1000 / cell.mCell.mIRCameraVideoFrameRate);
}
try {
encoder.Encode(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
encoder.Stop();
Stop();
}
catch (Exception e) {
Tracker.LogE(e);
}
}
public UserCategoryes(BaseWorker baseWorker)
{
UserCategories = new List<UserCategory>();
Load(baseWorker);
}
public static void LogInformation(this ILogger <BaseWorker> logger, BaseWorker self, IAppContext ctx, ISingletonDependency sng, IScopedDependency scp, ITransientDependency trn)
{
logger.LogInformation($"{self} - executing ...{Environment.NewLine} context: {ctx} | dependencies: [{sng}, {scp}, {trn}]");
}
public UserQuestions(BaseWorker baseWorker)
{
userQuestions = new List<UserQuestion>();
Load(baseWorker);
}
protected override void GrasshopperBootstrapSolveInstance(IGH_DataAccess da)
{
if (state == 0)
{
if (BaseWorker == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Worker class not provided.");
return;
}
var currentWorker = BaseWorker.Duplicate();
if (currentWorker == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Could not get a worker instance.");
return;
}
// Let the worker collect data.
currentWorker.GetData(da, Params);
// Create the task
var tokenSource = new CancellationTokenSource();
currentWorker.CancellationToken = tokenSource.Token;
currentWorker.Id = $"Worker-{da.Iteration}";
var currentRun = TaskCreationOptions != null
? new Task(() => currentWorker.DoWork(reportProgress, done), tokenSource.Token, (TaskCreationOptions)TaskCreationOptions)
: new Task(() => currentWorker.DoWork(reportProgress, done), tokenSource.Token);
// Add cancellation source to our bag
CancellationSources.Add(tokenSource);
// Add the worker to our list
Workers.Add(currentWorker);
tasks.Add(currentRun);
return;
}
if (setData == 0)
{
return;
}
if (Workers.Count > 0)
{
Interlocked.Decrement(ref state);
Workers[state].SetData(da);
}
if (state != 0)
{
return;
}
CancellationSources.Clear();
Workers.Clear();
ProgressReports.Clear();
tasks.Clear();
Interlocked.Exchange(ref setData, 0);
Message = "Done";
OnDisplayExpired(true);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
if (State == 0)
{
if (BaseWorker == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Worker class not provided.");
return;
}
var currentWorker = BaseWorker.Duplicate();
if (currentWorker == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Could not get a worker instance.");
return;
}
// Let the worker collect data.
currentWorker.GetData(DA, Params);
// Create the task
var tokenSource = new CancellationTokenSource();
currentWorker.CancellationToken = tokenSource.Token;
currentWorker.Id = $"Worker-{DA.Iteration}";
var currentRun = TaskCreationOptions != null
? new Task(() => currentWorker.DoWork(ReportProgress, Done), tokenSource.Token, (TaskCreationOptions)TaskCreationOptions)
: new Task(() => currentWorker.DoWork(ReportProgress, Done), tokenSource.Token);
// Add cancellation source to our bag
CancellationSources.Add(tokenSource);
// Add the worker to our list
Workers.Add(currentWorker);
Tasks.Add(currentRun);
return;
}
if (!SetData)
{
return;
}
if (Workers.Count > 0)
{
Workers[--State].SetData(DA);
}
if (State != 0)
{
return;
}
CancellationSources.Clear();
Workers.Clear();
ProgressReports.Clear();
Tasks.Clear();
SetData = false;
Message = "Done";
OnDisplayExpired(true);
}
