public void Can_select_db()
{
var redisManager = new BasicRedisClientManager("127.0.0.1");
using (var client = redisManager.GetClient())
{
client.Db = 2;
client.Set("db", 2);
}
using (var client = redisManager.GetClient())
{
client.Db = 3;
client.Set("db", 3);
}
using (var client = redisManager.GetClient())
{
client.Db = 2;
var db = client.Get<int>("db");
Assert.That(db, Is.EqualTo(2));
}
redisManager = new BasicRedisClientManager("127.0.0.1?db=3");
using (var client = redisManager.GetClient())
{
var db = client.Get<int>("db");
Assert.That(db, Is.EqualTo(3));
}
}
public void Run()
{
DateTime executionStart = DateTime.Now;
while (true)
{
Console.WriteLine("Resetting connection");
try
{
executionStart = DateTime.Now;
ResetPending = false;
_redis = new BasicRedisClientManager(CrisisTracker.Common.Settings.AidrRedisConsumer_RedisHost + ":" + CrisisTracker.Common.Settings.AidrRedisConsumer_RedisPort);
ConsumeStream();
while (_isConsuming)
Thread.Sleep(1000);
}
catch (Exception e)
{
Output.Print(Name, "Exception from Run:" + Environment.NewLine + e);
}
finally
{
Console.WriteLine("Disposing redis client");
_redis.Dispose();
}
if ((DateTime.Now - executionStart).TotalSeconds < 5)
{
Output.Print(Name, "Previous failure was quick. Waiting 60 seconds.");
Thread.Sleep(59000);
}
Console.WriteLine(".");
Thread.Sleep(1000);
}
}
public override void Configure(Container container)
{
string sc = ConfigurationManager.AppSettings.Get("DbConnection");
string rchost= ConfigurationManager.AppSettings.Get("SessionRedisHost");
rchost= (string.IsNullOrEmpty(rchost))? "localhost:6379": rchost;
string rcpassword= ConfigurationManager.AppSettings.Get("SessionRedisPassword");
string rcdbs= ConfigurationManager.AppSettings.Get("SessionRedisDb");
int rcdb;
if(! int.TryParse(rcdbs, out rcdb) ) rcdb= 10;
string sstout = ConfigurationManager.AppSettings.Get("SessionTimeout");
int sessionTimeout;
if(! int.TryParse(sstout, out sessionTimeout) ) sessionTimeout= 60*8;
var cacheClient= new BasicRedisClientManager( new string[]{rchost}, new string[]{rchost}, rcdb);
cacheClient.GetClient().Password= rcpassword;
container.Register<IAuthProvider>( new BdAuthProvider()
{
DbFactory=new ConnectionFactory(sc, FirebirdDialectProvider.Instance),
AuthUserSession= new UserSession()
{
CacheClient= cacheClient,
TimeOut=sessionTimeout,
}
});
string phost= ConfigurationManager.AppSettings.Get("CacheHost");
phost = (string.IsNullOrEmpty(phost))?"localhost:6379":phost;
string pdbs= ConfigurationManager.AppSettings.Get("CacheDb");
int pdb ;
if(! int.TryParse(pdbs, out pdb) ) pdb= 9;
string ppassword= ConfigurationManager.AppSettings.Get("CachePassword");
var p = new PooledRedisClientManager(new string[]{phost}, new string[]{phost}, pdb);
p.GetClient().Password= ppassword;
container.Register<ICacheClient>( p);
container.Register<IDbConnectionFactory>(
new ConnectionFactory(sc, FirebirdDialectProvider.Instance)
);
//Permit modern browsers (e.g. Firefox) to allow sending of any REST HTTP Method
base.SetConfig(new EndpointHostConfig
{
GlobalResponseHeaders =
{
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
{ "Access-Control-Allow-Headers","X-Requested-With"}
},
});
log.InfoFormat("AppHost Configured: " + DateTime.Now);
}
static void Main(string[] args)
{
Manager = new BasicRedisClientManager("localhost");
var q = new System.Timers.Timer { Interval = 2 };
q.Elapsed += CheckConnection;
q.Enabled = true;
if ("q" == Console.ReadLine())
return;
}
private void ConfigureApp(Container container){
var appSettings = new ConfigurationResourceManager();
double se= appSettings.Get("DefaultSessionExpiry", 480);
AuthProvider.DefaultSessionExpiry=TimeSpan.FromMinutes(se);
string cacheHost= appSettings.Get("REDISTOGO_URL","localhost:6379").Replace("redis://redistogo-appharbor:","").Replace("/","");
var p = new BasicRedisClientManager(new string[]{cacheHost});
OrmLiteConfig.DialectProvider= FirebirdOrmLiteDialectProvider.Instance;
IDbConnectionFactory dbFactory = new OrmLiteConnectionFactory(
ConfigUtils.GetConnectionString("ApplicationDb"));
container.Register(appSettings);
container.Register<Factory>(
new Factory(){
DbFactory=dbFactory,
RedisClientsManager = p
}
);
//container.Register<ICacheClient>(new MemoryCacheClient { FlushOnDispose = false });
container.Register<IRedisClientsManager>(c => p);
Plugins.Add(new AuthFeature(
() => new AuthUserSession(), // or Use your own typed Custom AuthUserSession type
new IAuthProvider[]
{
new AuthenticationProvider(){SessionExpiry=TimeSpan.FromMinutes(se)}
})
{
IncludeAssignRoleServices=false,
});
OrmLiteAuthRepository authRepo = new OrmLiteAuthRepository(
dbFactory
);
container.Register<IUserAuthRepository>(
c => authRepo
);
if(appSettings.Get("EnableRegistrationFeature", false))
Plugins.Add( new RegistrationFeature());
}
private static RedisMqHost CreateMqHost(int noOfRetries)
{
var redisFactory = new BasicRedisClientManager();
try
{
redisFactory.Exec(redis => redis.FlushAll());
}
catch (RedisException rex)
{
Debug.WriteLine("WARNING: Redis not started? \n" + rex.Message);
}
var mqHost = new RedisMqHost(redisFactory, noOfRetries, null);
return mqHost;
}
internal void RegisterRedisUserCache(IContainer container)
{
var appSettings = container.GetInstance<AppSettings>();
var redisClientManager = new BasicRedisClientManager(appSettings.RedisConnectionString);
_logger.Debug(appSettings.RedisConnectionString);
_logger.Debug(redisClientManager);
container.Configure(config =>
{
config.For<IRedisClientsManager>().Singleton().Use(redisClientManager);
config.For<IUserCacheService>().Singleton().Use<RedisUserCacheService>();
});
}
void ConfigureApp(Container container)
{
var appSettings = new ConfigurationResourceManager();
double se= appSettings.Get("DefaultSessionExpiry", 480);
AuthProvider.DefaultSessionExpiry=TimeSpan.FromMinutes(se);
string cacheHost= appSettings.Get("REDISTOGO_URL","localhost:6379").Replace("redis://redistogo:","").Replace("/","");
var redisClientManager = new BasicRedisClientManager(new string[]{cacheHost});
OrmLiteConfig.DialectProvider= MySqlDialectProvider.Instance;
IDbConnectionFactory dbFactory =
new OrmLiteConnectionFactory(ConfigUtils.GetConnectionString("ApplicationDb"));
string smtpServer= appSettings.Get("MAILGUN_SMTP_SERVER", "localhost");
string smtpLogin= appSettings.Get("MAILGUN_SMTP_LOGIN", "username");
string smtpPassword= appSettings.Get("MAILGUN_SMTP_PASSWORD", "PASSWORD");
int smtpPort= appSettings.Get("MAILGUN_SMTP_PORT", 587);
Mailer mailer = new Mailer(smtpServer, smtpPort, smtpLogin, smtpPassword);
var appConfig= new AppConfig(appSettings);
RepositoryClient rc = new RepositoryClient(dbFactory, redisClientManager);
Controller controller = new Controller(rc,mailer,appConfig);
container.Register<Controller>( controller );
AuthRepoProxy arp = new AuthRepoProxy(dbFactory, redisClientManager);
container.Register<AuthRepoProxy>( arp );
container.Register<IRedisClientsManager>(c => redisClientManager);
//container.Register<ICacheClient>(c => redisClientManager);
Plugins.Add(new AuthFeature( () => new AuthUserSession(), // or Use your own typed Custom AuthUserSession type
new IAuthProvider[]
{
new AuthenticationProvider(){SessionExpiry=TimeSpan.FromMinutes(se)}
})
{
IncludeAssignRoleServices=false
});
OrmLiteAuthRepository authRepo = new OrmLiteAuthRepository(dbFactory);
container.Register<IUserAuthRepository>(c => authRepo);
if(appSettings.Get("EnableRegistrationFeature", false))
Plugins.Add( new RegistrationFeature());
}
private static RedisMqHostPool CreateMqHostPool(int threadCount = 1)
{
var redisFactory = new BasicRedisClientManager();
try
{
redisFactory.Exec(redis => redis.FlushAll());
}
catch (RedisException rex)
{
Console.WriteLine("WARNING: Redis not started? \n" + rex.Message);
}
var mqHost = new RedisMqHostPool(redisFactory)
{
NoOfThreadsPerService = threadCount,
};
return mqHost;
}
public void Does_set_all_properties_on_Client_using_ClientsManagers()
{
var connStr = "redis://*****:*****@host:1?ssl=true&db=0&connectTimeout=2&sendtimeout=3&receiveTimeout=4&idletimeoutsecs=5&NamespacePrefix=prefix.";
var expected = "{Host:host,Port:1,Ssl:True,Client:nunit,Password:pass,Db:0,ConnectTimeout:2,SendTimeout:3,ReceiveTimeout:4,IdleTimeOutSecs:5,NamespacePrefix:prefix.}"
.FromJsv<RedisEndpoint>();
using (var pooledManager = new RedisManagerPool(connStr))
{
AssertClientManager(pooledManager, expected);
}
using (var pooledManager = new PooledRedisClientManager(connStr))
{
AssertClientManager(pooledManager, expected);
}
using (var basicManager = new BasicRedisClientManager(connStr))
{
AssertClientManager(basicManager, expected);
}
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
var clientManager = new BasicRedisClientManager("localhost:6379");
using (var client = clientManager.GetClient())
{
client.FlushDb();
}
RedisCacheProvider.SetClientManager(clientManager);
var dbFile = HttpContext.Current.Server.MapPath("~/App_Data/sample.db");
if (File.Exists(dbFile)) { File.Delete(dbFile); }
var configuration = Fluently.Configure()
.Database(
SQLiteConfiguration.Standard.UsingFile(dbFile)
)
.Mappings(m =>
{
m.FluentMappings.Add(typeof(BlogPostMapping));
})
.ExposeConfiguration(cfg =>
{
cfg.SetProperty(NHibernate.Cfg.Environment.GenerateStatistics, "true");
})
.Cache(c =>
{
c.UseQueryCache().UseSecondLevelCache().ProviderClass<RedisCacheProvider>();
})
.BuildConfiguration();
new SchemaExport(configuration).Create(false, true);
SessionFactory = configuration.BuildSessionFactory();
}
public override void Configure(Container container)
{
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(),
SqliteOrmLiteDialectProvider.Instance));
this.Container.Register<ICacheClient>(new MemoryCacheClient());
var dbFactory = this.Container.Resolve<IDbConnectionFactory>();
dbFactory.Exec(dbCmd => dbCmd.CreateTable<Movie>(true));
Routes
.Add<Movies>("/custom-movies", "GET")
.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);
//var onlyEnableFeatures = Feature.All.Remove(Feature.Jsv | Feature.Soap);
//SetConfig(new EndpointHostConfig
//{
// EnableFeatures = onlyEnableFeatures,
// DebugMode = true, //Show StackTraces for easier debugging
//});
var redisManager = new BasicRedisClientManager();
var mqHost = new RedisMqHost(redisManager, 2, null);
mqHost.RegisterHandler<Reverse>(x =>
this.Container.Resolve<ReverseService>().Execute(x.GetBody()));
mqHost.Start();
this.Container.Register((IMessageService)mqHost);
}
void ConfigureApp(Container container){
var appSettings = new ConfigurationResourceManager();
double se= appSettings.Get("DefaultSessionExpiry", 480);
AuthProvider.DefaultSessionExpiry=TimeSpan.FromMinutes(se);
string cacheHost= appSettings.Get("REDISTOGO_URL","localhost:6379").Replace("redis://redistogo-appharbor:","").Replace("/","");
var redisClientManager = new BasicRedisClientManager(new string[]{cacheHost});
OrmLiteConfig.DialectProvider= MySqlDialectProvider.Instance;
IDbConnectionFactory dbFactory = new OrmLiteConnectionFactory(
ConfigUtils.GetConnectionString("ApplicationDb"));
var factory = new Factory(){
DbFactory=dbFactory,
RedisClientsManager = redisClientManager
};
var empresa = factory.Execute(proxy=>{
return proxy.GetEmpresa();
});
var mailer = new Mailer(empresa);
Channel channel = new Channel(empresa.PublishKey,
empresa.SubscribeKey, empresa.SecretKey,"",false);
container.Register(channel);
container.Register(new AppConfig(appSettings){MailLogToken=empresa.MailLogToken});
container.Register<Factory>(factory);
container.Register(mailer);
//container.Register<ICacheClient>(new MemoryCacheClient { FlushOnDispose = false });
container.Register<IRedisClientsManager>(c => redisClientManager);
Plugins.Add(new AuthFeature(
() => new AuthUserSession(), // or Use your own typed Custom AuthUserSession type
new IAuthProvider[]
{
new AuthenticationProvider(){SessionExpiry=TimeSpan.FromMinutes(se)}
})
{
IncludeAssignRoleServices=false,
});
OrmLiteAuthRepository authRepo = new OrmLiteAuthRepository(
dbFactory
);
container.Register<IUserAuthRepository>(
c => authRepo
);
if(appSettings.Get("EnableRegistrationFeature", false))
Plugins.Add( new RegistrationFeature());
}
public void Remove_should_silently_continue_if_SocketException()
{
using (var invalidClientManager = new BasicRedisClientManager(InvalidHost))
{
// Arrange
const int key = 1;
var cache = new RedisCache("region_A", invalidClientManager);
// Act
Assert.DoesNotThrow(() =>
{
cache.Remove(key);
});
}
}
public void Can_change_db_for_client_BasicRedisClientManager()
{
using (var db1 = new BasicRedisClientManager(1, new string[] { TestConfig.SingleHost }))
using (var db2 = new BasicRedisClientManager(2, new string[] { TestConfig.SingleHost }))
{
var val = Environment.TickCount;
var key = "test" + val;
var db1c = db1.GetClient();
var db2c = db2.GetClient();
try
{
db1c.Set(key, val);
Assert.That(db2c.Get<int>(key), Is.EqualTo(0));
Assert.That(db1c.Get<int>(key), Is.EqualTo(val));
}
finally
{
db1c.Remove(key);
}
}
}
public void BasicRedisClientManager_alternates_hosts()
{
using (var redisManager = new BasicRedisClientManager(MasterHosts, SlaveHosts))
{
using (var master = redisManager.GetClient())
{
Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0]));
master.SetValue("KEY", "1");
}
using (var master = redisManager.GetClient())
{
Assert.That(master.GetHostString(), Is.EqualTo(MasterHosts[0]));
master.Increment("KEY", 1);
}
5.Times(i =>
{
using (var readOnly = redisManager.GetReadOnlyClient())
{
Assert.That(readOnly.GetHostString(), Is.EqualTo(SlaveHosts[i % SlaveHosts.Length]));
Assert.That(readOnly.GetValue("KEY"), Is.EqualTo("2"));
}
});
using (var cahce = redisManager.GetCacheClient())
{
Assert.That(cahce.Get<string>("KEY"), Is.EqualTo("2"));
}
}
}
public void RedisNativeClientTest3() {
var connectionString = ConfigurationManager.AppSettings.Get("cache:redis");
var key = "RedisParallelTest3";
var redisManager = new BasicRedisClientManager(connectionString);
redisManager.ConnectTimeout = 100;
using (var client = (IRedisNativeClient)redisManager.GetCacheClient()) {
client.Del(key);
}
var actions = Enumerable.Repeat(1, 100).Select(i => new Action(() => {
redisManager.ConnectTimeout = 100;
using (var client = (IRedisNativeClient)redisManager.GetCacheClient()) {
client.Incr(key);
}
})).ToArray();
Parallel.Invoke(actions);
}
protected RedisTest()
{
ClientManager = new BasicRedisClientManager(testDb, testHost);
Redis = GetRedisClient();
}
public void Put_and_Get_should_silently_continue_if_SocketException()
{
using (var invalidClientManager = new BasicRedisClientManager(InvalidHost))
{
// Arrange
const int key = 1;
var cache = new RedisCache("region_A", invalidClientManager);
// Act
cache.Put(key, new Person("A", 1));
// Assert
Assert.Null(cache.Get(key));
}
}
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
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());
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>(ServiceController.ExecuteMessage);
mqHost.Start();
this.Container.Register((IMessageService)mqHost);
}
}
public override void Configure(Container container)
{
string sc = ConfigurationManager.AppSettings.Get("DbConnection");
string rchost = ConfigurationManager.AppSettings.Get("SessionRedisHost");
rchost = (string.IsNullOrEmpty(rchost))? "localhost:6379": rchost;
string rcpassword = ConfigurationManager.AppSettings.Get("SessionRedisPassword");
string rcdbs = ConfigurationManager.AppSettings.Get("SessionRedisDb");
int rcdb;
if (!int.TryParse(rcdbs, out rcdb))
{
rcdb = 10;
}
string sstout = ConfigurationManager.AppSettings.Get("SessionTimeout");
int sessionTimeout;
if (!int.TryParse(sstout, out sessionTimeout))
{
sessionTimeout = 60 * 8;
}
var cacheClient = new BasicRedisClientManager(new string[] { rchost }, new string[] { rchost }, rcdb);
cacheClient.GetClient().Password = rcpassword;
container.Register <IAuthProvider>(new BdAuthProvider()
{
DbFactory = new ConnectionFactory(sc, FirebirdDialectProvider.Instance),
AuthUserSession = new UserSession()
{
CacheClient = cacheClient,
TimeOut = sessionTimeout,
}
});
string phost = ConfigurationManager.AppSettings.Get("CacheHost");
phost = (string.IsNullOrEmpty(phost))?"localhost:6379":phost;
string pdbs = ConfigurationManager.AppSettings.Get("CacheDb");
int pdb;
if (!int.TryParse(pdbs, out pdb))
{
pdb = 9;
}
string ppassword = ConfigurationManager.AppSettings.Get("CachePassword");
var p = new PooledRedisClientManager(new string[] { phost }, new string[] { phost }, pdb);
p.GetClient().Password = ppassword;
container.Register <ICacheClient>(p);
container.Register <IDbConnectionFactory>(
new ConnectionFactory(sc, FirebirdDialectProvider.Instance)
);
var config = new AppConfig(new ConfigurationResourceManager());
container.Register(config);
if (!Directory.Exists(config.PhotoDirectory))
{
Directory.CreateDirectory(config.PhotoDirectory);
}
//Mailer mailer = new Mailer(config);
//container.Register(mailer);
//HtmlReport.Register(this);
//Permit modern browsers (e.g. Firefox) to allow sending of any REST HTTP Method
base.SetConfig(new EndpointHostConfig
{
GlobalResponseHeaders =
{
{ "Access-Control-Allow-Origin", "*" },
{ "Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS" },
{ "Access-Control-Allow-Headers", "X-Requested-With" }
},
});
log.InfoFormat("AppHost Configured: " + DateTime.Now);
}
public override ServiceStackHost Init()
{
ServicePointManager.UseNagleAlgorithm = false;
ServicePointManager.DefaultConnectionLimit = 1000;
var conf = NLog.Config.ConfigurationItemFactory.Default;
conf.LayoutRenderers.RegisterDefinition("logsdir", typeof(LogsDir));
conf.LayoutRenderers.RegisterDefinition("Instance", typeof(Library.Logging.Instance));
NLog.LogManager.Configuration = new NLog.Config.XmlLoggingConfiguration($"{AppDomain.CurrentDomain.BaseDirectory}/logging.config");
LogManager.LogFactory = new global::ServiceStack.Logging.NLogger.NLogFactory();
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionTrapper;
AppDomain.CurrentDomain.FirstChanceException += ExceptionTrapper;
NServiceBus.Logging.LogManager.Use <NServiceBus.NLogFactory>();
IRedisClientsManager redisClient = null;
ICacheClient cacheClient;
IServerEvents serverEvents;
var connectionString = ConfigurationManager.ConnectionStrings["Redis"];
if (connectionString == null)
{
cacheClient = new MemoryCacheClient();
serverEvents = new MemoryServerEvents
{
IdleTimeout = TimeSpan.FromSeconds(30),
NotifyChannelOfSubscriptions = false
};
}
else
{
redisClient = new BasicRedisClientManager(connectionString.ConnectionString);
cacheClient = new RedisClientManagerCacheClient(redisClient);
serverEvents = new RedisServerEvents(redisClient)
{
Timeout = TimeSpan.FromSeconds(30),
NotifyChannelOfSubscriptions = false,
};
}
IDbConnectionFactory sql = new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider);
var connectionStringSql = ConfigurationManager.ConnectionStrings["SQL"];
if (connectionStringSql != null)
{
sql = new OrmLiteConnectionFactory(connectionStringSql.ConnectionString, SqlServer2012Dialect.Provider)
{
ConnectionFilter = x => new ProfiledDbConnection(x, Profiler.Current)
};
}
var pulse = ConfigureDemo();
var rabbit = ConfigureRabbit();
ConfigureMetrics();
_container = new Container(x =>
{
if (redisClient != null)
{
x.For <IRedisClientsManager>().Use(redisClient);
}
x.For <IDbConnectionFactory>().Use(sql);
x.For <ISubscriptionStorage>().Use <MssqlStorage>();
x.For <IManager>().Use <Manager>();
x.For <IFuture>().Use <Future>().Singleton();
x.For <ICacheClient>().Use(cacheClient);
x.For <IServerEvents>().Use(serverEvents);
x.For <ISubscriptionManager>().Use <SubscriptionManager>().Singleton();
x.For <IDemo>().Use(pulse);
x.For <IConnection>().Use(rabbit);
x.Scan(y =>
{
y.TheCallingAssembly();
y.AssembliesFromApplicationBaseDirectory((assembly) => assembly.FullName.StartsWith("Presentation.ServiceStack"));
y.WithDefaultConventions();
y.AddAllTypesOf <ISetup>();
y.AddAllTypesOf <ICommandMutator>();
y.ConnectImplementationsToTypesClosing(typeof(Q.IChange <,>));
});
});
// Do this before bus starts
InitiateSetup();
SetupApplication().Wait();
var bus = InitBus().Result;
_container.Configure(x => x.For <IMessageSession>().Use(bus).Singleton());
return(base.Init());
}
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);
}
}
private object Retrieve(Func<IRedisClient, string, object> redisCommand, string key)
{
HostElement hostElement =
_slaves.FirstOrDefault() ??
new HostElement
{
Host = _host,
Port = _port,
Password = _password
};
string password = hostElement.Password;
string host = hostElement.Host;
int port = hostElement.Port;
var readOnlyHosts = !String.IsNullOrEmpty(password) ?
String.Format("{0}@{1}:{2}", password, host, port) :
String.Format("{0}:{1}", host, port);
if (Environment.MachineName.Equals(host))
{
using (IRedisClientsManager redisManager = new BasicRedisClientManager(readOnlyHosts))
{
using (IRedisClient client = redisManager.GetClient())
{
return redisCommand.Invoke(client, key);
}
}
}
using (var redisManager = new PooledRedisClientManager(readOnlyHosts))
{
using (IRedisClient client = redisManager.GetClient())
{
return redisCommand.Invoke(client, key);
}
}
}
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(),
SqliteOrmLiteDialectProvider.Instance) {
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.Exec(dbCmd => dbCmd.CreateTable<Movie>(true));
ModelConfig<Movie>.Id(x => x.Title);
Routes
.Add<Movies>("/custom-movies", "GET")
.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());
container.RegisterValidators(typeof(CustomersValidator).Assembly);
//var onlyEnableFeatures = Feature.All.Remove(Feature.Jsv | Feature.Soap);
SetConfig(new EndpointHostConfig {
//EnableFeatures = onlyEnableFeatures,
DebugMode = true, //Show StackTraces for easier debugging
});
var redisManager = new BasicRedisClientManager();
var mqHost = new RedisMqHost(redisManager, 2, null);
mqHost.RegisterHandler<Reverse>(this.Container.Resolve<ReverseService>().Execute);
mqHost.Start();
this.Container.Register((IMessageService)mqHost);
}
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 BeginListeningForConfigurationChanges()
{
try
{
if (this.sentinePubSub == null)
{
var sentinelManager = new BasicRedisClientManager(sentinel.SentinelHosts, sentinel.SentinelHosts)
{
//Use BasicRedisResolver which doesn't validate non-Master Sentinel instances
RedisResolver = new BasicRedisResolver(sentinel.SentinelHosts, sentinel.SentinelHosts)
};
this.sentinePubSub = new RedisPubSubServer(sentinelManager)
{
HeartbeatInterval = null,
IsSentinelSubscription = true,
ChannelsMatching = new[] { RedisPubSubServer.AllChannelsWildCard },
OnMessage = SentinelMessageReceived
};
}
this.sentinePubSub.Start();
}
catch (Exception ex)
{
Log.Error("Error Subscribing to Redis Channel on {0}:{1}"
.Fmt(this.sentinelClient.Host, this.sentinelClient.Port), ex);
if (OnSentinelError != null)
OnSentinelError(ex);
}
}
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(),
SqliteOrmLiteDialectProvider.Instance)
{
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());
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
});
var redisManager = new BasicRedisClientManager();
var mqHost = new RedisMqHost(redisManager, 2, null);
mqHost.RegisterHandler <Reverse>(this.Container.Resolve <ReverseService>().Execute);
mqHost.Start();
this.Container.Register((IMessageService)mqHost);
}
public void Start(string redisServer)
{
// Initialize and start collectors only once
if (this.Redis == null)
{
this.PRCM = new BasicRedisClientManager(redisServer);
this.Redis = this.PRCM.GetClient();
if (CrawlNextLinkQueueManager == null)
{
CrawlNextLinkQueueManager = new System.Timers.Timer(2000);
CrawlNextLinkQueueManager.Elapsed += (o, ea) =>
{
CrawlNextLinkFromPool(this);
};
}
CrawlNextLinkQueueManager.Start();
//CrawlNextLinkFromPool(this);
if (CollectorsManager == null)
{
CollectorsManager = new System.Timers.Timer(500);
CollectorsManager.Elapsed += (o, ea) =>
{
LinkCollectorTaskPair workerToTerminate = null;
foreach (var worker in Collectors.Values)
{
if (worker.Task.IsCompleted ||
worker.Task.IsFaulted ||
worker.Task.IsCanceled)
{
workerToTerminate = worker;
break;
}
}
if (workerToTerminate != null)
{
workerToTerminate.Task.Dispose();
Collectors.Remove(workerToTerminate.LinkInfo.Link);
LinksCurrentlyProcessing.Remove(workerToTerminate.LinkInfo.Link);
CollectorCount[0] = Collectors.Count;
}
};
}
CollectorsManager.Start();
//if (PoolManager == null)
//{
// PoolManager = new System.Timers.Timer(10000);
// PoolManager.Elapsed += (o, ea) =>
// {
// PoolTop100SitesThatHaveBacklinksGreaterThan10(this);
// };
//}
//PoolManager.Stop();
//PoolManager.Start();
}
}
private void Command(Action<IRedisClient, string, CacheItem, TimeSpan> redisCommand, string key, CacheItem cacheItem, TimeSpan timeSpanExpiration)
{
if (Environment.MachineName.Equals(_host))
{
using (IRedisClientsManager redisManager = new BasicRedisClientManager(_writeHost))
{
using (IRedisClient client = redisManager.GetClient())
{
redisCommand.Invoke(client, key, cacheItem, timeSpanExpiration);
}
}
}
else
{
using (PooledRedisClientManager redisManager = new PooledRedisClientManager(_writeHost))
{
using (IRedisClient client = redisManager.GetClient())
{
redisCommand.Invoke(client, key, cacheItem, timeSpanExpiration);
}
}
}
}
public RedisCrawlUrlRepository()
{
clientManager = new BasicRedisClientManager("localhost:6379");
Client.FlushAll();
}
public void Lock_and_Unlock_should_silently_continue_if_SocketException()
{
using (var invalidClientManager = new BasicRedisClientManager(InvalidHost))
{
// Arrange
const int key = 1;
var cache = new RedisCache("region_A", invalidClientManager);
// Act / Assert
Assert.DoesNotThrow(() =>
{
cache.Put(key, new Person("A", 1));
cache.Lock(key);
cache.Unlock(key);
});
}
}
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 RedisSnapshotStorageProvider()
{
clientsManager = new BasicRedisClientManager(redisConnectionString);
}
