public virtual IClousotCache Create(IClousotCacheOptions options) { if (String.IsNullOrWhiteSpace(DbName) || options == null) { return(null); } var connection = BuildConnectionString(options).ToString(); Contract.Assert(DbName != null, "Helping cccheck"); SQLCacheModel model; if (options.ClearCache) { model = new SqlCacheModelClearExisting(connection, DbName, options.Trace); } else if (options.SaveToCache) { if (this.deleteOnModelChange) { model = new SqlCacheModelDropOnModelChange(connection, DbName, options.Trace); } else { model = new SqlCacheModelUseExisting(connection, DbName, options.Trace); } } else { model = new SqlCacheModelNoCreate(connection, DbName, options.Trace); } return(new ClousotCache(model, options)); }
public IClousotCache Create(IClousotCacheOptions options) { Contract.Ensures(Contract.Result <IClousotCache>() != null); var model = new MemCacheModel(); return(new ClousotCache(model, options)); }
IClousotCache IClousotCacheFactory.Create(IClousotCacheOptions options) { if (existing == null) { var memCache = new MemClousotCacheFactory().Create(options); this.existing = new UndisposableCacheDataAccessor(memCache); } return(this.existing); }
public StdDB(IClousotCacheOptions options) : base(new IClousotCacheFactory[] { new SQLClousotCacheFactory(options.CacheServer), //new SQLClousotCacheFactory(@"localhost\sqlexpress", true), new LocalDbClousotCacheFactory(), }) { Contract.Requires(options != null); }
public StdDB(IClousotCacheOptions options) : base(new IClousotCacheFactory[] { new SQLClousotCacheFactory(options.CacheServer) , //new SQLClousotCacheFactory(@"localhost\sqlexpress", true), new LocalDbClousotCacheFactory(), }) { Contract.Requires(options != null); }
protected virtual SqlConnectionStringBuilder BuildConnectionString(IClousotCacheOptions options) { Contract.Requires(options != null); Contract.Ensures(Contract.Result <SqlConnectionStringBuilder>() != null); return(new SqlConnectionStringBuilder { IntegratedSecurity = true, InitialCatalog = options.GetCacheDBName(), DataSource = this.DbName, UserInstance = false, MultipleActiveResultSets = true, ConnectTimeout = options.CacheServerTimeout, }); }
protected override SqlConnectionStringBuilder BuildConnectionString(IClousotCacheOptions options) { if (!string.IsNullOrWhiteSpace(options.CacheDirectory)) { var name = options.GetCacheDBName(); return(new SqlConnectionStringBuilder { IntegratedSecurity = true, InitialCatalog = name, DataSource = this.DbName, UserInstance = false, MultipleActiveResultSets = true, ConnectTimeout = options.CacheServerTimeout, AttachDBFilename = Path.Combine(options.CacheDirectory.AssumeNotNull(), name + ".mdf") }); } return(base.BuildConnectionString(options)); }
public virtual IClousotCache Create(IClousotCacheOptions options) { if (this.cacheAccessor == null) // avoids locking if not necessary { lock (this.LockCacheAccessor) if (this.cacheAccessor == null) { foreach (var factory in this.cacheDataAccessorFactories) { this.cacheAccessor = factory.Create(options); //test the db connection if (this.cacheAccessor != null && this.cacheAccessor.TestCache()) { break; } this.cacheAccessor = null; } } } return(new UndisposableCacheDataAccessor(this.cacheAccessor)); }
public ClousotCache(ICacheModel model, IClousotCacheOptions options) { Contract.Requires(model != null); Contract.Requires(options != null); this.options = options; this.model = model; try { // force db initialization var ignored = this.model.Metadatas.FirstOrDefault(); if (model.IsFresh) { var md = model.NewMetadata(); md.Key = "Version"; md.Value = Encoding.UTF8.GetBytes(options.ClousotVersion.AssumeNotNull()); model.AddOrUpdate(md); model.SaveChanges(now: true); } } catch (Exception e) { // failed this.model = null; if (options.Trace) { Console.WriteLine("[cache] Cannot open cache: {0}", e.Message); for (var inner = e.InnerException; inner != null; inner = inner.InnerException) { Console.WriteLine("[cache] Inner Exception: {0}", inner.Message); } } } }
public ClousotCache(ICacheModel model, IClousotCacheOptions options) { Contract.Requires(model != null); Contract.Requires(options != null); this.options = options; this.model = model; try { // force db initialization var ignored = this.model.Metadatas.FirstOrDefault(); if (model.IsFresh) { var md = model.NewMetadata(); md.Key = "Version"; md.Value = Encoding.UTF8.GetBytes(options.ClousotVersion.AssumeNotNull()); model.AddOrUpdate(md); model.SaveChanges(now: true); } } catch (Exception e) { // failed this.model = null; if (options.Trace) { Console.WriteLine("[cache] Cannot open cache: {0}", e.Message); for (var inner = e.InnerException; inner != null; inner = inner.InnerException) { Console.WriteLine("[cache] Inner Exception: {0}", inner.Message); } } } }
/// <summary> /// Extension method that creates cache asynchronously. /// </summary> /// <remarks> /// Task's result would be null if <see cref="factory"/>'s Create method returns null or when /// TestCache will return false. /// </remarks> public static Task<IClousotCache> CreateAndCheckAsync(this IClousotCacheFactory factory, IClousotCacheOptions options) { Contract.Requires(factory != null); Contract.Requires(options != null); // This implementation violates common TPL practice that suggest not to wrap // sync functions into async. But this helps to fix particular issue with // cache selection. // This implementation could be refined in the future by switching to appropriate // asynchronous implementation. return Task.Factory.StartNew(() => { var cache = factory.Create(options); if (cache == null || !cache.TestCache()) { return null; } return cache; }); }
IClousotCache IClousotCacheFactory.Create(IClousotCacheOptions options) { if (existing == null) { var memCache = new MemClousotCacheFactory().Create(options); this.existing = new UndisposableCacheDataAccessor(memCache); } return this.existing; }