private async Task BackendDiscoveryHandler()
        {
            while (this.IsRunning)
            {
                try
                {
                    var endpoints = await this.BackendDiscoverer.DiscoverAll();

                    foreach (var endpoint in endpoints)
                    {
                        var endpointId = BitConverter.ToString(endpoint.Encode());

                        var registeredEndpoint = new RegisteredBackend(endpoint, this);

                        if (this.backendEndpoints.TryAdd(endpointId, registeredEndpoint))
                        {
                            registeredEndpoint.Connect();

                            Console.WriteLine($"Backend registered [ {endpointId} ] ");
                            this.backendEndpointIds.Enqueue(endpointId);
                        }
                        else
                        {
                            this.backendEndpoints[endpointId].Heartbeat();
                        }
                    }

                    foreach (var endpointId in this.backendEndpoints.Keys)
                    {
                        if (!endpoints.Any(endpoint => BitConverter.ToString(endpoint.Encode()) == endpointId))
                        {
                            if (this.backendEndpoints.TryRemove(endpointId, out RegisteredBackend expiredBackend))
                            {
                                Console.WriteLine($"Backend {endpointId} expired");
                                expiredBackend.Close();
                            }
                        }
                    }
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message + ": " + ex.StackTrace);
                }

                await Task.Delay(5000);
            }
        }
Esempio n. 2
0
        private async Task BackendDiscoveryHandler()
        {
            while (this.IsRunning)
            {
                try
                {
                    foreach (var backendDiscoverer in this.BackendDiscoverers)
                    {
                        var backendEndpointIds = this.backendEndpointIds.GetOrAdd(backendDiscoverer.Name, new ConcurrentQueue <string>());

                        var endpoints = await backendDiscoverer.Discoverer.DiscoverAll();

                        foreach (var endpoint in endpoints)
                        {
                            var endpointId = BitConverter.ToString(endpoint.Encode());

                            var registeredEndpoint = new RegisteredBackend(backendDiscoverer.Name, endpoint, this);

                            if (this.backendEndpoints.TryAdd(endpointId, registeredEndpoint))
                            {
                                registeredEndpoint.Connect();

                                this.OnDiagnosticMessage($"Backend registered [ {backendDiscoverer.Name}/{endpointId} ] ");
                                backendEndpointIds.Enqueue(endpointId);
                            }
                            else
                            {
                                this.backendEndpoints[endpointId].Heartbeat();
                            }
                        }

                        foreach (var endpointId in backendEndpointIds)
                        {
                            if (!endpoints.Any(endpoint => BitConverter.ToString(endpoint.Encode()) == endpointId))
                            {
                                if (this.backendEndpoints.TryRemove(endpointId, out RegisteredBackend expiredBackend))
                                {
                                    this.OnDiagnosticMessage($"Backend {backendDiscoverer.Name}/{endpointId} expired");
                                    expiredBackend.Close();

                                    if (this.backendEndpointIds.TryRemove(backendDiscoverer.Name, out var oldEndpoints))
                                    {
                                        this.backendEndpointIds.GetOrAdd(backendDiscoverer.Name, new ConcurrentQueue <string>(oldEndpoints.Where(e => e != endpointId)));
                                    }
                                }
                            }
                        }
                    }

                    foreach (var backendDiscoverer in this.BackendDiscoverers)
                    {
                        this.OnDiagnosticMessage($"Backend: {backendDiscoverer.Name}");

                        var backendEndpointIds = this.backendEndpointIds.GetOrAdd(backendDiscoverer.Name, new ConcurrentQueue <string>());
                        foreach (var eid in backendEndpointIds)
                        {
                            this.OnDiagnosticMessage($"  {eid}");
                        }
                    }
                }
                catch (Exception ex)
                {
                    this.OnDiagnosticMessage(ex.Message + ": " + ex.StackTrace);
                }

                await Task.Delay(5000);
            }
        }