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)
{
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_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 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(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);
}
}
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());
}
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 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.GetClientsInfo().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 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();
Interlocked.Increment(ref 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));
}
public override void Configure(Container container)
{
IocShared.Configure(this);
JsConfig.EmitCamelCaseNames = true;
ServiceStack.Auth.RegisterService.AllowUpdates = true;
this.PreRequestFilters.Add((req, res) =>
{
req.Items["_DataSetAtPreRequestFilters"] = true;
});
this.GlobalRequestFilters.Add((req, res, dto) =>
{
req.Items["_DataSetAtRequestFilters"] = true;
if (dto is RequestFilter requestFilter)
{
res.StatusCode = requestFilter.StatusCode;
if (!requestFilter.HeaderName.IsNullOrEmpty())
{
res.AddHeader(requestFilter.HeaderName, requestFilter.HeaderValue);
}
res.Close();
}
if (dto is IRequiresSession secureRequests)
{
res.ReturnAuthRequired();
}
});
Plugins.Add(new SoapFormat());
Plugins.Add(new MiniProfilerFeature());
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 TemplatePagesFeature());
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
RedirectPaths =
{
{ "/swagger-ui", "/swagger-ui/" }
}
});
if (StartMqHost)
{
var redisManager = new BasicRedisClientManager();
var mqHost = new RedisMqServer(redisManager);
mqHost.RegisterHandler <Reverse>(ExecuteMessage);
mqHost.Start();
this.Container.Register((IMessageService)mqHost);
}
}
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(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
}
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 {
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);
}
}
/// <summary>
/// Application specific configuration
/// This method should initialize any IoC resources utilized by your web service classes.
/// </summary>
public override void Configure(Container container)
{
//Handle Exceptions occurring in Services:
this.ServiceExceptionHandlers.Add((httpReq, request, exception) => {
// Log your exceptions here
//...
// Call the default exception handler or prepare your own custom response
return(DtoUtils.CreateErrorResponse(request, exception));
});
// Handle Unhandled Exceptions occurring outside of Services
// E.g. in Request binding or filters:
//Handle Unhandled Exceptions occurring outside of Services
//E.g. Exceptions during Request binding or in filters:
this.UncaughtExceptionHandlers.Add((req, res, operationName, ex) => {
res.Write("Error: {0}: {1}".Fmt(ex.GetType().Name, ex.Message));
res.EndRequest(skipHeaders: true);
});
//Config examples
//this.Plugins.Add(new PostmanFeature());
//this.Plugins.Add(new CorsFeature());
// Handle Multiple Providers here. One per service.
var dbProvider = ConfigurationManager.AppSettings.Get("DatabaseProvider");
if (dbProvider == "MySQL")
{
var connectionString = ConfigurationManager.ConnectionStrings["Database_MySQL"].ConnectionString;
var dbFactory = new OrmLiteConnectionFactory(
connectionString,
ServiceStack.OrmLite.MySqlDialect.Provider);
container.Register <IDbConnectionFactory>(c => dbFactory);
}
else if (dbProvider == "SqlServer")
{
var connectionString = ConfigurationManager.ConnectionStrings["Database_SQLServer"].ConnectionString;
var dbFactory = new OrmLiteConnectionFactory(
connectionString,
ServiceStack.OrmLite.SqlServerDialect.Provider);
container.Register <IDbConnectionFactory>(c => dbFactory);
}
var queueProvider = ConfigurationManager.AppSettings.Get("QueueProvider");
if (queueProvider == "SQS")
{
var awsAccessKey = ConfigurationManager.AppSettings.Get("AwsAccessKey");
var awsSecretKey = ConfigurationManager.AppSettings.Get("AwsSecretKey");
var awsRegionEndpoint = ConfigurationManager.AppSettings.Get("AwsRegionEndpoint");
var region = RegionEndpoint.GetBySystemName(awsRegionEndpoint);
var queueUrl = ConfigurationManager.AppSettings.Get("QueueUrl");
container.Register <IMessageService>(c => new SqsMqServer(
awsAccessKey,
awsSecretKey,
region)
{
DisableBuffering = true
});
var mqServer = container.Resolve <IMessageService>();
mqServer.Start();
}
else if (queueProvider == "Redis")
{
//Message Queueing
var redisFactory = new PooledRedisClientManager("localhost:6379");
container.Register <IRedisClientsManager>(redisFactory);
var mqHost = new RedisMqServer(redisFactory, retryCount: 2);
mqHost.Start();
}
}
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.GetClientsInfo().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.RequestFilters.Add((req, res, dto) => {
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)
{
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();
}
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 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();
}
