public void Utils_publish_Rot13_messages()
{
var mqHost = new RabbitMqServer(ConnectionString);
var mqClient = mqHost.CreateMessageQueueClient();
Publish_4_Rot13_messages(mqClient);
mqHost.Stop();
}
public object Any(Hello request)
{
var mqServer = new RabbitMqServer("localhost")
{
CreateQueueFilter = (queueName, args) =>
{
args["x-dead-letter-exchange"] = "mx.servicestack.dlq";
args["x-dead-letter-routing-key"] = "mq:Hello.dlq";
},
//PublishMessageFilter = (queueName, properties, msg) =>
//{
// properties.AppId = "app:{0}".Fmt(queueName);
//},
//GetMessageFilter = (queueName, basicMsg) =>
//{
// var props = basicMsg.BasicProperties;
// //receivedMsgType = props.Type; //automatically added by RabbitMqProducer
// //receivedMsgApp = props.AppId;
//},
};
using (var mqClient = mqServer.CreateMessageQueueClient())
{
mqClient.Publish(new Hello {
Name = "Bugs Bunny"
});
}
return(new HelloResponse {
Result = $"Hello, {request.Name}!"
});
}
public ClientsResponse Post(Client client)
{
var mqServer = new RabbitMqServer("localhost")
{
CreateQueueFilter = (queueName, args) =>
{
args["x-dead-letter-exchange"] = "mx.servicestack.dlq";
args["x-dead-letter-routing-key"] = "mq:Client.dlq";
},
};
using (var mqClient = mqServer.CreateMessageQueueClient())
{
mqClient.Publish(new Client {
Name = "Client!", Id = client.Id
});
//var responseMsg = mqClient.Get<ClientsResponse>(QueueNames<ClientsResponse>.In);
//mqClient.Ack(responseMsg);
}
var message = client != null && client.Id != default(int) ? "Successfull" : "Error";
return(new ClientsResponse {
Response = message
});
}
public override void Configure(Container container)
{
var log = LogManager.GetLogger(typeof(AppHost));
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
Plugins.Add(new PostmanFeature());
Plugins.Add(new CorsFeature());
SetConfig(new HostConfig {
DebugMode = true
});
// Rabbit
var mqServer = new RabbitMqServer("192.168.99.100:32776");
mqServer.DisablePriorityQueues = true;
mqServer.RegisterHandler <CreateAccount>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <DeleteAccount>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <DeleteAccounts>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <GetAccount>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <GetAccounts>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <AccountCreatedEvent>(x => {
log.Info($"an event occurred! {x.SerializeToString()}");
return(null);
});
mqServer.Start();
container.Register <IMessageService>(c => mqServer);
container.RegisterAs <Bus, IBus>().ReusedWithin(ReuseScope.None);
// ORMLite
var dbFactory = new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider);
dbFactory.AutoDisposeConnection = false;
dbFactory.OpenDbConnection().CreateTableIfNotExists <AccountData>();
container.Register <IDbConnectionFactory>(c => dbFactory);
// Errors
this.ServiceExceptionHandlers.Add((httpReq, request, exception) =>
{
log.Error($"Error: {exception.Message}. {exception.StackTrace}.", exception);
return(null);
});
// var bus = container.Resolve<IBus>();
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
// bus.Send<CreateAccount, CreateAccountResponse>(new CreateAccount{Name="Peter"});
}
// GET: Uploadify
public ActionResult Index()
{
//List<user> list = _userService.GetModels(p => true).ToList();
var liset = RabbitMqServer.RabbitMq();
//DapperMethod.MappingDouble();
return(View());
}
public void Misc_publish_Reverse_messages()
{
using (var mqServer = new RabbitMqServer(RabbitMqConfig.RabbitMqHostName)) {
using (var mqClient = mqServer.CreateMessageQueueClient()) {
Publish_4_messages(mqClient);
}
}
}
public void Utils_publish_Reverse_messages()
{
using (var mqHost = new RabbitMqServer(ConnectionString))
using (var mqClient = mqHost.CreateMessageQueueClient())
{
Publish_4_messages(mqClient);
}
}
public void Utils_publish_Reverse_messages()
{
var mqHost = new RabbitMqServer(ConnectionString);
var mqClient = mqHost.CreateMessageQueueClient();
Publish_4_messages(mqClient);
mqHost.Stop();
}
public override void Configure(Container container)
{
var mqServer = new RabbitMqServer {
RetryCount = 1
};
container.Register <IMessageService>(c => mqServer);
mqServer.RegisterHandler <ThrowVoid>(ExecuteMessage);
AfterInitCallbacks.Add(appHost => mqServer.Start());
}
public override void Configure(Container container)
{
var mqServer = new RabbitMqServer(connectionString: TestsConfig.RabbitMQConnString);
mqServer.RegisterHandler <MqCustomException>(
ExecuteMessage,
HandleMqCustomException);
container.Register <IMessageService>(c => mqServer);
mqServer.Start();
}
public override void Configure(Container container)
{
var mqServer = new RabbitMqServer(connectionString: TestsConfig.RabbitMQConnString);
mqServer.RegisterHandler<MqCustomException>(
ExecuteMessage,
HandleMqCustomException);
container.Register<IMessageService>(c => mqServer);
mqServer.Start();
}
public override void Configure(Container container)
{
var mqServer = new RabbitMqServer();
mqServer.RegisterHandler<MqCustomException>(
ServiceController.ExecuteMessage,
HandleMqCustomException);
container.Register<IMessageService>(c => mqServer);
mqServer.Start();
}
public override void Configure(Container container)
{
var mqServer = new RabbitMqServer();
mqServer.RegisterHandler <MqCustomException>(
ServiceController.ExecuteMessage,
HandleMqCustomException);
container.Register <IMessageService>(c => mqServer);
mqServer.Start();
}
public override IMessageService CreateMqServer(int retryCount = 1)
{
var mqServer = new RabbitMqServer(connectionString: Config.RabbitMQConnString)
{
RetryCount = retryCount
};
using var conn = mqServer.ConnectionFactory.CreateConnection();
using var channel = conn.CreateModel();
channel.PurgeQueue <HelloIntro>();
channel.PurgeQueue <HelloIntroResponse>();
return(mqServer);
}
public override void Configure(Container container)
{
var log = LogManager.GetLogger(typeof(AppHost));
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
// HTTP
Plugins.Add(new PostmanFeature());
Plugins.Add(new CorsFeature());
SetConfig(new HostConfig {
DebugMode = true
});
// DB
var dbFactory = new OrmLiteConnectionFactory(Env.Postgres, PostgreSqlDialect.Provider);
//var dbFactory = new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider);
dbFactory.OpenDbConnection().CreateTableIfNotExists <TenantData>();
dbFactory.OpenDbConnection().CreateTableIfNotExists <UserData>();
container.Register <IDbConnectionFactory>(c => dbFactory);
// Rabbit
var mqServer = new RabbitMqServer($"{Env.Rabbit_Host}:{Env.Rabbit_Port}")
{
DisablePriorityQueues = true
};
// Message Handlers - Tenant Service
mqServer.RegisterHandler <CreateTenant>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <DeleteTenant>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <DeleteTenants>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <GetTenant>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <GetTenants>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <TenantCreatedEvent>(this.ExecuteMessage, noOfThreads: 4);
// Message Handlers - User Service
mqServer.RegisterHandler <CreateUser>(this.ExecuteMessage, noOfThreads: 4);
mqServer.RegisterHandler <UserCreatedEvent>(this.ExecuteMessage, noOfThreads: 4);
mqServer.Start();
container.Register <IMessageService>(c => mqServer);
container.RegisterAs <Bus, IBus>();
// Errors
this.ServiceExceptionHandlers.Add((httpReq, request, exception) =>
{
AppHost.Instance.Resolve <ILog>().Error($"Error: {exception.Message}. {exception.StackTrace}.", exception);
return(null);
});
}
public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
{
loggerFactory.AddConsole();
// define Rabbit MQ server.
var mqServer = new RabbitMqServer(RabbitConfig.Host);
mqServer.RegisterHandler <Api.HashGenerator>(m =>
{
var request = m.GetBody();
try
{
// Use WebClient class to make the who procedure clean and simple.
// This handler should be running on a different thread, so that no
// async/await is needed.
using (var webClient = new WebClient()) // WebClient class inherits IDisposable
{
var url = request.Url;
var htmlContent = webClient.DownloadString(url);
// then create MD5 by .NET crypto library
var hashValue = string.Join("", MD5.Create().ComputeHash(
Encoding.ASCII.GetBytes(htmlContent))
.Select(s => s.ToString("x2")));
return(new HashResponse()
{
Succeed = true,
Subscriber = request.Subscriber,
Url = request.Url,
Result = hashValue
});
}
}
catch (Exception ex)
{
return(new HashResponse()
{
Succeed = false,
Subscriber = request.Subscriber,
Url = request.Url,
Result = ex.Message
});
}
});
mqServer.Start();
app.UseServiceStack(new AppHost());
}
private static RabbitMqServer CreateMqServer(int noOfRetries = 2)
{
var redisFactory = TestConfig.BasicClientManger;
try
{
redisFactory.Exec(redis => redis.FlushAll());
}
catch (RedisException rex)
{
Debug.WriteLine("WARNING: Redis not started? \n" + rex.Message);
}
var mqHost = new RabbitMqServer(ConnectionString);
return mqHost;
}
internal static RabbitMqServer CreateMqServer(int noOfRetries = 2)
{
var mqServer = new RabbitMqServer(ConnectionString);
using var conn = mqServer.ConnectionFactory.CreateConnection();
using var channel = conn.CreateModel();
channel.PurgeQueue <Reverse>();
channel.PurgeQueue <Rot13>();
channel.PurgeQueue <Incr>();
channel.PurgeQueue <Wait>();
channel.PurgeQueue <Hello>();
channel.PurgeQueue <HelloResponse>();
channel.PurgeQueue <HelloNull>();
return(mqServer);
}
private static RabbitMqServer CreateMqServer(int noOfRetries = 2)
{
var redisFactory = TestConfig.BasicClientManger;
try
{
redisFactory.Exec(redis => redis.FlushAll());
}
catch (RedisException rex)
{
Debug.WriteLine("WARNING: Redis not started? \n" + rex.Message);
}
var mqHost = new RabbitMqServer(ConnectionString);
return(mqHost);
}
static async Task Main()
{
Console.WriteLine("Hello World!");
RabbitMqServer server = new RabbitMqServer();
if (!await server.Startup().ConfigureAwait(false))
{
Console.WriteLine("Failed to start. Exiting...");
return;
}
Console.WriteLine("Started server");
await Task.Delay(Timeout.Infinite);
//Console.WriteLine("Press enter to exit");
//Console.ReadLine();
//Console.WriteLine("Shutting Down...");
//await server.ShutdownAsync().ConfigureAwait(false);
}
public BusLifetime(IServiceProvider serviceProvider,
RabbitMqServer server,
ICommandDiscovery commandDiscovery,
IEventDiscovery eventDiscovery,
ILogger <BusLifetime> logger)
{
_serviceProvider = serviceProvider;
_server = server;
_logger = logger;
_registrar = new Registrar(_server, _serviceProvider, _logger);
commandDiscovery.Register(_registrar);
eventDiscovery.Register(_registrar);
_server.DisablePriorityQueues = true;
_server.DisablePublishingResponses = true;
_logger.Debug("Starting RabbitMQ server");
_server.Start();
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.ConfigureServices((hostContext, services) =>
{
AppHost = new GenericAppHost(typeof(MyService).Assembly)
{
ConfigureAppHost = host =>
{
var mqServer = new RabbitMqServer(hostContext.Configuration.GetConnectionString("RabbitMq"))
{
DisablePublishingToOutq = true,
};
mqServer.RegisterHandler <Hello>(host.ExecuteMessage);
host.Register <IMessageService>(mqServer);
}
}.Init();
services.AddSingleton(AppHost.Resolve <IMessageService>());
services.AddHostedService <MqWorker>();
});
public void Messages_with_no_responses_are_published_to_Request_outq_topic()
{
using (var mqServer = new RabbitMqServer())
{
mqServer.RegisterHandler<Hello>(m =>
{
"Hello, {0}!".Print(m.GetBody().Name);
return null;
});
mqServer.Start();
using (var mqClient = mqServer.CreateMessageQueueClient())
{
mqClient.Publish(new Hello { Name = "World" });
IMessage<Hello> msgCopy = mqClient.Get<Hello>(QueueNames<Hello>.Out);
mqClient.Ack(msgCopy);
Assert.That(msgCopy.GetBody().Name, Is.EqualTo("World"));
}
}
}
public BusLifetime(
RabbitMqServer server,
ICommandDiscovery commandDiscovery,
IEventDiscovery eventDiscovery,
IEventRegistrar eventRegistrar,
ICommandRegistrar commandRegistrar,
ILogger <BusLifetime> logger)
{
_server = server;
_eventRegistrar = eventRegistrar;
_commandRegistrar = commandRegistrar;
_logger = logger;
commandDiscovery.Register(_commandRegistrar);
eventDiscovery.Register(_eventRegistrar);
_server.DisablePriorityQueues = true;
_server.DisablePublishingResponses = true;
_logger.Info("Starting RabbitMQ server");
_server.Start();
}
public object Any(HashGenerator request)
{
// Check if client id exists.
if (request.Subscriber == null)
{
throw new HttpError(HttpStatusCode.BadRequest, $"The request is not valid - subscriber is empty.");
}
;
var url = request.Url;
// Check if the url is valid.
// Since we don't really "use" the uri object, just create one inline.
var urlValidationResult = Uri.TryCreate(url, UriKind.Absolute, out var uriResult) &&
(uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps);
if (!urlValidationResult)
{
throw new HttpError(HttpStatusCode.BadRequest, $"The url '{url}' is not valid.");
}
;
var mqServer = new RabbitMqServer("localhost");
// dispatch a new thread for message queue processing
new Thread(() =>
{
using (var mqClient = mqServer.CreateMessageQueueClient())
{
mqClient.Publish(request);
var response = mqClient.Get <HashResponse>(QueueNames <HashResponse> .In);
mqClient.Ack(response);
// if there are any notification registered,
// push notification
_serverEvents.NotifyChannel("hash", response.Body);
}
}).Start();
return(null);
}
public override void Configure(Funq.Container container)
{
//SwaggerUI配置用于调试
AddPlugin(new SwaggerFeature());
//IOC配置
ServiceLocatorConfig.Configura(container);
//rabbitmq配置
var mq = new RabbitMqServer(ConfigurationManager.AppSettings.Get("EventProcessorAddress"))
{
AutoReconnect = true,
DisablePriorityQueues = true,
RetryCount = 0
};
container.Register<IMessageService>(c => mq);
var mqServer = container.Resolve<IMessageService>();
//注册eventHandler
mq.RegisterHandler<BuildOrderReady>(ServiceController.ExecuteMessage, 1);
mq.RegisterHandler<PaySuccessReady>(ServiceController.ExecuteMessage, 1);
mqServer.Start();
}
public EventBus(RabbitMqServer server)
{
_server = server;
}
public void Message_with_response_are_published_to_Response_inq()
{
using (var mqServer = new RabbitMqServer())
{
mqServer.RegisterHandler<Hello>(m =>
new HelloResponse { Result = "Hello, {0}!".Fmt(m.GetBody().Name) });
mqServer.Start();
using (var mqClient = mqServer.CreateMessageQueueClient())
{
mqClient.Publish(new Hello { Name = "World" });
IMessage<HelloResponse> responseMsg = mqClient.Get<HelloResponse>(QueueNames<HelloResponse>.In);
mqClient.Ack(responseMsg);
Assert.That(responseMsg.GetBody().Result, Is.EqualTo("Hello, World!"));
}
}
}
public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var jwtprovider = new JwtAuthProviderReader
{
HashAlgorithm = "RS256",
PublicKeyXml = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_JWT_PUBLIC_KEY_XML),
#if (DEBUG)
RequireSecureConnection = false,
//EncryptPayload = true,
#endif
};
this.Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[] {
jwtprovider,
}));
#if (DEBUG)
SetConfig(new HostConfig {
DebugMode = true
});
#endif
SetConfig(new HostConfig {
DefaultContentType = MimeTypes.Json
});
RabbitMqMessageFactory rabitFactory = new RabbitMqMessageFactory();
rabitFactory.ConnectionFactory.UserName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_USER);
rabitFactory.ConnectionFactory.Password = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PASSWORD);
rabitFactory.ConnectionFactory.HostName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_HOST);
rabitFactory.ConnectionFactory.Port = Convert.ToInt32(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PORT));
rabitFactory.ConnectionFactory.VirtualHost = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_VHOST);
var mqServer = new RabbitMqServer(rabitFactory);
mqServer.RetryCount = 1;
mqServer.RegisterHandler <ScheduleRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <DeleteJobRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <RescheduleRequest>(base.ExecuteMessage);
mqServer.Start();
container.AddScoped <IMessageProducer, RabbitMqProducer>(serviceProvider =>
{
return(mqServer.CreateMessageProducer() as RabbitMqProducer);
});
container.AddScoped <IMessageQueueClient, RabbitMqQueueClient>(serviceProvider =>
{
return(mqServer.CreateMessageQueueClient() as RabbitMqQueueClient);
});
//****************SCHEDULER********************
string conn = string.Format("Server = {0}; Database = {1}; Uid = {2}; Pwd = {3}; Trust Server Certificate=true; Port= {4}; Use SSL Stream=true; SSL Mode=Require;",
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_SERVER),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DBNAME),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_RW_USER),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_RW_PASSWORD),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_PORT));
var properties = new NameValueCollection
{
["quartz.serializer.type"] = "json",
["quartz.scheduler.instanceName"] = "DotnetCoreScheduler",
["quartz.scheduler.instanceId"] = "instance_one",
["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz",
["quartz.threadPool.threadCount"] = "5",
["quartz.jobStore.misfireThreshold"] = "60000",
["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz",
["quartz.jobStore.useProperties"] = "true",
["quartz.jobStore.dataSource"] = "myDS",
["quartz.jobStore.tablePrefix"] = "QRTZ_",
["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.PostgreSQLDelegate, Quartz",
["quartz.dataSource.myDS.provider"] = "Npgsql ",
["quartz.dataSource.myDS.connectionString"] = conn
};
StdSchedulerFactory factory = new Quartz.Impl.StdSchedulerFactory(properties);
IScheduler scheduler = factory.GetScheduler().Result;
scheduler.Start().Wait();
container.AddScoped <IScheduler>(serviceProvider =>
{
return(scheduler);
});
string env = Environment.GetEnvironmentVariable(EnvironmentConstants.ASPNETCORE_ENVIRONMENT);
var redisServer = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_SERVER);
var redisPassword = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PASSWORD);
var redisPort = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PORT);
RedisClient client = null;
//if (env == "Staging")
//{
// client = new RedisClient(redisServer, Convert.ToInt32(redisPort));
//}
//else
//{
client = new RedisClient(string.Format("redis://{0}@{1}:{2}", redisPassword, redisServer, redisPort));
//}
//Setting Assembly version in Redis
AssemblyName assembly = Assembly.GetExecutingAssembly().GetName();
String version = assembly.Name.ToString() + " - " + assembly.Version.ToString();
client.Set("SchedulerAssembly", version);
this.GlobalRequestFilters.Add((req, res, requestDto) =>
{
ILog log = LogManager.GetLogger(GetType());
log.Info("In GlobalRequestFilters");
try
{
log.Info("In Try");
if (requestDto != null)
{
log.Info("In Auth Header");
var auth = req.Headers[HttpHeaders.Authorization];
if (string.IsNullOrEmpty(auth))
{
res.ReturnAuthRequired();
}
else
{
if (req.Headers[CacheConstants.RTOKEN] != null)
{
Resolve <IEbServerEventClient>().AddAuthentication(req);
}
var jwtoken = new JwtSecurityToken(auth.Replace("Bearer", string.Empty).Trim());
foreach (var c in jwtoken.Claims)
{
if (c.Type == "cid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add(CoreConstants.SOLUTION_ID, c.Value);
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).SolnId = c.Value;
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).SolnId = c.Value;
}
continue;
}
if (c.Type == "uid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("UserId", Convert.ToInt32(c.Value));
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).UserId = Convert.ToInt32(c.Value);
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserId = Convert.ToInt32(c.Value);
}
continue;
}
if (c.Type == "wc" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("wc", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).WhichConsole = c.Value.ToString();
}
continue;
}
if (c.Type == "sub" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("sub", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserAuthId = c.Value.ToString();
}
continue;
}
}
log.Info("Req Filter Completed");
}
}
}
catch (Exception e)
{
log.Info("ErrorStackTraceNontokenServices..........." + e.StackTrace);
log.Info("ErrorMessageNontokenServices..........." + e.Message);
log.Info("InnerExceptionNontokenServices..........." + e.InnerException);
}
});
}
public CommandRegistrar(RabbitMqServer server, IServiceProvider serviceProvider, ILogger <CommandRegistrar> logger)
{
_server = server;
_serviceProvider = serviceProvider;
_logger = logger;
}
public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var jwtprovider = new JwtAuthProviderReader
{
HashAlgorithm = "RS256",
PublicKeyXml = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_JWT_PUBLIC_KEY_XML),
RequireSecureConnection = false,
//EncryptPayload = true,
};
this.Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[] {
jwtprovider,
}));
#if (DEBUG)
SetConfig(new HostConfig {
DebugMode = true
});
#endif
SetConfig(new HostConfig {
DefaultContentType = MimeTypes.Json
});
string env = Environment.GetEnvironmentVariable(EnvironmentConstants.ASPNETCORE_ENVIRONMENT);
var redisServer = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_SERVER);
var redisPassword = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PASSWORD);
var redisPort = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PORT);
RedisClient client = null;
string redisConnectionString = string.Format("redis://{0}@{1}:{2}", redisPassword, redisServer, redisPort);
container.Register <IRedisClientsManager>(c => new RedisManagerPool(redisConnectionString));
client = (container.Resolve <IRedisClientsManager>() as RedisManagerPool).GetClient() as RedisClient;
AssemblyName assembly = Assembly.GetExecutingAssembly().GetName();
String version = assembly.Name.ToString() + " - " + assembly.Version.ToString();
client.Set("MQAssembly", version);
container.Register <IEbServerEventClient>(c => new EbServerEventClient()).ReusedWithin(ReuseScope.Request);
container.Register <IServiceClient>(c => new JsonServiceClient(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_SERVICESTACK_EXT_URL))).ReusedWithin(ReuseScope.Request);
container.Register <IEbConnectionFactory>(c => new EbConnectionFactory(c)).ReusedWithin(ReuseScope.Request);
container.Register <IEbStaticFileClient>(c => new EbStaticFileClient()).ReusedWithin(ReuseScope.Request);
RabbitMqMessageFactory rabitFactory = new RabbitMqMessageFactory();
rabitFactory.ConnectionFactory.UserName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_USER);
rabitFactory.ConnectionFactory.Password = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PASSWORD);
rabitFactory.ConnectionFactory.HostName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_HOST);
rabitFactory.ConnectionFactory.Port = Convert.ToInt32(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PORT));
rabitFactory.ConnectionFactory.VirtualHost = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_VHOST);
var mqServer = new RabbitMqServer(rabitFactory);
mqServer.RetryCount = 1;
mqServer.RegisterHandler <RefreshSolutionConnectionsRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadFileRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadImageRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadImageInfraMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadDpRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadLogoRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <NotificationToDBRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SaveRoleMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SaveUserMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SuspendUserMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <BrowserExceptionRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SaveUserGroupMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<GetImageFtpRequest>(base.ExecuteMessage, 3);
mqServer.RegisterHandler <EmailServicesRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SMSSentRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <ApiMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<SMSStatusLogMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<SlackPostMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<SlackAuthMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <ReportRenderMultipleMQRequest>(base.ExecuteMessage);
mqServer.Start();
container.AddScoped <IMessageProducer, RabbitMqProducer>(serviceProvider =>
{
return(mqServer.CreateMessageProducer() as RabbitMqProducer);
});
container.AddScoped <IMessageQueueClient, RabbitMqQueueClient>(serviceProvider =>
{
return(mqServer.CreateMessageQueueClient() as RabbitMqQueueClient);
});
//var quartzFeature = new QuartzFeature();
//// create a simple job trigger to repeat every minute
//quartzFeature.RegisterJob<MyJob>(
// trigger =>
// trigger.WithSimpleSchedule(s =>
// s.WithInterval(TimeSpan.FromSeconds(30))
// .RepeatForever()
// )
// .Build()
//);
//quartzFeature.RegisterJob<MyJob>(
// trigger =>
// trigger.WithDailyTimeIntervalSchedule(s => s.WithInterval(1, IntervalUnit.Minute))
// .Build()
//);
//// register the plugin
//Plugins.Add(quartzFeature);
this.GlobalRequestFilters.Add((req, res, requestDto) =>
{
ILog log = LogManager.GetLogger(GetType());
log.Info("In GlobalRequestFilters");
try
{
log.Info("In Try");
if (requestDto != null /*&& requestDto.GetType() != typeof(RefreshSolutionExtRequest)*/)
{
log.Info("In Auth Header");
var auth = req.Headers[HttpHeaders.Authorization];
if (string.IsNullOrEmpty(auth))
{
res.ReturnAuthRequired();
}
else
{
if (req.Headers[CacheConstants.RTOKEN] != null)
{
Resolve <IEbServerEventClient>().AddAuthentication(req);
}
var jwtoken = new JwtSecurityToken(auth.Replace("Bearer", string.Empty).Trim());
foreach (var c in jwtoken.Claims)
{
if (c.Type == "cid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add(CoreConstants.SOLUTION_ID, c.Value);
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).SolnId = c.Value;
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).SolnId = c.Value;
}
continue;
}
if (c.Type == "uid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("UserId", Convert.ToInt32(c.Value));
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).UserId = Convert.ToInt32(c.Value);
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserId = Convert.ToInt32(c.Value);
}
continue;
}
if (c.Type == "wc" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("wc", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).WhichConsole = c.Value.ToString();
}
continue;
}
if (c.Type == "sub" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("sub", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserAuthId = c.Value.ToString();
}
continue;
}
}
log.Info("Req Filter Completed");
}
}
}
catch (Exception e)
{
log.Info("ErrorStackTraceNontokenServices..........." + e.StackTrace);
log.Info("ErrorMessageNontokenServices..........." + e.Message);
log.Info("InnerExceptionNontokenServices..........." + e.InnerException);
}
});
}
public Registrar(RabbitMqServer server, IServiceProvider serviceProvider, ILogger <BusLifetime> logger)
{
_server = server;
_serviceProvider = serviceProvider;
_logger = logger;
}
public EventRegistrar(RabbitMqServer server, IServiceProvider serviceProvider, ILogger <EventRegistrar> logger)
{
_server = server;
_serviceProvider = serviceProvider;
_logger = logger;
}
public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var jwtprovider = new JwtAuthProviderReader
{
HashAlgorithm = "RS256",
PublicKeyXml = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_JWT_PUBLIC_KEY_XML),
#if (DEBUG)
RequireSecureConnection = false,
//EncryptPayload = true,
#endif
};
this.Plugins.Add(new CorsFeature(allowedHeaders: "rToken, bToken, Content-Type, Authorization, Access-Control-Allow-Origin, Access-Control-Allow-Credentials"));
this.Plugins.Add(new ServerEventsFeature());
this.Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[] {
jwtprovider,
}));
#if (DEBUG)
SetConfig(new HostConfig {
DebugMode = true
});
#endif
SetConfig(new HostConfig {
DefaultContentType = MimeTypes.Json
});
string env = Environment.GetEnvironmentVariable(EnvironmentConstants.ASPNETCORE_ENVIRONMENT);
var redisServer = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_SERVER);
var redisPassword = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PASSWORD);
var redisPort = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PORT);
//if (env == "Staging")
//{
// container.Register<IRedisClientsManager>(c => new RedisManagerPool(redisServer));
//}
//else
//{
var redisConnectionString = string.Format("redis://{0}@{1}:{2}", redisPassword, redisServer, redisPort);
container.Register <IRedisClientsManager>(c => new RedisManagerPool(redisConnectionString));
//}
container.Register <IUserAuthRepository>(c => new MyRedisAuthRepository(c.Resolve <IRedisClientsManager>()));
container.Register <IEbMqClient>(c => new EbMqClient()).ReusedWithin(ReuseScope.Request);
RabbitMqMessageFactory rabitFactory = new RabbitMqMessageFactory();
rabitFactory.ConnectionFactory.UserName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_USER);
rabitFactory.ConnectionFactory.Password = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PASSWORD);
rabitFactory.ConnectionFactory.HostName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_HOST);
rabitFactory.ConnectionFactory.Port = Convert.ToInt32(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PORT));
rabitFactory.ConnectionFactory.VirtualHost = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_VHOST);
var mqServer = new RabbitMqServer(rabitFactory);
container.AddScoped <IMessageProducer, RabbitMqProducer>(serviceProvider =>
{
return(mqServer.CreateMessageProducer() as RabbitMqProducer);
});
container.Register <IServerEvents>(c => new RedisServerEvents(c.Resolve <IRedisClientsManager>()));
container.Resolve <IServerEvents>().Start();
//Setting Assembly version in Redis
RedisClient client = (container.Resolve <IRedisClientsManager>() as RedisManagerPool).GetClient() as RedisClient;
AssemblyName assembly = Assembly.GetExecutingAssembly().GetName();
String version = assembly.Name.ToString() + " - " + assembly.Version.ToString();
client.Set("ServerEventsAssembly", version);
this.GlobalRequestFilters.Add((req, res, requestDto) =>
{
ILog log = LogManager.GetLogger(GetType());
log.Info("In GlobalRequestFilters");
try
{
log.Info("In Try");
if (requestDto != null)
{
log.Info("In Auth Header");
var auth = req.Headers[HttpHeaders.Authorization];
if (string.IsNullOrEmpty(auth))
{
res.ReturnAuthRequired();
}
else
{
if (req.Headers[CacheConstants.RTOKEN] != null)
{
log.Info("Req Headers Not Null");
}
var jwtoken = new JwtSecurityToken(auth.Replace("Bearer", string.Empty).Trim());
foreach (var c in jwtoken.Claims)
{
if (c.Type == "cid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add(CoreConstants.SOLUTION_ID, c.Value);
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).SolnId = c.Value;
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).SolnId = c.Value;
}
continue;
}
if (c.Type == "uid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("UserId", Convert.ToInt32(c.Value));
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).UserId = Convert.ToInt32(c.Value);
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserId = Convert.ToInt32(c.Value);
}
continue;
}
if (c.Type == "wc" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("wc", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).WhichConsole = c.Value.ToString();
}
continue;
}
if (c.Type == "sub" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("sub", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserAuthId = c.Value.ToString();
}
continue;
}
}
log.Info("Req Filter Completed");
}
}
}
catch (Exception e)
{
log.Info("ErrorStackTraceNontokenServices..........." + e.StackTrace);
log.Info("ErrorMessageNontokenServices..........." + e.Message);
log.Info("InnerExceptionNontokenServices..........." + e.InnerException);
}
});
}
public void Message_with_ReplyTo_are_published_to_the_ReplyTo_queue()
{
using (var mqServer = new RabbitMqServer())
{
mqServer.RegisterHandler<Hello>(m =>
new HelloResponse { Result = "Hello, {0}!".Fmt(m.GetBody().Name) });
mqServer.Start();
using (var mqClient = mqServer.CreateMessageQueueClient())
{
const string replyToMq = "mq:Hello.replyto";
mqClient.Publish(new Message<Hello>(new Hello { Name = "World" }) {
ReplyTo = replyToMq
});
IMessage<HelloResponse> responseMsg = mqClient.Get<HelloResponse>(replyToMq);
mqClient.Ack(responseMsg);
Assert.That(responseMsg.GetBody().Result, Is.EqualTo("Hello, World!"));
}
}
}
public override void Configure(Container container)
{
var co = this.Config;
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var jwtprovider = new MyJwtAuthProvider(AppSettings)
{
HashAlgorithm = "RS256",
PrivateKeyXml = EbLiveSettings.PrivateKeyXml,
PublicKeyXml = EbLiveSettings.PublicKeyXml,
#if (DEBUG)
RequireSecureConnection = false,
//EncryptPayload = true,
#endif
CreatePayloadFilter = (payload, session) =>
{
payload["sub"] = (session as CustomUserSession).UserAuthId;
payload["cid"] = (session as CustomUserSession).CId;
payload["uid"] = (session as CustomUserSession).Uid.ToString();
payload["wc"] = (session as CustomUserSession).WhichConsole;
},
ExpireTokensIn = TimeSpan.FromHours(10),
ExpireRefreshTokensIn = TimeSpan.FromHours(12),
PersistSession = true,
SessionExpiry = TimeSpan.FromHours(12)
};
this.Plugins.Add(new CorsFeature(allowedHeaders: "Content-Type, Authorization, Access-Control-Allow-Origin, Access-Control-Allow-Credentials"));
this.Plugins.Add(new ProtoBufFormat());
Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[] {
new MyFacebookAuthProvider(AppSettings)
{
AppId = "151550788692231",
AppSecret = "94ec1a04342e5cf7e7a971f2eb7ad7bc",
Permissions = new string[] { "email, public_profile" }
},
new MyTwitterAuthProvider(AppSettings)
{
ConsumerKey = "6G9gaYo7DMx1OHYRAcpmkPfvu",
ConsumerSecret = "Jx8uUIPeo5D0agjUnqkKHGQ4o6zTrwze9EcLtjDlOgLnuBaf9x",
// CallbackUrl = "http://*****:*****@{1}:{2}?ssl=true",
EbLiveSettings.RedisPassword, EbLiveSettings.RedisServer, EbLiveSettings.RedisPort);
container.Register <IRedisClientsManager>(c => new RedisManagerPool(redisConnectionString));
container.Register <IUserAuthRepository>(c => new EbRedisAuthRepository(c.Resolve <IRedisClientsManager>()));
container.Register <JwtAuthProvider>(jwtprovider);
container.Register <ITenantDbFactory>(c => new TenantDbFactory(c)).ReusedWithin(ReuseScope.Request);
RabbitMqMessageFactory rabitFactory = new RabbitMqMessageFactory();
rabitFactory.ConnectionFactory.UserName = EbLiveSettings.RabbitUser;
rabitFactory.ConnectionFactory.Password = EbLiveSettings.RabbitPassword;
rabitFactory.ConnectionFactory.HostName = EbLiveSettings.RabbitHost;
rabitFactory.ConnectionFactory.Port = EbLiveSettings.RabbitPort;
rabitFactory.ConnectionFactory.VirtualHost = EbLiveSettings.RabbitVHost;
var mqServer = new RabbitMqServer(rabitFactory);
mqServer.RetryCount = 1;
//mqServer.RegisterHandler<EmailServicesMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<RefreshSolutionConnectionsMqRequestTest>(base.ExecuteMessage);
//mqServer.RegisterHandler<UploadFileMqRequestTest>(base.ExecuteMessage);
//mqServer.RegisterHandler<ImageResizeMqRequestTest>(base.ExecuteMessage);
//mqServer.RegisterHandler<FileMetaPersistMqRequestTest>(base.ExecuteMessage);
//mqServer.RegisterHandler<SlackPostMqRequest>(base.ExecuteMessage);
////mqServer.RegisterHandler<SlackAuthMqRequest>(base.ExecuteMessage);
mqServer.Start();
container.AddScoped <IMessageProducer, RabbitMqProducer>(serviceProvider =>
{
return(mqServer.CreateMessageProducer() as RabbitMqProducer);
});
container.AddScoped <IMessageQueueClient, RabbitMqQueueClient>(serviceProvider =>
{
return(mqServer.CreateMessageQueueClient() as RabbitMqQueueClient);
});
//Add a request filter to check if the user has a session initialized
this.GlobalRequestFilters.Add((req, res, requestDto) =>
{
ILog log = LogManager.GetLogger(GetType());
log.Info("In GlobalRequestFilters");
try
{
if (requestDto.GetType() == typeof(Authenticate))
{
log.Info("In Authenticate");
string TenantId = (requestDto as Authenticate).Meta != null ? (requestDto as Authenticate).Meta["cid"] : "expressbase";
log.Info(TenantId);
RequestContext.Instance.Items.Add("TenantAccountId", TenantId);
}
}catch (Exception e)
{
log.Info("ErrorStackTrace..........." + e.StackTrace);
log.Info("ErrorMessage..........." + e.Message);
log.Info("InnerException..........." + e.InnerException);
}
try
{
if (requestDto != null && requestDto.GetType() != typeof(Authenticate) && requestDto.GetType() != typeof(GetAccessToken) && requestDto.GetType() != typeof(UniqueRequest) && requestDto.GetType() != typeof(CreateAccountRequest) && requestDto.GetType() != typeof(EmailServicesRequest) && requestDto.GetType() != typeof(RegisterRequest))
{
var auth = req.Headers[HttpHeaders.Authorization];
if (string.IsNullOrEmpty(auth))
{
res.ReturnAuthRequired();
}
else
{
var jwtoken = new JwtSecurityToken(auth.Replace("Bearer", string.Empty).Trim());
foreach (var c in jwtoken.Claims)
{
if (c.Type == "cid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("TenantAccountId", c.Value);
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).TenantAccountId = c.Value;
}
if (requestDto is EbServiceStackRequest)
{
(requestDto as EbServiceStackRequest).TenantAccountId = c.Value;
}
continue;
}
if (c.Type == "uid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("UserId", Convert.ToInt32(c.Value));
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).UserId = Convert.ToInt32(c.Value);
}
if (requestDto is EbServiceStackRequest)
{
(requestDto as EbServiceStackRequest).UserId = Convert.ToInt32(c.Value);
}
continue;
}
if (c.Type == "wc" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("wc", c.Value);
if (requestDto is EbServiceStackRequest)
{
(requestDto as EbServiceStackRequest).WhichConsole = c.Value.ToString();
}
continue;
}
}
}
}
}
catch (Exception e)
{
log.Info("ErrorStackTraceNontokenServices..........." + e.StackTrace);
log.Info("ErrorMessageNontokenServices..........." + e.Message);
log.Info("InnerExceptionNontokenServices..........." + e.InnerException);
}
});
this.GlobalResponseFilters.Add((req, res, responseDto) =>
{
if (responseDto.GetResponseDto() != null)
{
if (responseDto.GetResponseDto().GetType() == typeof(GetAccessTokenResponse))
{
res.SetSessionCookie("Token", (res.Dto as GetAccessTokenResponse).AccessToken);
}
}
});
}
public CommandBus(RabbitMqServer server)
{
_server = server;
}
