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);
}
