public ServerManager(IServiceMessageProcessor serviceMessageProcessor, ITaskRepository taskRepository, IUnitOfWorkFactory unitOfWorkFactory, IServerRepository serverRepository, IContextSettings contextSettings, ServerManagerConfiguration serverManagerConfiguration)
: base(serverManagerConfiguration)
{
if (serviceMessageProcessor == null)
{
throw new ArgumentNullException(nameof(serviceMessageProcessor));
}
if (taskRepository == null)
{
throw new ArgumentNullException(nameof(taskRepository));
}
if (unitOfWorkFactory == null)
{
throw new ArgumentNullException(nameof(unitOfWorkFactory));
}
if (contextSettings == null)
{
throw new ArgumentNullException(nameof(contextSettings));
}
if (serverRepository == null)
{
throw new ArgumentNullException(nameof(serverRepository));
}
this.serviceMessageProcessor = serviceMessageProcessor;
this.taskRepository = taskRepository;
this.unitOfWorkFactory = unitOfWorkFactory;
this.contextSettings = contextSettings;
this.serverRepository = serverRepository;
queues = managerConfiguration.Queues;
queues.Add("default");
}
/// <summary>
/// Initializes a new instance of the <see cref="RegistryService"/> class.
/// </summary>
/// <param name="registryConfigurationOptions">The registry configuration options.</param>
/// <param name="messageSerializer">The message serializer.</param>
/// <param name="serviceMessageProcessor">The service message processor.</param>
/// <param name="messageToServiceMapper">The message to service mapper.</param>
/// <param name="messageTypeCache">The message type cache.</param>
/// <param name="accessTokenService">The access token service.</param>
/// <param name="registryServiceLogger">The registry service logger.</param>
/// <param name="tcpNetworkConnectorLogger">The tcp network connector logger.</param>
/// <param name="registryServiceMessageProcessorLogger">The registry service message processor logger.</param>
/// <param name="httpNetworkConnectorLogger">The http network connector logger.</param>
public RegistryService(
IOptions <RegistryConfiguration> registryConfigurationOptions,
IMessageSerializer messageSerializer,
IServiceMessageProcessor serviceMessageProcessor,
IMessageToServiceMapper messageToServiceMapper,
IRegistryServiceMessageTypeCache messageTypeCache,
IAccessTokenService accessTokenService,
ILogger <RegistryService> registryServiceLogger,
ILogger <TcpNetworkConnector> tcpNetworkConnectorLogger,
ILogger <RegistryServiceMessageProcessor> registryServiceMessageProcessorLogger,
ILogger <HttpNetworkConnector> httpNetworkConnectorLogger)
{
_messageSerializer = messageSerializer;
_serviceMessageProcessor = serviceMessageProcessor;
_registryServiceMessageProcessor = new RegistryServiceMessageProcessor(this, registryServiceMessageProcessorLogger);
_messageToServiceMapper = messageToServiceMapper;
RegistryConfiguration registryConfiguration = registryConfigurationOptions.Value;
_tcpListener = new TcpListener(IPAddress.Any, registryConfiguration.Port);
_messageTypeCache = messageTypeCache;
_accessTokenService = accessTokenService;
_registryServiceLogger = registryServiceLogger;
_tcpNetworkConnectorLogger = tcpNetworkConnectorLogger;
_httpNetworkConnectorLogger = httpNetworkConnectorLogger;
}
public TeamCityArtifactsWriter(IServiceMessageProcessor target)
: base(target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
}
/// <summary>
/// Creates generic processor that calls messages updaters and sends output to provided deledate.
/// </summary>
/// <param name="processor">writer of service messages objects</param>
/// <param name="generator">flow id generator that is called to create next flowId</param>
/// <param name="updaters">service message updaters, i.e. timestamp updater</param>
public FlowServiceMessageWriter([NotNull] IServiceMessageProcessor processor,
[NotNull] IFlowIdGenerator generator,
[NotNull] IEnumerable <IServiceMessageUpdater> updaters)
{
myProcessor = processor;
myGenerator = generator;
myUpdaters = IncludeFlowId(updaters);
}
public TeamCityWriterFacade(
[NotNull] IServiceMessageProcessor processor,
[NotNull] ITeamCityBlockWriter <ITeamCityWriter> blockWriter,
[NotNull] ITeamCityCompilationBlockWriter <ITeamCityWriter> compilationWriter,
[NotNull] ITeamCityTestsWriter testsWriter,
[NotNull] ITeamCityMessageWriter messageWriter,
[NotNull] ITeamCityArtifactsWriter artifactsWriter,
[NotNull] ITeamCityBuildStatusWriter statusWriter,
[NotNull] ITeamCityFlowWriter <ITeamCityWriter> flowWriter,
[NotNull] IDisposable disposeCallback)
{
if (processor == null)
{
throw new ArgumentNullException(nameof(processor));
}
if (blockWriter == null)
{
throw new ArgumentNullException(nameof(blockWriter));
}
if (compilationWriter == null)
{
throw new ArgumentNullException(nameof(compilationWriter));
}
if (testsWriter == null)
{
throw new ArgumentNullException(nameof(testsWriter));
}
if (messageWriter == null)
{
throw new ArgumentNullException(nameof(messageWriter));
}
if (artifactsWriter == null)
{
throw new ArgumentNullException(nameof(artifactsWriter));
}
if (statusWriter == null)
{
throw new ArgumentNullException(nameof(statusWriter));
}
if (flowWriter == null)
{
throw new ArgumentNullException(nameof(flowWriter));
}
if (disposeCallback == null)
{
throw new ArgumentNullException(nameof(disposeCallback));
}
_processor = processor;
_blockWriter = blockWriter;
_compilationWriter = compilationWriter;
_testsWriter = testsWriter;
_messageWriter = messageWriter;
_artifactsWriter = artifactsWriter;
_statusWriter = statusWriter;
_flowWriter = flowWriter;
_dispose = disposeCallback;
}
public TeamCityBlockWriter(IServiceMessageProcessor target, Func <IDisposable, TCloseBlock> closeBlock)
: base(target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (closeBlock == null)
{
throw new ArgumentNullException(nameof(closeBlock));
}
_closeBlock = closeBlock;
}
private TeamCityWriterImpl(
[NotNull] IServiceMessageProcessor processor,
[NotNull] TeamCityFlowWriter <ITeamCityWriter> flowWriter,
[NotNull] TeamCityBlockWriter <ITeamCityWriter> blockWriter,
[NotNull] TeamCityCompilationBlockWriter <ITeamCityWriter> compilationWriter,
[NotNull] TeamCityTestSuiteBlock testsWriter,
[NotNull] ITeamCityMessageWriter messageWriter,
[NotNull] ITeamCityArtifactsWriter artifactsWriter,
[NotNull] ITeamCityBuildStatusWriter statusWriter,
[NotNull] IDisposable dispose)
: base(processor, blockWriter, compilationWriter, testsWriter, messageWriter, artifactsWriter, statusWriter, flowWriter, dispose)
{
if (processor == null)
{
throw new ArgumentNullException(nameof(processor));
}
if (flowWriter == null)
{
throw new ArgumentNullException(nameof(flowWriter));
}
if (blockWriter == null)
{
throw new ArgumentNullException(nameof(blockWriter));
}
if (compilationWriter == null)
{
throw new ArgumentNullException(nameof(compilationWriter));
}
if (testsWriter == null)
{
throw new ArgumentNullException(nameof(testsWriter));
}
if (messageWriter == null)
{
throw new ArgumentNullException(nameof(messageWriter));
}
if (artifactsWriter == null)
{
throw new ArgumentNullException(nameof(artifactsWriter));
}
if (statusWriter == null)
{
throw new ArgumentNullException(nameof(statusWriter));
}
if (dispose == null)
{
throw new ArgumentNullException(nameof(dispose));
}
_writeCheck = new ISubWriter[] { blockWriter, compilationWriter, testsWriter, flowWriter };
}
/// <summary>
/// Creates generic processor that calls messages updaters and sends output to provided deledate.
/// </summary>
/// <param name="processor">writer of service messages objects</param>
/// <param name="generator">flow id generator that is called to create next flowId</param>
/// <param name="updaters">service message updaters, i.e. timestamp updater</param>
public FlowServiceMessageWriter([NotNull] IServiceMessageProcessor processor,
[NotNull] IFlowIdGenerator generator,
[NotNull] IEnumerable <IServiceMessageUpdater> updaters)
{
if (processor == null)
{
throw new ArgumentNullException(nameof(processor));
}
if (generator == null)
{
throw new ArgumentNullException(nameof(generator));
}
if (updaters == null)
{
throw new ArgumentNullException(nameof(updaters));
}
_processor = processor;
_generator = generator;
_updaters = IncludeFlowId(updaters);
}
/// <summary>
/// Initializes an instance of the <see cref="ClientMessageProcessor"/> class.
/// </summary>
/// <param name="messageToServiceMapper">The message to service mapper.</param>
/// <param name="messageSerializer">The message serializer.</param>
/// <param name="messageQueueConfigurationOptions">The message queue configuration options.</param>
/// <param name="serviceMessageProcessor">The service message processor.</param>
/// <param name="messageTypeCache">The message type cache.</param>
/// <param name="clientMessageProcessorLogger">The client message processor logger.</param>
/// <param name="sslWSNetworkConnectorLogger">The ssl websocket network connector logger.</param>
/// <param name="wsHandshakeLogger">The websocket handshake logger.</param>
public ClientMessageProcessor(
IMessageToServiceMapper messageToServiceMapper,
IMessageSerializer messageSerializer,
IOptions <MessageQueueConfiguration> messageQueueConfigurationOptions,
IServiceMessageProcessor serviceMessageProcessor,
IClientMessageTypeCache messageTypeCache,
ILogger <ClientMessageProcessor> clientMessageProcessorLogger,
ILogger <SslWSNetworkConnector> sslWSNetworkConnectorLogger,
ILogger <NeuralmWSHandshakeHandler> wsHandshakeLogger)
{
_messageToServiceMapper = messageToServiceMapper;
_messageSerializer = messageSerializer;
_messageQueueConfiguration = messageQueueConfigurationOptions.Value;
_serviceMessageProcessor = serviceMessageProcessor;
_messageTypeCache = messageTypeCache;
_clientMessageProcessorLogger = clientMessageProcessorLogger;
_sslWSNetworkConnectorLogger = sslWSNetworkConnectorLogger;
_wsHandshakeLogger = wsHandshakeLogger;
_tcpListener = new TcpListener(IPAddress.Any, _messageQueueConfiguration.Port);
}
public TeamCityWriterFacade([NotNull] IServiceMessageProcessor processor,
[NotNull] ITeamCityBlockWriter <ITeamCityWriter> blockWriter,
[NotNull] ITeamCityCompilationBlockWriter <ITeamCityWriter> compilationWriter,
[NotNull] ITeamCityTestsWriter testsWriter,
[NotNull] ITeamCityMessageWriter messageWriter,
[NotNull] ITeamCityArtifactsWriter artifactsWriter,
[NotNull] ITeamCityBuildStatusWriter statusWriter,
[NotNull] ITeamCityFlowWriter <ITeamCityWriter> flowWriter,
[NotNull] IDisposable disposeCallback)
{
myProcessor = processor;
myBlockWriter = blockWriter;
myCompilationWriter = compilationWriter;
myTestsWriter = testsWriter;
myMessageWriter = messageWriter;
myArtifactsWriter = artifactsWriter;
myStatusWriter = statusWriter;
myFlowWriter = flowWriter;
myDispose = disposeCallback;
}
public TeamCityBlockWriter(IServiceMessageProcessor target, Func <IDisposable, TCloseBlock> closeBlock) : base(target)
{
myCloseBlock = closeBlock;
}
protected sealed override T Create(IServiceMessageProcessor proc)
{
return(Create(new FlowServiceMessageWriter(proc, new DefaultFlowIdGenerator(), Enumerable.Empty <IServiceMessageUpdater>())));
}
protected abstract T Create(IServiceMessageProcessor proc);
public TaskManager(IScheduleRepository scheduleRepository, ITaskRepository taskRepository, IJsonConverter jsonConverter, ITaskBuilder taskBuilder, ITaskProcessing taskProcessing, IServiceMessageProcessor serviceMessageProcessor, IUnitOfWorkFactory unitOfWorkFactory, IContextSettings contextSettings, TaskManagerConfiguration managerConfiguration) : base(managerConfiguration)
{
if (scheduleRepository == null)
{
throw new ArgumentNullException(nameof(scheduleRepository));
}
if (taskRepository == null)
{
throw new ArgumentNullException(nameof(taskRepository));
}
if (jsonConverter == null)
{
throw new ArgumentNullException(nameof(jsonConverter));
}
if (taskBuilder == null)
{
throw new ArgumentNullException(nameof(taskBuilder));
}
if (taskProcessing == null)
{
throw new ArgumentNullException(nameof(taskProcessing));
}
if (serviceMessageProcessor == null)
{
throw new ArgumentNullException(nameof(serviceMessageProcessor));
}
if (unitOfWorkFactory == null)
{
throw new ArgumentNullException(nameof(unitOfWorkFactory));
}
if (contextSettings == null)
{
throw new ArgumentNullException(nameof(contextSettings));
}
this.scheduleRepository = scheduleRepository;
this.taskRepository = taskRepository;
this.jsonConverter = jsonConverter;
this.taskBuilder = taskBuilder;
this.taskProcessing = taskProcessing;
this.unitOfWorkFactory = unitOfWorkFactory;
this.contextSettings = contextSettings;
ServiceMessageHandlerId = Guid.NewGuid();
serviceMessageProcessor.RegisteredServiceMessageHandler(this);
taskProcessing.OnTaskProcessed += OnTaskProcessed;
}
public TeamCityArtifactsWriter(IServiceMessageProcessor target) : base(target)
{
}
protected override ITeamCityMessageWriter Create(IServiceMessageProcessor proc)
{
return(new TeamCityMessageWriter(proc));
}
public TeamCityMessageWriter(IServiceMessageProcessor target)
: base(target)
{
}
public TeamCityBuildStatusWriter(IServiceMessageProcessor target) : base(target)
{
}
protected override ITeamCityTestWriter Create(IServiceMessageProcessor proc)
{
return(new TeamCityTestWriter(proc, "BadaBumBigBadaBum", DisposableDelegate.Empty));
}
protected override ITeamCityCompilationBlockWriter Create(IServiceMessageProcessor proc)
{
return(new TeamCityCompilationBlockWriter(proc));
}
