/// <summary>
/// Регистрирует тип сообщения
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="provider"></param>
/// <returns></returns>
public static IMessageTypeProvider Register <T>(this IMessageTypeProvider provider)
{
var type = typeof(T);
var tag = AttributeHelper.GetPropertyName <MessageQueueNameAttribute>(type, true);
return(provider.Register(tag, type));
}
public void RegisterCqrsStuff(IMessageTypeProvider messageTypeProvider, IHandlerTypeProvider handlerTypeProvider)
{
var types = this.GetType().Assembly.GetTypes();
messageTypeProvider.RegisterMessages(types);
handlerTypeProvider.RegisterHandlers(types);
}
public JsonClient(IClient client, IMessageTypeProvider typeProvider, ISerializer serializer)
{
Client = client ?? throw new ArgumentNullException(nameof(client));
MessageTypeProvider = typeProvider ?? throw new ArgumentNullException(nameof(typeProvider));
Serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
Client.MessageReceived += HandleClientMessage;
Client.Disconnected += HandleDisconnection;
}
public MessagingHostOptionsBuilder(MessagingHostBuilder hostBuilder, IServiceCollection serviceCollection,
IMessageTypeProvider messageTypeProvider, IMessageTopicProvider topicProvider)
{
_hostBuilder = hostBuilder;
_serviceCollection = serviceCollection;
_messageTypeProvider = messageTypeProvider;
_topicProvider = topicProvider;
}
private static Result <string> GetMessageType <TType>(IMessageTypeProvider messageTypeProvider)
{
if (TypesMessageNameCache.TryGetValue(typeof(TType), out var type))
{
return(Result.Ok(type));
}
return(messageTypeProvider.GetMessageType <TType>()
.OnSuccess(messageType => { TypesMessageNameCache.TryAdd(typeof(TType), messageType); }));
}
public static string[] GetMessageTypes <TType>(IMessageTypeProvider messageTypeProvider)
{
var messageType = GetMessageType <TType>(messageTypeProvider);
if (messageType.IsSuccess)
{
return(TypeMetadataCache <TType> .MessageTypeNames.Concat(new[]
{
messageType.Value
})
.ToArray());
}
return(TypeMetadataCache <TType> .MessageTypeNames);
}
public async Task InvokeAsync(
HttpContext httpContext,
IMessageTypeProvider messageTypeProvider)
{
var requestPath = httpContext.Request.Path;
if (requestPath == "/CqrsInfo")
{
var s = "Available Messages:" + Environment.NewLine;
foreach (var s1 in messageTypeProvider.MessagesList)
{
s += $"- {s1} {Environment.NewLine}";
}
await httpContext.Response.WriteAsync(s);
}
else
{
await _nextMiddleware(httpContext);
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
IMessageTypeProvider messageTypeProvider,
IOptions <FrameworkConfiguration> frameworkConfigOptions,
IMailboxProcessor mailboxProcessor,
IApplicationLifetime applicationLifetime)
{
applicationLifetime.ApplicationStopping.Register(() =>
{
_commandConsumer1?.Stop();
_commandConsumer2?.Stop();
_commandConsumer3?.Stop();
_domainEventProcessor?.Stop();
_applicationEventProcessor?.Stop();
_messagePublisher?.Stop();
_commandBus?.Stop();
mailboxProcessor.Stop();
});
mailboxProcessor.Start();
messageTypeProvider.Register(new Dictionary <string, string>
{
["Login"] = "******"
})
.Register("Modify", typeof(Modify));
StartMessageQueueComponents();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler(new GlobalExceptionHandlerOptions(loggerFactory, env));
}
//app.UseMiniProfiler();
PathBase = Configuration.Instance[nameof(PathBase)];
app.UsePathBase(PathBase);
app.Use(next => context =>
{
context.Request.Path = context.Request.Path.Value.Replace("//", "/");
return(next(context));
});
app.Use(next => context =>
{
context.Request.EnableRewind();
context.Response.EnableRewind();
return(next(context));
});
//app.Use(async (context, next) =>
//{
// await next();
// if (context.Response.StatusCode == StatusCodes.Status404NotFound)
// {
// context.Request.Path = "/Home/Error";
// await next();
// }
//});
app.UseForwardedHeaders(new ForwardedHeadersOptions
{
ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
});
app.UseStaticFiles();
app.UseMvc(routes =>
{
routes.MapRoute("default",
"{controller=Home}/{action=Index}/{id?}");
});
app.UseLogLevelController();
app.UseMessageProcessorDashboardMiddleware();
var logger = loggerFactory.CreateLogger <Startup>();
logger.SetMinLevel(LogLevel.Information);
logger.LogInformation($"Startup configured env: {env.EnvironmentName}");
}
void IMessageTypeProvider.RegisterTypes(IMessageTypeProvider provider) => SelectTypesInternal(provider.GetTypes());
public IMessage Deserialize(string data, IMessageTypeProvider typeProvider, IMessageNameProvider nameProvider) => throw new NotImplementedException();
public MessageProvider(IMessageTypeProvider messageTypeProvider)
{
_messageTypeProvider = messageTypeProvider;
}
public EventNamespaceMessageSerializer(IMessageTypeProvider messageTypeProvider)
{
_messageTypeProvider = messageTypeProvider;
}
public void RegisterCqrsStuff(IMessageTypeProvider messageTypeProvider, IHandlerTypeProvider handlerTypeProvider)
{
// throw new NotImplementedException();
}
