public void TestMQRedis() { var redisFactory = new PooledRedisClientManager("localhost:6379"); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); //Server - MQ Service Impl: mqHost.RegisterHandler <Hello>(m => { Trace.WriteLine("Received 1: " + m.GetBody()); return(new HelloResponse() { Result = "ten ten ten" }); }); //Client - Process Response: mqHost.RegisterHandler <HelloResponse>(m => { Trace.WriteLine($"Received 2: {m.GetBody().Result}: {DateTime.Now.ToString()}"); return(null); }); mqHost.Start(); //Producer - Start publishing messages: var mqClient = mqHost.CreateMessageQueueClient(); mqClient.Publish(new Hello { Name = "ServiceStack" }); Thread.Sleep(10000); Assert.True(true); }
public override void Configure(Container container) { //base.Routes // .Add<Hello>("/hello") // .Add<Hello>("/hello/{Name}"); container.Register(new ConsumerInfo() { Name = ServiceName }); var redisFactory = new PooledRedisClientManager("localhost:6379"); container.Register <IRedisClientsManager>(redisFactory); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); GlobalMessageRequestFilters.Add(MyGlobalRequestFilter); mqHost.RequestFilter = RequestFilter; mqHost.ResponseFilter = ResponseFilter; //Listens for 'Hello' messages sent with: mqClient.Publish(new Hello { ... }) mqHost.RegisterHandler <VehicleContainer>(base.ExecuteMessage); mqHost.RegisterHandler <tWorks.Alfa.AlfaCommons.Actors.Requests.GetLegitimationsForCustomer>(base.ExecuteMessage); mqHost.Start(); //Starts listening for messages }
RedisMqServer CreateServer() { using (var redis = new RedisClient()) redis.FlushAll(); var mqServer = new RedisMqServer(new BasicRedisClientManager()); mqServer.RegisterHandler <Sleep0>(m => new Sleep0 { Id = counter.Sleep0++ }); mqServer.RegisterHandler <Sleep10>(m => { Thread.Sleep(10); return(new Sleep10 { Id = counter.Sleep10++ }); }); mqServer.RegisterHandler <Sleep100>(m => { Thread.Sleep(100); return(new Sleep100 { Id = counter.Sleep100++ }); }); mqServer.RegisterHandler <Sleep1000>(m => { Thread.Sleep(1000); return(new Sleep1000 { Id = counter.Sleep1000++ }); }); return(mqServer); }
RedisMqServer CreateServer() { using (var redis = new RedisClient(TestConfig.SingleHost)) redis.FlushAll(); var mqServer = new RedisMqServer(TestConfig.BasicClientManger); mqServer.RegisterHandler <Sleep0>(m => new Sleep0 { Id = Interlocked.Increment(ref counter.Sleep0) }); mqServer.RegisterHandler <Sleep10>(m => { Thread.Sleep(10); return(new Sleep10 { Id = Interlocked.Increment(ref counter.Sleep10) }); }); mqServer.RegisterHandler <Sleep100>(m => { Thread.Sleep(100); return(new Sleep100 { Id = Interlocked.Increment(ref counter.Sleep100) }); }); mqServer.RegisterHandler <Sleep1000>(m => { Thread.Sleep(1000); return(new Sleep1000 { Id = Interlocked.Increment(ref counter.Sleep1000) }); }); return(mqServer); }
public static void Main(string[] args) { var redisFactory = new PooledRedisClientManager("139.59.75.204:6379"); var mqServer = new RedisMqServer(redisFactory, retryCount: 2); //Client - MQ Service Impl: //Listens for 'HelloResponse' returned by the 'Hello' Service mqServer.RegisterHandler <HelloResponse>(m => { Console.WriteLine("Received: " + m.GetBody().Result); // See comments below // m.Options = (int)MessageOption.None; return(null); }); //or to call an existing service with: //mqServer.RegisterHandler<HelloResponse>(m => // this.ServiceController.ExecuteMessage(m)); mqServer.Start(); //Starts listening for messages var mqClient = mqServer.CreateMessageQueueClient(); mqClient.Publish(new Hello { Name = "Client 1" }); Console.WriteLine("Client running. Press any key to terminate..."); Console.ReadLine(); //Prevent self-hosted Console App from exiting }
public RedisClient(string name) { Name = name; redisFactory = new PooledRedisClientManager("localhost:6379"); mqServer = new RedisMqServer(redisFactory, retryCount: 2); mqServer.RequestFilter = RequestFilter; //Client - MQ Service Impl: ////Listens for 'HelloResponse' returned by the 'Hello' Service mqServer.RegisterHandler <VehicleContainerResponse>(m => { return(m); }); mqServer.RegisterHandler <tWorks.Alfa.AlfaCommons.Actors.Requests.GetLegitimationsForCustomer>(m => { object o = m.GetBody().Result; OnServiceHandlerTriggered?.Invoke(this, $"{name}> Received {nameof(tWorks.Alfa.AlfaCommons.Actors.Requests.GetLegitimationsForCustomer)}Response?: {m.Body.Dump()}"); return(null); }); //or to call an existing service with: //mqServer.RegisterHandler<HelloResponse>(m => // this.ServiceController.ExecuteMessage(m)); mqServer.Start(); //Starts listening for messages }
RedisMqServer CreateServer() { using (var redis = new RedisClient()) redis.FlushAll(); var mqServer = new RedisMqServer(new BasicRedisClientManager()); mqServer.RegisterHandler<Spin0>(m => new Spin0 { Id = counter.Spin0++ }); mqServer.RegisterHandler<Spin10>(m => { var sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds < 10) Thread.SpinWait(100000); return new Spin10 { Id = counter.Spin10++ }; }); mqServer.RegisterHandler<Spin100>(m => { var sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds < 100) Thread.SpinWait(100000); return new Spin100 { Id = counter.Spin100++ }; }); mqServer.RegisterHandler<Spin1000>(m => { var sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds < 1000) Thread.SpinWait(100000); return new Spin1000 { Id = counter.Spin1000++ }; }); return mqServer; }
RedisMqServer CreateServer() { using (var redis = new RedisClient(TestConfig.SingleHost)) redis.FlushAll(); var mqServer = new RedisMqServer(TestConfig.BasicClientManger); mqServer.RegisterHandler<Spin0>(m => new Spin0 { Id = Interlocked.Increment(ref counter.Spin0) }); mqServer.RegisterHandler<Spin10>(m => { var sw = Stopwatch.StartNew(); SpinWait.SpinUntil(() => sw.ElapsedMilliseconds < 10); return new Spin10 { Id = Interlocked.Increment(ref counter.Spin10) }; }); mqServer.RegisterHandler<Spin100>(m => { var sw = Stopwatch.StartNew(); SpinWait.SpinUntil(() => sw.ElapsedMilliseconds < 100); return new Spin100 { Id = Interlocked.Increment(ref counter.Spin100) }; }); mqServer.RegisterHandler<Spin1000>(m => { var sw = Stopwatch.StartNew(); SpinWait.SpinUntil(() => sw.ElapsedMilliseconds < 1000); return new Spin1000 { Id = Interlocked.Increment(ref counter.Spin1000) }; }); return mqServer; }
public void post_transaction_ok_with_authentication() { var uniqueCallbackQ = "mq:c1" + ":" + Guid.NewGuid().ToString("N"); var transaction = new Transaction { Amount = 10.00m, Card = "XXXXXXXXXX124", CreateDate = DateTime.UtcNow, SubscriptionId = 101, GatewayTransactionId = "123456", TransactionTypeId = (long)TRANSACTION_TYPE.AuthorizeAndCapture, TransactionStatusId = (long)TRANSACTION_STATUS.Pending, GatewayResponse = "ok" }; var clientMsg = new Message <Transaction>(transaction) { ReplyTo = uniqueCallbackQ, Tag = "basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(DefaultAdmin.Username + ":" + DefaultAdmin.Password)) }; var redisFactory = new PooledRedisClientManager("localhost:6379"); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); var mqClient = mqHost.CreateMessageQueueClient(); mqClient.Publish(clientMsg); var response = mqClient.Get <PostResponse <Transaction> >(clientMsg.ReplyTo, new TimeSpan(0, 10, 10)); //Blocks thread on client until reply message is received var result = response.GetBody().Result; Assert.IsNotNull(result); Assert.IsTrue(result.Id > 0); }
public void Utils_publish_Rot13_messages() { var mqHost = new RedisMqServer(TestConfig.BasicClientManger, 2); var mqClient = mqHost.CreateMessageQueueClient(); Publish_4_Rot13_messages(mqClient); mqHost.Stop(); }
public override void Configure(Funq.Container container) { PathProvider.BinaryPath = "~".MapAbsolutePath(); ServiceStack.Text.JsConfig.EmitCamelCaseNames = true; RequestBinders.Add(typeof(CommitAttempt), request => new CommitAttempt() { UserAgent = request.Headers["User-Agent"], RawBody = request.GetRawBody() }); Routes .Add<CommitAttempt>("/commit") .Add<CommitMessages>("/commits") .Add<MessageErrors>("/errors") // //.Add<CommitMessage>("/commitMessage") ; var redisFactory = new PooledRedisClientManager("localhost:6379"); container.Register<IRedisClientsManager>(redisFactory); //var mqHost = new RedisMqHost(redisFactory); var mqHost = new RedisMqServer(redisFactory); container.Register<IMessageService>(mqHost); container.Register(mqHost.MessageFactory); mqHost.RegisterHandler<CommitAttempt>(ServiceController.ExecuteMessage); //mqHost.RegisterHandler<CommitMessage>(ServiceController.ExecuteMessage); mqHost.Start(); }
public override void Configure(Container container) { base.Routes .Add <RentalServiceTestCommand>("/rttest"); var redisFactory = new PooledRedisClientManager("localhost:6379"); container.Register <IRedisClientsManager>(redisFactory); var mqHost = new RedisMqServer(redisFactory, 2); var mqClient = mqHost.CreateMessageQueueClient(); mqHost.RegisterHandler <RentalServiceTestCommand>(m => { new RentalServiceTestCommandHandler().HandleMessage(m, mqClient); return(base.ExecuteMessage(m)); }); mqHost.RegisterHandler <AnotherRentalServiceTestCommand>(m => { new AnotherRetntalServiceTestCommandHandler().HandleMessage(m, mqClient); return(base.ExecuteMessage(m)); }); mqHost.RegisterHandler <StartRentalCommand>(m => { new StartRentalCommandHandler().HandleMessage(m, mqClient); return(base.ExecuteMessage(m)); }); mqHost.RegisterHandler <StopRentalCommand>(m => { new StopRentalCommandHandler().HandleMessage(m, mqClient); return(base.ExecuteMessage(m)); }); mqHost.Start(); }
private readonly IRedisClientsManager clientsManager; //Thread safe redis client/conn factory public RedisQueueHandlerWorker(IRedisClientsManager clientsManager, RedisMqServer mqServer, string queueName, Action<IQueueHandlerBackgroundWorker, Exception> errorHandler) : base(queueName, errorHandler) { if (clientsManager == null) throw new ArgumentNullException("clientsManager"); if (mqServer == null) throw new ArgumentNullException("mqServer"); this.clientsManager = clientsManager; this.MqServer = mqServer; }
public override void Configure(Container container) { container.RegisterAutoWired <EmailProvider>(); container.RegisterAutoWired <FacebookGateway>(); container.RegisterAutoWired <TwitterGateway>(); Plugins.Add(new RazorFormat()); Plugins.Add(new RequestLogsFeature()); var appSettings = new AppSettings(); Plugins.Add(new AuthFeature(() => new CustomSession(), new IAuthProvider[] { new CredentialsAuthProvider(appSettings), new TwitterAuthProvider(appSettings), new FacebookAuthProvider(appSettings), })); container.Register <IRedisClientsManager>(new PooledRedisClientManager("localhost:6379")); container.Register(c => c.Resolve <IRedisClientsManager>().GetCacheClient()); container.Register <IDbConnectionFactory>( new OrmLiteConnectionFactory("~/App_Data/db.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }); //Store User Data into above OrmLite database container.Register <IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())); //If using and RDBMS to persist UserAuth, we must create required tables var authRepo = container.Resolve <IAuthRepository>(); authRepo.InitSchema(); //Register MQ Service var mqService = new RedisMqServer(container.Resolve <IRedisClientsManager>()); container.Register <IMessageService>(mqService); container.Register(mqService.MessageFactory); mqService.RegisterHandler <SMessage>(ServiceController.ExecuteMessage); mqService.RegisterHandler <CallFacebook>(ServiceController.ExecuteMessage); mqService.RegisterHandler <EmailMessage>(ServiceController.ExecuteMessage); mqService.RegisterHandler <PostStatusTwitter>(ServiceController.ExecuteMessage); mqService.Start(); if (appSettings.Get("ResetAllOnStartUp", false)) { ResetAll(container, (OrmLiteAuthRepository)authRepo); } }
public void Can_MqServer_recover_from_server_terminated_client_connections() { LogManager.LogFactory = new ConsoleLogFactory(); var clientManager = new PooledRedisClientManager(new[] { "localhost" }) { CheckConnected = true }; var mqHost = new RedisMqServer(clientManager, retryCount: 2); var sum = 0; mqHost.RegisterHandler<Incr>(c => { var dto = c.GetBody(); sum += dto.Value; "Received {0}, sum: {1}".Print(dto.Value, sum); return null; }); mqHost.Start(); 10.Times(i => { ThreadPool.QueueUserWorkItem(x => { using (var client = mqHost.CreateMessageQueueClient()) { "Publish: {0}...".Print(i); client.Publish(new Incr { Value = i }); Thread.Sleep(10); } }); }); ThreadPool.QueueUserWorkItem(_ => { using (var client = (RedisClient)clientManager.GetClient()) { client.SetConfig("timeout", "1"); var clientAddrs = client.GetClientList().ConvertAll(x => x["addr"]); "Killing clients: {0}...".Print(clientAddrs.Dump()); clientAddrs.ForEach(client.ClientKill); } }); 20.Times(i => { using (var client = mqHost.CreateMessageQueueClient()) { "Publish: {0}...".Print(i); client.Publish(new Incr { Value = i }); } Thread.Sleep(2000); }); }
public void Attach(Container container) { var messageService = new RedisMqServer(container.Resolve <IRedisClientsManager>()); foreach (var handlerRegistration in _handlerRegistrations) { handlerRegistration(messageService, container); } container.Register <IMessageService>(messageService); messageService.Start(); }
public override void Configure(Container container) { container.RegisterAutoWired<EmailProvider>(); container.RegisterAutoWired<FacebookGateway>(); container.RegisterAutoWired<TwitterGateway>(); Plugins.Add(new RazorFormat()); Plugins.Add(new RequestLogsFeature()); var appSettings = new AppSettings(); Plugins.Add(new AuthFeature(() => new CustomSession(), new IAuthProvider[] { new CredentialsAuthProvider(appSettings), new TwitterAuthProvider(appSettings), new FacebookAuthProvider(appSettings), })); container.Register<IRedisClientsManager>(new PooledRedisClientManager("localhost:6379")); container.Register(c => c.Resolve<IRedisClientsManager>().GetCacheClient()); container.Register<IDbConnectionFactory>( new OrmLiteConnectionFactory("~/App_Data/db.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }); //Store User Data into above OrmLite database container.Register<IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>())); //If using and RDBMS to persist UserAuth, we must create required tables var authRepo = container.Resolve<IAuthRepository>(); authRepo.InitSchema(); //Register MQ Service var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>()); container.Register<IMessageService>(mqService); container.Register(mqService.MessageFactory); mqService.RegisterHandler<SMessage>(ServiceController.ExecuteMessage); mqService.RegisterHandler<CallFacebook>(ServiceController.ExecuteMessage); mqService.RegisterHandler<EmailMessage>(ServiceController.ExecuteMessage); mqService.RegisterHandler<PostStatusTwitter>(ServiceController.ExecuteMessage); mqService.Start(); if (appSettings.Get("ResetAllOnStartUp", false)) { ResetAll(container, (OrmLiteAuthRepository)authRepo); } }
private static RedisMqServer 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 RedisMqServer(redisFactory, noOfRetries); return mqHost; }
public static bool RunMqInLoop(RedisMqServer mqServer, int iterations = 100, int sleepMs = 10, Action callback = null) { int count = 0; int errors = 0; 10.Times(i => { ThreadPool.QueueUserWorkItem(_ => { while (Interlocked.Decrement(ref iterations) >= 0) { using (var client = mqServer.CreateMessageQueueClient()) { try { var redis = (RedisNativeClient)((RedisMessageQueueClient)client).ReadWriteClient; client.Publish(new Msg { Host = redis.Host + ":" + redis.Port }); Interlocked.Increment(ref count); if (count % (iterations / 10) == 0) { lock (mqServer) "count: {0}, errors: {1}".Print(count, errors); } } catch (Exception ex) { Interlocked.Increment(ref errors); } Thread.Sleep(sleepMs); } } lock (mqServer) { if (callback != null) { callback(); callback = null; } } }); }); return(true); }
private static RedisMqServer 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 RedisMqServer(redisFactory, noOfRetries); return(mqHost); }
public override void Configure(Container container) { var redisFactory = new PooledRedisClientManager("localhost:6379"); container.Register <IRedisClientsManager>(redisFactory); var mqHost = new RedisMqServer(redisFactory, 2); var mqClient = mqHost.CreateMessageQueueClient(); mqHost.RegisterHandler <CreateInvoiceCommand>(m => { new CreateInvoiceCommandHandler().HandleMessage(m, mqClient); return(base.ExecuteMessage(m)); }); mqHost.Start(); }
public RedisMqServer Configure() { var redisFactory = new PooledRedisClientManager("localhost:6379"); var mqServer = new RedisMqServer(redisFactory, retryCount: 2); mqServer.RegisterHandler <RentalServiceTestCommandResponse>(m => { new RentalServiceTestCommandResponseHandler().HandleMessage(m); return(null); }); mqServer.RegisterHandler <AnotherRentalServiceTestCommandResponse>(m => { new AnotherRentalServiceTestCommandResponseHandler().HandleMessage(m); return(null); }); return(mqServer); }
public override void Configure(Container container) { var configurationBuilder = new ConfigurationBuilder() .SetBasePath(AppContext.BaseDirectory) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); AppSettings = new NetCoreAppSettings(configurationBuilder.Build()); var redisFactory = new PooledRedisClientManager( AppSettings.GetString(AppSettingsKeys.RedisConnection)); var mqServer = new RedisMqServer(redisFactory, retryCount: AppSettings.Get <int>(AppSettingsKeys.RedisRetries)); var cacheClient = redisFactory.GetCacheClient(); var jobGroupId = AppSettings.GetString(AppSettingsKeys.JobGroupId); var jobCompletedCacheKey = CacheKeys.JobCompleted <JobResponse>(jobGroupId); var numberOfJobs = AppSettings.Get <int>(AppSettingsKeys.NumberOfJobs); cacheClient.Remove(jobCompletedCacheKey); mqServer.RegisterHandler <JobResponse>(m => { Console.WriteLine("Received: " + m.GetBody().Result); cacheClient.Increment(jobCompletedCacheKey, 1); if (cacheClient.Get <int>(jobCompletedCacheKey) >= numberOfJobs) { appLifetime.StopApplication(); } return(null); }); AfterInitCallbacks.Add(host => { mqServer.Start(); var mqClient = mqServer.CreateMessageQueueClient(); for (var i = 1; i <= numberOfJobs; i++) { mqClient.Publish(new JobRequest { JobId = Guid.NewGuid().ToString(), GroupId = jobGroupId, Description = $"Job {i}" }); } }); }
RedisMqServer CreateServer() { using (var redis = new RedisClient(TestConfig.SingleHost)) redis.FlushAll(); var mqServer = new RedisMqServer(TestConfig.BasicClientManger); mqServer.RegisterHandler <Spin0>(m => new Spin0 { Id = counter.Spin0++ }); mqServer.RegisterHandler <Spin10>(m => { var sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds < 10) { Thread.SpinWait(100000); } return(new Spin10 { Id = counter.Spin10++ }); }); mqServer.RegisterHandler <Spin100>(m => { var sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds < 100) { Thread.SpinWait(100000); } return(new Spin100 { Id = counter.Spin100++ }); }); mqServer.RegisterHandler <Spin1000>(m => { var sw = Stopwatch.StartNew(); while (sw.ElapsedMilliseconds < 1000) { Thread.SpinWait(100000); } return(new Spin1000 { Id = counter.Spin1000++ }); }); return(mqServer); }
/// <summary> /// Application specific configuration /// This method should initialize any IoC resources utilized by your web service classes. /// </summary> public override void Configure(Container container) { //Config examples //this.Plugins.Add(new PostmanFeature()); //this.Plugins.Add(new CorsFeature()); Routes.Add <ISO8583>(Common.Constants.PUSH_TO_MQ_URL); var redisFactory = new PooledRedisClientManager(Common.Constants.MQ_SERVER_ADDRESS); container.Register <IRedisClientsManager>(redisFactory); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); //Server - MQ Service Impl: //Listens for 'Hello' messages sent with: mqClient.Publish(new Hello { ... }) mqHost.RegisterHandler <ISO8583>(base.ExecuteMessage); mqHost.Start(); //Starts listening for messages }
public void can_call_an_unauthenticated_method() { var uniqueCallbackQ = "mq:c1" + ":" + Guid.NewGuid().ToString("N"); var clientMsg = new Message<GetFactorial>(new GetFactorial {ForNumber = 2}) { ReplyTo = uniqueCallbackQ }; var redisFactory = new PooledRedisClientManager("localhost:6379"); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); var mqClient = mqHost.CreateMessageQueueClient(); mqClient.Publish(clientMsg); var response = mqClient.Get<GetFactorialResponse>(clientMsg.ReplyTo, new TimeSpan(0, 0, 10)); //Blocks thread on client until reply message is received Assert.IsNotNull(response); Assert.AreEqual(2, response.GetBody().Result); }
public override void Configure(Container container) { var configurationBuilder = new ConfigurationBuilder() .SetBasePath(AppContext.BaseDirectory) .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true); AppSettings = new NetCoreAppSettings(configurationBuilder.Build()); var redisFactory = new PooledRedisClientManager( AppSettings.GetString(AppSettingsKeys.RedisConnection)); var mqServer = new RedisMqServer(redisFactory, retryCount: AppSettings.Get <int>(AppSettingsKeys.RedisRetries)); mqServer.RegisterHandler <JobRequest>(base.ExecuteMessage); AfterInitCallbacks.Add(host => { mqServer.Start(); }); }
public static bool RunMqInLoop(RedisMqServer mqServer, int iterations = 100, int sleepMs = 10, Action callback = null) { int count = 0; int errors = 0; 10.Times(i => { ThreadPool.QueueUserWorkItem(_ => { while (Interlocked.Decrement(ref iterations) >= 0) { using (var client = mqServer.CreateMessageQueueClient()) { try { var redis = (RedisNativeClient)((RedisMessageQueueClient)client).ReadWriteClient; client.Publish(new Msg { Host = redis.Host + ":" + redis.Port }); Interlocked.Increment(ref count); if (count % (iterations / 10) == 0) lock (mqServer) "count: {0}, errors: {1}".Print(count, errors); } catch (Exception ex) { Interlocked.Increment(ref errors); } Thread.Sleep(sleepMs); } } lock (mqServer) { if (callback != null) { callback(); callback = null; } } }); }); return true; }
public void can_call_an_authenticated_method() { var uniqueCallbackQ = "mq:c1" + ":" + Guid.NewGuid().ToString("N"); var clientMsg = new Message<Secure>(new Secure()) { ReplyTo = uniqueCallbackQ, Tag = "basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(SystemConstants.AllowedUser + ":" + SystemConstants.AllowedPass)) }; var redisFactory = new PooledRedisClientManager("localhost:6379"); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); var mqClient = mqHost.CreateMessageQueueClient(); mqClient.Publish(clientMsg); var response = mqClient.Get<SecureResponse>(clientMsg.ReplyTo, new TimeSpan(0, 0, 10)); //Blocks thread on client until reply message is received Assert.IsNotNull(response); Assert.AreEqual("Confidential", response.GetBody().Result); }
public override void Configure(Container container) { //base.Routes // .Add<Hello>("/hello") // .Add<Hello>("/hello/{Name}"); var redisFactory = new PooledRedisClientManager("139.59.75.204:6379"); container.Register <IRedisClientsManager>(redisFactory); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); //Server - MQ Service Impl: //Listens for 'Hello' messages sent with: mqClient.Publish(new Hello { ... }) mqHost.RegisterHandler <Hello>(base.ExecuteMessage); mqHost.RegisterHandler <EmailRequest>(base.ExecuteMessage); mqHost.Start(); //Starts listening for messages }
public override void Configure(Container container) { LogManager.LogFactory = new ConsoleLogFactory(); SetConfig(new HostConfig { DebugMode = true, HandlerFactoryPath = "lbr-api", }); Plugins.RemoveAll(x => x is HtmlFormat); Plugins.Add(new InfoFormat()); Plugins.Add(new CorsFeature()); var appConfig = new AppConfig(new AppSettings()); var url = appConfig.MongoURI; var conventions = new ConventionPack { new IgnoreExtraElementsConvention(true) }; ConventionRegistry.Register("IgnoreExtraElements", conventions, _ => true); container.Register <Store> (new Store(url)); container.Register <IInformant> (new Informant()); container.Register <IHtmlBodyMail> (new HtmlBodyMail()); container.Register <AppConfig> (appConfig); var redisFactory = new BasicRedisClientManager(appConfig.RedisURL); container.Register <IRedisClientsManager>(redisFactory); // req. to log exceptions in redis var mqServer = new RedisMqServer(container.Resolve <IRedisClientsManager>()); container.Register <IMessageService>(mqServer); container.Register(mqServer.MessageFactory); mqServer.RegisterHandler <CreateDiagnosticoInfo> (ServiceController.ExecuteMessage); mqServer.Start(); }
public override void Configure(Container container) { base.Routes .Add <Hello>("/hello") .Add <Hello>("/hello/{Name}"); var redisFactory = new PooledRedisClientManager("localhost:6379"); container.Register <IRedisClientsManager>(redisFactory); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); //Server - MQ Service Impl: //Listens for 'Hello' messages sent with: mqClient.Publish(new Hello { ... }) //mqHost.RegisterHandler<Hello>(base.ExecuteMessage); mqHost.RegisterHandler <Hello>(m => new HelloResponse { Result = "Hello, " + m.GetBody().Name } ); mqHost.Start(); //Starts listening for messages }
RedisMqServer CreateServer() { using (var redis = new RedisClient(TestConfig.SingleHost)) redis.FlushAll(); var mqServer = new RedisMqServer(TestConfig.BasicClientManger); mqServer.RegisterHandler<Sleep0>(m => new Sleep0 { Id = counter.Sleep0++ }); mqServer.RegisterHandler<Sleep10>(m => { Thread.Sleep(10); return new Sleep10 { Id = counter.Sleep10++ }; }); mqServer.RegisterHandler<Sleep100>(m => { Thread.Sleep(100); return new Sleep100 { Id = counter.Sleep100++ }; }); mqServer.RegisterHandler<Sleep1000>(m => { Thread.Sleep(1000); return new Sleep1000 { Id = counter.Sleep1000++ }; }); return mqServer; }
public static IHostBuilder CreateHostBuilder(string[] args) => Host.CreateDefaultBuilder(args) .ConfigureServices((hostContext, services) => { AppHost = new GenericAppHost(typeof(MyService).Assembly) { ConfigureAppHost = host => { host.Register <IRedisClientsManager>( new RedisManagerPool(hostContext.Configuration.GetConnectionString("RedisMq"))); var mqServer = new RedisMqServer(host.Resolve <IRedisClientsManager>()) { DisablePublishingToOutq = true, }; mqServer.RegisterHandler <Hello>(host.ExecuteMessage); host.Register <IMessageService>(mqServer); } }.Init(); services.AddSingleton(AppHost.Resolve <IRedisClientsManager>()); services.AddSingleton(AppHost.Resolve <IMessageService>()); services.AddHostedService <MqWorker>(); });
RedisMqServer CreateServer() { using (var redis = new RedisClient(TestConfig.SingleHost)) redis.FlushAll(); var mqServer = new RedisMqServer(TestConfig.BasicClientManger); mqServer.RegisterHandler <Spin0>(m => new Spin0 { Id = Interlocked.Increment(ref counter.Spin0) }); mqServer.RegisterHandler <Spin10>(m => { var sw = Stopwatch.StartNew(); SpinWait.SpinUntil(() => sw.ElapsedMilliseconds < 10); return(new Spin10 { Id = Interlocked.Increment(ref counter.Spin10) }); }); mqServer.RegisterHandler <Spin100>(m => { var sw = Stopwatch.StartNew(); SpinWait.SpinUntil(() => sw.ElapsedMilliseconds < 100); return(new Spin100 { Id = Interlocked.Increment(ref counter.Spin100) }); }); mqServer.RegisterHandler <Spin1000>(m => { var sw = Stopwatch.StartNew(); SpinWait.SpinUntil(() => sw.ElapsedMilliseconds < 1000); return(new Spin1000 { Id = Interlocked.Increment(ref counter.Spin1000) }); }); return(mqServer); }
RedisMqServer CreateServer() { using (var redis = new RedisClient()) redis.FlushAll(); var mqServer = new RedisMqServer(new BasicRedisClientManager()); mqServer.RegisterHandler<Wait0>(m => new Wait0 { Id = counter.Wait0++ }); mqServer.RegisterHandler<Wait10>(m => { Thread.Sleep(10); return new Wait10 { Id = counter.Wait10++ }; }); mqServer.RegisterHandler<Wait100>(m => { Thread.Sleep(100); return new Wait100 { Id = counter.Wait100++ }; }); mqServer.RegisterHandler<Wait1000>(m => { Thread.Sleep(1000); return new Wait1000 { Id = counter.Wait1000++ }; }); return mqServer; }
public void post_transaction_ok_with_authentication() { var uniqueCallbackQ = "mq:c1" + ":" + Guid.NewGuid().ToString("N"); var transaction = new Transaction { Amount = 10.00m, Card = "XXXXXXXXXX124", CreateDate = DateTime.UtcNow, SubscriptionId = 101, GatewayTransactionId = "123456", TransactionTypeId = (long)TRANSACTION_TYPE.AuthorizeAndCapture, TransactionStatusId = (long)TRANSACTION_STATUS.Pending, GatewayResponse = "ok" }; var clientMsg = new Message<Transaction>(transaction) { ReplyTo = uniqueCallbackQ, Tag = "basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(DefaultAdmin.Username + ":" + DefaultAdmin.Password)) }; var redisFactory = new PooledRedisClientManager("localhost:6379"); var mqHost = new RedisMqServer(redisFactory, retryCount: 2); var mqClient = mqHost.CreateMessageQueueClient(); mqClient.Publish(clientMsg); var response = mqClient.Get<PostResponse<Transaction>>(clientMsg.ReplyTo, new TimeSpan(0,10,10)); //Blocks thread on client until reply message is received var result = response.GetBody().Result; Assert.IsNotNull(result); Assert.IsTrue(result.Id > 0); }
public override void Configure(Container container) { Plugins.Add(new SessionFeature()); GlobalRequestFilters.Add((req, res, dto) => { var userPass = req.GetBasicAuthUserAndPassword(); if (userPass == null) { return; } var userName = userPass.Value.Key; if (userName != SystemConstants.AllowedUser || userPass.Value.Value != SystemConstants.AllowedPass) return; _currentSessionGuid = Guid.NewGuid(); var sessionKey = userName + "/" + _currentSessionGuid.ToString("N"); //set session for this request (as no cookies will be set on this request) req.Items["ss-session"] = sessionKey; res.SetPermanentCookie("ss-session", sessionKey); }); GlobalRequestFilters.Add((req, res, dto) => { if (!(dto is Secure)) return; var sessionId = req.GetItemOrCookie("ss-session") ?? string.Empty; var sessionIdParts = sessionId.SplitOnFirst('/'); if (sessionIdParts.Length < 2 || sessionIdParts[0] != SystemConstants.AllowedUser || sessionIdParts[1] != _currentSessionGuid.ToString("N")) { res.ReturnAuthRequired(); return; } ((Secure)dto).UserName = sessionIdParts[0]; }); GlobalMessageRequestFilters.Add((req, res,dto) => { var tag = ((BasicRequest) req).Message.Tag; if (string.IsNullOrWhiteSpace(tag) || !tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase)) return; var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5))); var i = creds.IndexOf(':'); var userName = creds.Substring(0, i); var userPass = creds.Substring(i+1); if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass) return; _currentSessionGuid = Guid.NewGuid(); var sessionKey = userName + "/" + _currentSessionGuid.ToString("N"); //set session for this request (as no cookies will be set on this request) req.Items["ss-session"] = sessionKey; res.SetPermanentCookie("ss-session", sessionKey); }); GlobalMessageRequestFilters.Add((req, res, dto) => { if (!(dto is Secure)) return; var sessionId = req.GetItemOrCookie("ss-session") ?? string.Empty; var sessionIdParts = sessionId.SplitOnFirst('/'); if (sessionIdParts.Length < 2 || sessionIdParts[0] != SystemConstants.AllowedUser || sessionIdParts[1] != _currentSessionGuid.ToString("N")) { res.ReturnAuthRequired(); return; } ((Secure)dto).UserName = sessionIdParts[0]; }); Func<IMessage, IMessage> filterSecureRequests = (message) => { var tag = message.Tag; if (string.IsNullOrWhiteSpace(tag)) return message; if (tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase)) { var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5))); var i = creds.IndexOf(':'); var userName = creds.Substring(0, i); var userPass = creds.Substring(i + 1); if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass) { message.Tag = null; return message; } _currentSessionGuid = Guid.NewGuid(); var sessionKey = userName + "/" + _currentSessionGuid.ToString("N"); SessionContext = new SessionContext { SessionKey = sessionKey, Username = userName }; container.Register(SessionContext); message.Tag = sessionKey; return message; } message.Tag = null; return message; }; var sercureLogic = new SecureLogic(); container.Register(sercureLogic); //Wire up the secure service over the message broker var redisFactory = new PooledRedisClientManager("localhost:6379"); container.Register<IRedisClientsManager>(redisFactory); // req. to log exceptions in redis var mqHost = new RedisMqServer(redisFactory, retryCount: 2) {RequestFilter = filterSecureRequests, ResponseFilter = FilterSecureReponses}; mqHost.RegisterHandler<Secure>(m => HandleSecureRequests(m, sercureLogic)); mqHost.RegisterHandler<GetFactorial>(m => ServiceController.ExecuteMessage(m)); mqHost.Start(); //Starts listening for messages }
static void Main2(string[] args) { var sbLogFactory = new StringBuilderLogFactory(); LogManager.LogFactory = sbLogFactory; var log = LogManager.GetLogger(typeof(Program)); var clientManager = new PooledRedisClientManager(new[] { "localhost" }) { PoolTimeout = 1000, }; var mqHost = new RedisMqServer(clientManager, retryCount: 2); var msgsProcessed = 0; var sum = 0; mqHost.RegisterHandler<Incr>(c => { var dto = c.GetBody(); sum += dto.Value; log.InfoFormat("Received {0}, sum: {1}", dto.Value, sum); msgsProcessed++; return null; }); mqHost.Start(); 10.Times(i => { ThreadPool.QueueUserWorkItem(x => { using (var client = mqHost.CreateMessageQueueClient()) { try { log.InfoFormat("Publish: {0}...", i); client.Publish(new Incr { Value = i }); } catch (Exception ex) { log.InfoFormat("Start Publish exception: {0}", ex.Message); clientManager.GetClientPoolActiveStates().PrintDump(); clientManager.GetReadOnlyClientPoolActiveStates().PrintDump(); } Thread.Sleep(10); } }); }); ThreadPool.QueueUserWorkItem(_ => { using (var client = (RedisClient)clientManager.GetClient()) { client.SetConfig("timeout", "1"); var clientAddrs = client.GetClientList().ConvertAll(x => x["addr"]); log.InfoFormat("Killing clients: {0}...", clientAddrs.Dump()); try { clientAddrs.ForEach(client.ClientKill); } catch (Exception ex) { log.InfoFormat("Client exception: {0}", ex.Message); } } }); 20.Times(i => { using (var client = mqHost.CreateMessageQueueClient()) { try { log.InfoFormat("Publish: {0}...", i); client.Publish(new Incr { Value = i }); } catch (Exception ex) { log.InfoFormat("Publish exception: {0}", ex.Message); clientManager.GetClientPoolActiveStates().PrintDump(); clientManager.GetReadOnlyClientPoolActiveStates().PrintDump(); } } Thread.Sleep(1000); }); Thread.Sleep(2000); "Messages processed: {0}".Print(msgsProcessed); "Logs: ".Print(); sbLogFactory.GetLogs().Print(); Console.ReadKey(); }
public override void Configure(Funq.Container container) { //to inject third-party IoC (for example for NInject use SrviceStack.ContainerAdapter.NInject) //IKernel kernel=new StandartKernel(); //kernel.Bind<TrackedDataRepository>().ToSelf(); //container.Adapter=new NinjectContainerAdapter(kernel); -> provide a adapter layer for NInject to use in Funq Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new BasicAuthProvider() , new TwitterAuthProvider(new AppSettings())})); Plugins.Add(new RegistrationFeature()); //register validators Plugins.Add(new ValidationFeature()); container.RegisterValidators(typeof(Common.Entry).Assembly, typeof(EntryService).Assembly); //request logs Plugins.Add(new RequestLogsFeature()); // added ability to view request via http:/..../requestlogs //cache registration container.Register<ICacheClient>(new MemoryCacheClient()); container.Register<IRedisClientsManager>(new PooledRedisClientManager("localhost:6379")); //container.Register<ICacheClient>(r => (ICacheClient)r.Resolve<IRedisClientsManager>().GetCacheClient()); var userRepository = new InMemoryAuthRepository(); container.Register<IUserAuthRepository>(userRepository); string hash; string salt; new SaltedHash().GetHashAndSaltString("password1", out hash, out salt); userRepository.CreateUserAuth(new UserAuth() { Id = 1, DisplayName = "Joe user", Email = "*****@*****.**", UserName = "******", LastName = "jname", PasswordHash = hash, Salt = salt, Roles = new List<string> { RoleNames.Admin }//, //Permissions = new List<string> { "GetStatus", "AddStatus" } }, "password1"); //automatically inject in all public properties container.RegisterAutoWired<TrackedDataRepository>().ReusedWithin(Funq.ReuseScope.Default); container.RegisterAutoWired<TrackedDataRepository2>().ReusedWithin(Funq.ReuseScope.Default); var dbConFactory = new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/data.txt"), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }; container.Register<IDbConnectionFactory>(dbConFactory); SetConfig(new EndpointHostConfig { DebugMode = true }); var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>()); mqService.RegisterHandler<Entry>(ServiceController.ExecuteMessage); mqService.Start(); //install Razor Plugins.Add(new RazorFormat()); }
public void Can_MqServer_recover_from_server_terminated_client_connections() { LogManager.LogFactory = new ConsoleLogFactory(); var clientManager = new PooledRedisClientManager(new[] { "localhost" }) { }; var mqHost = new RedisMqServer(clientManager, retryCount: 2); var sum = 0; mqHost.RegisterHandler <Incr>(c => { var dto = c.GetBody(); sum += dto.Value; "Received {0}, sum: {1}".Print(dto.Value, sum); return(null); }); mqHost.Start(); 10.Times(i => { ThreadPool.QueueUserWorkItem(x => { using (var client = mqHost.CreateMessageQueueClient()) { "Publish: {0}...".Print(i); client.Publish(new Incr { Value = i }); Thread.Sleep(10); } }); }); ThreadPool.QueueUserWorkItem(_ => { using (var client = (RedisClient)clientManager.GetClient()) { client.SetConfig("timeout", "1"); var clientAddrs = client.GetClientList().ConvertAll(x => x["addr"]); "Killing clients: {0}...".Print(clientAddrs.Dump()); try { clientAddrs.ForEach(client.ClientKill); } catch (Exception ex) { "Client exception: {0}".Print(ex.Message); } } }); 20.Times(i => { using (var client = mqHost.CreateMessageQueueClient()) { "Publish: {0}...".Print(i); client.Publish(new Incr { Value = i }); } Thread.Sleep(2000); }); }
public override void Configure(Container container) { JsConfig.EmitCamelCaseNames = true; this.PreRequestFilters.Add((req, res) => { req.Items["_DataSetAtPreRequestFilters"] = true; }); this.RequestFilters.Add((req, res, dto) => { req.Items["_DataSetAtRequestFilters"] = true; var requestFilter = dto as RequestFilter; if (requestFilter != null) { res.StatusCode = requestFilter.StatusCode; if (!requestFilter.HeaderName.IsNullOrEmpty()) { res.AddHeader(requestFilter.HeaderName, requestFilter.HeaderValue); } res.Close(); } var secureRequests = dto as IRequiresSession; if (secureRequests != null) { res.ReturnAuthRequired(); } }); this.Container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory( "~/App_Data/db.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }); this.Container.Register<ICacheClient>(new MemoryCacheClient()); //this.Container.Register<ICacheClient>(new BasicRedisClientManager()); ConfigureAuth(container); //this.Container.Register<ISessionFactory>( // c => new SessionFactory(c.Resolve<ICacheClient>())); var dbFactory = this.Container.Resolve<IDbConnectionFactory>(); dbFactory.Run(db => db.CreateTable<Movie>(true)); ModelConfig<Movie>.Id(x => x.Title); Routes .Add<Movies>("/custom-movies", "GET, OPTIONS") .Add<Movies>("/custom-movies/genres/{Genre}") .Add<Movie>("/custom-movies", "POST,PUT") .Add<Movie>("/custom-movies/{Id}") .Add<MqHostStats>("/mqstats"); var resetMovies = this.Container.Resolve<ResetMoviesService>(); resetMovies.Post(null); Plugins.Add(new ValidationFeature()); Plugins.Add(new SessionFeature()); Plugins.Add(new ProtoBufFormat()); Plugins.Add(new SwaggerFeature()); container.RegisterValidators(typeof(CustomersValidator).Assembly); container.Register(c => new FunqSingletonScope()).ReusedWithin(ReuseScope.Default); container.Register(c => new FunqRequestScope()).ReusedWithin(ReuseScope.Request); container.Register(c => new FunqNoneScope()).ReusedWithin(ReuseScope.None); Routes.Add<IocScope>("/iocscope"); //var onlyEnableFeatures = Feature.All.Remove(Feature.Jsv | Feature.Soap); SetConfig(new EndpointHostConfig { GlobalResponseHeaders = { { "Access-Control-Allow-Origin", "*" }, { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" }, { "Access-Control-Allow-Headers", "Content-Type, X-Requested-With" }, }, //EnableFeatures = onlyEnableFeatures, DebugMode = true, //Show StackTraces for easier debugging }); if (StartMqHost) { var redisManager = new BasicRedisClientManager(); var mqHost = new RedisMqServer(redisManager); mqHost.RegisterHandler<Reverse>(ServiceController.ExecuteMessage); mqHost.Start(); this.Container.Register((IMessageService)mqHost); } }
public override void Configure(Container container) { IocShared.Configure(this); JsConfig.EmitCamelCaseNames = true; this.PreRequestFilters.Add((req, res) => { req.Items["_DataSetAtPreRequestFilters"] = true; }); this.GlobalRequestFilters.Add((req, res, dto) => { req.Items["_DataSetAtRequestFilters"] = true; var requestFilter = dto as RequestFilter; if (requestFilter != null) { res.StatusCode = requestFilter.StatusCode; if (!requestFilter.HeaderName.IsNullOrEmpty()) { res.AddHeader(requestFilter.HeaderName, requestFilter.HeaderValue); } res.Close(); } var secureRequests = dto as IRequiresSession; if (secureRequests != null) { res.ReturnAuthRequired(); } }); this.Container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory( "~/App_Data/db.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }); this.Container.Register<ICacheClient>(new MemoryCacheClient()); //this.Container.Register<ICacheClient>(new BasicRedisClientManager()); ConfigureAuth(container); //this.Container.Register<ISessionFactory>( // c => new SessionFactory(c.Resolve<ICacheClient>())); var dbFactory = this.Container.Resolve<IDbConnectionFactory>(); using (var db = dbFactory.Open()) db.DropAndCreateTable<Movie>(); ModelConfig<Movie>.Id(x => x.Title); Routes .Add<Movies>("/custom-movies", "GET, OPTIONS") .Add<Movies>("/custom-movies/genres/{Genre}") .Add<Movie>("/custom-movies", "POST,PUT") .Add<Movie>("/custom-movies/{Id}") .Add<MqHostStats>("/mqstats"); var resetMovies = this.Container.Resolve<ResetMoviesService>(); resetMovies.Post(null); container.Register<IRedisClientsManager>(c => new RedisManagerPool()); Plugins.Add(new ValidationFeature()); Plugins.Add(new SessionFeature()); Plugins.Add(new ProtoBufFormat()); Plugins.Add(new RequestLogsFeature { //RequestLogger = new RedisRequestLogger(container.Resolve<IRedisClientsManager>()) RequestLogger = new CsvRequestLogger(), }); Plugins.Add(new SwaggerFeature { //UseBootstrapTheme = true OperationFilter = x => x.Consumes = x.Produces = new[] { MimeTypes.Json, MimeTypes.Xml }.ToList(), RouteSummary = { { "/swaggerexamples", "Swagger Examples Summary" } } }); Plugins.Add(new PostmanFeature()); Plugins.Add(new CorsFeature()); Plugins.Add(new AutoQueryFeature { MaxLimit = 100 }); Plugins.Add(new AdminFeature()); container.RegisterValidators(typeof(CustomersValidator).Assembly); typeof(ResponseStatus) .AddAttributes(new ServiceStack.DataAnnotations.DescriptionAttribute("This is the Response Status!")); typeof(ResponseStatus) .GetProperty("Message") .AddAttributes(new ServiceStack.DataAnnotations.DescriptionAttribute("A human friendly error message")); //var onlyEnableFeatures = Feature.All.Remove(Feature.Jsv | Feature.Soap); SetConfig(new HostConfig { AdminAuthSecret = AuthTestsBase.AuthSecret, ApiVersion = "0.2.0", //EnableFeatures = onlyEnableFeatures, DebugMode = true, //Show StackTraces for easier debugging }); if (StartMqHost) { var redisManager = new BasicRedisClientManager(); var mqHost = new RedisMqServer(redisManager); mqHost.RegisterHandler<Reverse>(ExecuteMessage); mqHost.Start(); this.Container.Register((IMessageService)mqHost); } }
public override void Configure(Container container) { IocShared.Configure(this); JsConfig.EmitCamelCaseNames = true; this.PreRequestFilters.Add((req, res) => { req.Items["_DataSetAtPreRequestFilters"] = true; }); this.GlobalRequestFilters.Add((req, res, dto) => { req.Items["_DataSetAtRequestFilters"] = true; var requestFilter = dto as RequestFilter; if (requestFilter != null) { res.StatusCode = requestFilter.StatusCode; if (!requestFilter.HeaderName.IsNullOrEmpty()) { res.AddHeader(requestFilter.HeaderName, requestFilter.HeaderValue); } res.Close(); } var secureRequests = dto as IRequiresSession; if (secureRequests != null) { res.ReturnAuthRequired(); } }); this.Container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory( "~/App_Data/db.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }); this.Container.Register<ICacheClient>(new MemoryCacheClient()); //this.Container.Register<ICacheClient>(new BasicRedisClientManager()); ConfigureAuth(container); //this.Container.Register<ISessionFactory>( // c => new SessionFactory(c.Resolve<ICacheClient>())); var dbFactory = this.Container.Resolve<IDbConnectionFactory>(); using (var db = dbFactory.Open()) db.DropAndCreateTable<Movie>(); ModelConfig<Movie>.Id(x => x.Title); Routes .Add<Movies>("/custom-movies", "GET, OPTIONS") .Add<Movies>("/custom-movies/genres/{Genre}") .Add<Movie>("/custom-movies", "POST,PUT") .Add<Movie>("/custom-movies/{Id}") .Add<MqHostStats>("/mqstats"); var resetMovies = this.Container.Resolve<ResetMoviesService>(); resetMovies.Post(null); Plugins.Add(new ValidationFeature()); Plugins.Add(new SessionFeature()); Plugins.Add(new ProtoBufFormat()); Plugins.Add(new RequestLogsFeature()); Plugins.Add(new SwaggerFeature()); Plugins.Add(new PostmanFeature()); Plugins.Add(new CorsFeature()); container.RegisterValidators(typeof(CustomersValidator).Assembly); //var onlyEnableFeatures = Feature.All.Remove(Feature.Jsv | Feature.Soap); SetConfig(new HostConfig { AdminAuthSecret = AuthTestsBase.AuthSecret, //EnableFeatures = onlyEnableFeatures, DebugMode = true, //Show StackTraces for easier debugging }); if (StartMqHost) { var redisManager = new BasicRedisClientManager(); var mqHost = new RedisMqServer(redisManager); mqHost.RegisterHandler<Reverse>(ServiceController.ExecuteMessage); mqHost.Start(); this.Container.Register((IMessageService)mqHost); } }
static void Main(string[] args) { var clientManager = new PooledRedisClientManager(new[] { "localhost" }) { PoolTimeout = 1000, }; using (var client = clientManager.GetClient()) { client.FlushAll(); } var mqHost = new RedisMqServer(clientManager); var msgsProcessed = 0; var msgsQueued = 0; var sum = 0; mqHost.RegisterHandler<Incr>(c => { var dto = c.GetBody(); sum += dto.Value; Console.WriteLine("Received {0}, sum: {1}", dto.Value, sum); msgsProcessed++; return null; }); mqHost.Start(); var processes = Process.GetProcessesByName("redis-server"); var timer = new Timer(s => { using (var client = mqHost.MessageFactory.CreateMessageProducer()) { try { client.Publish(new Incr { Value = 1 }); msgsQueued++; Console.WriteLine("Message #{0} published.", msgsQueued); } catch { } } }, null, TimeSpan.Zero, TimeSpan.FromSeconds(1)); Thread.Sleep(5000); timer.Change(Timeout.Infinite, Timeout.Infinite); Thread.Sleep(1000); int msgsQueuedBeforeKill = msgsQueued; int msgsProcessedBeforeKill = msgsProcessed; processes[0].Kill(); timer.Change(TimeSpan.Zero, TimeSpan.FromSeconds(1)); Thread.Sleep(15000); timer.Dispose(); Thread.Sleep(1000); mqHost.GetStats().PrintDump(); mqHost.GetStatus().Print(); "Messages queued before kill: {0}".Print(msgsQueuedBeforeKill); "Messages processed before kill: {0}".Print(msgsProcessedBeforeKill); "Messages queued: {0}".Print(msgsQueued); "Messages processed: {0}".Print(msgsProcessed); Console.ReadKey(); }
public override void Configure(Funq.Container container) { //Confiture our application //IKernel kernel = new StandardKernel(); //kernel.Bind<TrackedDataRepository>().ToSelf(); //similar to funq, singleton. Class resolved to itself //container.Adapter = new NinjectContainerAdapter(kernel); //Authentication configuration - iOC container Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new BasicAuthProvider(), new TwitterAuthProvider(new AppSettings()) })); Plugins.Add(new RegistrationFeature()); //registration for new user Plugins.Add(new ValidationFeature()); container.RegisterValidators(typeof(EntryService).Assembly); //configure validators Plugins.Add(new RequestLogsFeature()); //enable request logs feature, a user with Admin privilages is needed Plugins.Add(new RazorFormat()); container.Register <ICacheClient>(new MemoryCacheClient()); //cache client // can set up Redis/Azure //Redis container.Register<IRedisClientManager>(c => new PooledRedisClientManager(redis client path)); //container.Register<ICacheClient>(c =>(ICacheClient)c.Resolve<IRedisClientManager>().GetCacheClient(); < resolve to cache client Redis' client. var userRepository = new InMemoryAuthRepository(); //in memory auth repository container.Register <IUserAuthRepository>(userRepository); //add a user string hash; string salt; new SaltedHash().GetHashAndSaltString("password", out hash, out salt); userRepository.CreateUserAuth(new UserAuth { Id = 1, DisplayName = "JoeUser", Email = "*****@*****.**", UserName = "******", FirstName = "Joe", LastName = "User", PasswordHash = hash, salt = salt, Roles = new List <string> { RoleNames.Admin } // have to have this role in order to call AssignRoles, UnAssignRoles default services //Roles = new List<string> { "User" },//this is Role Authorization //Permissions = new List<string> {"GetStatus"} //this is Permission Authorization }, "password"); //user is created in the repository var dbConnectionFactory = new OrmLiteConnectionFactory(HttpContext.Current.Server.MapPath("~/App_Data/data.txtx"), SqlliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current); //enables any calls through ORM to be profiled. }; container.Register <IDbConnectionFactory>(dbConnectionFactory) //anywhere you want to use dbConnectionFactory, Funq will automatically populate this container.RegisterAutoWired <TrackedDataRepository>(); //Autowiring services and auto inject any public properties, SINGLETON by default //You can set the scope with ReusedWIthin LogManager.LogFactory = new EventLogFactory("ProteinTracker.Logging", "Application"); //name //source SetConfig(new EndpointHostConfig { DebugMode = true }); container.Register <IRedisClientsManager>(new PooledRedisClientManager("localhost:6379")); //default redis port var mqService = new RedisMqServer(container.Resolve <IRedisClientsManager>()); mqService.RegisterHandler <Entry>(ServiceController.ExecuteMessage); //executs the service that handles the Entry message //listens for Entry messages mqSerice.Start(); //start listening for messages }
public void Can_failover_MqServer_at_runtime() { const int iterations = 100; var failoverHost = "redis-failover:6379"; var localClient = new RedisClient("localhost:6379"); localClient.FlushDb(); var failoverClient = new RedisClient(failoverHost); failoverClient.FlushDb(); var clientManager = new PooledRedisClientManager(new[] { "localhost" }); var mqHost = new RedisMqServer(clientManager); var map = new Dictionary<string, int>(); var received = 0; mqHost.RegisterHandler<Msg>(c => { var dto = c.GetBody(); received++; int count; map.TryGetValue(dto.Host, out count); map[dto.Host] = count + 1; lock (clientManager) { "Received #{0} from {1}".Print(received, dto.Host); if (received == iterations) Monitor.Pulse(clientManager); } return null; }); mqHost.Start(); RunMqInLoop(mqHost, iterations: iterations, callback: () => { lock (clientManager) "{0} msgs were published.".Print(iterations); }); Thread.Sleep(500); clientManager.FailoverTo(failoverHost); lock (clientManager) Monitor.Wait(clientManager); "localclient inq: {0}, outq: {1}".Print( localClient.GetListCount("mq:Msg.inq"), localClient.GetListCount("mq:Msg.outq")); "failoverClient inq: {0}, outq: {1}".Print( failoverClient.GetListCount("mq:Msg.inq"), failoverClient.GetListCount("mq:Msg.outq")); Assert.That(received, Is.EqualTo(100)); Assert.That(map.Count, Is.EqualTo(2)); var msgsFromAllHosts = 0; foreach (var count in map.Values) { Assert.That(count, Is.GreaterThan(0)); msgsFromAllHosts += count; } Assert.That(msgsFromAllHosts, Is.EqualTo(iterations)); }
static void Main(string[] args) { var clientManager = new PooledRedisClientManager(new[] { "localhost" }) { PoolTimeout = 1000, }; using (var client = clientManager.GetClient()) { client.FlushAll(); } var mqHost = new RedisMqServer(clientManager); var msgsProcessed = 0; var msgsQueued = 0; var sum = 0; mqHost.RegisterHandler <Incr>(c => { var dto = c.GetBody(); sum += dto.Value; Console.WriteLine("Received {0}, sum: {1}", dto.Value, sum); msgsProcessed++; return(null); }); mqHost.Start(); var processes = Process.GetProcessesByName("redis-server"); var timer = new Timer(s => { using (var client = mqHost.MessageFactory.CreateMessageProducer()) { try { client.Publish(new Incr { Value = 1 }); msgsQueued++; Console.WriteLine("Message #{0} published.", msgsQueued); } catch { } } }, null, TimeSpan.Zero, TimeSpan.FromSeconds(1)); Thread.Sleep(5000); timer.Change(Timeout.Infinite, Timeout.Infinite); Thread.Sleep(1000); int msgsQueuedBeforeKill = msgsQueued; int msgsProcessedBeforeKill = msgsProcessed; processes[0].Kill(); timer.Change(TimeSpan.Zero, TimeSpan.FromSeconds(1)); Thread.Sleep(15000); timer.Dispose(); Thread.Sleep(1000); mqHost.GetStats().PrintDump(); mqHost.GetStatus().Print(); "Messages queued before kill: {0}".Print(msgsQueuedBeforeKill); "Messages processed before kill: {0}".Print(msgsProcessedBeforeKill); "Messages queued: {0}".Print(msgsQueued); "Messages processed: {0}".Print(msgsProcessed); Console.ReadKey(); }
public override void Configure(Container container) { JsConfig.EmitCamelCaseNames = true; this.PreRequestFilters.Add((req, res) => { req.Items["_DataSetAtPreRequestFilters"] = true; }); this.RequestFilters.Add((req, res, dto) => { req.Items["_DataSetAtRequestFilters"] = true; var requestFilter = dto as RequestFilter; if (requestFilter != null) { res.StatusCode = requestFilter.StatusCode; if (!requestFilter.HeaderName.IsNullOrEmpty()) { res.AddHeader(requestFilter.HeaderName, requestFilter.HeaderValue); } res.Close(); } var secureRequests = dto as IRequiresSession; if (secureRequests != null) { res.ReturnAuthRequired(); } }); this.Container.Register <IDbConnectionFactory>(c => new OrmLiteConnectionFactory( "~/App_Data/db.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }); this.Container.Register <ICacheClient>(new MemoryCacheClient()); //this.Container.Register<ICacheClient>(new BasicRedisClientManager()); ConfigureAuth(container); //this.Container.Register<ISessionFactory>( // c => new SessionFactory(c.Resolve<ICacheClient>())); var dbFactory = this.Container.Resolve <IDbConnectionFactory>(); dbFactory.Run(db => db.CreateTable <Movie>(true)); ModelConfig <Movie> .Id(x => x.Title); Routes .Add <Movies>("/custom-movies", "GET, OPTIONS") .Add <Movies>("/custom-movies/genres/{Genre}") .Add <Movie>("/custom-movies", "POST,PUT") .Add <Movie>("/custom-movies/{Id}") .Add <MqHostStats>("/mqstats"); var resetMovies = this.Container.Resolve <ResetMoviesService>(); resetMovies.Post(null); Plugins.Add(new ValidationFeature()); Plugins.Add(new SessionFeature()); Plugins.Add(new ProtoBufFormat()); Plugins.Add(new SwaggerFeature()); container.RegisterValidators(typeof(CustomersValidator).Assembly); container.Register(c => new FunqSingletonScope()).ReusedWithin(ReuseScope.Default); container.Register(c => new FunqRequestScope()).ReusedWithin(ReuseScope.Request); container.Register(c => new FunqNoneScope()).ReusedWithin(ReuseScope.None); Routes.Add <IocScope>("/iocscope"); //var onlyEnableFeatures = Feature.All.Remove(Feature.Jsv | Feature.Soap); SetConfig(new EndpointHostConfig { GlobalResponseHeaders = { { "Access-Control-Allow-Origin", "*" }, { "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" }, { "Access-Control-Allow-Headers", "Content-Type, X-Requested-With" }, }, //EnableFeatures = onlyEnableFeatures, DebugMode = true, //Show StackTraces for easier debugging }); if (StartMqHost) { var redisManager = new BasicRedisClientManager(); var mqHost = new RedisMqServer(redisManager); mqHost.RegisterHandler <Reverse>(ServiceController.ExecuteMessage); mqHost.Start(); this.Container.Register((IMessageService)mqHost); } }
public void Can_failover_MqServer_at_runtime() { const int iterations = 100; var failoverHost = "redis-failover:6379"; var localClient = new RedisClient("localhost:6379"); localClient.FlushDb(); var failoverClient = new RedisClient(failoverHost); failoverClient.FlushDb(); var clientManager = new PooledRedisClientManager(new[] { "localhost" }); var mqHost = new RedisMqServer(clientManager); var map = new Dictionary <string, int>(); var received = 0; mqHost.RegisterHandler <Msg>(c => { var dto = c.GetBody(); received++; int count; map.TryGetValue(dto.Host, out count); map[dto.Host] = count + 1; lock (clientManager) { "Received #{0} from {1}".Print(received, dto.Host); if (received == iterations) { Monitor.Pulse(clientManager); } } return(null); }); mqHost.Start(); RunMqInLoop(mqHost, iterations: iterations, callback: () => { lock (clientManager) "{0} msgs were published.".Print(iterations); }); Thread.Sleep(500); clientManager.FailoverTo(failoverHost); lock (clientManager) Monitor.Wait(clientManager); map.PrintDump(); "localclient inq: {0}, outq: {1}".Print( localClient.GetListCount("mq:Msg.inq"), localClient.GetListCount("mq:Msg.outq")); "failoverClient inq: {0}, outq: {1}".Print( failoverClient.GetListCount("mq:Msg.inq"), failoverClient.GetListCount("mq:Msg.outq")); Assert.That(received, Is.EqualTo(100)); Assert.That(map.Count, Is.EqualTo(2)); var msgsFromAllHosts = 0; foreach (var count in map.Values) { Assert.That(count, Is.GreaterThan(0)); msgsFromAllHosts += count; } Assert.That(msgsFromAllHosts, Is.EqualTo(iterations)); }
public override void Configure(Container container) { IocShared.Configure(this); JsConfig.EmitCamelCaseNames = true; this.PreRequestFilters.Add((req, res) => { req.Items["_DataSetAtPreRequestFilters"] = true; }); this.GlobalRequestFilters.Add((req, res, dto) => { req.Items["_DataSetAtRequestFilters"] = true; var requestFilter = dto as RequestFilter; if (requestFilter != null) { res.StatusCode = requestFilter.StatusCode; if (!requestFilter.HeaderName.IsNullOrEmpty()) { res.AddHeader(requestFilter.HeaderName, requestFilter.HeaderValue); } res.Close(); } var secureRequests = dto as IRequiresSession; if (secureRequests != null) { res.ReturnAuthRequired(); } }); this.Container.Register <IDbConnectionFactory>(c => new OrmLiteConnectionFactory( "~/App_Data/db.sqlite".MapHostAbsolutePath(), SqliteDialect.Provider) { ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current) }); this.Container.Register <ICacheClient>(new MemoryCacheClient()); //this.Container.Register<ICacheClient>(new BasicRedisClientManager()); ConfigureAuth(container); //this.Container.Register<ISessionFactory>( // c => new SessionFactory(c.Resolve<ICacheClient>())); var dbFactory = this.Container.Resolve <IDbConnectionFactory>(); using (var db = dbFactory.Open()) db.DropAndCreateTable <Movie>(); ModelConfig <Movie> .Id(x => x.Title); Routes .Add <Movies>("/custom-movies", "GET, OPTIONS") .Add <Movies>("/custom-movies/genres/{Genre}") .Add <Movie>("/custom-movies", "POST,PUT") .Add <Movie>("/custom-movies/{Id}") .Add <MqHostStats>("/mqstats"); var resetMovies = this.Container.Resolve <ResetMoviesService>(); resetMovies.Post(null); container.Register <IRedisClientsManager>(c => new RedisManagerPool()); Plugins.Add(new ValidationFeature()); Plugins.Add(new SessionFeature()); Plugins.Add(new ProtoBufFormat()); Plugins.Add(new RequestLogsFeature { RequestLogger = new RedisRequestLogger(container.Resolve <IRedisClientsManager>()) }); Plugins.Add(new SwaggerFeature { //UseBootstrapTheme = true }); Plugins.Add(new PostmanFeature()); Plugins.Add(new CorsFeature()); container.RegisterValidators(typeof(CustomersValidator).Assembly); //var onlyEnableFeatures = Feature.All.Remove(Feature.Jsv | Feature.Soap); SetConfig(new HostConfig { AdminAuthSecret = AuthTestsBase.AuthSecret, //EnableFeatures = onlyEnableFeatures, DebugMode = true, //Show StackTraces for easier debugging }); if (StartMqHost) { var redisManager = new BasicRedisClientManager(); var mqHost = new RedisMqServer(redisManager); mqHost.RegisterHandler <Reverse>(ServiceController.ExecuteMessage); mqHost.Start(); this.Container.Register((IMessageService)mqHost); } }
public override void Configure(Container container) { LogManager.LogFactory = new Log4NetFactory(true); container.Register(_dbConnectionFactory); var basicAuthProvider = new BasicAuthProvider(); container.Register(basicAuthProvider); Plugins.Add(new AuthFeature( () => new AuthUserSession(), new IAuthProvider[] {basicAuthProvider, }, SystemConstants.LoginUrl )); var userRepo = new OrmLiteAuthRepository(_dbConnectionFactory); container.Register<IAuthRepository>(userRepo); var cacheClient = new MemoryCacheClient(); container.Register(cacheClient); var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionRepository = new TransactionRepository { DbConnectionFactory = _dbConnectionFactory }; var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository }; var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository }; var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository }; var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository }; var transactionLogic = new TransactionLogic {Repository = transactionRepository}; container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic); container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic); container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic); container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic); container.Register<IRest<Transaction, GetTransactions>>(transactionLogic); CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null); var redisLocation = ConfigurationManager.AppSettings["ReddisService"]; Container.Register<IRedisClientsManager>(new PooledRedisClientManager(redisLocation)); var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>()); var messagingHandlers = new MessageService { Log = new Logger(typeof(MessageService).Name) }; Func<IMessage, IMessage> filterSecureRequests = (message) => { /* var tag = message.Tag; if (string.IsNullOrWhiteSpace(tag)) return message; if (tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase)) { var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5))); var i = creds.IndexOf(':'); var userName = creds.Substring(0, i); var userPass = creds.Substring(i + 1); if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass) { message.Tag = null; return message; } _currentSessionGuid = Guid.NewGuid(); var sessionKey = userName + "/" + _currentSessionGuid.ToString("N"); SessionContext = new SessionContext { SessionKey = sessionKey, Username = userName }; container.Register(SessionContext); message.Tag = sessionKey; return message; } message.Tag = null;*/ return message; }; mqService.RequestFilter = filterSecureRequests; Func<IMessage<Transaction>, PostResponse<Transaction>> handlePostTransactions = (message) => { var service = new TransactionWebService { Logic = transactionLogic }; var request = new BasicRequest {Message = message, Dto = message.GetBody()}; var response = new BasicResponse(request); //userRepo.TryAuthenticate() service.SessionFactory.GetOrCreateSession(request, response); var session = service.GetSession(); session.UserName = "******"; var results = new PostResponse<Transaction> {Result = (Transaction) service.Post(message.GetBody())}; return results; }; // Dto Get Operations mqService.RegisterHandler<GetCurrencyTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), currencyTypeLogic)); mqService.RegisterHandler<GetTransactions>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionLogic)); mqService.RegisterHandler<GetTransactionStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionStatusTypeLogic)); mqService.RegisterHandler<GetTransactionNotificationStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionNotificationStatusTypeLogic)); mqService.RegisterHandler<GetTransactionTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionTypeLogic)); // Dto Post Operations mqService.RegisterHandler<CurrencyType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), currencyTypeLogic.Post)); mqService.RegisterHandler<Transaction>(handlePostTransactions); mqService.RegisterHandler<TransactionStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionStatusTypeLogic.Post)); mqService.RegisterHandler<TransactionNotificationStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionNotificationStatusTypeLogic.Post)); mqService.RegisterHandler<TransactionType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionTypeLogic.Post)); // Dto Put Opertations mqService.RegisterHandler<DeleteCurrencyType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), currencyTypeLogic)); mqService.RegisterHandler<DeleteTransaction>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionLogic)); mqService.RegisterHandler<DeleteTransactionStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionStatusTypeLogic)); mqService.RegisterHandler<DeleteTransactionNotificationStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionNotificationStatusTypeLogic)); mqService.RegisterHandler<DeleteTransactionType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionTypeLogic)); mqService.Start(); }