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();
}
public void Utils_publish_Rot13_messages()
{
var mqHost = new RedisMqServer(TestConfig.BasicClientManger, 2);
var mqClient = mqHost.CreateMessageQueueClient();
Publish_4_Rot13_messages(mqClient);
mqHost.Stop();
}
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();
}
