public FileSystemMessageBus(IDependencyResolver resolver, ScaleoutConfiguration configuration) : base(resolver, configuration) { Open(0); // Use only one stream if (Directory.Exists(BasePath)) { var files = new DirectoryInfo(BasePath).GetFiles(); foreach (var file in files) { file.Delete(); } } else { Directory.CreateDirectory(BasePath); } _watcher = new FileSystemWatcher(BasePath, "*.txt") { IncludeSubdirectories = false, EnableRaisingEvents = true }; _watcher.Created += FileCreated; }
public void ValidMaxQueueLength(int maxLength) { var config = new ScaleoutConfiguration(); config.MaxQueueLength = maxLength; Assert.Equal(maxLength, config.MaxQueueLength); }
public NServiceBusMessageBus(IDependencyResolver resolver, IBus busInstance, ScaleoutConfiguration configuration) : base(resolver, configuration) { _bus = busInstance; // By default, there is only 1 stream in this NServiceBus backplane, and we'll open it here Open(0); }
public NServiceBusMessageBus(IDependencyResolver resolver, IBus busInstance, ScaleoutConfiguration configuration) : base(resolver, configuration) { Bus = busInstance; Configure.Instance.Configurer.ConfigureComponent <Receiver>(DependencyLifecycle.InstancePerCall) .ConfigureProperty((r) => r.SignalRMessageBus, this); // By default, there is only 1 stream in this NServiceBus backplane, and we'll open it here Open(0); }
public void Configuration(IAppBuilder app) { var config = new ScaleoutConfiguration { MaxQueueLength = 10, QueueBehavior = QueuingBehavior.Always }; var omb = new OrleansMessageBus(GlobalHost.DependencyResolver, config); GlobalHost.DependencyResolver.Register(typeof(IMessageBus), () => omb); app.MapSignalR(); }
public void StreamManagerValidatesScaleoutConfig() { var perfCounters = new Microsoft.AspNet.SignalR.Infrastructure.PerformanceCounterManager(); var config = new ScaleoutConfiguration(); config.QueueBehavior = QueuingBehavior.Always; config.MaxQueueLength = 0; Assert.Throws <InvalidOperationException>(() => new ScaleoutStreamManager((int x, IList <Message> list) => { return(TaskAsyncHelper.Empty); }, (int x, ulong y, ScaleoutMessage msg) => { }, 0, new TraceSource("Stream Manager"), perfCounters, config)); }
public void ThrowingFromErrorCallbackIsCaught() { var config = new ScaleoutConfiguration() { RetryOnError = true, OnError = ex => { throw new Exception(); } }; var queue = new ScaleoutTaskQueue(new TraceSource("Queue"), "0", config); queue.SetError(new Exception()); }
public void EnqueueWithoutOpenRaisesOnError() { var tcs = new TaskCompletionSource <object>(); var config = new ScaleoutConfiguration() { RetryOnError = true, OnError = ex => tcs.SetException(ex) }; var queue = new ScaleoutTaskQueue(new TraceSource("Queue"), "0", config); queue.Enqueue(_ => { throw new InvalidOperationException(); }, null); Assert.Throws <AggregateException>(() => tcs.Task.Wait()); }
public OrleansMessageBus(IDependencyResolver resolver, ScaleoutConfiguration configuration) : base(resolver, configuration) { grain = PubSubGrainFactory.GetGrain(Guid.NewGuid()); subscriber = new MessageObserver((messages) => { lock (grain) { OnReceived(messages[0].StreamIndex, messages.Select(x => x.MappingId).Max(), new ScaleoutMessage(messages)); } }); subscriberReference = MessageObserverFactory.CreateObjectReference(subscriber).Result; grain.Subscribe(subscriberReference).Wait(); }
public void StreamManagerValidatesScaleoutConfig() { var loggerFactory = new Mock <ILoggerFactory>(); var perfCounters = new SignalRPerformanceCounterManager(loggerFactory.Object); var config = new ScaleoutConfiguration(); config.QueueBehavior = QueuingBehavior.Always; config.MaxQueueLength = 0; Assert.Throws <InvalidOperationException>(() => new ScaleoutStreamManager((int x, IList <Message> list) => { return(TaskAsyncHelper.Empty); }, (int x, ulong y, ScaleoutMessage msg) => { }, 0, new Mock <ILogger>().Object, perfCounters, config)); }
public void Configuration(IAppBuilder app) { // Any connection or hub wire up and configuration should go here app.MapSignalR(); // Note: to get this working, make sure that the user account your app pool runs under has sufficient access to all queues // involved in this setup! That means: all signalr.nservicebus.backplaneservice* queues and the System.Web* queues. Bus = Configure .With() .DefaultBuilder() .UseTransport <Msmq>() .UseInMemoryTimeoutPersister() .UnicastBus() .LoadMessageHandlers() .CreateBus() .Start(); var config = new ScaleoutConfiguration() { MaxQueueLength = 100 }; // Or whatever you want GlobalHost.DependencyResolver.UseNServiceBus(Bus, config); }
/// <summary> /// Use NServiceBus backplane for SignalR. /// </summary> /// <param name="resolver">The dependency resolver.</param> /// <param name="busInstance">The instance of the NServiceBus IBus instance inside the current host.</param> /// <param name="configuration">Scaleout configuration parameters to be used by SignalR.</param> /// <returns>The dependency resolver.</returns> public static IDependencyResolver UseNServiceBus(this IDependencyResolver resolver, IBus busInstance, ScaleoutConfiguration configuration) { var bus = new Lazy <NServiceBusMessageBus>(() => new NServiceBusMessageBus(resolver, busInstance, configuration)); resolver.Register(typeof(IMessageBus), () => bus.Value); return(resolver); }
public static IDependencyResolver UseBus(this IDependencyResolver resolver, ScaleoutConfiguration configuration) { resolver.Register(typeof(IMessageBus), () => new ServiceBus(resolver, configuration, _bus)); return(resolver); }
public ServiceBus(IDependencyResolver resolver, ScaleoutConfiguration configuration, Bus bus) : base(resolver, configuration) { _bus = bus; _bus.OnReceived += _bus_OnReceived; }
protected void UseMessageBus(MessageBusType type, IDependencyResolver resolver, ScaleoutConfiguration configuration = null, int streams = 1) { switch (type) { case MessageBusType.Default: break; case MessageBusType.Fake: var bus = new FakeScaleoutBus(resolver, streams); resolver.Register(typeof(IMessageBus), () => bus); break; case MessageBusType.SqlServer: break; case MessageBusType.ServiceBus: break; case MessageBusType.Redis: break; default: break; } }
public void InvalidMaxQueueLength(int maxLength) { var config = new ScaleoutConfiguration(); Assert.Throws <ArgumentOutOfRangeException>(() => config.MaxQueueLength = maxLength); }