public Job(TaskPool.Task main,int l) { line = l; Pre = null; Main = main; Post = null; }
public Job(TaskPool.Task pre, TaskPool.Task main, TaskPool.Task post,int l) { line = l; Pre = pre; Main = main; Post = post; }
public ClientRequstsForm() : base() { InitializeComponent(); taskPool = new TaskPool(); random = new Random(); }
public OperatorsForm() : base() { InitializeComponent(); taskPool = new TaskPool(); random = new Random(); }
public UsersForm() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public RedirectToOperatorForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public ExceptionScheduleReportForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public void FaultedTaskExceptionIsSet() { var taskPool = new TaskPool(1); taskPool.Add(Task.Factory.StartNew(() => { throw new Exception("This is a test"); })); var ex = Assert.Throws<AggregateException>(() => taskPool.Drain().Wait()); Assert.Equal("This is a test", ex.GetBaseException().Message); }
public ConfigForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public CallClientByRequestNumberForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public AdditionalServicesForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public DefaultScheduleForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public LifeSituationsForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public ClientRequestsForm() : base() { InitializeComponent(); taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; stateControl.Initialize<ClientRequestState>(); }
public EditOperatorForm(Guid? operatorId = null) { InitializeComponent(); this.operatorId = operatorId.HasValue ? operatorId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public EditMediaConfigFileForm(Guid? mediaConfigFileId = null) : base() { InitializeComponent(); this.mediaConfigFileId = mediaConfigFileId.HasValue ? mediaConfigFileId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public void MultipleTasksBiggerThanPoolSizeOneThrows() { var taskPool = new TaskPool(1); long value = 0; taskPool.Add(Task.Factory.StartNew(() => { Thread.Sleep(1000); Interlocked.Increment(ref value); })); taskPool.Add(Task.Factory.StartNew(() => { Thread.Sleep(100); throw new InvalidOperationException("failed!"); })); taskPool.Add(Task.Factory.StartNew(() => { Thread.Sleep(1000); Interlocked.Increment(ref value); })); var ex = Assert.Throws<AggregateException>(() => taskPool.Drain().Wait()); Assert.Equal("failed!", ex.GetBaseException().Message); }
public void AddingMoreThanPoolSizeWaits() { var taskPool = new TaskPool(1); long value = 0; taskPool.Add(Task.Factory.StartNew(() => { Thread.Sleep(500); Interlocked.Increment(ref value); })); taskPool.Add(Task.Factory.StartNew(() => { Thread.Sleep(500); Interlocked.Increment(ref value); })); taskPool.Add(Task.Factory.StartNew(() => { Thread.Sleep(500); Interlocked.Increment(ref value); })); taskPool.Drain().Wait(); Assert.Equal(3, value); }
public EditAdditionalServiceForm(Guid? additionalServiceId = null) : base() { InitializeComponent(); this.additionalServiceId = additionalServiceId.HasValue ? additionalServiceId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public EditClientForm(Guid? clientId = null) : base() { InitializeComponent(); this.clientId = clientId.HasValue ? clientId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public EditOfficeForm(Guid? officeId = null) : base() { InitializeComponent(); this.officeId = officeId.HasValue ? officeId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public SelectServiceControl() { InitializeComponent(); if (designtime) { return; } taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public EditAdministratorForm(Guid? administratorId = null) { InitializeComponent(); this.administratorId = administratorId.HasValue ? administratorId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; permissionsFlagsControl.Initialize<AdministratorPermissions>(); }
public EditClientRequestForm(Guid clientRequestId) : base() { InitializeComponent(); this.clientRequestId = clientRequestId; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; typeControl.Initialize<ClientRequestType>(); }
public EditServiceStepForm(Guid? serviceId, Guid? serviceStepId = null) { InitializeComponent(); this.serviceId = serviceId.HasValue ? serviceId.Value : Guid.Empty; this.serviceStepId = serviceStepId.HasValue ? serviceStepId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public OfficeLoginForm(Guid officeId) { InitializeComponent(); Settings = new LoginSettings(); loginSettingsControl.Settings = Settings; this.officeId = officeId; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public LoginForm(UserRole userRole) : base() { InitializeComponent(); this.userRole = userRole; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; languageControl.Initialize<Language>(); loginSettingsControl.Settings = LoginSettings; }
public EditServiceGroupForm(Guid? parentId = null, Guid? serviceGroupId = null) : base() { InitializeComponent(); this.parenGrouptId = parentId.HasValue ? parentId.Value : Guid.Empty; this.serviceGroupId = serviceGroupId.HasValue ? serviceGroupId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; }
public EditWorkplaceForm(Guid? workplaceId = null) { InitializeComponent(); this.workplaceId = workplaceId.HasValue ? workplaceId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; typeControl.Initialize<WorkplaceType>(); modificatorControl.Initialize<WorkplaceModificator>(); }
public EditServiceRenderingForm(Guid scheduleId, Guid? serviceRenderingId = null) { InitializeComponent(); this.scheduleId = scheduleId; this.serviceRenderingId = serviceRenderingId.HasValue ? serviceRenderingId.Value : Guid.Empty; taskPool = new TaskPool(); taskPool.OnAddTask += taskPool_OnAddTask; taskPool.OnRemoveTask += taskPool_OnRemoveTask; modeСontrol.Initialize<ServiceRenderingMode>(); }
public ActionResult New() { using (var db = new QuesoContext()) { board = new Board(); board.Active = true; var poolTasks = TaskPool.Random(); foreach (var poolTask in poolTasks) { var task = new Task() { Name = poolTask.Name, Challenge = poolTask.Challenge }; board.Tasks.Add(task); } db.Boards.Add(board); db.SaveChanges(); } return(View()); }
public void TaskPool_Should_Create_and_Enqueue_Actions_in_Thread() { var threadIds = new List <int>(); var lockObject = new object(); var waitHandle = new CountdownEvent(10); TaskPool taskPool = new TaskPool(3); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); taskPool.Enqueue(() => getTask(lockObject, waitHandle, threadIds)); waitHandle.Wait(); waitHandle.Reset(); Assert.AreEqual(3, threadIds.Distinct().Count()); }
private void SetMinValue(TaskPool pool, TextBox tb) { try { int value = int.Parse(tb.Text); pool.Setminthread(value); switch (pool.Name) { case "A": SysConfig.userProfile.ControlCommandThreadPool_Min = value; break; case "B": SysConfig.userProfile.AutoCollectionThreadPool_Min = value; break; case "C": SysConfig.userProfile.HeartbeatThreadPool_Min = value; break; case "D": SysConfig.userProfile.NetServerThreadPool_Min = value; break; case "E": SysConfig.userProfile.V88ThreadPool_Min = value; break; } SysConfig.userProfile.SaveConfig(); MessageBox.Show("设置成功,立即生效"); } catch (Exception) { MessageBox.Show("请输入整数"); } }
public void Run() { TaskPool pool = TaskPool.GetInstance(new Generator(), 5); while (true) { string str = Console.ReadLine(); if (str == "p") { pool.Pause(); } else if (str == "r") { pool.Resume(); } else if (str == "stop") { break; } else if (str == "pa") { Task <bool> task = pool.PauseAysnc(); Console.WriteLine("PAUSE ASYNC"); bool result = task.Result; Console.WriteLine("PAUSED"); } else { try { int n = Convert.ToInt32(str); Generator.MAX = n; } catch { } } } }
public void Shoul_Be_Able_To_Configure_Default_Taskpool() { var threadIds = new ConcurrentBag <int>(); var waitHandle = new CountdownEvent(4); Action runTask = () => { Thread.Sleep(1000); threadIds.Add(Thread.CurrentThread.ManagedThreadId); waitHandle.Signal(); }; int poolSize = 2; var taskPool = new TaskPool(poolSize); AsyncTasks.AddPool("testPool2", taskPool); AsyncTasks.Run(runTask, "testPool2"); AsyncTasks.Run(runTask, "testPool2"); AsyncTasks.Run(runTask, "testPool2"); AsyncTasks.Run(runTask, "testPool2"); waitHandle.Wait(); AsyncTasks.RemoveAll(); Assert.AreEqual(poolSize, threadIds.Distinct().Count()); }
public void Start() { try { StartRoundEventArgs args = new StartRoundEventArgs(); args.TaskPool = TaskPool; args.Token = Token; args.CancelTokenSource = CancelTokenSource; args.WinLength = WinLength; StartGameHandler?.Invoke(this, args); Task.WaitAll(TaskPool.ToArray(), Token); } catch (OperationCanceledException ex) { //throw new Exception("Stop game"); } catch (Exception ex) { throw new Exception("Start game exception", ex.InnerException); } finally { if (FinishGameHandler != null) { FinishGameHandler.Invoke(this, new System.EventArgs()); } else { Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("{0} : {1} ---- {2} : {3}", Team1.Name, Team1.Count, Team2.Name, Team2.Count); Console.WriteLine("End GAME!!!"); } } }
protected ParallelModuleBase(bool runOnServer, bool runOnClient, ModBase parent) : base(runOnServer, runOnClient, parent) { taskPool = new TaskPool(ErrorCallback); }
public void QueryLiveInfo(Action <Networking.ServerInfo> onServerRulesReceived, Action <Networking.ServerInfo> onQueryDone) { if (!SteamManager.IsInitialized) { return; } if (int.TryParse(QueryPort, out int parsedPort) && IPAddress.TryParse(IP, out IPAddress parsedIP)) { if (MatchmakingPingResponse?.QueryActive ?? false) { MatchmakingPingResponse.Cancel(); } MatchmakingPingResponse = new Steamworks.SteamMatchmakingPingResponse( (server) => { ServerName = server.Name; RespondedToSteamQuery = true; PlayerCount = server.Players; MaxPlayers = server.MaxPlayers; HasPassword = server.Passworded; PingChecked = true; Ping = server.Ping; LobbyID = 0; TaskPool.Add("QueryServerRules (QueryLiveInfo)", server.QueryRulesAsync(), (t) => { onQueryDone(this); if (t.Status == TaskStatus.Faulted) { TaskPool.PrintTaskExceptions(t, "Failed to retrieve rules for " + ServerName); return; } var rules = ((Task <Dictionary <string, string> >)t).Result; SteamManager.AssignServerRulesToServerInfo(rules, this); onServerRulesReceived(this); }); }, () => { RespondedToSteamQuery = false; }); MatchmakingPingResponse.HQueryPing(parsedIP, parsedPort); } else if (OwnerID != 0) { if (SteamFriend == null) { SteamFriend = new Steamworks.Friend(OwnerID); } if (LobbyID == 0) { TaskPool.Add("RequestSteamP2POwnerInfo", SteamFriend?.RequestInfoAsync(), (t) => { onQueryDone(this); if ((SteamFriend?.IsPlayingThisGame ?? false) && ((SteamFriend?.GameInfo?.Lobby?.Id ?? 0) != 0)) { LobbyID = SteamFriend?.GameInfo?.Lobby?.Id.Value ?? 0; Steamworks.SteamMatchmaking.OnLobbyDataChanged += UpdateInfoFromSteamworksLobby; SteamFriend?.GameInfo?.Lobby?.Refresh(); } else { RespondedToSteamQuery = false; } }); } else { onQueryDone(this); } } }
static AsyncUniTask() { TaskPool.RegisterSizeGetter(typeof(AsyncUniTask <TStateMachine>), () => pool.Size); }
static WaitAsyncSource() { TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size); }
/// <summary> /// Runs the MRU cache /// </summary> /// <returns>An awaitable task.</returns> /// <param name="selfinfo">This peer's information</param> /// <param name="storesize">The size of the MRU store</param> /// <param name="maxage">The maximum amount of time items are stored</param> /// <param name="buffersize">The size of the parallel processing buffer</param> private static Task RunMRUAsync(PeerInfo selfinfo, int storesize, TimeSpan maxage, int buffersize) { var storechan = Channel.Create <MRUInternalStore>(); return(AutomationExtensions.RunTask(new { Request = Channels.MRURequests.ForRead, Routing = Channels.RoutingTableRequests.ForWrite, Stats = Channels.MRUStats.ForRead, Store = storechan.AsRead() }, async self => { var cache = new MRUCache <Key, byte[]>(storesize, maxage); var store = new MRUCache <Key, byte[]>(int.MaxValue, maxage); log.Debug($"Store is now running"); // Set up a shared error handler for logging and reporting errors Func <MRURequest, Exception, Task> errorHandler = async(req, ex) => { log.Warn("Failed to process request, sending error", ex); try { await req.SendResponseAsync(ex); } catch (Exception ex2) { log.Warn("Failed to forward error report", ex2); } }; using (var tp = new TaskPool <MRURequest>(buffersize, errorHandler)) while (true) { log.Debug($"Store is waiting for requests ..."); var mreq = await MultiChannelAccess.ReadFromAnyAsync( self.Stats.RequestRead(), self.Store.RequestRead(), self.Request.RequestRead() ); if (mreq.Channel == self.Stats) { log.Debug($"Store got stat request"); var r = (IWriteChannel <MRUStatResponse>)mreq.Value; await r.WriteAsync(new MRUStatResponse() { Items = cache.Count + store.Count, Oldest = new DateTime(Math.Min(cache.OldestItem.Ticks, store.OldestItem.Ticks)), Size = cache.Select(x => x.Value.Length).Sum() + store.Select(x => x.Value.Length).Sum(), Stats = (Channels.MRURequests.Get() as ProfilingChannel <MRURequest>)?.ReportStats() }); continue; } if (mreq.Channel == self.Store) { var sreq = (MRUInternalStore)mreq.Value; log.Debug($"Store got internal store request"); var shouldBroadCast = sreq.Peers != null && !store.TryGetValue(sreq.Key, out _); store.Add(sreq.Key, sreq.Data); // We currently rely on the injector to broadcast, // If we enable this, we need some logic to figure out // the source of the Add, to both allow re-insertion // and avoid repeated broadcasts if two peers determine // they are *the* handling peer //if (shouldBroadCast) //await tp.Run(new MRURequest() { }, () => BroadcastValueAsync(selfinfo, sreq)); continue; } var req = (MRURequest)mreq.Value; log.Debug($"Store got request {req.Operation}"); try { switch (req.Operation) { case MRUOperation.Add: { // Always store it in our cache cache.Add(req.Key, req.Data); // Process long-term if needed await tp.Run(req, () => StoreLongTermAsync(selfinfo, self.Routing, storechan.AsWrite(), req.Key, req.Data)); // Respond that we completed await tp.Run(req, () => req.SendResponseAsync(req.Key, null)); break; } case MRUOperation.Get: { var res = cache.TryGetValue(req.Key, out var data); if (!res) { res = store.TryGetValue(req.Key, out data); } await tp.Run(req, () => req.SendResponseAsync(req.Key, data, res)); break; } case MRUOperation.Expire: cache.ExpireOldItems(); store.ExpireOldItems(); await tp.Run(req, () => req.SendResponseAsync(null, null)); break; default: throw new Exception($"Unable to handle request with type {req.Operation}"); } log.Debug($"Store completed request {req.Operation}"); } catch (Exception ex) { await errorHandler(req, ex); } } })); }
/// <summary> /// Runs the router and forwarder /// </summary> /// <returns>An awaitable result.</returns> /// <param name="owner">The owner of the routing table.</param> /// <param name="k">The redundancy parameter.</param> /// <param name="buffersize">The size of the forwarding buffer.</param> public static Task RunAsync(PeerInfo owner, int k, int buffersize = 10) { return(AutomationExtensions.RunTask( new { Requests = Channels.RoutingTableRequests.ForRead, Stats = Channels.RoutingTableStats.ForRead, PeerReq = Channels.PeerRequests.ForWrite }, async self => { // Setup the routing table, and add us to it var table = new RoutingTable(owner.Key, k); table.Add(owner); log.Debug($"Router is now running"); // Set up the error handler Func <RoutingRequest, Exception, Task> errorHandler = async(t, ex) => { log.Warn("Routing operation failed, sending failure response to requester", ex); try { await t.Response.WriteAsync(new RoutingResponse() { Exception = ex, Succes = false }); } catch (Exception ex2) { log.Warn("Failed to forward error message", ex2); } }; using (var tp = new TaskPool <RoutingRequest>(buffersize, errorHandler)) while (true) { // Wait for requests log.Debug($"Router is waiting for requests ..."); var r = await MultiChannelAccess.ReadFromAnyAsync(self.Stats.RequestRead(), self.Requests.RequestRead()); if (r.Channel == self.Stats) { log.Debug($"Router got stat request"); var m = (IWriteChannel <RoutingStatsResponse>)r.Value; await m.WriteAsync(new RoutingStatsResponse() { Count = table.Count, Stats = (Channels.RoutingTableRequests.Get() as ProfilingChannel <RoutingRequest>)?.ReportStats() }); continue; } var data = (RoutingRequest)r.Value; try { log.Debug($"Router got request {data.Operation}"); // Multiplex the operation switch (data.Operation) { case RoutingOperation.Add: { var success = table.Add(data.Data, out var isNew); if (data.Response != null) { await tp.Run(data, () => data.Response.WriteAsync(new RoutingResponse() { Succes = true, IsNew = isNew })); } // If the peer is new, discover what peers it knows if (isNew) { log.Debug($"New peer, requesting refresh"); await tp.Run(data, () => self.PeerReq.WriteAsync(new PeerRequest() { Operation = PeerOperation.Refresh, Key = data.Data.Key })); log.Debug($"Peer refresh requested"); } break; } case RoutingOperation.Remove: { var sucess = table.RemoveKey(data.Key); if (data.Response != null) { await tp.Run(data, () => data.Response.WriteAsync(new RoutingResponse() { Succes = sucess })); } break; } case RoutingOperation.Lookup: { var peers = table.Nearest(data.Key, k, data.OnlyKBucket); await tp.Run(data, () => data.Response.WriteAsync(new RoutingResponse() { Succes = true, Peers = peers })); break; } default: throw new Exception($"Operation not supported: {data.Operation}"); } } catch (Exception ex) { await errorHandler(data, ex); } } })); }
public WebManager() { taskPool = new TaskPool <WebTask>(); }
public Loop(int threadNum = MaxThread) { pool = new TaskPool(threadNum); }
/// <summary> /// Runs a single peer connection, using the IPC link /// </summary> /// <returns>An awaitable task.</returns> /// <param name="self">This peer's information</param> /// <param name="remote">The remote peer's information</param> /// <param name="connecthandler">The method used to obtain the connection.</param> /// <param name="input">The channel for reading requests.</param> /// <param name="maxparallel">The maximum number of parallel handlers</param> private static async Task RunSingleConnection(PeerInfo self, PeerInfo remote, Func <Task <Stream> > connecthandler, IReadChannel <ConnectionRequest> input, int maxparallel) { // Get the local handler for remote requests var remotehandler = Channels.RemoteRequests.Get(); LeanIPC.IPCPeer connection = null; try { if (connecthandler == null) { throw new ArgumentNullException(nameof(connecthandler)); } if (input == null) { throw new ArgumentNullException(nameof(input)); } log.Debug($"Setting up connection to {remote?.Key}"); // Connect to the remote peer connection = new LeanIPC.IPCPeer(await connecthandler()); // Setup a handler for remote requests, that forwards responses from the remote handler connection.AddUserTypeHandler <Protocol.Request>( async(id, req) => { await connection.SendResponseAsync(id, (await remotehandler.SendConnectionRequestAsync(null, null, id, req)).Response); return(true); } ); var mainTask = connection.RunMainLoopAsync(self != remote); Key targetKey = null; // Grab a connection to update the routing table automatically var routingrequests = Channels.RoutingTableRequests.Get(); log.Debug($"Peer connection running {self.Key}, {self.Address}"); using (var tp = new TaskPool <ConnectionRequest>(maxparallel, (t, ex) => log.Warn("Unexpected error handling request", ex))) while (true) { log.Debug($"Peer connection is waiting for request ..."); // Get either a local or a remote request var req = await input.ReadAsync(); log.Debug($"Peer connection got request, handling on taskpool ..."); await tp.Run(req, () => { log.Debug($"Peer connection is forwarding a local {req.Request.Operation} request to the remote"); return(Task.Run(async() => { ConnectionResponse res; try { var p = await connection.SendAndWaitAsync <Protocol.Request, Protocol.Response>(req.Request); if (targetKey == null) { // Record the target key targetKey = p.Self.Key; if (remote == null || remote.Key == null) { remote = new PeerInfo(p.Self.Key, remote.Address); } // Write a registration request to the broker await Channels.ConnectionBrokerRegistrations.Get().WriteAsync( new ConnectionRegistrationRequest() { IsTerminate = false, UpdateRouting = true, Peer = remote } ); log.Debug($"Registering peer in routing table: {remote.Key} {remote.Address} ..."); await routingrequests.AddPeerAsync(remote.Key, remote); } if (p.Peers != null) { log.Debug($"Registering {p.Peers.Count} peers with the routing table ..."); foreach (var peer in p.Peers) { await routingrequests.AddPeerAsync(peer.Key, peer); } log.Debug($"Registered {p.Peers.Count} peers with the routing table"); } res = new ConnectionResponse() { Key = p.Self.Key, Response = p }; } catch (Exception ex) { log.Warn($"Failed to get result, sending error response", ex); res = new ConnectionResponse() { Key = targetKey, Exception = ex }; log.Warn($"Killing peer due to the previous exception"); await input.RetireAsync(); } if (req.Response != null) { try { await req.Response.WriteAsync(res); } catch (Exception ex) { log.Warn("Failed to send response", ex); } } })); }); } } finally { await remotehandler.RetireAsync(); if (connection != null) { try { await connection.ShutdownAsync(); } catch (Exception ex) { log.Warn("Failed to shut down IPC Peer", ex); } } // Write a registration request to the broker await Channels.ConnectionBrokerRegistrations.Get().WriteAsync( new ConnectionRegistrationRequest() { IsTerminate = false, UpdateRouting = false, Peer = remote } ); } }
/// <summary> /// Runs a process that handles remote requests /// </summary> /// <param name="selfinfo">Description of the owning node</param> /// <param name="maxparallel">The maximum number of requests to handle in parallel</param> /// <returns>The async.</returns> public static Task RunAsync(PeerInfo selfinfo, int maxparallel = 10) { return(AutomationExtensions.RunTask(new { Requests = Channels.RemoteRequests.ForRead, Routing = Channels.RoutingTableRequests.ForWrite }, async self => { log.Debug("Running the remote handler"); // Set up an error handler Func <ConnectionRequest, Exception, Task> errorHandler = async(t, ex) => { try { await t.Response.WriteAsync(new ConnectionResponse() { Exception = ex, RequestID = t.RequestID }); } catch (Exception ex2) { log.Warn("Failed to send error response", ex2); } }; using (var tp = new TaskPool <ConnectionRequest>(maxparallel, errorHandler)) while (true) { log.Debug("Remote handler is waiting for requests ..."); var req = await self.Requests.ReadAsync(); log.Debug($"Remote handler got a {req.Request.Operation} request ({req.RequestID})"); await tp.Run(req, async() => { log.Debug($"Remote handler is processing {req.Request.Operation} request ({req.RequestID})"); if (req.Key != null && req.EndPoint != null) { log.Debug($"Updating route table with remote request data {req.Key} - {req.EndPoint}"); await self.Routing.AddPeerAsync(req.Key, new PeerInfo(req.Key, req.EndPoint)); } switch (req.Request.Operation) { case Protocol.Operation.Ping: await HandlePingRequestAsync(selfinfo, req); break; case Protocol.Operation.Store: await HandleStoreRequestAsync(selfinfo, req); break; case Protocol.Operation.FindValue: await HandleFindRequestAsync(selfinfo, req); break; case Protocol.Operation.FindPeer: await HandleNodeLookupRequestAsync(selfinfo, req); break; default: await req.Response.WriteAsync(new ConnectionResponse() { RequestID = req.RequestID, Exception = new Exception($"Invalid operation: {req.Request.Operation}") }); break; } log.Debug($"Remote handler finished processing {req.Request.Operation} request ({req.RequestID})"); }); } })); }
public Consumer() { _device = TaskPool.GetInstance(); // IsResultOK = false; }
protected override TimedTimerEntry RegisterTimer(Action action, int timeout) { return(TaskPool.CallDelayed(timeout, action)); }
public bool TaskPool(TaskPool e) { return(Test(e)); }
protected virtual bool BuildMessage(BufferSegment buffer) { if (m_messagePart == null) { m_messagePart = new IPCMessagePart(); } var reader = new FastBigEndianReader(buffer) { Position = buffer.Offset + m_readOffset, MaxPosition = buffer.Offset + m_readOffset + m_remainingLength, }; bool built; try { built = m_messagePart.Build(reader); } catch { logger.Error("Cannot build message. Length={0} LengthSize={3} RemainingLength={1} Data={2}", m_messagePart.Length, m_remainingLength, m_messagePart.Data, m_messagePart.LengthBytesCount); throw; } // if message is complete if (built) { var dataPos = reader.Position; // prevent to read above reader.MaxPosition = dataPos + m_messagePart.Length.Value; IPCMessage message; try { message = IPCMessageSerializer.Instance.Deserialize(m_messagePart.Data); } catch (Exception ex) { reader.Seek(dataPos, SeekOrigin.Begin); logger.Debug("Message = {0}", m_messagePart.Data.ToString(" ")); logger.Error("Error while deserializing IPC Message : " + ex); return(m_remainingLength <= 0 || BuildMessage(buffer)); } TaskPool.AddMessage(() => ProcessMessage(message)); m_remainingLength -= (int)(reader.Position - (buffer.Offset + m_readOffset)); m_writeOffset = m_readOffset = (int)reader.Position - buffer.Offset; m_messagePart = null; return(m_remainingLength <= 0 || BuildMessage(buffer)); } m_remainingLength -= (int)(reader.Position - (buffer.Offset + m_readOffset)); m_readOffset = (int)reader.Position - buffer.Offset; m_writeOffset = m_readOffset + m_remainingLength; EnsureBuffer(m_messagePart.Length.HasValue ? m_messagePart.Length.Value : 5); return(false); }
/* Main */ private static void Main(string[] args) { ParseArgs(args); Console.SetWindowSize(100, 30); //Console.SetCursorPosition(0, 5); Console.BackgroundColor = ConsoleColor.Blue; Console.ForegroundColor = ConsoleColor.White; ConsoleKeyInfo cki; Console.WriteLine("Starting DnsTest with workstation name {0}", _wksName); Console.WriteLine("Touches autorisées: S pour search, G pour lister les serveurs, P pour purger les serveurs"); Console.WriteLine("Mode Hardcore {0}", _hardcore.ToString()); var rootzone = new RootZone(); // on charge la zone.root de l'iana. Check4PublicSuffixList(); DnsServer.Retries = _retries; DnsServer.Timeout = _timeout; // debuguer. /* * bool result; * string log; * var domain = DomainParser.DomainParser.Parse("fzbiuzhfizufizfzfz.fr"); * Console.WriteLine("{0} , {1} , {2}", domain.DomainName, domain.Libelle, domain.Extension); * var DnsServer = RootZone.GetServer(domain.DomainName)?.Ip; * RootZone.GetAll(); * DnsServer.IsNsRecorded(domain.DomainName, 2000, out result, out log, DnsServer); * Console.WriteLine(log); * * * * var domain2 = DomainParser.DomainParser.Parse("maktalent.xn--kprw13d"); * Console.WriteLine("{0} , {1} , {2}", domain2.DomainName, domain2.Libelle, domain2.Extension); * var DnsServer2 = RootZone.GetServer("xn--kprw13d")?.Ip; * RootZone.GetAll(); * DnsServer.IsNsRecorded("maktalent.xn--kprw13d", 2000, out result, out log, DnsServer2); * Console.WriteLine(log); * * Console.ReadKey(); */ var doneEvent = new AutoResetEvent(false); var taskPool = new TaskPool(_taskCount + 1); var dbDomains = new List <DomainDb.Domain>(); Full_List_Extensions = Full_List_Extensions.Except(List_Extensions).ToArray(); DomainDb.Db.ConnectionString = string.Format("Server={0};Database={1};Uid={2};Pwd={3};Port={4};MinimumPoolSize=16;maximumpoolsize=64;Charset=utf8;", _mySqlServer, _mySqlDatabase, _mySqlUsername, _mySqlPassword, 3306, _taskCount); Console.WriteLine("Init thread pool..."); var queueDomainPack = new Queue <List <DomainDb.Domain> >(); var sw = new Stopwatch(); Stopwatch swUpdate = new Stopwatch(); Task.Factory.StartNew(() => { while (true) { lock (lockObj) { RootZone.Purge(); } if (sw.IsRunning) { sw.Stop(); } if (swUpdate.IsRunning) { swUpdate.Stop(); } Console.WriteLine("Scanning..."); using (var db = new Db()) { Console.WriteLine("Reset libelle..."); db.ResetLibelle(_wksName); Thread.Sleep(1000); Console.WriteLine("Get For Processing..."); queueDomainPack.Enqueue(db.GetForProcessing(_wksName, _processBuffer)); } Console.WriteLine("Dequeue..."); dbDomains.Clear(); dbDomains = queueDomainPack.Dequeue(); Console.WriteLine("Querying {0} entries...", dbDomains.Count); if (!sw.IsRunning) { sw.Start(); } if (!swUpdate.IsRunning) { swUpdate.Start(); } for (int i = 0; i < dbDomains.Count; i++) { var i1 = i; //taskPool.QueueTask(async () => taskPool.QueueTask(() => { Interlocked.Increment(ref _libelles); bool insertion = false; Random rnd = new Random(); foreach (string List_Extension in List_Extensions.OrderBy(x => rnd.Next()).ToArray()) { var domainEntity = dbDomains[i1]; bool result; string log; domainEntity.DomainName = string.Concat(domainEntity.Libelle, List_Extension); //domainEntity.Extension = DomainParser.DomainParser.Parse(domainEntity.DomainName).Extension; domainEntity.Extension = List_Extension.Substring(1); var DnsServer = RootZone.GetServer(domainEntity.Extension)?.Ip; int thistimeout = _timeout; if (List_Extension == ".cn") { thistimeout = 2000; } if (List_Extension == ".cc") { thistimeout = 2000; } if (List_Extension == ".ca") { thistimeout = 1000; } if (List_Extension == ".co") { thistimeout = 500; } var thread = Thread.CurrentThread.ManagedThreadId; //var NsRecorded = await DnsServer.IsNsRecordedAsync(domainEntity.DomainName, thistimeout, DnsServer); //if (!NsRecorded.success) if (!DnsPerformer.DnsServer.IsNsRecorded(domainEntity.DomainName, domainEntity.Extension, thistimeout, out result, out log, DnsServer)) { Interlocked.Increment(ref _failed); domainEntity.Processing = null; } else { domainEntity.Processing = null; if (isWindows) { domainEntity.LastDate = TimeZoneInfo.ConvertTime(DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Romance Standard Time")); } else { domainEntity.LastDate = TimeZoneInfo.ConvertTime(DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Europe/Paris")); } domainEntity.NsRecorded = result; //domainEntity.NsRecorded = NsRecorded.result; if (domainEntity.NsRecorded == true) { if (_hardcore == true) { insertion = true; } Interlocked.Increment(ref _found); using (var db = new DomainDb.Db()) { if (db.Save(domainEntity)) { if (_hardcore == false) { insertion = true; } Interlocked.Increment(ref _inserted); } } } } } // foreach // repasse sur l'ensemble si première fois ou si on a detecté un nom dans la première liste. if (insertion == true || dbDomains[i1].LastDate == null) { //Console.WriteLine("[DEBUG] Passe complète sur " + dbDomains[i1].Libelle); foreach (string List_Extension in Full_List_Extensions.OrderBy(x => rnd.Next()).ToArray()) { var domainEntity = dbDomains[i1]; bool result; string log; domainEntity.DomainName = string.Concat(domainEntity.Libelle, List_Extension); domainEntity.Extension = List_Extension.Substring(1); var DnsServer = RootZone.GetServer(domainEntity.Extension)?.Ip; int thistimeout = _timeout; if (List_Extension == ".cn") { thistimeout = 2000; } if (List_Extension == ".cc") { thistimeout = 2000; } if (List_Extension == ".ca") { thistimeout = 500; } if (List_Extension == ".co") { thistimeout = 500; } var thread = Thread.CurrentThread.ManagedThreadId; if (!DnsPerformer.DnsServer.IsNsRecorded(domainEntity.DomainName, domainEntity.Extension, thistimeout, out result, out log, DnsServer)) { Interlocked.Increment(ref _failed); domainEntity.Processing = null; } else { domainEntity.Processing = null; if (isWindows) { domainEntity.LastDate = TimeZoneInfo.ConvertTime(DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Romance Standard Time")); } else { domainEntity.LastDate = TimeZoneInfo.ConvertTime(DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Europe/Paris")); } domainEntity.NsRecorded = result; if (domainEntity.NsRecorded == true) { using (var db = new Db()) { Interlocked.Increment(ref _found); if (db.Save(domainEntity)) { Interlocked.Increment(ref _inserted); insertion = true; } } } } } // foreach } }); //taskpool } // for buffer dbDomains taskPool.WaitAll(); dbDomains.Clear(); } //while true } , TaskCreationOptions.LongRunning); taskPool.WaitAll(); Task.Factory.StartNew(() => { int precedentQuery = 0; swUpdate.Restart(); while (true) { if (DnsServer.QueryNumber > 0 && dbDomains.Count > 0) { int maxworkerThreads; int maxportThreads; int availableworkerThreads; int availableportThreads; ThreadPool.GetMaxThreads(out maxworkerThreads, out maxportThreads); ThreadPool.GetAvailableThreads(out availableworkerThreads, out availableportThreads); var currentQuery = DnsServer.QueryNumber; stats.Enqueue((currentQuery - precedentQuery) / swUpdate.Elapsed.TotalSeconds); precedentQuery = currentQuery; swUpdate.Restart(); lock (lockObj) { // ouais ok y'avait plus propre. var console = Console.CursorTop; Console.ResetColor(); Console.SetCursorPosition(0, console); Console.Write(new string(' ', Console.WindowWidth)); Console.SetCursorPosition(0, console + 1); Console.Write(new string(' ', Console.WindowWidth)); Console.SetCursorPosition(0, console + 2); Console.Write(new string(' ', Console.WindowWidth)); Console.BackgroundColor = ConsoleColor.DarkGreen; Console.ForegroundColor = ConsoleColor.White; Console.SetCursorPosition(0, console + 3); Console.Write("{0}/{1} threads en cours / {2:0.000} QPS instantané / {3:0.000} QPS total / {4}/{5} libelles tested\n", maxworkerThreads - availableworkerThreads - 1, taskPool.GetTasks(), stats.Average(), DnsServer.QueryNumber / sw.Elapsed.TotalSeconds, _libelles, dbDomains.Count); Console.Write("{0} Domains tested / {1}% Fail / {2} Domains Found / {3} New Inserted\n", DnsServer.QueryNumber, (_failed / (float)DnsServer.QueryNumber) * 100, _found, _inserted); Console.SetCursorPosition(0, console); Console.BackgroundColor = ConsoleColor.Blue; Console.ForegroundColor = ConsoleColor.White; } } Thread.Sleep(1000); } }); do { cki = Console.ReadKey(); Console.TreatControlCAsInput = true; if (cki.Key == ConsoleKey.G) { lock (lockObj) { RootZone.GetAll(); } continue; } if (cki.Key == ConsoleKey.P) { lock (lockObj) { RootZone.Purge(); } continue; } if (cki.Key == ConsoleKey.S) { WriteLog("Extension à rechercher : "); lock (lockObj) { var extension = Console.ReadLine(); RootZone.GetExtension(extension); } continue; } else { WriteLog("Touches autorisées: S pour search, G pour lister les serveurs, P pour purger les serveurs"); } } while (cki.Key != ConsoleKey.Escape); sw.Stop(); Console.WriteLine(); Console.ReadKey(); } // Main
public static void Queue(this Task task) { TaskPool.Queue(() => task); }
public void Update() { if (!buildAble) { return; } buildFrameCount++; int loopTimeOutCount = 0; while (true) { loopTimeOutCount++; if (loopTimeOutCount > BuildMaxloopTime) { #if DEBUG Debug.LogError($"该界面构建帧超时退出!"); #endif return; } //构建任务栈为空 if (taskStack.Count == 0) { buildAble = false; AllCompleted?.Invoke(); AllCompleted = null; // 每次都置空完全构建完毕回调 //Debug.Log($"该界面构造帧数为 : {buildFrameCount}"); //Debug.Log($"该界面构造耗时为 : {CostTime}毫秒!"); buildFrameCount = 0; return; } //获取当前任务,判断是否已完成,未完成则继续构建 currentTask = taskStack.Peek(); if (currentTask.IsComplete) { currentTask.Reset(); TaskPool.RestoreTask(currentTask); taskStack.Pop(); continue; } try { currentTask.BuildAtUpdate(); buildedCount += currentTask.BuildedFrameCount; if (buildedCount >= this.buildWorkPerFrame) { buildedCount = 0; return; } } catch (Exception ex) { DestroySelf(); #if DEBUG Debug.LogError($"UI{currentTask.TaskMeta.RootMeta.Name}构建失败!"); Debug.LogError(ex.Message + ex.StackTrace); #endif currentTask.Reset(); TaskPool.RestoreTask(currentTask); taskStack.Pop(); #if UNITY_EDITOR Application.Quit(); #endif } } }
public static void Queue(this Func <Task> func) { TaskPool.Queue(func); }
/// <summary> /// 初始化 Web 请求管理器的新实例。 /// </summary> public WebRequestManager() { m_TaskPool = new TaskPool <WebRequestTask>(); m_Timeout = 30f; }
public void OnAwake() { m_TaskPool = new TaskPool <WebRequestTask>(); m_Timeout = 30f; }
public DownloadManager() { taskPool = new TaskPool <DownloadTask>(); }
public override void CleanupAfterTest() { base.CleanupAfterTest(); TaskPool.CancelAllTasks(); }
/// <summary> /// Update LODs going up or down a single step only for runtime optimizations /// </summary> /// <param name="camera"></param> public void UpdateLODs(Vector3 camera) { //Loop Trough Active Nodes Deciding If We Should Keep Them Or Not HashSet <QuadNode <ChunkData> > ac = new HashSet <QuadNode <ChunkData> >(); foreach (QuadNode <ChunkData> node in this.activeChunks) { //Show Node if ((node.isBranch || node.depth < maxDepth) && canSplit(camera, node)) { if (node.isLeaf) { Split(node); } //If I already am generating this LOD if (splitTasks.ContainsKey(node)) { Task t = splitTasks[node]; if (t.state == TaskStatus.Complete) { //Can switch to child nodes DiscardNode(node); ShowNodeSplit(node, ((PlanetSplitTask)t).meshes, ac); splitTasks.Remove(node); } else { //Not yet, keep current ShowNode(node, ac); } } //If I am not yet generating this LOD, keep current else { PlanetSplitTask t = new PlanetSplitTask((s) => { PlanetSplitTask self = (PlanetSplitTask)s; //Generate Meshes for (int i = 0; i < 4; i++) { QuadNode <ChunkData> child = self.parent[(Quadrant)i]; MeshData m = meshService.Make( child.range.a, child.range.b, child.range.d, child.range.c, child.value.faceRegion, this.radius); self.meshes[i] = m; } }); t.parent = node; splitTasks[node] = t; TaskPool.EnqueueInvocation(t); ShowNode(node, ac); } } //Collapse Or Keep Node else { //Is Root, Cannot Split OR Child Wants To Merge But Parent Wants To Split if (node.isRoot || canSplit(camera, node.parent)) { ShowNode(node, ac); } //Child Wants To Merge And Parent Wants To Be Shown else { if (mergeTasks.ContainsKey(node.parent)) { //Generation already started Task t = mergeTasks[node.parent]; if (t.state == TaskStatus.Complete) { //Generation is complete, show parent DiscardNode(node.parent[Quadrant.NorthEast]); DiscardNode(node.parent[Quadrant.SouthEast]); DiscardNode(node.parent[Quadrant.NorthWest]); DiscardNode(node.parent[Quadrant.SouthWest]); ShowNodeMerge(node.parent, ((PlanetMergeTask)t).mesh, ac); mergeTasks.Remove(node.parent); } else { //Generation is not complete, keep node ShowNode(node, ac); } } else if (!ac.Contains(node.parent)) { //No generation started, keep node, start generation PlanetMergeTask t = new PlanetMergeTask((s) => { PlanetMergeTask self = (PlanetMergeTask)s; MeshData m = meshService.Make( self.node.range.a, self.node.range.b, self.node.range.d, self.node.range.c, self.node.value.faceRegion, this.radius); self.mesh = m; }); t.node = node.parent; mergeTasks[node.parent] = t; TaskPool.EnqueueInvocation(t); ShowNode(node, ac); } } } } //Set The Active Chunks this.activeChunks = ac; }
public WebRequestManager() { m_eventManager = FrameworkEntry.Instance.GetManager <EventManager>(); m_TaskPool = new TaskPool <WebRequestTask>(); Timeout = 30f; }