Exemple #1
0
 public Job(TaskPool.Task main,int l)
 {
     line = l;
     Pre = null;
     Main = main;
     Post = null;
 }
Exemple #2
0
 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();
        }
Exemple #4
0
        public OperatorsForm()
            : base()
        {
            InitializeComponent();

            taskPool = new TaskPool();
            random = new Random();
        }
Exemple #5
0
        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);
            }
Exemple #9
0
        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>();
        }
Exemple #15
0
        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;
        }
Exemple #20
0
        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;
        }
Exemple #21
0
        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;
        }
Exemple #26
0
        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;
        }
Exemple #27
0
        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;
        }
Exemple #29
0
        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>();
        }
Exemple #31
0
        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());
        }
Exemple #33
0
        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("请输入整数");
            }
        }
Exemple #34
0
        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 { }
                }
            }
        }
Exemple #35
0
        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());
        }
Exemple #36
0
        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!!!");
                }
            }
        }
Exemple #37
0
 protected ParallelModuleBase(bool runOnServer, bool runOnClient, ModBase parent) : base(runOnServer, runOnClient, parent)
 {
     taskPool = new TaskPool(ErrorCallback);
 }
Exemple #38
0
        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);
                }
            }
        }
Exemple #39
0
 static AsyncUniTask()
 {
     TaskPool.RegisterSizeGetter(typeof(AsyncUniTask <TStateMachine>), () => pool.Size);
 }
 static WaitAsyncSource()
 {
     TaskPool.RegisterSizeGetter(typeof(WaitAsyncSource), () => pool.Size);
 }
Exemple #41
0
        /// <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);
                        }
                    }
            }));
        }
Exemple #42
0
        /// <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>();
 }
Exemple #44
0
 public Loop(int threadNum = MaxThread)
 {
     pool = new TaskPool(threadNum);
 }
Exemple #45
0
        /// <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
                }
                    );
            }
        }
Exemple #46
0
        /// <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;
 }
Exemple #48
0
 protected override TimedTimerEntry RegisterTimer(Action action, int timeout)
 {
     return(TaskPool.CallDelayed(timeout, action));
 }
Exemple #49
0
 public bool TaskPool(TaskPool e)
 {
     return(Test(e));
 }
Exemple #50
0
        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);
        }
Exemple #51
0
    /* 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);
 }
Exemple #53
0
        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);
 }
Exemple #55
0
 /// <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>();
 }
Exemple #58
0
        public override void CleanupAfterTest()
        {
            base.CleanupAfterTest();

            TaskPool.CancelAllTasks();
        }
Exemple #59
0
        /// <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;
        }
Exemple #60
0
 public WebRequestManager()
 {
     m_eventManager = FrameworkEntry.Instance.GetManager <EventManager>();
     m_TaskPool     = new TaskPool <WebRequestTask>();
     Timeout        = 30f;
 }