public PeriodicAnnouncerImpl(ICancellationTokenSource cancellationTokenSource, IPofSerializer courierSerializer, ReadableCourierEndpoint localEndpoint, NetworkBroadcaster networkBroadcaster)
{
this.cancellationTokenSource = cancellationTokenSource;
this.courierSerializer = courierSerializer;
this.localEndpoint = localEndpoint;
this.networkBroadcaster = networkBroadcaster;
}
public TrafficLight(ICancellationTokenSource ctsSource, params PictureBox[] lights) : this()
{
ctsSource.ContractedNotNull("ctsSource");
Contract.Requires(ctsSource.Source != null);
lights.ContractedNotNull("lights");
Contract.Requires(3 < lights.Length);
Contract.Requires(lights[0] != null);
Contract.Requires(lights[1] != null);
Contract.Requires(lights[2] != null);
Contract.Requires(lights[3] != null);
Contract.Ensures(_ctsSource != null);
Contract.Ensures(_ctsSource.Source != null);
Contract.Ensures(_crossTownLight != null);
Contract.Ensures(_upTownLeftTurnLight != null);
Contract.Ensures(_downTownLeftTurnLight != null);
Contract.Ensures(_upDownTownLight != null);
_ctsSource = ctsSource;
_crossTownLight = lights[0];
_upTownLeftTurnLight = lights[1];
_downTownLeftTurnLight = lights[2];
_upDownTownLight = lights[3];
}
public PofDispatcherImpl(PofStreamReader reader, IConcurrentDictionary <Type, Action <object> > handlersByType, IConcurrentSet <Action> shutdownHandlers, ICancellationTokenSource dispatcherTaskCancellationTokenSource)
{
this.reader = reader;
this.handlersByType = handlersByType;
this.shutdownHandlers = shutdownHandlers;
this.dispatcherTaskCancellationTokenSource = dispatcherTaskCancellationTokenSource;
}
public AmazonSqsQueueFactory(IAmazonSqsConfiguration configuration, ICancellationTokenSource cancellationTokenSource)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(cancellationTokenSource, nameof(cancellationTokenSource));
_configuration = configuration;
_cancellationTokenSource = cancellationTokenSource;
}
public PeriodicResenderImpl(IThreadingProxy threadingProxy, UnacknowledgedReliableMessageContainer unacknowledgedReliableMessageContainer, MessageTransmitterImpl messageTransmitter)
{
this.threadingProxy = threadingProxy;
this.unacknowledgedReliableMessageContainer = unacknowledgedReliableMessageContainer;
this.messageTransmitter = messageTransmitter;
this.cancellationTokenSource = threadingProxy.CreateCancellationTokenSource();
}
public HostSessionImpl(HostContext hostContext, ICancellationTokenSource cancellationTokenSource, MessageSender messageSender, PofDispatcher pofDispatcher, IConcurrentSet <Guid> remotelyHostedServices, IUniqueIdentificationSet availableInvocationIds, IConcurrentDictionary <uint, AsyncValueBox> invocationResponseBoxesById)
{
this.hostContext = hostContext;
this.cancellationTokenSource = cancellationTokenSource;
this.messageSender = messageSender;
this.pofDispatcher = pofDispatcher;
this.remotelyHostedServices = remotelyHostedServices;
this.availableInvocationIds = availableInvocationIds;
this.invocationResponseBoxesById = invocationResponseBoxesById;
}
public IAssemblyRunner Create(IRunListener listener, IResourceManager resourceManager, ICancellationTokenSource cancellationTokenSource)
{
var builder = new ContainerBuilder();
builder.RegisterModule(new EvaluationModule(listener, useSeparateAppDomains: false /* don't care */));
// Re-registering
builder.RegisterInstance(resourceManager).As<IResourceManager>();
builder.RegisterInstance(cancellationTokenSource).As<ICancellationTokenSource>();
// Only SetupCommon's and CleanupCommon's should be added for assembly suite
builder.RegisterInstance(new OperationSorter(new[] { typeof (SetupCommon), typeof (CleanupCommon) })).As<IOperationSorter>();
var container = builder.Build();
return new AssemblyRunner(container.Resolve<IAssemblyLoader>(), container.Resolve<ISuiteRunner>());
}
public HostPhase(ICollectionFactory collectionFactory, IThreadingProxy threadingProxy, HostSessionFactory hostSessionFactory, HostContext hostContext, IListenerSocket listenerSocket)
{
this.threadingProxy = threadingProxy;
this.hostSessionFactory = hostSessionFactory;
this.hostContext = hostContext;
this.listenerSocket = listenerSocket;
this.cancellationTokenSource = threadingProxy.CreateCancellationTokenSource();
this.listenerThread = threadingProxy.CreateThread(ListenerThreadEntryPoint, new ThreadCreationOptions {
IsBackground = true
});
sessions = collectionFactory.CreateConcurrentSet <HostSession>();
}
public ServiceBus(IServiceBusConfiguration configuration, ITransportMessageFactory transportMessageFactory,
IPipelineFactory pipelineFactory, ISubscriptionManager subscriptionManager, ICancellationTokenSource cancellationTokenSource)
{
Guard.AgainstNull(configuration, nameof(configuration));
Guard.AgainstNull(transportMessageFactory, nameof(transportMessageFactory));
Guard.AgainstNull(pipelineFactory, nameof(pipelineFactory));
Guard.AgainstNull(subscriptionManager, nameof(subscriptionManager));
_configuration = configuration;
_pipelineFactory = pipelineFactory;
_cancellationTokenSource = cancellationTokenSource ?? new DefaultCancellationTokenSource();
_messageSender = new MessageSender(transportMessageFactory, _pipelineFactory, subscriptionManager);
}
public SuiteRunner(
IResourceManager resourceManager,
IResultFactory resultFactory,
IContextRunner contextRunner,
ITestRunner testRunner,
IRunListener listener,
ICancellationTokenSource cancellationTokenSource)
{
_resourceManager = resourceManager;
_resultFactory = resultFactory;
_contextRunner = contextRunner;
_testRunner = testRunner;
_listener = listener;
_cancellationTokenSource = cancellationTokenSource;
}
public CourierAnnouncerImpl(
IThreadingProxy threadingProxy,
ManageableCourierEndpoint localEndpoint,
OutboundEnvelopeManager outboundEnvelopeManager)
{
this.threadingProxy = threadingProxy;
this.localEndpoint = localEndpoint;
this.outboundEnvelopeManager = outboundEnvelopeManager;
this.thread = threadingProxy.CreateThread(ThreadStart, new ThreadCreationOptions()
{
IsBackground = true
});
this.cancellationTokenSource = threadingProxy.CreateCancellationTokenSource();
}
private ISuiteResult RunAssemblySuites(
Assembly assembly,
[CanBeNull] string cachePath,
ICancellationTokenSource cancellationTokenSource,
IIntent assemblyIntent)
{
using (var appDomain = _appDomainFactory.Create(assembly, cachePath))
{
var cancellation = appDomain.CreateProxy <ICancellation>(typeof(CrossAppDomainCancellation));
var assemblyRunnerFactory = appDomain.CreateProxy <IAssemblyRunnerFactory>(typeof(AssemblyRunnerFactory));
var assemblyRunner = assemblyRunnerFactory.Create(_listener, _resourceManager, cancellation);
cancellationTokenSource.Token.Register(cancellation.Cancel);
return(assemblyRunner.Run(assemblyIntent));
}
}
public WebHost(ICancellationTokenSource cancellationTokenSource, ISettings settings)
{
Verify.RequireNotNull(cancellationTokenSource, "cancellationTokenSource");
Verify.RequireNotNull(settings, "settings");
this.cancellationTokenSource = cancellationTokenSource;
this.settings = settings;
cancellationToken = cancellationTokenSource.Token;
try
{
hostName = Dns.GetHostName();
}
catch (Exception err)
{
logger.Error("Error getting host name {0}", err);
hostName = "127.0.0.1";
}
}
public QueuePollerHost(ICancellationTokenSource cancellationTokenSource, ISettings settings, IQueuePollerFactory queuePollerFactory, IDocumentStore documentStore, ISchemaUpdater schemaUpdater)
{
Verify.RequireNotNull(cancellationTokenSource, "cancellationTokenSource");
Verify.RequireNotNull(settings, "settings");
Verify.RequireNotNull(queuePollerFactory, "queuePollerFactory");
Verify.RequireNotNull(documentStore, "documentStore");
Verify.RequireNotNull(schemaUpdater, "SchemaUpdater");
this.cancellationTokenSource = cancellationTokenSource;
this.settings = settings;
this.queuePollerFactory = queuePollerFactory;
this.documentStore = documentStore;
this.schemaUpdater = schemaUpdater;
cancellationToken = cancellationTokenSource.Token;
CreateDefaultEnvirtonmentIfNoneExists();
UpdateSchemaIfNeeded();
}
public IAssemblyRunner Create(IRunListener listener, IResourceManager resourceManager, ICancellationTokenSource cancellationTokenSource)
{
var builder = new ContainerBuilder();
builder.RegisterModule(new EvaluationModule(listener, useSeparateAppDomains: false /* don't care */));
// Re-registering
builder.RegisterInstance(resourceManager).As <IResourceManager>();
builder.RegisterInstance(cancellationTokenSource).As <ICancellationTokenSource>();
// Only SetupCommon's and CleanupCommon's should be added for assembly suite
builder.RegisterInstance(new OperationSorter(new[] { typeof(SetupCommon), typeof(CleanupCommon) })).As <IOperationSorter>();
var container = builder.Build();
return(new AssemblyRunner(container.Resolve <IAssemblyLoader>(), container.Resolve <ISuiteRunner>()));
}
