protected override void EstablishContext()
{
base.EstablishContext();
LocalEndpointUri = "tibco://localhost:7222/mt_client";
LocalErrorUri = "tibco://localhost:7222/mt_client_error";
RemoteEndpointUri = "tibco://localhost:7222/mt_server";
LocalEndpoint = new TibcoEndpoint(LocalEndpointUri, new XmlMessageSerializer());
LocalErrorEndpoint = new TibcoEndpoint(LocalErrorUri, new XmlMessageSerializer());
RemoteEndpoint = new TibcoEndpoint(RemoteEndpointUri, new XmlMessageSerializer());
SetupSubscriptionService();
LocalBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom(LocalEndpointUri);
x.SendErrorsTo(LocalErrorUri);
x.SetConcurrentConsumerLimit(2);
x.SetConcurrentReceiverLimit(2);
});
RemoteBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom(RemoteEndpointUri);
});
}
private static void Main()
{
/////setup
XmlConfigurator.ConfigureAndWatch(new FileInfo("log4net.xml"));
WindsorContainer c = new DefaultMassTransitContainer();
IEndpointFactory ef = EndpointFactoryConfigurator.New(e => e.RegisterTransport <MsmqEndpoint>());
c.Kernel.AddComponentInstance("endpointFactory", typeof(IEndpointFactory), ef);
c.AddComponent <SimpleMessageHandler>();
c.AddComponentLifeStyle("counter", typeof(Counter), LifestyleType.Singleton);
c.AddComponentLifeStyle("rvaoeuaoe", typeof(CacheUpdateResponseHandler), LifestyleType.Transient);
IServiceBus bus = ServiceBusConfigurator.New(b =>
{
b.ReceiveFrom("msmq://localhost/mt_client");
b.ConfigureService <SubscriptionClientConfigurator>(sc => sc.SetSubscriptionServiceEndpoint("msmq://localhost/mt_subscriptions"));
b.ConfigureService <HealthClientConfigurator>(hc => hc.SetHeartbeatInterval(10));
});
c.Kernel.AddComponentInstance("bus", typeof(IServiceBus), bus);
bus.Subscribe <CacheUpdateResponseHandler>();
bus.Subscribe <SimpleMessageHandler>();
IEndpoint ep = c.Resolve <IEndpointFactory>().GetEndpoint(new Uri("msmq://localhost/mt_subscriptions"));
var subTester = new SubscriptionServiceTester(ep, bus, c.Resolve <Counter>());
var healthTester = new HealthServiceTester(c.Resolve <Counter>(), bus);
var timeoutTester = new TimeoutTester(bus);
bus.Subscribe(healthTester);
///////
Console.WriteLine("Please enter the number of hours you would like this test to run for?");
Console.WriteLine("(use 0.1 for 6 minutes)");
Console.WriteLine("(use 0.016 for 1 minute)");
string input = Console.ReadLine();
double hours = double.Parse(input ?? "0");
DateTime stopTime = DateTime.Now.AddHours(hours);
Console.WriteLine("Test Started");
var rand = new Random();
while (DateTime.Now < stopTime)
{
subTester.Test();
healthTester.Test();
timeoutTester.Test();
Thread.Sleep(rand.Next(5, 10) * 1000);
PrintTime(bus, c.Resolve <Counter>());
}
//print final stuff (probably do this by tester)
subTester.Results();
Console.WriteLine("Done (press any key to exit)");
Console.ReadKey(true);
}
public ServiceInstance(string name, IEndpointFactory endpointFactory, string subscriptionServiceEndpointAddress, Action <IObjectBuilder> configureBuilder, Action <IServiceBusConfigurator> configurator)
{
ObjectBuilder = MockRepository.GenerateMock <IObjectBuilder>();
ObjectBuilder.Stub(x => x.GetInstance <IEndpointFactory>()).Return(endpointFactory);
configureBuilder(ObjectBuilder);
ControlBus = ControlBusConfigurator.New(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.ReceiveFrom(name + "_control");
x.PurgeBeforeStarting();
});
DataBus = ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.ConfigureService <SubscriptionClientConfigurator>(y =>
{
// setup endpoint
y.SetSubscriptionServiceEndpoint(subscriptionServiceEndpointAddress);
});
x.ReceiveFrom(name);
x.UseControlBus(ControlBus);
x.SetConcurrentConsumerLimit(5);
configurator(x);
});
}
void SubscriptionManager()
{
_bus = ServiceBusConfigurator.New(servicesBus =>
{
servicesBus.ReceiveFrom("msmq://localhost/mt_subscription_ui");
servicesBus.SetObjectBuilder(_builder);
servicesBus.ConfigureService <SubscriptionClientConfigurator>(client =>
{
// need to add the ability to read from configuratino settings somehow
client.SetSubscriptionServiceEndpoint("msmq://localhost/mt_subscriptions");
});
});
_unsubscribe = _bus.Subscribe(this);
_subscriptionServiceEndpoint = _builder.GetInstance <IEndpointFactory>().GetEndpoint("msmq://localhost/mt_subscriptions");
_subscriptionServiceEndpoint.Send(new CacheUpdateRequest(_bus.Endpoint.Uri));
// _timeoutRepository.TimeoutAdded += TimeoutRefreshNeeded;
// _timeoutRepository.TimeoutUpdated += TimeoutRefreshNeeded;
// _timeoutRepository.TimeoutRemoved += TimeoutRefreshNeeded;
}
public DoWork(IObjectBuilder objectBuilder)
{
ObjectBuilder = objectBuilder;
var endpointFactory = EndpointFactoryConfigurator.New(x =>
{
x.RegisterTransport <MsmqEndpoint>();
x.SetObjectBuilder(objectBuilder);
x.SetDefaultSerializer <XmlMessageSerializer>();
});
ControlBus = ControlBusConfigurator.New(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.ReceiveFrom(new Uri(ConfigurationManager.AppSettings["SourceQueue"]).AppendToPath("_control"));
x.PurgeBeforeStarting();
});
DataBus = ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.ConfigureService <SubscriptionClientConfigurator>(y =>
{
y.SetSubscriptionServiceEndpoint(ConfigurationManager.AppSettings["SubscriptionQueue"]);
});
x.ReceiveFrom(ConfigurationManager.AppSettings["SourceQueue"]);
x.UseControlBus(ControlBus);
x.SetConcurrentConsumerLimit(4);
x.ImplementDistributorWorker <DoSimpleWorkItem>(ConsumeMessage);
});
}
protected override void EstablishContext()
{
base.EstablishContext();
const string subscriptionServiceEndpointAddress = "loopback://localhost/mt_subscriptions";
SubscriptionBus = ServiceBusConfigurator.New(x => { x.ReceiveFrom(subscriptionServiceEndpointAddress); });
SetupSubscriptionService();
LocalBus = ServiceBusConfigurator.New(x =>
{
x.ConfigureService <SubscriptionClientConfigurator>(y =>
{
// setup endpoint
y.SetSubscriptionServiceEndpoint(subscriptionServiceEndpointAddress);
});
x.ReceiveFrom("loopback://localhost/mt_client");
});
RemoteBus = ServiceBusConfigurator.New(x =>
{
x.ConfigureService <SubscriptionClientConfigurator>(y =>
{
// setup endpoint
y.SetSubscriptionServiceEndpoint(subscriptionServiceEndpointAddress);
});
x.ReceiveFrom("loopback://localhost/mt_server");
});
SetupHealthService();
Thread.Sleep(1000);
}
protected override void EstablishContext()
{
base.EstablishContext();
LocalEndpoint = EndpointFactory.GetEndpoint(LocalEndpointUri);
LocalErrorEndpoint = EndpointFactory.GetEndpoint(LocalErrorUri);
RemoteEndpoint = EndpointFactory.GetEndpoint(RemoteEndpointUri);
SetupSubscriptionService();
LocalBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom(LocalEndpointUri);
x.SendErrorsTo(LocalErrorUri);
});
RemoteBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom(RemoteEndpointUri);
});
}
public void Start()
{
ControlBus = ControlBusConfigurator.New(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.ReceiveFrom(ConfigurationManager.AppSettings["SourceQueue"] + "_control");
x.PurgeBeforeStarting();
});
DataBus = ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(ObjectBuilder);
x.ConfigureService <SubscriptionClientConfigurator>(y =>
{
y.SetSubscriptionServiceEndpoint(ConfigurationManager.AppSettings["SubscriptionQueue"]);
});
x.ReceiveFrom(ConfigurationManager.AppSettings["SourceQueue"]);
x.UseControlBus(ControlBus);
x.SetConcurrentConsumerLimit(4);
x.ConfigureService <GridConfigurator>(grid =>
{
if (ConfigurationManager.AppSettings["IsProposer"].Equals("true"))
{
grid.SetProposer();
}
grid.For <DoSimpleWorkItem>().Use <DoWork>();
});
});
}
protected override void EstablishContext()
{
base.EstablishContext();
LocalBus = ServiceBusConfigurator.New(x => { x.ReceiveFrom("multicast://227.43.1.1:5309/"); });
RemoteBus = ServiceBusConfigurator.New(x => { x.ReceiveFrom("multicast://227.43.1.1:5309/"); });
}
protected override void EstablishContext()
{
base.EstablishContext();
LocalBus = ServiceBusConfigurator.New(x =>
{
x.ReceiveFrom("loopback://localhost/mt_client");
});
}
protected virtual IServiceBus SetupServiceBus(Uri uri, Action <IServiceBusConfigurator> configure)
{
IServiceBus bus = ServiceBusConfigurator.New(x =>
{
x.ReceiveFrom(uri);
configure(x);
});
Buses.Add(bus);
return(bus);
}
protected void RegisterServiceBus(Uri endpointUri, Action <IServiceBusConfigurator> configAction)
{
Kernel.Register(
Component.For <IServiceBus>().UsingFactoryMethod((kernel, context) =>
{
return(ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(kernel.Resolve <IObjectBuilder>());
x.ReceiveFrom(endpointUri);
configAction(x);
}));
}).LifeStyle.Singleton);
}
protected void RegisterServiceBus(Uri endpointUri, Action <IServiceBusConfigurator> configAction)
{
Bind <IServiceBus>()
.ToMethod(context =>
{
return(ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(context.Kernel.Get <IObjectBuilder>());
x.ReceiveFrom(endpointUri);
configAction(x);
}));
})
.InSingletonScope();
}
protected void RegisterServiceBus(Uri endpointUri, Action <IServiceBusConfigurator, IContext> configAction)
{
For <IServiceBus>()
.Singleton()
.Use(context =>
{
return(ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(context.GetInstance <IObjectBuilder>());
x.ReceiveFrom(endpointUri);
configAction(x, context);
}));
});
}
protected override void EstablishContext()
{
base.EstablishContext();
_before = new ManualResetEvent(false);
_after = new ManualResetEvent(false);
LocalBus = ServiceBusConfigurator.New(x =>
{
x.ReceiveFrom("loopback://localhost/mt_client");
x.BeforeConsumingMessage(() => { _before.Set(); });
x.AfterConsumingMessage(() => { _after.Set(); });
});
}
private static void Main(string[] args)
{
_log.Info("Server Loading");
var cfg = RunnerConfigurator.New(c =>
{
c.SetServiceName("SampleClientService");
c.SetDisplayName("SampleClientService");
c.SetDescription("SampleClientService");
c.DependencyOnMsmq();
c.RunAsLocalSystem();
c.ConfigureService <ClientService>(typeof(ClientService).Name, s =>
{
s.WhenStarted(o =>
{
var bus = ServiceBusConfigurator.New(servicesBus =>
{
servicesBus.ReceiveFrom("msmq://localhost/mt_client");
servicesBus.ConfigureService <SubscriptionClientConfigurator>(client =>
{
// need to add the ability to read from configuratino settings somehow
client.SetSubscriptionServiceEndpoint("msmq://localhost/mt_subscriptions");
});
});
o.Start(bus);
});
s.WhenStopped(o => o.Stop());
s.CreateServiceLocator(() =>
{
var container = new DefaultMassTransitContainer();
IEndpointFactory endpointFactory = EndpointFactoryConfigurator.New(e =>
{
e.SetObjectBuilder(ServiceLocator.Current.GetInstance <IObjectBuilder>());
e.RegisterTransport <MsmqEndpoint>();
});
container.Kernel.AddComponentInstance("endpointFactory", typeof(IEndpointFactory), endpointFactory);
container.AddComponent <ClientService>(typeof(ClientService).Name);
container.AddComponent <PasswordUpdater>();
return(ServiceLocator.Current); //set in the DefaultMTContainer
});
});
});
Runner.Host(cfg, args);
}
protected override void Before_each()
{
_builder = MockRepository.GenerateMock <IObjectBuilder>();
_endpointFactory = EndpointFactoryConfigurator.New(x =>
{
x.SetObjectBuilder(_builder);
x.SetDefaultSerializer <XmlMessageSerializer>();
x.RegisterTransport <LoopbackEndpoint>();
});
_builder.Stub(x => x.GetInstance <IEndpointFactory>()).Return(_endpointFactory);
_bus = ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(_builder);
x.ReceiveFrom("loopback://localhost/servicebus");
});
}
protected override void EstablishContext()
{
base.EstablishContext();
SubscriptionBus = ServiceBusConfigurator.New(x =>
{
x.ReceiveFrom(SubscriptionServiceUri);
x.SetConcurrentConsumerLimit(1);
});
SetupSubscriptionService(ObjectBuilder);
SetupLocalBus();
SetupRemoteBus();
Instances = new Dictionary <string, ServiceInstance>();
}
private static void Main(string[] args)
{
XmlConfigurator.ConfigureAndWatch(new FileInfo("server.log4net.xml"));
_log.Info("Server Loading");
IRunConfiguration cfg = RunnerConfigurator.New(c =>
{
c.SetServiceName("SampleService");
c.SetServiceName("Sample Service");
c.SetServiceName("Something");
c.DependencyOnMsmq();
c.RunAsLocalSystem();
c.ConfigureService <PasswordUpdateService>(typeof(PasswordUpdateService).Name, s =>
{
s.WhenStarted(o =>
{
IServiceBus bus = ServiceBusConfigurator.New(x =>
{
x.ReceiveFrom("msmq://localhost/mt_server");
x.ConfigureService <SubscriptionClientConfigurator>(b => { b.SetSubscriptionServiceEndpoint("msmq://localhost/mt_subscriptions"); });
});
o.Start(bus);
});
s.WhenStopped(o => o.Stop());
s.CreateServiceLocator(() =>
{
var container = new DefaultMassTransitContainer();
IEndpointFactory endpointFactory = EndpointFactoryConfigurator
.New(x =>
{
x.SetObjectBuilder(ServiceLocator.Current.GetInstance <IObjectBuilder>());
x.RegisterTransport <MsmqEndpoint>();
});
container.Kernel.AddComponentInstance("endpointFactory", typeof(IEndpointFactory), endpointFactory);
container.AddComponent <PasswordUpdateService>(typeof(PasswordUpdateService).Name);
return(ServiceLocator.Current); //set in DefaultMTContainer
});
});
});
Runner.Host(cfg, args);
}
private static void ConfigureHealthService(IServiceConfigurator <HealthService> configurator)
{
configurator.CreateServiceLocator(() =>
{
var container = new DefaultMassTransitContainer();
container.AddComponent <HealthService>(typeof(HealthService).Name);
container.AddComponent("sagaRepository", typeof(ISagaRepository <>), typeof(InMemorySagaRepository <>));
var endpointFactory = EndpointFactoryConfigurator.New(x =>
{
// the default
x.SetObjectBuilder(container.Resolve <IObjectBuilder>());
x.RegisterTransport <MsmqEndpoint>();
});
container.Kernel.AddComponentInstance("endpointFactory", typeof(IEndpointFactory), endpointFactory);
var bus = ServiceBusConfigurator.New(x =>
{
x.SetObjectBuilder(container.Resolve <IObjectBuilder>());
x.ReceiveFrom("msmq://localhost/mt_health");
x.ConfigureService <SubscriptionClientConfigurator>(client =>
{
// need to add the ability to read from configuratino settings somehow
client.SetSubscriptionServiceEndpoint("msmq://localhost/mt_subscriptions");
});
});
container.Kernel.AddComponentInstance("bus", typeof(IServiceBus), bus);
return(container.Resolve <IObjectBuilder>());
});
configurator.WhenStarted(service => { service.Start(); });
configurator.WhenStopped(service =>
{
service.Stop();
service.Dispose();
});
}
protected override void EstablishContext()
{
base.EstablishContext();
SetupSubscriptionService();
LocalBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom(new UriBuilder("activemq", ActiveMQHostName, 61616, "mt_client").Uri);
});
RemoteBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom(new UriBuilder("activemq", ActiveMQHostName, 61616, "mt_server").Uri);
});
}
protected override void EstablishContext()
{
base.EstablishContext();
SetupSubscriptionService();
LocalBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom("loopback://localhost/mt_client");
});
RemoteBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom("loopback://localhost/mt_server");
});
}
protected void SetupRemoteBus()
{
RemoteControlBus = ControlBusConfigurator.New(x =>
{
x.ReceiveFrom(ServerControlUri);
x.PurgeBeforeStarting();
});
RemoteBus = ServiceBusConfigurator.New(x =>
{
x.ConfigureService <SubscriptionClientConfigurator>(y =>
{
// setup endpoint
y.SetSubscriptionServiceEndpoint(SubscriptionServiceUri);
});
x.ReceiveFrom(ServerUri);
x.UseControlBus(RemoteControlBus);
});
}
private static void ConfigureSubscriptionService(IServiceConfigurator <SubscriptionService> configurator)
{
configurator.CreateServiceLocator(() =>
{
var container = new DefaultMassTransitContainer();
container.AddComponent("sagaRepository", typeof(ISagaRepository <>), typeof(InMemorySagaRepository <>));
container.AddComponent <ISubscriptionRepository, InMemorySubscriptionRepository>();
container.AddComponent <SubscriptionService, SubscriptionService>(typeof(SubscriptionService).Name);
var endpointFactory = EndpointFactoryConfigurator.New(x =>
{
// the default
x.SetObjectBuilder(container.Resolve <IObjectBuilder>());
x.RegisterTransport <MsmqEndpoint>();
});
container.Kernel.AddComponentInstance("endpointFactory", typeof(IEndpointFactory), endpointFactory);
var bus = ServiceBusConfigurator.New(servicesBus =>
{
servicesBus.SetObjectBuilder(container.Resolve <IObjectBuilder>());
servicesBus.ReceiveFrom("msmq://localhost/mt_subscriptions");
servicesBus.SetConcurrentConsumerLimit(1);
});
container.Kernel.AddComponentInstance("bus", typeof(IServiceBus), bus);
return(container.ObjectBuilder);
});
configurator.WhenStarted(service => service.Start());
configurator.WhenStopped(service =>
{
service.Stop();
service.Dispose();
});
}
protected void SetupLocalBus()
{
LocalControlBus = ControlBusConfigurator.New(x =>
{
x.ReceiveFrom(ClientControlUri);
x.PurgeBeforeStarting();
});
LocalBus = ServiceBusConfigurator.New(x =>
{
x.ConfigureService <SubscriptionClientConfigurator>(y =>
{
// setup endpoint
y.SetSubscriptionServiceEndpoint(SubscriptionServiceUri);
});
x.ReceiveFrom(ClientUri);
x.SetConcurrentConsumerLimit(4);
x.UseControlBus(LocalControlBus);
ConfigureLocalBus(x);
});
}
protected override void EstablishContext()
{
base.EstablishContext();
SetupSubscriptionService();
LocalControlBus = ControlBusConfigurator.New(x =>
{
x.ReceiveFrom("loopback://localhost/mt_client_control");
x.PurgeBeforeStarting();
});
RemoteControlBus = ControlBusConfigurator.New(x =>
{
x.ReceiveFrom("loopback://localhost/mt_server_control");
x.PurgeBeforeStarting();
});
LocalBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom("loopback://localhost/mt_client");
x.UseControlBus(LocalControlBus);
});
RemoteBus = ServiceBusConfigurator.New(x =>
{
x.AddService <SubscriptionPublisher>();
x.AddService <SubscriptionConsumer>();
x.ReceiveFrom("loopback://localhost/mt_server");
x.UseControlBus(RemoteControlBus);
});
}
