public CoordinationSessionOwner(ISessionManager sessionManager,
ISessionProvider sessionProvider,
IDateTimeProvider dateTimeProvider,
IOptions <CoordinationManagerOptions> optionsAccessor,
ILogger <CoordinationSessionOwner> logger = null)
{
if (sessionManager == null)
{
throw new ArgumentNullException(nameof(sessionManager));
}
if (sessionProvider == null)
{
throw new ArgumentNullException(nameof(sessionProvider));
}
if (dateTimeProvider == null)
{
throw new ArgumentNullException(nameof(dateTimeProvider));
}
if (optionsAccessor == null)
{
throw new ArgumentNullException(nameof(optionsAccessor));
}
_sessionManager = sessionManager;
_sessionProvider = sessionProvider;
_dateTimeProvider = dateTimeProvider;
_logger = logger;
_options = optionsAccessor.Value ?? new CoordinationManagerOptions();
_session = BuildSession();
}
private SmartGlassClient(
Device device,
ConnectResponseMessage connectResponse,
CryptoContext cryptoContext)
{
_messageTransport = new MessageTransport(device.Address.ToString(), cryptoContext);
_sessionMessageTransport = new SessionMessageTransport(
_messageTransport,
new SessionInfo()
{
ParticipantId = connectResponse.ParticipantId
});
_sessionMessageTransport.MessageReceived += (s, e) =>
{
var consoleStatusMessage = e.Message as ConsoleStatusMessage;
if (consoleStatusMessage != null)
{
ConsoleStatusChanged?.Invoke(this, new ConsoleStatusChangedEventArgs(
new ConsoleStatus()
{
Configuration = consoleStatusMessage.Configuration,
ActiveTitles = consoleStatusMessage.ActiveTitles
}
));
}
};
_sessionMessageTransport.SendAsync(new LocalJoinMessage());
_inputChannel = new DisposableAsyncLazy <InputChannel>(async() =>
{
return(new InputChannel(await StartChannelAsync(ServiceType.SystemInput)));
});
}
#pragma warning restore IDE0032
public ModuleSupervisor(DirectoryInfo directory,
IMetadataReader metadataReader,
ILogger <ModuleSupervisor> logger = null)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
Directory = directory;
_metadataReader = metadataReader;
_logger = logger;
// Volatile write op (Is avtually not necessary here, because the CLR enforces thread-safety.)
_state = ModuleSupervisorState.Initializing;
_metadataLazy = new DisposableAsyncLazy <IModuleMetadata>(
factory: LookupMetadataAsync,
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread | DisposableAsyncLazyOptions.RetryOnFailure);
_supervisorProcess = new AsyncProcess(SupervisorProcessRoutine, start: true);
_disposeHelper = new AsyncDisposeHelper(DisposeInternalAsync);
}
public CoordinationLockManager(ICoordinationSessionOwner sessionOwner,
ISessionManager sessionManager,
CoordinationEntryCache cache,
ICoordinationStorage storage,
IStoredEntryManager storedEntryManager,
ICoordinationWaitManager waitManager,
ICoordinationExchangeManager exchangeManager,
ILogger <CoordinationLockManager> logger = null)
{
if (cache == null)
{
throw new ArgumentNullException(nameof(cache));
}
if (storage == null)
{
throw new ArgumentNullException(nameof(storage));
}
if (storedEntryManager == null)
{
throw new ArgumentNullException(nameof(storedEntryManager));
}
if (waitManager == null)
{
throw new ArgumentNullException(nameof(waitManager));
}
if (exchangeManager == null)
{
throw new ArgumentNullException(nameof(exchangeManager));
}
if (sessionOwner == null)
{
throw new ArgumentNullException(nameof(sessionOwner));
}
if (sessionManager == null)
{
throw new ArgumentNullException(nameof(sessionManager));
}
_sessionOwner = sessionOwner;
_sessionManager = sessionManager;
_cache = cache;
_storage = storage;
_storedEntryManager = storedEntryManager;
_waitManager = waitManager;
_exchangeManager = exchangeManager;
_logger = logger;
_sessionTerminationSource = new DisposableAsyncLazy <TaskCancellationTokenSource>(
factory: BuildSessionTerminationSourceAsync,
disposal: DestroySessionTerminationSourceAsync,
DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
}
public DebugConnection(IAddressConversion <IPEndPoint> addressConversion,
IMetadataAccessor metadataAccessor,
IOptions <ModuleDebugOptions> optionsAccessor,
IOptions <RemoteMessagingOptions> remoteOptionsAccessor,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory = null)
{
if (addressConversion == null)
{
throw new ArgumentNullException(nameof(addressConversion));
}
if (metadataAccessor == null)
{
throw new ArgumentNullException(nameof(metadataAccessor));
}
if (optionsAccessor == null)
{
throw new ArgumentNullException(nameof(optionsAccessor));
}
if (remoteOptionsAccessor == null)
{
throw new ArgumentNullException(nameof(remoteOptionsAccessor));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
_addressConversion = addressConversion;
_metadataAccessor = metadataAccessor;
_options = optionsAccessor.Value ?? new ModuleDebugOptions();
_remoteOptions = remoteOptionsAccessor.Value ?? new RemoteMessagingOptions();
_serviceProvider = serviceProvider;
_loggerFactory = loggerFactory;
_logger = _loggerFactory?.CreateLogger <DebugConnection>();
_debugPort = new Lazy <IPEndPoint>(() => _addressConversion.Parse(_options.DebugConnection), LazyThreadSafetyMode.PublicationOnly);
_tcpClientLazy = new DisposableAsyncLazy <TcpClient>(
factory: CreateTcpClientAsync,
disposal: tcpClient => { tcpClient.Dispose(); return(Task.CompletedTask); },
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
_proxyHostLazy = new DisposableAsyncLazy <ProxyHost>(
factory: CreateProxyHostAsync,
disposal: proxyHost => proxyHost.DisposeAsync(),
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
}
public DebugCoordinationManager(DebugConnection debugConnection, ILogger <DebugCoordinationManager> logger = null)
{
if (debugConnection == null)
{
throw new ArgumentNullException(nameof(debugConnection));
}
_debugConnection = debugConnection;
_logger = logger;
_proxyLazy = new DisposableAsyncLazy <IProxy <CoordinationManagerSkeleton> >(
factory: CreateProxyAsync,
disposal: p => p.DisposeAsync(),
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
_sessionLazy = new DisposableAsyncLazy <Session>(
factory: GetSessionInternalAsync,
options: DisposableAsyncLazyOptions.ExecuteOnCallingThread | DisposableAsyncLazyOptions.RetryOnFailure);
}
public DebugSession(DebugPort debugServer,
TcpClient tcpClient,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory)
{
if (debugServer == null)
{
throw new ArgumentNullException(nameof(debugServer));
}
if (tcpClient == null)
{
throw new ArgumentNullException(nameof(tcpClient));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
_debugServer = debugServer;
_tcpClient = tcpClient;
Address = tcpClient.Client.RemoteEndPoint as IPEndPoint;
_serviceProvider = serviceProvider;
_loggerFactory = loggerFactory;
_logger = _loggerFactory?.CreateLogger <DebugSession>();
var streamLogger = _loggerFactory?.CreateLogger <DisposeAwareStream>();
_stream = new DisposeAwareStream(_tcpClient.GetStream(), OnDebugStreamsCloses, streamLogger);
_propertiesLazy = new DisposableAsyncLazy <DebugModuleProperties>(
factory: CreatePropertiesAsync,
disposal: DisposePropertiesAsync,
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
_proxyHostLazy = new DisposableAsyncLazy <ProxyHost>(
factory: CreateProxyHostAsync,
disposal: proxyHost => proxyHost.DisposeAsync(),
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
}
public DebugLogicalEndPoint(DebugConnection debugConnection, EndPointAddress endPoint, ILogger <DebugLogicalEndPoint> logger = null)
{
if (debugConnection == null)
{
throw new ArgumentNullException(nameof(debugConnection));
}
if (endPoint == default)
{
throw new ArgumentDefaultException(nameof(endPoint));
}
_debugConnection = debugConnection;
EndPoint = endPoint;
_logger = logger;
_proxyLazy = new DisposableAsyncLazy <IProxy <LogicalEndPointSkeleton> >(
factory: CreateProxyAsync,
disposal: p => p.DisposeAsync(),
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
}
public CoordinationExchangeManager(ICoordinationSessionOwner sessionOwner,
ISessionManager sessionManager,
ILockWaitDirectory lockWaitDirectory,
IProvider <ICoordinationLockManager> lockManager,
ICoordinationStorage storage,
CoordinationEntryCache cache,
IPhysicalEndPointMultiplexer <TAddress> endPointMultiplexer,
IAddressConversion <TAddress> addressConversion,
IOptions <CoordinationManagerOptions> optionsAccessor,
ILogger <CoordinationExchangeManager <TAddress> > logger = null)
{
if (sessionOwner == null)
{
throw new ArgumentNullException(nameof(sessionOwner));
}
if (sessionManager == null)
{
throw new ArgumentNullException(nameof(sessionManager));
}
if (lockWaitDirectory == null)
{
throw new ArgumentNullException(nameof(lockWaitDirectory));
}
if (lockManager == null)
{
throw new ArgumentNullException(nameof(lockManager));
}
if (storage == null)
{
throw new ArgumentNullException(nameof(storage));
}
if (cache == null)
{
throw new ArgumentNullException(nameof(cache));
}
if (endPointMultiplexer == null)
{
throw new ArgumentNullException(nameof(endPointMultiplexer));
}
if (addressConversion == null)
{
throw new ArgumentNullException(nameof(addressConversion));
}
_sessionOwner = sessionOwner;
_sessionManager = sessionManager;
_lockWaitDirectory = lockWaitDirectory;
_lockManager = lockManager;
_storage = storage;
_cache = cache;
_endPointMultiplexer = endPointMultiplexer;
_addressConversion = addressConversion;
_logger = logger;
_options = optionsAccessor.Value ?? new CoordinationManagerOptions();
_physicalEndPoint = new DisposableAsyncLazy <IPhysicalEndPoint <TAddress> >(
factory: GetLocalSessionEndPointAsync,
disposal: DisposePhysicalEndPointAsync,
DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread);
_receiveProcess = new AsyncProcess(ReceiveProcess);
_receiveProcess.Start();
}
