public PetsController(ILogger <PetsController> logger, IMapper mapper, IPetFinder petFinder, IEndpointProvider endpointProvider)
{
_logger = logger;
this.mapper = mapper;
this.petFinder = petFinder;
this.endpointProvider = endpointProvider;
}
internal EndpointContainer(IEndpointProvider endpointProvider)
{
this.Ingestion = endpointProvider.GetEndpoint(EndpointName.Ingestion);
this.Live = endpointProvider.GetEndpoint(EndpointName.Live);
this.Profiler = endpointProvider.GetEndpoint(EndpointName.Profiler);
this.Snapshot = endpointProvider.GetEndpoint(EndpointName.Snapshot);
}
/// <summary>
/// Establece la Url del servicio Aspen a donde se envian las solicitudes.
/// </summary>
/// <param name="endpointProvider">Instancia con la configuración del servicio Aspen.</param>
/// <param name="proxy">Configuración del servidor Proxy que se debe utilizar para conectar con el servicio Aspen.</param>
/// <returns>Instancia de <see cref="ILoggingSettings" /> que permite la configuración de trazas de seguimiento.</returns>
public ILoggingSettings RoutingTo(IEndpointProvider endpointProvider, IWebProxy proxy)
{
Throw.IfNull(endpointProvider, nameof(endpointProvider));
this.endpointProvider = endpointProvider;
this.proxy = proxy;
return(this);
}
public Server(
IHttpListener listener,
IEndpointProvider endpointProvider,
IOutput output,
ISoapDecoder soapDecoder,
ILogger logger,
IContentTypeProvider contentTypeProvider,
IWebRequestFactory webRequestFactory)
{
this.listener = listener;
this.endpointProvider = endpointProvider;
this.output = output;
this.soapDecoder = soapDecoder;
this.logger = logger;
this.contentTypeProvider = contentTypeProvider;
this.webRequestFactory = webRequestFactory;
try
{
listener.Prefixes.Add(endpointProvider.ServerBaseUrl);
}
catch (ArgumentException ex)
{
throw new FailException(
string.Format(
"While attempting to listen on URL '{1}': {0}",
ex.Message,
endpointProvider.ServerBaseUrl),
ex);
}
logger.Info("Listening on: {0}", endpointProvider.ServerBaseUrl);
}
public PickConnectionMiddleware(
IServerProvider serverProvider,
IEndpointProvider endpointProvider)
{
ServerProvider = serverProvider ?? throw new ArgumentNullException(nameof(serverProvider));
EndpointProvider = endpointProvider ?? throw new ArgumentNullException(nameof(endpointProvider));
}
internal void ResolveRoutes(IEndpointProvider endpointProvider)
{
foreach (Route route in m_RouteMap.Values)
{
route.Resolve(endpointProvider);
}
}
public void Resolve(IEndpointProvider endpointProvider)
{
foreach (var pair in m_RouteResolvers)
{
var endpoint = pair.Value.Resolve(Name, pair.Key, endpointProvider);
m_MessageRoutes[pair.Key] = endpoint;
}
}
public Endpoint Resolve(string route, RoutingKey key, IEndpointProvider endpointProvider)
{
if (endpointProvider.Contains(route))
{
return(endpointProvider.Get(route));
}
throw new ApplicationException(string.Format("Endpoint '{0}' not found", route));
}
public PickConnectionMiddleware(IServerProvider serverProvider,
IEndpointProvider endpointProvider)
{
if (serverProvider == null) throw new ArgumentNullException(nameof(serverProvider));
if (endpointProvider == null) throw new ArgumentNullException(nameof(endpointProvider));
ServerProvider = serverProvider;
EndpointProvider = endpointProvider;
}
public Endpoint Resolve(string route, RoutingKey key, IEndpointProvider endpointProvider)
{
var endpointName = m_Map.Where(pair => pair.Key(key)).Select(pair => pair.Value).SingleOrDefault();
if (endpointName == null)
{
return(m_FallbackResolver.Resolve(route, key, endpointProvider));
}
return(endpointProvider.Get(endpointName));
}
public RestSharpClient(Credentials credentials, Uri serverUri, IEndpointProvider endpointProvider)
{
if (string.IsNullOrEmpty(credentials.Password) || string.IsNullOrEmpty(credentials.Login))
{
throw new Exception("Login and password need to be supplied");
}
_authToken = Base64Converter.Encode($"{credentials.Login}:{credentials.Password}");
_serverUri = serverUri ?? throw new ArgumentNullException(nameof(serverUri));
_endpointProvider = endpointProvider ?? throw new ArgumentNullException(nameof(endpointProvider));
}
public Program(
IRunner scenarioRunner,
IEndpointProvider endpointProvider,
IOutput output,
IScenarioTypeFinder scenarioTypeFinder,
ILogger logger)
{
this.scenarioRunner = scenarioRunner;
this.endpointProvider = endpointProvider;
this.output = output;
this.scenarioTypeFinder = scenarioTypeFinder;
this.logger = logger;
}
public CqrsEngine(
ILog log,
IMessagingEngine messagingEngine,
IEndpointProvider endpointProvider,
params IRegistration[] registrations)
: this(
log,
new DefaultDependencyResolver(),
messagingEngine,
endpointProvider,
false,
registrations)
{
}
public Client(
IEndpointProvider endpointProvider,
ISoapDecoder soapDecoder,
IWebRequestFactory webRequestFactory,
ISecurityHeaderFactory securityHeaderFactory,
ILogger logger,
IContentTypeProvider contentTypeProvider)
{
this.endpointProvider = endpointProvider;
this.soapDecoder = soapDecoder;
this.webRequestFactory = webRequestFactory;
this.securityHeaderFactory = securityHeaderFactory;
this.logger = logger;
this.contentTypeProvider = contentTypeProvider;
}
public CqrsEngine(
ILogFactory logFactory,
IDependencyResolver dependencyResolver,
IMessagingEngine messagingEngine,
IEndpointProvider endpointProvider,
params IRegistration[] registrations)
: this(
logFactory,
dependencyResolver,
messagingEngine,
endpointProvider,
false,
registrations)
{
}
/// <summary>
/// Inicializa una nueva instancia de la clase <see cref="ServiceLocator" />
/// </summary>
/// <param name="nonceGenerator">Instancia de <see cref="INonceGenerator" /> que se utiliza para inicializar el proveedor de valores nonce o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="epochGenerator">Instancia de <see cref="IEpochGenerator" /> que se utiliza para inicializar el proveedor de valores epoch o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="headersManager">Instancia de <see cref="IHeadersManager" /> que se utiliza para inicializar el proveedor de cabeceras para las solicitudes al servicio o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="requestHeaderNames">Instancia de <see cref="IHeaderElement" /> que se utiliza para inicializar el proveedor de los nombres de cabeceras personalizadas o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="payloadClaimNames">Instancia de <see cref="IPayloadClaimElement" /> que se utiliza para inicializar el proveedor de los nombres para las reclamaciones usadas en la carga útil del servicio o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="payloadClaimsManager">Instancia de <see cref="IPayloadClaimsManager" /> que se utiliza para inicializar el proveedor de reclamaciones de la carga útil o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="jwtJsonSerializer">Instancia de <see cref="IJsonSerializer" /> que se utiliza para inicializar el proveedor de serialización y deserialización de JWT o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="webProxy">Instancia de <see cref="IWebProxy" /> que se utiliza para inicializar el proveedor del servidor proxy o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="loggingProvider">Instancia de <see cref="ILoggingProvider" /> que se utiliza para inicializar el proveedor de escritura de trazas de seguimiento o <c>null</c> para utilizar la instancia predeterminada.</param>
/// <param name="endpointProvider">Instancia que implementa <see cref="IEndpointProvider"/> para la obtención de valores de configuración.</param>
/// <param name="appIdentity">Instancia que implementa <see cref="IAppIdentity"/> para la obtención de valores de configuración.</param>
private void RegisterInstance(
INonceGenerator nonceGenerator = null,
IEpochGenerator epochGenerator = null,
IHeadersManager headersManager = null,
IHeaderElement requestHeaderNames = null,
IPayloadClaimElement payloadClaimNames = null,
IPayloadClaimsManager payloadClaimsManager = null,
IJsonSerializer jwtJsonSerializer = null,
IWebProxy webProxy = null,
ILoggingProvider loggingProvider = null,
IEndpointProvider endpointProvider = null,
IAppIdentity appIdentity = null)
{
lock (padlock)
{
INonceGenerator instanceOfNonceGenerator = nonceGenerator ?? this.NonceGenerator ?? new GuidNonceGenerator();
IEpochGenerator instanceOfEpochGenerator = epochGenerator ?? this.EpochGenerator ?? new UnixEpochGenerator();
IHeaderElement instanceOfRequestHeaderNames = requestHeaderNames ?? this.RequestHeaderNames ?? new DefaultHeaderElement();
IPayloadClaimElement instanceOfPayloadClaimNames = payloadClaimNames ?? this.PayloadClaimNames ?? new DefaultPayloadClaimElement();
IPayloadClaimsManager instanceOfPayloadClaimsManager = payloadClaimsManager ?? this.PayloadClaimsManager ?? new DefaultPayloadClaimsManager();
IHeadersManager instanceOfHeadersManager = headersManager ?? this.HeadersManager ?? new DefaultHeadersManager();
IJsonSerializer instanceOfJwtJsonSerializer = jwtJsonSerializer ?? this.JwtJsonSerializer ?? new JsonNetSerializer();
IWebProxy instanceOfWebProxy = webProxy ?? this.WebProxy ?? new NullWebProxy();
ILoggingProvider instanceOfLoggingProvider = loggingProvider ?? this.LoggingProvider ?? new NullLoggingProvider();
IEndpointProvider instanceOfEndpointProvider = endpointProvider ?? new EnvironmentEndpoint();
IAppIdentity instanceOfAppIdentity = appIdentity ?? new EnvironmentIdentity();
if (this.container != null)
{
this.container.Dispose();
this.container = null;
}
this.container = new Container();
this.container.RegisterInstance <IEnvironmentRuntime>(new EnvironmentRuntime());
this.container.RegisterInstance(instanceOfNonceGenerator);
this.container.RegisterInstance(instanceOfEpochGenerator);
this.container.RegisterInstance(instanceOfRequestHeaderNames);
this.container.RegisterInstance(instanceOfHeadersManager);
this.container.RegisterInstance(instanceOfPayloadClaimNames);
this.container.RegisterInstance(instanceOfPayloadClaimsManager);
this.container.RegisterInstance(instanceOfJwtJsonSerializer);
this.container.RegisterInstance(instanceOfWebProxy);
this.container.RegisterInstance(instanceOfLoggingProvider);
this.container.RegisterInstance(instanceOfEndpointProvider);
this.container.RegisterInstance(instanceOfAppIdentity);
}
}
public Endpoint Resolve(string route, RoutingKey key, IEndpointProvider endpointProvider)
{
if (key.Priority == 0)
{
return(new Endpoint(
"InMemory",
/*key.LocalBoundedContext + "." + */ route,
true,
SerializationFormat.Json));
}
return(new Endpoint(
"InMemory",
/*key.LocalBoundedContext + "." + */ route + "." + key.Priority,
true,
SerializationFormat.Json));
}
public CqrsEngine(
ILogFactory logFactory,
IDependencyResolver dependencyResolver,
IMessagingEngine messagingEngine,
IEndpointProvider endpointProvider,
bool createMissingEndpoints,
params IRegistration[] registrations)
: this(
logFactory,
dependencyResolver,
messagingEngine,
endpointProvider,
createMissingEndpoints,
true,
registrations)
{
}
public CqrsEngine(
ILog log,
IDependencyResolver dependencyResolver,
IMessagingEngine messagingEngine,
IEndpointProvider endpointProvider,
bool createMissingEndpoints,
bool enableInputMessagesLogging,
params IRegistration[] registrations)
{
Log = log;
_createMissingEndpoints = createMissingEndpoints;
DependencyResolver = dependencyResolver;
_registrations = registrations;
EndpointResolver = new DefaultEndpointResolver();
MessagingEngine = messagingEngine;
_endpointProvider = endpointProvider;
Contexts = new List <Context>();
DefaultRouteMap = new RouteMap("default");
EnableInputMessagesLogging = enableInputMessagesLogging;
}
public Endpoint Resolve(string route, RoutingKey key, IEndpointProvider endpointProvider)
{
lock (_cache)
{
if (_cache.TryGetValue(Tuple.Create(route, key), out var ep))
{
return(ep);
}
if (endpointProvider.Contains(route))
{
ep = endpointProvider.Get(route);
_cache.Add(Tuple.Create(route, key), ep);
return(ep);
}
ep = CreateEndpoint(route, key);
_cache.Add(Tuple.Create(route, key), ep);
return(ep);
}
}
public CqrsEngine(
ILog log,
IDependencyResolver dependencyResolver,
IMessagingEngine messagingEngine,
IEndpointProvider endpointProvider,
bool createMissingEndpoints,
params IRegistration[] registrations)
{
_log = log;
_createMissingEndpoints = createMissingEndpoints;
DependencyResolver = dependencyResolver;
EndpointResolver = new DefaultEndpointResolver();
MessagingEngine = messagingEngine;
_endpointProvider = endpointProvider;
Contexts = new List <Context>();
DefaultRouteMap = new RouteMap("default");
CommandInterceptorsQueue = new CommandInterceptorsQueue();
EventInterceptorsQueue = new EventInterceptorsQueue();
InitRegistrations(registrations);
}
protected override void Init()
{
foreach (var initStep in m_InitPreSteps)
{
initStep(Kernel);
}
if (Kernel.HasComponent(typeof(IEndpointProvider)))
{
throw new Exception("IEndpointProvider already registered in container, can not register IEndpointProvider from MessagingConfiguration");
}
Kernel.Register(
Component.For <IEndpointProvider>()
.Forward <ISubDependencyResolver>()
.ImplementedBy <EndpointResolver>()
.Named("EndpointResolver")
.DependsOn(new { endpoints = MessagingConfiguration.GetEndpoints() }));
var subDependencyResolver = Kernel.Resolve <ISubDependencyResolver>("EndpointResolver");
m_EndpointProvider = Kernel.Resolve <IEndpointProvider>("EndpointResolver");
Kernel.Resolver.AddSubResolver(subDependencyResolver);
m_MessagingEngine = new MessagingEngine(new LogToConsole(),
new TransportResolver(MessagingConfiguration.GetTransports() ?? new Dictionary <string, TransportInfo>(), m_JailStrategies),
MessagingConfiguration.GetProcessingGroups(),
m_TransportFactories.ToArray());
Kernel.Register(
Component.For <IMessagingEngine>().Instance(m_MessagingEngine)
);
Kernel.ComponentRegistered += OnComponentRegistered;
Kernel.ComponentModelCreated += ProcessModel;
foreach (var initStep in m_InitPostSteps)
{
initStep(Kernel);
}
}
/// <summary>
/// Creates an executor using a custom <paramref name="endpointProvider"/>.
/// </summary>
public Executor(IEndpointProvider <TEndpoint> endpointProvider)
{
_endpointProvider = endpointProvider;
}
public static void Configure(IEndpointProvider endpointProvider)
{
_instance = new WormholeFactory(endpointProvider);
}
protected WormholeFactory(IEndpointProvider endpointProvider)
{
_factories = new ConcurrentDictionary <string, object>();
_endpointProvider = endpointProvider;
}
public SecurityHeaderFactory(
IEndpointProvider endpointProvider,
IDateTimeProvider dateTimeProvider,
IRandomNumberGeneratorProvider randomNumberGeneratorProvider)
{
this.endpointProvider = endpointProvider;
this.dateTimeProvider = dateTimeProvider;
this.randomNumberGeneratorProvider = randomNumberGeneratorProvider;
}
public AzureDevOpsAccountSource(IEndpointProvider endpointProvider) => _endpointProvider = endpointProvider;
public JenkinsJobsSource(IEndpointProvider endpointsProvider)
{
_endpointsProvider = endpointsProvider;
}
private static IJiraClient CreateClient(ClientType clientType, Credentials credentials, Uri serverUri, IEndpointProvider endpointProvider)
{
return(clientType switch
{
ClientType.RestSharp => new RestSharpClient(credentials, serverUri, endpointProvider),
ClientType.Flurl => new FlurlClient(credentials, serverUri, endpointProvider),
_ => throw new ArgumentOutOfRangeException(nameof(clientType), clientType, null)
});
public DocumentGetter(IEndpointProvider endpointProvider)
{
EndpointProvider = endpointProvider;
}
public SendAlertSvc()
{
// config bind here
receiverProvider = new SQLReceiverProvider();
endpointProvider = new MockEndpointProvider();
}
public DocumentCreator(IEndpointProvider endpointProvider)
{
EndpointProvider = endpointProvider;
}
public AzureSubscriptionSource(IEndpointProvider endpointProvider) => _endpointProvider = endpointProvider;
public RabbitMqMessagingService(IEndpointProvider endpointProvider)
: base(endpointProvider)
{
}
public AzureDevOpsRepositorySource(IEndpointProvider endpointProvider) => _endpointProvider = endpointProvider;
public AppVeyorProjectSource(IEndpointProvider endpointsProvider) => _endpointsProvider = endpointsProvider;
