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)
{
}
