/// <summary>
/// Create a connection using an IEndpointResolver.
/// </summary>
/// <param name="endpointResolver">
/// The endpointResolver that returns the endpoints to use for the connection attempt.
/// </param>
/// <param name="clientProvidedName">
/// Application-specific connection name, will be displayed in the management UI
/// if RabbitMQ server supports it. This value doesn't have to be unique and cannot
/// be used as a connection identifier, e.g. in HTTP API requests.
/// This value is supposed to be human-readable.
/// </param>
/// <returns>Open connection</returns>
/// <exception cref="BrokerUnreachableException">
/// When no hostname was reachable.
/// </exception>
public IConnection CreateConnection(IEndpointResolver endpointResolver, string clientProvidedName)
{
IConnection conn;
try
{
if (AutomaticRecoveryEnabled)
{
var autorecoveringConnection = new AutorecoveringConnection(this, clientProvidedName);
autorecoveringConnection.Init(endpointResolver);
conn = autorecoveringConnection;
}
else
{
IProtocol protocol = Protocols.DefaultProtocol;
conn = protocol.CreateConnection(this, false, endpointResolver.SelectOne(this.CreateFrameHandler), clientProvidedName);
}
}
catch (Exception e)
{
throw new BrokerUnreachableException(e);
}
return(conn);
}
internal void SetFallbackResolver(IEndpointResolver fallbackResolver, bool replace = false)
{
if (replace || m_FallbackResolver == null)
{
m_FallbackResolver = fallbackResolver;
}
}
public void Test_ApiOnly_Disabled( )
{
Api api = MakeApi("address1", false);
IEndpointResolver resolver = GetResolver( );
Assert.Throws <EndpointNotFoundException>(() => resolver.ResolveEndpoint("address1", false));
}
public void Init(IEndpointResolver endpoints)
{
_endpoints = endpoints;
IFrameHandler fh = endpoints.SelectOne(_factory.CreateFrameHandler);
Init(fh);
}
public IActionResult Invoke(IRequestHandler requestHandler, string url)
{
IEndpointResolver endpointResolver = requestHandler.GetService <IEndpointResolver>();
Endpoint endpoint = endpointResolver.GetEndpoint(requestHandler, url);
if (endpoint == null)
{
return(null);
}
if (endpoint.DisallowAnonymous)
{
if (!requestHandler.HttpContext.User.Identity.IsAuthenticated || !this.HasRequiredClaims(requestHandler, endpoint))
{
if (string.IsNullOrEmpty(endpoint.SignInUrl))
{
throw new HttpException(403, "Access denied.");
}
return((requestHandler as Controller).Redirect(endpoint.SignInUrl));
}
}
IEndpoint endpointInstance = this.GetEndpointInstance(endpoint);
if (endpointInstance == null)
{
return(null);
}
return(endpointInstance.Invoke(requestHandler, endpoint, endpointResolver.GetArguments(endpoint.UrlTemplate, url)));
}
public async Task Init(IEndpointResolver endpoints)
{
this.endpoints = endpoints;
var fh = await endpoints.SelectOne(m_factory.CreateFrameHandler);
this.Init(fh);
}
public void Init(IEndpointResolver endpoints)
{
this.endpoints = endpoints;
var fh = endpoints.SelectOne(m_factory.CreateFrameHandler);
this.Init(fh);
}
public RabbitMqSink(
RabbitMqSinkOptions options,
IEndpointResolver endpointResolver,
Action<ConnectionFactory> connectionFactorySetup,
ITextFormatter formatter,
TextToBinaryFormatterOptions formatterOptions = null,
string clientProviderName = null) : this(options, endpointResolver, connectionFactorySetup,
public static T SelectOne <T>(this IEndpointResolver resolver, Func <AmqpTcpEndpoint, T> selector)
{
var t = default(T);
Exception exception = null;
foreach (var ep in resolver.All())
{
try
{
t = selector(ep);
if (t.Equals(default(T)) == false)
{
return(t);
}
}
catch (Exception e)
{
exception = e;
}
}
if (Object.Equals(t, default(T)) && exception != null)
{
throw exception;
}
return(t);
}
public static T SelectOne <T>(this IEndpointResolver resolver, Func <AmqpTcpEndpoint, T> selector)
{
var t = default(T);
var exceptions = new List <Exception>();
foreach (AmqpTcpEndpoint ep in resolver.All())
{
try
{
t = selector(ep);
if (!t.Equals(default(T)))
{
return(t);
}
}
catch (Exception e)
{
exceptions.Add(e);
}
}
if (Object.Equals(t, default(T)) && exceptions.Count > 0)
{
throw new AggregateException(exceptions);
}
return(t);
}
public void Test_Endpoint_NotFound( )
{
Api api = MakeApi("my-api");
IEndpointResolver resolver = GetResolver( );
Assert.Throws <EndpointNotFoundException>(() => resolver.ResolveEndpoint("my-api/my-end-point", false));
}
/// <inheritdoc cref="IRegistration"/>
public void Create(CqrsEngine cqrsEngine)
{
if (m_Resolver == null)
{
m_Resolver = cqrsEngine.DependencyResolver.GetService(Dependencies.First()) as IEndpointResolver;
}
cqrsEngine.EndpointResolver = m_Resolver;
}
public void Test_ApiOnly_DuplicateName( )
{
Api api = MakeApi("address1", true);
Api api2 = MakeApi("address1", true);
IEndpointResolver resolver = GetResolver( );
Assert.Throws <ConnectorConfigException>(() => resolver.ResolveEndpoint("address1", false));
}
public void Test_Empty( )
{
IEndpointResolver resolver = GetResolver( );
EndpointAddressResult result = resolver.ResolveEndpoint(new string[] {}, false);
Assert.That(result, Is.Not.Null);
Assert.That(result.ApiId, Is.EqualTo(0));
Assert.That(result.EndpointId, Is.EqualTo(0));
}
public void Test_Endpoint_CaseMismatch( )
{
Api api = MakeApi("my-api");
ApiResourceEndpoint endpoint = MakeEndpoint(api, "my-eNd-point");
IEndpointResolver resolver = GetResolver( );
Assert.Throws <EndpointNotFoundException>(() => resolver.ResolveEndpoint("my-api/my-end-point", false));
}
public void Test_Endpoint_DuplicateName( )
{
Api api = MakeApi("my-api");
ApiResourceEndpoint endpoint = MakeEndpoint(api, "my-end-point");
ApiResourceEndpoint endpoint2 = MakeEndpoint(api, "my-end-point");
IEndpointResolver resolver = GetResolver( );
Assert.Throws <ConnectorConfigException>(() => resolver.ResolveEndpoint("my-api/my-end-point", false));
}
public CqrsEngine(IDependencyResolver dependencyResolver, IMessagingEngine messagingEngine, IEndpointResolver endpointResolver, bool createMissingEndpoints, params IRegistration[] registrations)
{
m_Logger.Debug("CqrsEngine instanciating. createMissingEndpoints: " + createMissingEndpoints);
m_CreateMissingEndpoints = createMissingEndpoints;
m_DependencyResolver = dependencyResolver;
m_Registrations = registrations;
m_EndpointResolver = endpointResolver;
m_MessagingEngine = messagingEngine;
m_BoundedContexts = new List <BoundedContext>();
init();
}
public void Test_ApiOnly_Exists( )
{
Api api = MakeApi("address1");
IEndpointResolver resolver = GetResolver( );
EndpointAddressResult result = resolver.ResolveEndpoint("address1", false);
Assert.That(result, Is.Not.Null);
Assert.That(result.ApiId, Is.EqualTo(api.Id));
Assert.That(result.EndpointId, Is.EqualTo(0));
}
public void Test_Endpoint_WithSuffix( )
{
Api api = MakeApi("my-api");
ApiResourceEndpoint endpoint = MakeEndpoint(api, "my-end-point");
IEndpointResolver resolver = GetResolver( );
EndpointAddressResult result = resolver.ResolveEndpoint("my-api/my-end-point/0", false);
Assert.That(result, Is.Not.Null);
Assert.That(result.ApiId, Is.EqualTo(api.Id));
Assert.That(result.EndpointId, Is.EqualTo(endpoint.Id));
}
private Endpoint CreateEndpoint(IEndpointResolver endpointResolver, ZipkinTracerOptions options)
{
// get defaults
var defaultEndpoint = endpointResolver.GetEndpoint();
// overwrite with values from user-supplied options
return(new Endpoint
{
ServiceName = options.ServiceName ?? defaultEndpoint?.ServiceName ?? "Unknown",
IPAddress = options.ServiceIpAddress ?? defaultEndpoint?.IPAddress ?? IPAddress.Loopback,
Port = options.ServicePort != 0 ? options.ServicePort : defaultEndpoint?.Port ?? 0
});
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="innerService">The service that will be wrapped and called by this service.</param>
/// <param name="endpointResolver">The service that resolve endpoints.</param>
/// <param name="entityRepository">The service that load entities.</param>
public ApiKeySecurity(IConnectorService innerService, IEndpointResolver endpointResolver, IEntityRepository entityRepository)
{
if (innerService == null)
{
throw new ArgumentNullException(nameof(innerService));
}
if (endpointResolver == null)
{
throw new ArgumentNullException(nameof(endpointResolver));
}
_innerService = innerService;
_endpointResolver = endpointResolver;
}
public FluentApi(IEndpointResolver endpointResolver)
{
_endpointResolver = endpointResolver;
ApiEndpointAttribute attribute = typeof(T).GetCustomAttributes(true)
.OfType <ApiEndpointAttribute>()
.FirstOrDefault();
if (attribute == null)
{
throw new ArgumentException(string.Format("The Type {0} cannot be used in this way, it has no ApiEndpointAttribute", typeof(T)));
}
_endPointInfo.Uri = attribute.EndpointUri;
}
public async Task InvokeAsync(HttpContext httpContext, IEndpointResolver endpointResolver)
{
Data.Entities.Endpoint endpoint = await endpointResolver.ResolveAsync(httpContext);
if (endpoint != null)
{
if (!endpoint.DisallowAnonymous || (httpContext.User.Identity.IsAuthenticated && endpoint.EndpointPermissions.All(ep => httpContext.User.HasClaim(PlatformusClaimTypes.Permission, ep.Permission.Code))))
{
byte[] responseBody;
Func <Task <byte[]> > defaultValueFunc = async() =>
{
IActionResult actionResult = await this.CreateRequestProcessor(endpoint).ProcessAsync(httpContext, endpoint);
if (actionResult == null)
{
return(null);
}
return(await this.GetResponseBodyAsync(httpContext, actionResult));
};
if (string.IsNullOrEmpty(endpoint.ResponseCacheCSharpClassName))
{
responseBody = await defaultValueFunc();
}
else
{
responseBody = await this.CreateResponseCache(endpoint).GetWithDefaultValueAsync(
httpContext,
defaultValueFunc
);
}
if (responseBody != null)
{
await httpContext.Response.Body.WriteAsync(responseBody, 0, responseBody.Length);
return;
}
}
}
await this.next(httpContext);
}
/// <summary>
/// Create a connection using an IEndpointResolver.
/// </summary>
/// <param name="endpointResolver">
/// The endpointResolver that returns the endpoints to use for the connection attempt.
/// </param>
/// <param name="clientProvidedName">
/// Application-specific connection name, will be displayed in the management UI
/// if RabbitMQ server supports it. This value doesn't have to be unique and cannot
/// be used as a connection identifier, e.g. in HTTP API requests.
/// This value is supposed to be human-readable.
/// </param>
/// <returns>Open connection</returns>
/// <exception cref="BrokerUnreachableException">
/// When no hostname was reachable.
/// </exception>
public IConnection CreateConnection(IEndpointResolver endpointResolver, string clientProvidedName)
{
ConnectionConfig config = CreateConfig(clientProvidedName);
try
{
if (AutomaticRecoveryEnabled)
{
return(new AutorecoveringConnection(config, endpointResolver));
}
return(new Connection(config, endpointResolver.SelectOne(CreateFrameHandler)));
}
catch (Exception e)
{
throw new BrokerUnreachableException(e);
}
}
public static LoggerAuditSinkConfiguration RabbitMq(
this LoggerAuditSinkConfiguration configuration,
Action <RabbitMqSinkOptions> optionsSetup,
IEndpointResolver endpointResolver,
Action <ConnectionFactory> connectionFactorySetup,
IBinaryFormatter binaryFormatter,
LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose,
LoggingLevelSwitch levelSwitch = null,
string clientProviderName = null)
{
RabbitMqSinkOptions options = configuration.Create(optionsSetup);
RabbitMqSink rabbitMqSink = new RabbitMqSink(options, endpointResolver, connectionFactorySetup, binaryFormatter,
clientProviderName);
configuration.Sink(rabbitMqSink, restrictedToMinimumLevel, levelSwitch);
return(configuration);
}
public ConnectorService(IEndpointResolver endpointResolver, IEntityRepository entityRepository, IComponentContext componentContext)
{
if (endpointResolver == null)
{
throw new ArgumentNullException("endpointResolver");
}
if (entityRepository == null)
{
throw new ArgumentNullException("entityRepository");
}
if (componentContext == null)
{
throw new ArgumentNullException("componentContext");
}
_endpointResolver = endpointResolver;
_entityRepository = entityRepository;
_componentContext = componentContext;
}
public AutorecoveringConnection(ConnectionConfig config, IEndpointResolver endpoints)
{
_config = config;
_endpoints = endpoints;
IFrameHandler fh = _endpoints.SelectOne(_config.FrameHandlerFactory);
_innerConnection = new Connection(_config, fh);
Action <Exception, string> onException =
(exception, context) =>
_innerConnection.OnCallbackException(CallbackExceptionEventArgs.Build(exception, context));
_recoverySucceededWrapper = new EventingWrapper <EventArgs>("OnConnectionRecovery", onException);
_connectionRecoveryErrorWrapper = new EventingWrapper <ConnectionRecoveryErrorEventArgs>("OnConnectionRecoveryError", onException);
_consumerTagChangeAfterRecoveryWrapper = new EventingWrapper <ConsumerTagChangedAfterRecoveryEventArgs>("OnConsumerRecovery", onException);
_queueNameChangeAfterRecoveryWrapper = new EventingWrapper <QueueNameChangedAfterRecoveryEventArgs>("OnQueueRecovery", onException);
ConnectionShutdown += HandleConnectionShutdown;
}
public static LoggerSinkConfiguration RabbitMq(
this LoggerSinkConfiguration configuration,
Action <RabbitMqSinkOptions> optionsSetup,
IEndpointResolver endpointResolver,
Action <ConnectionFactory> connectionFactorySetup,
LogEventJsonConverterOptions jsonConverterOptions = null,
LogEventLevel restrictedToMinimumLevel = LogEventLevel.Verbose,
LoggingLevelSwitch levelSwitch = null,
string clientProviderName = null)
{
RabbitMqSinkOptions options = configuration.Create(optionsSetup);
RabbitMqSink rabbitMqSink = new RabbitMqSink(options, endpointResolver, connectionFactorySetup,
new JsonToUtf8BytesFormatter(jsonConverterOptions ?? new LogEventJsonConverterOptions()),
clientProviderName);
configuration.Sink(rabbitMqSink, restrictedToMinimumLevel, levelSwitch);
return(configuration);
}
public void AddSubscribedCommand(Type command, uint priority, IEndpointResolver resolver)
{
if (Type == null)
{
Type = RouteType.Commands;
}
if (Type != RouteType.Commands)
{
throw new ApplicationException($"Can not subscribe for commands on events route '{Name}'.");
}
var routingKey = new RoutingKey
{
LocalContext = m_Context,
MessageType = command,
Priority = priority,
RouteType = Type.Value,
CommunicationType = CommunicationType.Subscribe
};
m_RouteResolvers[routingKey] = resolver;
}
public void AddPublishedEvent(Type @event, uint priority, IEndpointResolver resolver)
{
if (Type == null)
{
Type = RouteType.Events;
}
if (Type != RouteType.Events)
{
throw new ApplicationException($"Can not publish for events with commands route '{Name}'.");
}
var routingKey = new RoutingKey
{
LocalContext = m_Context,
RouteType = Type.Value,
MessageType = @event,
Priority = priority,
CommunicationType = CommunicationType.Publish
};
m_RouteResolvers[routingKey] = resolver;
}
public void Init(IEndpointResolver endpoints)
{
this.endpoints = endpoints;
var fh = endpoints.SelectOne(m_factory.CreateFrameHandler);
this.Init(fh);
}