public CloudConnection(IConnection connection, IHubProtocol protocol, HubHostOptions options, HubLifetimeManager <THub> lifetimeManager, HubDispatcher <THub> hubDispatcher, ILoggerFactory loggerFactory) { _connection = connection ?? throw new ArgumentNullException(nameof(connection)); _protocol = protocol ?? throw new ArgumentNullException(nameof(protocol)); _options = options ?? throw new ArgumentNullException(nameof(options)); _lifetimeManager = lifetimeManager ?? throw new ArgumentNullException(nameof(lifetimeManager)); _hubDispatcher = hubDispatcher ?? throw new ArgumentNullException(nameof(hubDispatcher)); _loggerFactory = loggerFactory ?? NullLoggerFactory.Instance; _logger = _loggerFactory.CreateLogger <CloudConnection <THub> >(); _timeoutTimer = new Timer(state => ((CloudConnection <THub>)state).TimeoutElapsed(), this, Timeout.Infinite, Timeout.Infinite); _reconnectTimer = new Timer(state => ((CloudConnection <THub>)state).StartAsync().GetAwaiter().GetResult(), this, Timeout.Infinite, Timeout.Infinite); connection.OnReceived((data, state) => ((CloudConnection <THub>)state).OnDataReceivedAsync(data), this); connection.Closed += OnHttpConnectionClosed; }
public PersistentLifetimeManager(HubLifetimeManager <THub> hubLifetimeManager) { var intervalStr = Environment.GetEnvironmentVariable(SendingInterval); if (intervalStr != null) { var intervalInt = Convert.ToInt32(intervalStr); Interval = TimeSpan.FromMilliseconds(intervalInt); } else { Interval = TimeSpan.FromMilliseconds(100); } _internalLifetimeManager = hubLifetimeManager; _timer = new System.Timers.Timer(100); _timer.Elapsed += async(sender, e) => { try { await StartBroadcastInternal(); } catch (Exception ex) { Console.WriteLine($"{ex}"); } }; _timer.Start(); LoadData(); }
public CurrencyListenerService( HubLifetimeManager <CurrencyHub> hubManager, ILogger <CurrencyListenerService> logger) { _hubManager = hubManager; _logger = logger; }
public UnitOfWork(PodNomsDbContext context, ILogger <UnitOfWork> logger, HubLifetimeManager <EntityUpdatesHub> hub) { _logger = logger; _hub = hub; _context = context; }
public void SetHubLifetimeManager(HubLifetimeManager <THub> hubLifetimeManager) { foreach (var factory in _hubManagerConsumerFactories) { factory.HubLifetimeManager = hubLifetimeManager; } HubLifetimeManager = hubLifetimeManager; }
/// <summary> /// Initializes a new instance of the <see cref="HubConnectionHandler{THub}"/> class. /// </summary> /// <param name="lifetimeManager">The hub lifetime manager.</param> /// <param name="protocolResolver">The protocol resolver used to resolve the protocols between client and server.</param> /// <param name="globalHubOptions">The global options used to initialize hubs.</param> /// <param name="hubOptions">Hub specific options used to initialize hubs. These options override the global options.</param> /// <param name="loggerFactory">The logger factory.</param> /// <param name="userIdProvider">The user ID provider used to get the user ID from a hub connection.</param> /// <param name="serviceScopeFactory">The service scope factory.</param> /// <remarks>This class is typically created via dependency injection.</remarks> public HubConnectionHandler(HubLifetimeManager <THub> lifetimeManager, IHubProtocolResolver protocolResolver, IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions, ILoggerFactory loggerFactory, IUserIdProvider userIdProvider, IServiceScopeFactory serviceScopeFactory ) { _protocolResolver = protocolResolver; _lifetimeManager = lifetimeManager; _loggerFactory = loggerFactory; _hubOptions = hubOptions.Value; _globalHubOptions = globalHubOptions.Value; _logger = loggerFactory.CreateLogger <HubConnectionHandler <THub> >(); _userIdProvider = userIdProvider; _enableDetailedErrors = false; bool disableImplicitFromServiceParameters; List <IHubFilter>?hubFilters = null; if (_hubOptions.UserHasSetValues) { _maximumMessageSize = _hubOptions.MaximumReceiveMessageSize; _enableDetailedErrors = _hubOptions.EnableDetailedErrors ?? _enableDetailedErrors; _maxParallelInvokes = _hubOptions.MaximumParallelInvocationsPerClient; disableImplicitFromServiceParameters = _hubOptions.DisableImplicitFromServicesParameters; if (_hubOptions.HubFilters != null) { hubFilters = new List <IHubFilter>(_hubOptions.HubFilters); } } else { _maximumMessageSize = _globalHubOptions.MaximumReceiveMessageSize; _enableDetailedErrors = _globalHubOptions.EnableDetailedErrors ?? _enableDetailedErrors; _maxParallelInvokes = _globalHubOptions.MaximumParallelInvocationsPerClient; disableImplicitFromServiceParameters = _globalHubOptions.DisableImplicitFromServicesParameters; if (_globalHubOptions.HubFilters != null) { hubFilters = new List <IHubFilter>(_globalHubOptions.HubFilters); } } _dispatcher = new DefaultHubDispatcher <THub>( serviceScopeFactory, new HubContext <THub>(lifetimeManager), _enableDetailedErrors, disableImplicitFromServiceParameters, new Logger <DefaultHubDispatcher <THub> >(loggerFactory), hubFilters, lifetimeManager); }
public PresenceHubLifetimeManager(IUserTracker <THub> userTracker, IServiceScopeFactory serviceScopeFactory, ILoggerFactory loggerFactory, IServiceProvider serviceProvider) { _userTracker = userTracker; _userTracker.UsersJoined += OnUsersJoined; _userTracker.UsersLeft += OnUsersLeft; _serviceScopeFactory = serviceScopeFactory; _serviceProvider = serviceProvider; _logger = loggerFactory.CreateLogger <PresenceHubLifetimeManager <THub, THubLifetimeManager> >(); _wrappedHubLifetimeManager = serviceProvider.GetRequiredService <THubLifetimeManager>(); }
public SupportChatService(UserManager <ApplicationUser> userManager, IOptions <ChatSettings> chatSettings, IConfiguration options, IPushSubscriptionStore subscriptionStore, IPushNotificationService notificationService, HubLifetimeManager <ChatHub> hub, SlackSupportClient slackSupport) { _chatSettings = chatSettings.Value; _notificationService = notificationService; _hub = hub; _options = options; _userManager = userManager; _subscriptionStore = subscriptionStore; _slackSupport = slackSupport; }
public ProxyHubConnectionHandler( HubLifetimeManager <THub> lifetimeManager, IHubProtocolResolver protocolResolver, IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions, ILoggerFactory loggerFactory, IUserIdProvider userIdProvider, IServiceScopeFactory serviceScopeFactory, IValueManagerStorageContainerInitializer storageContainerAccessor) : base(lifetimeManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory, userIdProvider, serviceScopeFactory) { this.storageContainerInitializer = storageContainerAccessor; }
public HubHost(HubLifetimeManager <THub> lifetimeManager, IHubProtocolResolver protocolResolver, HubDispatcher <THub> hubDispatcher, IOptions <HubHostOptions> options, ILoggerFactory loggerFactory) { _lifetimeManager = lifetimeManager ?? throw new ArgumentNullException(nameof(lifetimeManager)); _protocolResolver = protocolResolver ?? throw new ArgumentNullException(nameof(protocolResolver)); _hubDispatcher = hubDispatcher ?? throw new ArgumentNullException(nameof(hubDispatcher)); _options = options != null ? options.Value : throw new ArgumentNullException(nameof(options)); _loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory)); _logger = loggerFactory.CreateLogger <HubHost <THub> >(); }
public ChatController( IHttpContextAccessor contextAccessor, UserManager <ApplicationUser> userManager, ILogger <ChatController> logger, IOptions <ChatSettings> chatSettings, IOptions <AppSettings> appSettings, IPushSubscriptionStore subscriptionStore, IPushNotificationService notificationService, HubLifetimeManager <ChatHub> hub, IMapper mapper, IUnitOfWork unitOfWork, IChatRepository chatRepository, ISupportChatService supportChatService) : base(contextAccessor, userManager, logger) { _chatRepository = chatRepository; _unitOfWork = unitOfWork; _chatSettings = chatSettings.Value; _appSettings = appSettings.Value; _subscriptionStore = subscriptionStore; _notificationService = notificationService; _hub = hub; _mapper = mapper; _supportChatService = supportChatService; }
public ConvertUrlToMp3Service( ILogger <ConvertUrlToMp3Service> logger, HubLifetimeManager <PublicUpdatesHub> hub, AudioDownloader downloader, IOptions <AppSettings> appSettings, IOptions <StorageSettings> storageSettings, IUrlProcessService urlProcessService, IFileUploader fileUploader, IMP3Tagger tagger) : base(logger) { _hub = hub; _downloader = downloader; _urlProcessService = urlProcessService; _fileUploader = fileUploader; _tagger = tagger; _appSettings = appSettings.Value; _storageSettings = storageSettings.Value; }
public HubProxyHandler( IOptionsMonitor <UpstreamOptions> upstreamSettings, HubLifetimeManager <THub> lifetimeManager, IHubProtocolResolver protocolResolver, IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <THub> > hubOptions, ILoggerFactory loggerFactory, IUserIdProvider userIdProvider, IServiceScopeFactory serviceScopeFactory, HttpServerlessMessageHandler <THub> upstream) : base(lifetimeManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory, userIdProvider, serviceScopeFactory) { _protocolResolver = protocolResolver; _upstreamSettings = upstreamSettings; _lifetimeManager = lifetimeManager; _loggerFactory = loggerFactory; _hubOptions = hubOptions.Value; _globalHubOptions = globalHubOptions.Value; _logger = loggerFactory.CreateLogger <HubConnectionHandler <THub> >(); _userIdProvider = userIdProvider; _upstream = upstream; _enableDetailedErrors = true; }
public HubProxyHandler( HubLifetimeManager <Hub> lifetimeManager, IHubProtocolResolver protocolResolver, IOptions <HubOptions> globalHubOptions, IOptions <HubOptions <Hub> > hubOptions, ILoggerFactory loggerFactory, IUserIdProvider userIdProvider, IServiceScopeFactory serviceScopeFactory, IHubProxyInvoker rest) : base(lifetimeManager, protocolResolver, globalHubOptions, hubOptions, loggerFactory, userIdProvider, serviceScopeFactory) { _protocolResolver = protocolResolver; _lifetimeManager = lifetimeManager; _loggerFactory = loggerFactory; _hubOptions = hubOptions.Value; _globalHubOptions = globalHubOptions.Value; _logger = loggerFactory.CreateLogger <HubConnectionHandler <Hub> >(); _userIdProvider = userIdProvider; _rest = rest; _enableDetailedErrors = false; _maximumMessageSize = _globalHubOptions.MaximumReceiveMessageSize; _enableDetailedErrors = _globalHubOptions.EnableDetailedErrors ?? _enableDetailedErrors; }
public DebugController(IOptions <StorageSettings> settings, IOptions <AppSettings> appSettings, HubLifetimeManager <DebugHub> hub, IConfiguration config, IPageParser pageParser, IOptions <HelpersSettings> helpersSettings, IOptions <AudioFileStorageSettings> audioFileStorageSettings, IOptions <ImageFileStorageSettings> imageFileStorageSettings, IOptions <JwtIssuerOptions> jwtIssuerOptions, IPushSubscriptionStore subscriptionStore, IEntryRepository entryRepository, UserManager <ApplicationUser> userManager, ILogger <DebugController> logger, IMapper mapper, IPushNotificationService notificationService, IPodcastRepository podcastRepository, IUnitOfWork unitOfWork, IHttpContextAccessor contextAccessor, IMailSender mailSender) : base(contextAccessor, userManager, logger) { _appSettings = appSettings.Value; _storageSettings = settings.Value; _helpersSettings = helpersSettings.Value; _audioFileStorageSettings = audioFileStorageSettings.Value; _imageFileStorageSettings = imageFileStorageSettings.Value; _jwtIssuerOptions = jwtIssuerOptions.Value; _hub = hub; _config = config; _pageParser = pageParser; _mapper = mapper; _subscriptionStore = subscriptionStore; _entryRepository = entryRepository; _notificationService = notificationService; _podcastRepository = podcastRepository; _unitOfWork = unitOfWork; _mailSender = mailSender; }
public GroupExceptProxy(HubLifetimeManager <THub> lifetimeManager, string groupName, IReadOnlyList <string> excludedConnectionIds) { _lifetimeManager = lifetimeManager; _groupName = groupName; _excludedConnectionIds = excludedConnectionIds; }
public MultipleGroupProxy(HubLifetimeManager <THub> lifetimeManager, IReadOnlyList <string> groupNames) { _lifetimeManager = lifetimeManager; _groupNames = groupNames; }
public GroupProxy(HubLifetimeManager <THub> lifetimeManager, string groupName) { _lifetimeManager = lifetimeManager; _groupName = groupName; }
public MultipleUserProxy(HubLifetimeManager <THub> lifetimeManager, IReadOnlyList <string> userIds) { _lifetimeManager = lifetimeManager; _userIds = userIds; }
public MultipleClientProxy(HubLifetimeManager <THub> lifetimeManager, IReadOnlyList <string> connectionIds) { _lifetimeManager = lifetimeManager; _connectionIds = connectionIds; }
public SingleClientProxy(HubLifetimeManager <THub> lifetimeManager, string connectionId) { _lifetimeManager = lifetimeManager; _connectionId = connectionId; }
public AllClientsExceptProxy(HubLifetimeManager <THub> lifetimeManager, IReadOnlyList <string> excludedConnectionIds) { _lifetimeManager = lifetimeManager; _excludedConnectionIds = excludedConnectionIds; }
public UserProxy(HubLifetimeManager <THub> lifetimeManager, string userId) { _lifetimeManager = lifetimeManager; _userId = userId; }
/// <summary> /// Constructor /// </summary> /// <param name="hubLifetimeManager"></param> /// <param name="logger"></param> public ConnectionHandler(HubLifetimeManager <THub> hubLifetimeManager, ILogger <ConnectionHandler <THub> > logger) { _hubLifetimeManager = hubLifetimeManager as IRebusHubLifetimeManager ?? throw new ArgumentNullException(nameof(hubLifetimeManager), "HubLifetimeManager<> must be of type IRebusHubLifetimeManager"); _logger = logger; }
public ChatController(HubLifetimeManager <EchoHub> echoLifetimeManager) { _echoLifetimeManager = echoLifetimeManager; }
public AllClientProxy(HubLifetimeManager <THub> lifetimeManager) { _lifetimeManager = lifetimeManager; }
public HubContext(HubLifetimeManager <THub> lifetimeManager) { _lifetimeManager = lifetimeManager; _clients = new HubClients <THub>(_lifetimeManager); Groups = new GroupManager <THub>(lifetimeManager); }
public RealtimeController( ILogger <RealtimeController> logger, HubLifetimeManager <EntityUpdatesHub> hub) : base(logger) { _hub = hub; }
public HubClients(HubLifetimeManager <THub> lifetimeManager) { _lifetimeManager = lifetimeManager; All = TypedClientBuilder <T> .Build(new AllClientProxy <THub>(_lifetimeManager)); }
public AllConsumer(HubLifetimeManager <THub> hubLifetimeManager) : base(hubLifetimeManager) { }