public void If_connects_after_disposal_should_redispose_underlying_connection()
{
var logger = MockRepository.GenerateMock <IEasyNetQLogger>();
var eventBus = MockRepository.GenerateMock <IEventBus>();
var connectionFactory = MockRepository.GenerateMock <IConnectionFactory>();
var mockConnection = MockRepository.GenerateMock <IConnection>();
PersistentConnection mockPersistentConnection = MockRepository.GenerateMock <PersistentConnection>(connectionFactory, logger, eventBus);
// This test is constructed using small delays, such that the IConnectionFactory will return a connection just _after the IPersistentConnection has been disposed.
TimeSpan shimDelay = TimeSpan.FromSeconds(0.5);
connectionFactory.Expect(cf => cf.CreateConnection()).WhenCalled(a =>
{
Thread.Sleep(shimDelay.Double());
a.ReturnValue = mockConnection;
}).Repeat.Once();
Task.Factory.StartNew(() => { mockPersistentConnection.Initialize(); }); // Start the persistent connection attempting to connect.
Thread.Sleep(shimDelay); // Allow some time for the persistent connection code to try to create a connection.
// First call to dispose. Because CreateConnection() is stubbed to delay for shimDelay.Double(), it will not yet have returned a connection. So when the PersistentConnection is disposed, no underlying IConnection should yet be disposed.
mockPersistentConnection.Dispose();
mockConnection.AssertWasNotCalled(underlyingConnection => underlyingConnection.Dispose());
Thread.Sleep(shimDelay.Double()); // Allow time for persistent connection code to _return its connection ...
// Assert that the connection returned from connectionFactory.CreateConnection() (_after the PersistentConnection was disposed), still gets disposed.
mockConnection.AssertWasCalled(latedCreatedUnderlyingConnection => latedCreatedUnderlyingConnection.Dispose());
// Ensure that PersistentConnection also did not flag (eg to IPersistentChannel) the late-made connection as successful.
connectionFactory.AssertWasNotCalled(c => c.Success());
// Ensure that PersistentConnection does not retry after was disposed.
connectionFactory.AssertWasNotCalled(c => c.Next());
}
public void Should_retry_connection_for_expected_connection_types_OnConnected(Type exceptionType)
{
var mockBuilder = new MockBuilder();
using (mockBuilder.Bus)
{
var first = true;
var succeeded = false;
mockBuilder.ConnectionFactory.Succeeded.Returns(c => succeeded);
mockBuilder.ConnectionFactory.When(x => x.Success()).Do(c => succeeded = true);
mockBuilder.ConnectionFactory.Configuration.ConnectIntervalAttempt = TimeSpan.FromSeconds(1);
var connection = new PersistentConnection(mockBuilder.ConnectionFactory, mockBuilder.EventBus);
mockBuilder.EventBus.Subscribe <ConnectionCreatedEvent>(e => {
if (first)
{
first = false;
ThrowException(exceptionType);
}
});
connection.Initialize();
Thread.Sleep(TimeSpan.FromSeconds(2));
mockBuilder.ConnectionFactory.Received(3).CreateConnection();
first.ShouldEqual(false);
}
}
public void If_connects_after_disposal_should_redispose_underlying_connection()
{
var eventBus = Substitute.For <IEventBus>();
var connectionFactory = Substitute.For <IConnectionFactory>();
var mockConnection = Substitute.For <IConnection>();
PersistentConnection mockPersistentConnection = Substitute.For <PersistentConnection>(connectionFactory, eventBus);
// This test is constructed using small delays, such that the IConnectionFactory will return a connection just _after the IPersistentConnection has been disposed.
TimeSpan shimDelay = TimeSpan.FromSeconds(0.5);
connectionFactory.CreateConnection().Returns(a =>
{
Thread.Sleep(shimDelay.Double());
return(mockConnection);
});
Task.Factory.StartNew(() => { mockPersistentConnection.Initialize(); }); // Start the persistent connection attempting to connect.
Thread.Sleep(shimDelay); // Allow some time for the persistent connection code to try to create a connection.
// First call to dispose. Because CreateConnection() is stubbed to delay for shimDelay.Double(), it will not yet have returned a connection. So when the PersistentConnection is disposed, no underlying IConnection should yet be disposed.
mockPersistentConnection.Dispose();
mockConnection.DidNotReceive().Dispose();
Thread.Sleep(shimDelay.Double()); // Allow time for persistent connection code to _return its connection ...
// Assert that the connection returned from connectionFactory.CreateConnection() (_after the PersistentConnection was disposed), still gets disposed.
mockConnection.Received().Dispose();
// Ensure that PersistentConnection also did not flag (eg to IPersistentChannel) the late-made connection as successful.
connectionFactory.DidNotReceive().Success();
// Ensure that PersistentConnection does not retry after was disposed.
connectionFactory.DidNotReceive().Next();
}
public Task Invoke(IDictionary <string, object> environment)
{
var serverRequest = new ServerRequest(environment);
var serverResponse = new ServerResponse(environment);
var hostContext = new HostContext(serverRequest, serverResponse);
// Add CORS support
var origins = serverRequest.RequestHeaders.GetHeaders("Origin");
if (origins != null && origins.Any(origin => !String.IsNullOrEmpty(origin)))
{
serverResponse.ResponseHeaders["Access-Control-Allow-Origin"] = origins;
serverResponse.ResponseHeaders["Access-Control-Allow-Credentials"] = AllowCredentialsTrue;
}
hostContext.Items[HostConstants.SupportsWebSockets] = LazyInitializer.EnsureInitialized(
ref _supportWebSockets,
ref _supportWebSocketsInitialized,
ref _supportWebSocketsLock,
() => environment.SupportsWebSockets());
hostContext.Items[HostConstants.ShutdownToken] = environment.GetShutdownToken();
hostContext.Items[HostConstants.DebugMode] = environment.GetIsDebugEnabled();
serverRequest.DisableRequestBuffering();
serverResponse.DisableResponseBuffering();
_connection.Initialize(_resolver, hostContext);
return(_connection.ProcessRequestAsync(hostContext));
}
public Task Invoke(IDictionary <string, object> environment)
{
var serverRequest = new ServerRequest(environment);
var serverResponse = new ServerResponse(environment);
var hostContext = new HostContext(serverRequest, serverResponse);
string origin = serverRequest.RequestHeaders.GetHeader("Origin");
if (_configuration.EnableCrossDomain)
{
// Add CORS response headers support
if (!String.IsNullOrEmpty(origin))
{
serverResponse.ResponseHeaders.SetHeader("Access-Control-Allow-Origin", origin);
serverResponse.ResponseHeaders.SetHeader("Access-Control-Allow-Credentials", "true");
}
}
else
{
string callback = serverRequest.QueryString["callback"];
// If it's a JSONP request and we're not allowing cross domain requests then block it
// If there's an origin header and it's not a same origin request then block it.
if (!String.IsNullOrEmpty(callback) ||
(!String.IsNullOrEmpty(origin) && !IsSameOrigin(serverRequest.Url, origin)))
{
return(EndResponse(environment, 403, Resources.Forbidden_CrossDomainIsDisabled));
}
}
// Add the nosniff header for all responses to prevent IE from trying to sniff mime type from contents
serverResponse.ResponseHeaders.SetHeader("X-Content-Type-Options", "nosniff");
// REVIEW: Performance
hostContext.Items[HostConstants.SupportsWebSockets] = environment.SupportsWebSockets();
hostContext.Items[HostConstants.ShutdownToken] = environment.GetShutdownToken();
hostContext.Items[HostConstants.DebugMode] = environment.GetIsDebugEnabled();
serverRequest.DisableRequestCompression();
serverResponse.DisableResponseBuffering();
_connection.Initialize(_configuration.Resolver, hostContext);
if (!_connection.Authorize(serverRequest))
{
// If we failed to authorize the request then return a 403 since the request
// can't do anything
return(EndResponse(environment, 403, "Forbidden"));
}
else
{
return(_connection.ProcessRequest(hostContext));
}
}
public void Should_not_retry_connection_for_unexpected_connection_types()
{
var mockBuilder = new MockBuilder();
using (mockBuilder.Bus)
{
mockBuilder.ConnectionFactory.Configuration.ConnectIntervalAttempt = TimeSpan.FromSeconds(1);
mockBuilder.ConnectionFactory.CreateConnection().Returns(c =>
{
ThrowException(typeof(Exception));
return(null);
});
var connection = new PersistentConnection(mockBuilder.ConnectionFactory, mockBuilder.EventBus);
Assert.Throws <Exception>(() => connection.Initialize());
}
}
public override Task ProcessRequestAsync(HttpContextBase context)
#endif
{
// https://developer.mozilla.org/En/HTTP_Access_Control
string origin = context.Request.Headers["Origin"];
if (!String.IsNullOrEmpty(origin))
{
context.Response.AddHeader("Access-Control-Allow-Origin", origin);
context.Response.AddHeader("Access-Control-Allow-Credentials", "true");
}
var request = new AspNetRequest(context);
var response = new AspNetResponse(context);
var hostContext = new HostContext(request, response);
// Determine if the client should bother to try a websocket request
#if NET45
hostContext.Items[HostConstants.SupportsWebSockets] = HttpRuntime.IISVersion != null && HttpRuntime.IISVersion.Major >= 8 && !String.IsNullOrEmpty(context.Request.ServerVariables[WebSocketVersionServerVariable]);
#else
hostContext.Items[HostConstants.SupportsWebSockets] = false;
#endif
// Set the debugging flag
hostContext.Items[HostConstants.DebugMode] = context.IsDebuggingEnabled;
// Set the host shutdown token
hostContext.Items[HostConstants.ShutdownToken] = AppDomainTokenSource.Token;
// Stick the context in here so transports or other asp.net specific logic can
// grab at it.
hostContext.Items["System.Web.HttpContext"] = context;
// Initialize the connection
_connection.Initialize(_resolver, hostContext);
try
{
return(_connection.ProcessRequestAsync(hostContext));
}
catch (NotSupportedException) // WebSockets not supported
{
context.Response.StatusCode = 501; // HTTP 501 Not Implemented
return(TaskAsyncHelper.Empty);
}
}
public override Task Invoke(IOwinContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (JsonUtility.TryRejectJSONPRequest(_configuration, context))
{
return(TaskAsyncHelper.Empty);
}
var connectionFactory = new PersistentConnectionFactory(_configuration.Resolver);
PersistentConnection connection = connectionFactory.CreateInstance(_connectionType);
connection.Initialize(_configuration.Resolver);
return(connection.ProcessRequest(context.Environment));
}
public void Should_retry_connection_for_expected_connection_types_CreateConnection(Type exceptionType)
{
var mockBuilder = new MockBuilder();
using (mockBuilder.Bus)
{
mockBuilder.ConnectionFactory.Configuration.ConnectIntervalAttempt = TimeSpan.FromSeconds(1);
mockBuilder.ConnectionFactory.Succeeded.Returns(false, true);
mockBuilder.ConnectionFactory.CreateConnection().Returns(c =>
{
ThrowException(exceptionType);
return(null);
}, c => mockBuilder.Connection);
var connection = new PersistentConnection(mockBuilder.ConnectionFactory, mockBuilder.EventBus);
connection.Initialize();
connection.IsConnected.ShouldEqual(false);
Thread.Sleep(TimeSpan.FromSeconds(2));
connection.IsConnected.ShouldEqual(true);
mockBuilder.ConnectionFactory.Received(3).CreateConnection();
}
}
public Task Invoke(IDictionary <string, object> env)
{
var serverRequest = new ServerRequest(env);
var serverResponse = new ServerResponse(env);
var hostContext = new HostContext(serverRequest, serverResponse);
var origins = serverRequest.RequestHeaders.GetHeaders("Origin");
if (origins != null && origins.Any(origin => !String.IsNullOrEmpty(origin)))
{
serverResponse.ResponseHeaders["Access-Control-Allow-Origin"] = origins;
serverResponse.ResponseHeaders["Access-Control-Allow-Credentials"] = AllowCredentialsTrue;
}
hostContext.Items[HostConstants.SupportsWebSockets] = env.ContainsKey(OwinConstants.WebSocketSupport);
serverRequest.DisableRequestBuffering();
serverResponse.DisableResponseBuffering();
_connection.Initialize(_resolver, hostContext);
return(_connection.ProcessRequestAsync(hostContext));
}