private static void ForGame(Guid gameId, IHubContext ctx, Action<dynamic> actionOnValidClient)
 {
     foreach (var registration in Registry.ClientToGames.Where(x => x.Value == gameId))
     {
         actionOnValidClient(ctx.Clients().Client(registration.Key));
     }
 }

        public SignalRLogSink(IHubContext context, IFormatProvider formatProvider)
        {
            if (context == null) throw new ArgumentNullException(nameof(context));

            _formatProvider = formatProvider;
            _context = context;
        }

        public QueueProcessor(Logger log, IDataStore dataStore, IHubContext<IMatchmakingClient> hub, ITracker tracker, IMatchEvaluator matchBuilder, CircularBuffer<TimeSpan> timeToMatch)
        {
            _log = log;
            _dataStore = dataStore;
            _hub = hub;
            _tracker = tracker;
            _matchBuilder = matchBuilder;
            _timeToMatch = timeToMatch;

            _queueSleepMin = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMin") );
            _queueSleepMax = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepMax") );
            _queueSleepLength = Int32.Parse( CloudConfigurationManager.GetSetting("QueueSleepLength") );

            Task.Run( async () =>
            {
                _log.Info("Running QueueProcessor...");

                while( true )
                {
                    var sleepTime = _queueSleepMax;

                    try
                    {
                        await processQueue();
                        sleepTime = _queueSleepMax - (_dataStore.DocumentDbPopulation * (_queueSleepMax/_queueSleepLength));
                    }
                    catch(Exception ex)
                    {
                        _log.Error(ex);
                    }

                    Thread.Sleep(sleepTime < _queueSleepMin ? _queueSleepMin : sleepTime);
                }
            });
        }

        /// <summary>
        /// Adds a sink that writes log events as documents to a SignalR hub.
        /// 
        /// </summary>
        /// <param name="loggerConfiguration">The logger configuration.</param><param name="context">The hub context.</param><param name="restrictedToMinimumLevel">The minimum log event level required in order to write an event to the sink.</param><param name="batchPostingLimit">The maximum number of events to post in a single batch.</param><param name="period">The time to wait between checking for event batches.</param><param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
        /// <returns>
        /// Logger configuration, allowing configuration to continue.
        /// </returns>
        /// <exception cref="T:System.ArgumentNullException">A required parameter is null.</exception>
        public static LoggerConfiguration SignalR(this LoggerSinkConfiguration loggerConfiguration, IHubContext context, LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose, int batchPostingLimit = 5, TimeSpan? period = null, IFormatProvider formatProvider = null)
        {
            if (loggerConfiguration == null) throw new ArgumentNullException(nameof(loggerConfiguration));
            if (context == null) throw new ArgumentNullException(nameof(context));

            return loggerConfiguration.Sink(new SignalRLogSink(context, formatProvider), restrictedToMinimumLevel);
        }

 public DemoHub(
     IHubContext<TypedDemoHub, IClient> typedDemoContext,
     IPersistentConnectionContext<RawConnection> rawConnectionContext)
 {
     _typedDemoContext = typedDemoContext;
     _rawConnectionContext = rawConnectionContext;
 }

        public void DeleteSessionMessageTutor(string sessionId, string sendTo, string message, IHubContext context)
        {
            //var name = Context.User.Identity.Name;
            using (var db = new ApplicationDbContext())
            {
                var user = db.Useras.Where(c => c.UserName == sendTo && c.SessionId == sessionId).FirstOrDefault();
                if (user == null)
                {
                    // context.Clients.Caller.showErrorMessage("Could not find that user.");
                }
                else
                {
                    db.Entry(user)
                        .Collection(u => u.Connections)
                        .Query()
                        .Where(c => c.Connected == true)
                        .Load();

                    if (user.Connections == null)
                    {
                        //  Clients.Caller.showErrorMessage("The user is no longer connected.");
                    }
                    else
                    {
                        foreach (var connection in user.Connections)
                        {
                            context.Clients.Client(connection.ConnectionID)
                                 .recieverSessionClosed(message);
                        }
                    }
                }
            }
        }

 /// <summary>
 /// Construct a sink posting to the specified database.
 /// </summary>
 /// <param name="context">The hub context.</param>
 /// <param name="batchPostingLimit">The maximium number of events to post in a single batch.</param>
 /// <param name="period">The time to wait between checking for event batches.</param>
 /// <param name="formatProvider">Supplies culture-specific formatting information, or null.</param>
 public SignalRSink(IHubContext context, int batchPostingLimit, TimeSpan period, IFormatProvider formatProvider)
     : base(batchPostingLimit, period)
 {
     if (context == null)
         throw new ArgumentNullException("context");
     _formatProvider = formatProvider;
     _context = context;
 }

        private ProxyWatcher(IHubContext context)
        {
            Context = context;

            _GatewayServer.ClientManager.OnClientConnectEvent += ClientManager_OnClientConnectEvent;
            _GatewayServer.ClientManager.OnClientDisconnectEvent += ClientManager_OnClientDisconnectEvent;
            _GatewayServer.ClientManager.OnPairedEvent += ClientManager_OnPairedEvent;
        }

        public Task Join(IHubContext<Drey.Server.Hubs.IRuntimeClient> hubContext, ClaimsPrincipal principal, string connectionId, Task onConnected)
        {
            _log.Info("Joining groups.");

            hubContext.Groups.Add(connectionId, principal.Identity.Name);
            _clientRegistry.Add(connectionId, principal.Identity.Name);

            return onConnected;
        }

        public Task Leave(IHubContext<Drey.Server.Hubs.IRuntimeClient> hubContext, ClaimsPrincipal principal, string connectionId, Task onDisconnected)
        {
            _log.Info("Leaving groups.");

            //hubContext.Groups.Remove(connectionId, principal.Identity.Name);
            _clientRegistry.Remove(connectionId);

            return onDisconnected;
        }

 public GameThread(IHubContext context)
 {
     _random = new Random();
     IsStarted = false;
     _hub = context;
     this.Game = new Game(Guid.NewGuid().ToString());
     _service = new TwitterService("vCBYBvYAdRrgWs5z0zmD1A", "eHqhut7IVR4aUWlgBwuURl3QssL7ASf7hNIi3AovjY");
     _service.AuthenticateWith("68329856-dHYH7dgh85Qkiv7vaNjoScNDTngJtNrjdH8JCLcvt", "KFtWesqC94jxkgSVYrpMlg4IKIcitmJF7MQW0b5Q");
 }

 public AlarmCheck(string UserId, string UserName)
 {
     _userId = UserId;
     _userName = UserName;
     _alarmHub = GlobalHost.ConnectionManager.GetHubContext<AlarmHub>();
     StartTimer();
 }

        public ShapeBroadCaster()
        {
            var broadCastLoop = new Timer(UpdateShape, null, BroadCastInterval, BroadCastInterval);
            shouldUpdateShape = false;

            shapeHub = GlobalHost.ConnectionManager.GetHubContext<MoveShapeHub>();
        }

        public BackgroundServerTimeTimer()
        {
            HostingEnvironment.RegisterObject(this);

            hub = GlobalHost.ConnectionManager.GetHubContext<ClientPushHub>();
            taskTimer = new Timer(OnTimerElapsed, null, TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(5));
        }

 public BackgroundTicker(IHubMessageService hubMessageService)
 {
     _hubMessageService = hubMessageService;
     HostingEnvironment.RegisterObject(this);
     hub = GlobalHost.ConnectionManager.GetHubContext<StatsHub>();
     taskTimer = new Timer(OnTimerElasped, null, TimeSpan.FromSeconds(2), TimeSpan.FromSeconds(2));
 }

 public DataEngine(int pollIntervalMillis)
 {
     //HostingEnvironment.RegisterObject(this);
     _hubs = GlobalHost.ConnectionManager.GetHubContext<DataHub>();
     _pollIntervalMillis = pollIntervalMillis;
     dataRandom = new Random(DateTime.Now.Millisecond);
 }

 public RandomGenerator(int pollIntervalMillis)
 {
     //HostingEnvironment.RegisterObject(this);
     _hubs = GlobalHost.ConnectionManager.GetHubContext<MyHub>();
     _pollIntervalMillis = pollIntervalMillis;
     _numberRand = new Random();
 }

 public SignalRConsole()
 {
     var url = "http://localhost:8945";
     WebApp.Start<Startup>(url);
     System.Console.WriteLine("Server running on {0}", url);
     _hubContext = GlobalHost.ConnectionManager.GetHubContext<SignalrProxy>();
 }

 public GameHub(Game game)
 {
     _game = game;
     _timer = new Timer();
     _timer.Elapsed += CreateGame;
     _context = GlobalHost.ConnectionManager.GetHubContext<GameHub>();
 }

 public SignalRActor()
 {
     _chat = GlobalHost.ConnectionManager.GetHubContext<PositionHub>();
     Receive<Taxi.PositionBearing>(p => positionChanged(p));
     Receive<Taxi.Status>(status => statusChanged(status));
     Receive<Publisher.SourceAvailable>(s => sourceChanged(s));
 }