public async Task Should_be_able_to_delete_time_series() { var expectedClientNames = new[] { TimeSeriesName + "A", TimeSeriesName + "C" }; using (var store = NewRemoteTimeSeriesStore(createDefaultTimeSeries: false)) { await store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument(expectedClientNames[0])); await store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument("TimeSeriesThatWillBeDeleted")); await store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument(expectedClientNames[1])); await store.Admin.DeleteTimeSeriesAsync("TimeSeriesThatWillBeDeleted", true); var timeSeriesNames = await store.Admin.GetTimeSeriesNamesAsync(); Assert.Equal(expectedClientNames.Length, timeSeriesNames.Count()); foreach (var name in expectedClientNames) { Assert.Contains(name, timeSeriesNames); } } }
protected virtual IDatabaseChanges CreateDatabaseChanges(string database) { if (string.IsNullOrEmpty(Url)) { throw new InvalidOperationException("Changes API requires usage of server/client"); } database = database ?? DefaultDatabase; var dbUrl = MultiDatabase.GetRootDatabaseUrl(Url); if (string.IsNullOrEmpty(database) == false) { dbUrl = dbUrl + "/databases/" + database; } return(new RemoteDatabaseChanges(dbUrl, Credentials, jsonRequestFactory, Conventions, GetReplicationInformerForDatabase(database), () => databaseChanges.Remove(database))); }
private void UpdateReplicationInformationFromDocument(JsonDocument document) { var replicationDocument = document.DataAsJson.JsonDeserialization <ReplicationDocument>(); replicationDestinations = replicationDocument.Destinations.Select(x => { var url = string.IsNullOrEmpty(x.ClientVisibleUrl) ? x.Url : x.ClientVisibleUrl; if (string.IsNullOrEmpty(url) || x.Disabled || x.IgnoredClient) { return(null); } if (string.IsNullOrEmpty(x.Database)) { return(new OperationMetadata(url, x.Username, x.Password, x.Domain, x.ApiKey)); } return(new OperationMetadata( MultiDatabase.GetRootDatabaseUrl(url) + "/databases/" + x.Database + "/", x.Username, x.Password, x.Domain, x.ApiKey)); }) // filter out replication destination that don't have the url setup, we don't know how to reach them // so we might as well ignore them. Probably private replication destination (using connection string names only) .Where(x => x != null) .ToList(); foreach (var replicationDestination in replicationDestinations) { FailureCounter value; if (failureCounts.TryGetValue(replicationDestination.Url, out value)) { continue; } failureCounts[replicationDestination.Url] = new FailureCounter(); } }
/// <summary> /// Initialize the document store access method to RavenDB /// </summary> protected virtual void InitializeInternal() { var rootDatabaseUrl = MultiDatabase.GetRootDatabaseUrl(Url); #if !DNXCORE50 // TODO [ppekrol] how to set this? rootServicePoint = ServicePointManager.FindServicePoint(new Uri(rootDatabaseUrl)); rootServicePoint.UseNagleAlgorithm = false; rootServicePoint.Expect100Continue = false; rootServicePoint.ConnectionLimit = 256; rootServicePoint.MaxIdleTime = Timeout.Infinite; #endif databaseCommandsGenerator = () => { string databaseUrl = Url; if (string.IsNullOrEmpty(DefaultDatabase) == false) { databaseUrl = rootDatabaseUrl; databaseUrl = databaseUrl + "/databases/" + DefaultDatabase; } return(new ServerClient(new AsyncServerClient(databaseUrl, Conventions, new OperationCredentials(ApiKey, Credentials), jsonRequestFactory, currentSessionId, GetReplicationInformerForDatabase, null, Listeners.ConflictListeners, true))); }; asyncDatabaseCommandsGenerator = () => { var asyncServerClient = new AsyncServerClient(Url, Conventions, new OperationCredentials(ApiKey, Credentials), jsonRequestFactory, currentSessionId, GetReplicationInformerForDatabase, null, Listeners.ConflictListeners, true); if (string.IsNullOrEmpty(DefaultDatabase)) { return(asyncServerClient); } return(asyncServerClient.ForDatabase(DefaultDatabase)); }; }
public void CreateDb(string dbname = null) { try { if (dbname == null) { dbname = "test"; } var doc = MultiDatabase.CreateDatabaseDocument(dbname); store.AsyncDatabaseCommands.GlobalAdmin.CreateDatabaseAsync(doc).Wait(); } catch (Exception ex) { if (ex.Message.Contains("already exists")) { Log($"Database '{dbname}' already exists!"); } else { Log("Cannot create DB " + dbname + ". Exception : " + ex.Message, true); throw; } } }
public ReplicationInformer GetReplicationInformerForDatabase(string dbName = null) { var key = Url; dbName = dbName ?? DefaultDatabase; if (string.IsNullOrEmpty(dbName) == false) { key = MultiDatabase.GetRootDatabaseUrl(Url) + "/databases/" + dbName; } #if SILVERLIGHT || NETFX_CORE lock (replicationInformersLocker) { ReplicationInformer result; if (!replicationInformers.TryGetValue(key, out result)) { result = Conventions.ReplicationInformerFactory(key); replicationInformers.Add(key, result); } return(result); } #else return(replicationInformers.GetOrAdd(key, Conventions.ReplicationInformerFactory)); #endif }
static SlappCommand() { // Initialise Slapp try { // Construct the database jsonDatabase = new SplatTagJsonDatabase(saveFolder); multiSourceImporter = new GenericFilesImporter(saveFolder); splatTagDatabase = new MultiDatabase(saveFolder, jsonDatabase, multiSourceImporter); // Construct the controller. splatTagController = new SplatTagController(splatTagDatabase); initialiseTask = Task.Run(() => { // Load the database splatTagController.Initialise(); }); } catch (Exception ex) { throw new InvalidOperationException("Exception: " + ex.ToString()); } }
public async Task AdminClientWorkWithOAuthEnabled() { var client = (IAsyncFilesCommandsImpl)NewAsyncClient(enableAuthentication: true, apiKey: apiKey); var adminClient = client.Admin; await adminClient.CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("testName")); var names = await adminClient.GetNamesAsync(); Assert.Equal(2, names.Length); Assert.Contains("AdminClientWorkWithOAuthEnabled", names); var stats = await adminClient.GetStatisticsAsync(); Assert.Equal(0, stats.Length); // 0 because our fs aren't active using (var createdFsClient = new AsyncFilesServerClient(client.ServerUrl, "testName")) { var buffer = Enumerable.Range(1, 1).Select(x => (byte)(x % byte.MaxValue)).ToArray(); await createdFsClient.UploadAsync("fooFoo", new MemoryStream(buffer)); } await adminClient.DeleteFileSystemAsync("testName", true); }
public async Task EnsureDatabaseExistsAsync(string name, bool ignoreFailures = false, CancellationToken token = default(CancellationToken)) { var serverClient = (AsyncServerClient)(innerAsyncServerClient.ForSystemDatabase()); var doc = MultiDatabase.CreateDatabaseDocument(name); serverClient.ForceReadFromMaster(); try { var get = await serverClient.GetAsync(doc.Id, token).ConfigureAwait(false); if (get != null) { return; } await serverClient.GlobalAdmin.CreateDatabaseAsync(doc, token).ConfigureAwait(false); try { await new RavenDocumentsByEntityName().ExecuteAsync(serverClient.ForDatabase(name), new DocumentConvention(), token).ConfigureAwait(false); } catch (Exception) { // this is a courtesy, not required, and can happen if we don't have permissions to the new db } } catch (Exception) { if (ignoreFailures == false) { throw; } } }
public void Store(object entity) { var shardId = shardResolutionStrategy.GenerateShardIdFor(entity, this); var shard = shards[shardId]; BulkInsertOperation bulkInsertOperation; if (Bulks.TryGetValue(shardId, out bulkInsertOperation) == false) { var actualDatabaseName = database ?? ((dynamic)shard).DefaultDatabase ?? MultiDatabase.GetDatabaseName(shard.Url); bulkInsertOperation = new BulkInsertOperation(actualDatabaseName, shard, shard.Listeners, options, shard.Changes()); Bulks.Add(shardId, bulkInsertOperation); } DatabaseCommands = string.IsNullOrWhiteSpace(database) ? shard.AsyncDatabaseCommands : shard.AsyncDatabaseCommands.ForDatabase(database); string id; if (generateEntityIdOnTheClient.TryGetIdFromInstance(entity, out id) == false) { id = generateEntityIdOnTheClient.GetOrGenerateDocumentKey(entity); } var modifyDocumentId = shardStrategy.ModifyDocumentId(shardedDocumentStore.Conventions, shardId, id); bulkInsertOperation.Store(entity, modifyDocumentId); }
public async Task CanUseBetween() { using (var server1 = new RavenDbServer(new RavenConfiguration() { Port = Port1, ServerName = ServerName1 }) { RunInMemory = true, UseEmbeddedHttpServer = true }.Initialize()) { var doc = MultiDatabase.CreateDatabaseDocument("db1"); ((ServerClient)server1.DocumentStore.DatabaseCommands.ForSystemDatabase()).GlobalAdmin.CreateDatabase(doc); using (var store1 = new DocumentStore { Url = "http://localhost:" + Port1, DefaultDatabase = "db1" }.Initialize()) { new Users_ByName().Execute(store1); new UsersTransformer().Execute(store1); using (var session = store1.OpenSession("db1")) { session.Store(new User { Name = "Name1", LastName = "LastName1" }); session.Store(new User { Name = "Name2", LastName = "LastName2" }); session.SaveChanges(); } store1.DatabaseCommands.PutAttachment("attachement1", null, new MemoryStream(new byte[] { 3 }), new RavenJObject()); using (var server2 = new RavenDbServer(new RavenConfiguration() { Port = Port2, ServerName = ServerName2 }) { RunInMemory = true, UseEmbeddedHttpServer = true }.Initialize()) { var doc2 = MultiDatabase.CreateDatabaseDocument("db2"); ((ServerClient)server2.DocumentStore.DatabaseCommands.ForSystemDatabase()).GlobalAdmin.CreateDatabase(doc2); using (var store2 = new DocumentStore { Url = "http://localhost:" + Port2, DefaultDatabase = "db2" }.Initialize()) { var smugglerApi = new SmugglerDatabaseApi(); await smugglerApi.Between(new SmugglerBetweenOptions <RavenConnectionStringOptions> { From = new RavenConnectionStringOptions { Url = "http://localhost:" + Port1, DefaultDatabase = "db1" }, To = new RavenConnectionStringOptions { Url = "http://localhost:" + Port2, DefaultDatabase = "db2" } }); var docs = store2.DatabaseCommands.GetDocuments(0, 10); Assert.Equal(3, docs.Length); var indexes = store2.DatabaseCommands.GetIndexes(0, 10); Assert.Equal(1, indexes.Length); var transformers = store2.DatabaseCommands.GetTransformers(0, 10); Assert.Equal(1, transformers.Length); var attachments = store2.DatabaseCommands.GetAttachments(0, new Etag(), 10); Assert.Equal(1, attachments.Length); } } } } }
public static string Databases(this string url, int pageSize, int start) { var databases = MultiDatabase.GetRootDatabaseUrl(url) + "/databases?pageSize=" + pageSize; return(start > 0 ? databases + "&start=" + start : databases); }
public async Task TestMassiveParallelDatabaseLoads(string storageEngine) { using (var server = GetNewServer()) { var defaultStore = server.DocumentStore; var userRJO = RavenJObject.FromObject(new User { Name = "Abe" }); for (var i = 0; i < 120; i++) { var dbName = "Database" + i; var databaseDocument = MultiDatabase.CreateDatabaseDocument(dbName); databaseDocument.Settings["Raven/StorageTypeName"] = storageEngine; databaseDocument.Settings.Add("Raven/Tenants/MaxIdleTimeForTenantDatabase", "20"); await defaultStore.AsyncDatabaseCommands.GlobalAdmin.CreateDatabaseAsync( databaseDocument).ConfigureAwait(false); using (var curStore = new DocumentStore() { Url = GetServerUrl(false, server.SystemDatabase.ServerUrl), Conventions = new DocumentConvention() { FailoverBehavior = FailoverBehavior.FailImmediately }, DefaultDatabase = dbName }) { curStore.Initialize(); using (var bi = curStore.BulkInsert()) { for (var j = 0; j < 5; j++) { bi.Store(new User() { Name = "UserNumber" + j }); } } } await defaultStore.JsonRequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(null, defaultStore.Url + "/admin/databases-toggle-disable?id=" + dbName + "&isSettingDisabled=true", HttpMethod.Post, null, defaultStore.Conventions, null)).ExecuteRequestAsync().ConfigureAwait(false); } Parallel.For(0, 120, new ParallelOptions() { MaxDegreeOfParallelism = 20 }, i => { var dbName = "Database" + i; defaultStore.JsonRequestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(null, defaultStore.Url + "/admin/databases-toggle-disable?id=" + dbName + "&isSettingDisabled=false", HttpMethod.Post, null, defaultStore.Conventions, null)).ExecuteRequest(); using (var store = NewDocumentStore(databaseName: dbName, seedData: new[] { new string[] {} }, indexes: new AbstractIndexCreationTask[] { })) { store.DatabaseCommands.Put("users/1", null, userRJO, null); } }); } }
private TcpConnectionInfo GetTcpInfo() { var convention = new DocumentConvention(); //since we use it only once when the connection is initialized, no reason to keep requestFactory around for long using (var requestFactory = new HttpJsonRequestFactory(1)) using (var request = requestFactory.CreateHttpJsonRequest(new CreateHttpJsonRequestParams(null, string.Format("{0}/info/tcp", MultiDatabase.GetRootDatabaseUrl(_destination.Url)), HttpMethod.Get, new OperationCredentials(_destination.ApiKey, CredentialCache.DefaultCredentials), convention) { Timeout = TimeSpan.FromSeconds(15) })) { var result = request.ReadResponseJson(); var tcpConnectionInfo = convention.CreateSerializer().Deserialize <TcpConnectionInfo>(new RavenJTokenReader(result)); if (_log.IsInfoEnabled) { _log.Info($"Will replicate to {_destination.Database} @ {_destination.Url} via {tcpConnectionInfo.Url}"); } return(tcpConnectionInfo); } }
protected virtual DocumentStore GetDocumentStore( [CallerMemberName] string caller = null, string dbSuffixIdentifier = null, string path = null, Action <DatabaseDocument> modifyDatabaseDocument = null, Func <string, string> modifyName = null, string apiKey = null) { var name = caller != null ? $"{caller}_{Interlocked.Increment(ref _counter)}" : Guid.NewGuid().ToString("N"); if (dbSuffixIdentifier != null) { name = $"{name}_{dbSuffixIdentifier}"; } if (modifyName != null) { name = modifyName(name); } var hardDelete = true; var runInMemory = true; if (path == null) { path = NewDataPath(name); } else { hardDelete = false; runInMemory = false; } var doc = MultiDatabase.CreateDatabaseDocument(name); doc.Settings[RavenConfiguration.GetKey(x => x.Core.RunInMemory)] = runInMemory.ToString(); doc.Settings[RavenConfiguration.GetKey(x => x.Core.DataDirectory)] = path; doc.Settings[RavenConfiguration.GetKey(x => x.Core.ThrowIfAnyIndexOrTransformerCouldNotBeOpened)] = "true"; doc.Settings[RavenConfiguration.GetKey(x => x.Indexing.MinNumberOfMapAttemptsAfterWhichBatchWillBeCanceledIfRunningLowOnMemory)] = int.MaxValue.ToString(); modifyDatabaseDocument?.Invoke(doc); TransactionOperationContext context; using (Server.ServerStore.ContextPool.AllocateOperationContext(out context)) { context.OpenReadTransaction(); if (Server.ServerStore.Read(context, Constants.Database.Prefix + name) != null) { throw new InvalidOperationException($"Database '{name}' already exists"); } } var store = new DocumentStore { Url = UseFiddler(Server.Configuration.Core.ServerUrl), DefaultDatabase = name, ApiKey = apiKey }; ModifyStore(store); store.Initialize(); store.DatabaseCommands.GlobalAdmin.CreateDatabase(doc); store.AfterDispose += (sender, args) => { if (CreatedStores.TryRemove(store) == false) { return; // can happen if we are wrapping the store inside sharded one } if (Server.Disposed == false) { var databaseTask = Server.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(name); if (databaseTask != null && databaseTask.IsCompleted == false) { databaseTask.Wait(); // if we are disposing store before database had chance to load then we need to wait } store.DatabaseCommands.GlobalAdmin.DeleteDatabase(name, hardDelete: hardDelete); } }; CreatedStores.Add(store); return(store); }
public static string AdminStats(this string url) { return(MultiDatabase.GetRootDatabaseUrl(url) + "/admin/stats"); }
private void WriteToServer(string url, Stream serverStream) { const string debugTag = "bulk/insert/document"; var jsonParserState = new JsonParserState(); //var streamNetworkBuffer = new BufferedStream(serverStream, 32 * 1024); var streamNetworkBuffer = serverStream; var writeToStreamBuffer = new byte[32 * 1024]; var header = Encoding.UTF8.GetBytes(RavenJObject.FromObject(new TcpConnectionHeaderMessage { DatabaseName = MultiDatabase.GetDatabaseName(url), Operation = TcpConnectionHeaderMessage.OperationTypes.BulkInsert }).ToString()); streamNetworkBuffer.Write(header, 0, header.Length); JsonOperationContext.ManagedPinnedBuffer bytes; using (_jsonOperationContext.GetManagedBuffer(out bytes)) { while (_documents.IsCompleted == false) { _cts.Token.ThrowIfCancellationRequested(); MemoryStream jsonBuffer; try { jsonBuffer = _documents.Take(); } catch (InvalidOperationException) { break; } var needToThrottle = _throttlingEvent.Wait(0) == false; _jsonOperationContext.ResetAndRenew(); using (var jsonParser = new UnmanagedJsonParser(_jsonOperationContext, jsonParserState, debugTag)) using (var builder = new BlittableJsonDocumentBuilder(_jsonOperationContext, BlittableJsonDocumentBuilder.UsageMode.ToDisk, debugTag, jsonParser, jsonParserState)) { _jsonOperationContext.CachedProperties.NewDocument(); builder.ReadObjectDocument(); while (true) { var read = jsonBuffer.Read(bytes.Buffer.Array, bytes.Buffer.Offset, bytes.Length); if (read == 0) { throw new EndOfStreamException("Stream ended without reaching end of json content"); } jsonParser.SetBuffer(bytes, read); if (builder.Read()) { break; } } _buffers.Add(jsonBuffer); builder.FinalizeDocument(); WriteVariableSizeInt(streamNetworkBuffer, builder.SizeInBytes); WriteToStream(streamNetworkBuffer, builder, writeToStreamBuffer); } if (needToThrottle) { streamNetworkBuffer.Flush(); _throttlingEvent.Wait(500); } } streamNetworkBuffer.WriteByte(0); //done streamNetworkBuffer.Flush(); } }
public async Task StoreAsync(object entity) { var shardId = shardResolutionStrategy.GenerateShardIdFor(entity, this); var shard = shards[shardId]; BulkInsertOperation bulkInsertOperation; if (Bulks.TryGetValue(shardId, out bulkInsertOperation) == false) { var actualDatabaseName = database ?? ((DocumentStore)shard).DefaultDatabase ?? MultiDatabase.GetDatabaseName(shard.Url); bulkInsertOperation = new BulkInsertOperation(actualDatabaseName, shard, shard.Listeners); Bulks.Add(shardId, bulkInsertOperation); } DatabaseCommands = shard.AsyncDatabaseCommands; string id; if (generateEntityIdOnTheClient.TryGetIdFromInstance(entity, out id) == false) { id = generateEntityIdOnTheClient.GetOrGenerateDocumentKey(entity); } var modifyDocumentId = shardStrategy.ModifyDocumentId(shardedDocumentStore.Conventions, shardId, id); await bulkInsertOperation.StoreAsync(entity, modifyDocumentId).ConfigureAwait(false); }
public static string Databases(this string url, int pageSize, int start) { var databases = $"{MultiDatabase.GetRootDatabaseUrl(url)}/databases?pageSize={pageSize}"; return(start > 0 ? $"{databases}&start={start}" : databases); }
public async Task Foo() { IFilesStore store = null; #region create_fs_2 await store.AsyncFilesCommands.Admin .CreateFileSystemAsync(new FileSystemDocument { Id = "Raven/FileSystem/NorthwindFS", Settings = { { Constants.FileSystem.DataDirectory, "~/FileSystems/NorthwindFS" }, { Constants.ActiveBundles, "Versioning" } } }); #endregion #region create_fs_3 await store.AsyncFilesCommands.Admin .CreateFileSystemAsync(MultiDatabase.CreateFileSystemDocument("NorthwindFS")); #endregion #region ensure_fs_exists_2 await store.AsyncFilesCommands.Admin .EnsureFileSystemExistsAsync("NorthwindFS"); #endregion #region delete_fs_2 await store.AsyncFilesCommands.Admin .DeleteFileSystemAsync(hardDelete : true); #endregion #region start_backup_2 await store.AsyncFilesCommands.Admin .StartBackup(@"C:\backups\NorthwindFS", null, false, "NorthwindFS"); #endregion #region start_backup_3 BackupStatus status = await store.AsyncFilesCommands.Configuration .GetKeyAsync <BackupStatus>(BackupStatus.RavenBackupStatusDocumentKey); if (status.IsRunning) { // ... // } #endregion #region start_restore_2 long restoreOperationId = await store.AsyncFilesCommands.Admin .StartRestore(new FilesystemRestoreRequest() { BackupLocation = @"C:\backups\NorthwindFS", FilesystemLocation = @"~\FileSystems\NewNorthwindFS", FilesystemName = "NewNorthwindFS" }); #endregion #region start_restore_3 using (var sysDbStore = new DocumentStore { Url = "http://localhost:8080/" }.Initialize()) { await new Operation((AsyncServerClient)sysDbStore.AsyncDatabaseCommands, restoreOperationId) .WaitForCompletionAsync(); } #endregion #region start_compact_2 long compactOperationId = await store.AsyncFilesCommands.Admin .StartCompact("NorthwindFS"); #endregion #region start_compact_3 using (var sysDbStore = new DocumentStore { Url = "http://localhost:8080/" }.Initialize()) { await new Operation((AsyncServerClient)sysDbStore.AsyncDatabaseCommands, compactOperationId) .WaitForCompletionAsync(); } #endregion #region reset_indexes_2 await store.AsyncFilesCommands.Admin .ResetIndexes("NorthwindFS"); #endregion #region get_names_2 string[] fsNames = await store.AsyncFilesCommands.Admin .GetNamesAsync(); #endregion #region get_stats_2 FileSystemStats[] fsStats = await store.AsyncFilesCommands.Admin .GetStatisticsAsync(); #endregion }
protected virtual DocumentStore GetDocumentStore([CallerMemberName] string caller = null, string dbSuffixIdentifier = null, string path = null, Action <DatabaseDocument> modifyDatabaseDocument = null, string apiKey = null, bool deleteDbAfterDispose = true) { var name = caller != null ? $"{caller}_{Interlocked.Increment(ref _counter)}" : Guid.NewGuid().ToString("N"); if (dbSuffixIdentifier != null) { name = $"{name}_{dbSuffixIdentifier}"; } var runInMemory = true; if (path == null) { path = NewDataPath(name); } else { runInMemory = false; } var doc = MultiDatabase.CreateDatabaseDocument(name); doc.Settings[RavenConfiguration.GetKey(x => x.Core.RunInMemory)] = runInMemory.ToString(); doc.Settings[RavenConfiguration.GetKey(x => x.Core.DataDirectory)] = path; doc.Settings[RavenConfiguration.GetKey(x => x.Core.ThrowIfAnyIndexOrTransformerCouldNotBeOpened)] = "true"; doc.Settings[RavenConfiguration.GetKey(x => x.Indexing.MinNumberOfMapAttemptsAfterWhichBatchWillBeCanceledIfRunningLowOnMemory)] = int.MaxValue.ToString(); modifyDatabaseDocument?.Invoke(doc); TransactionOperationContext context; using (Server.ServerStore.ContextPool.AllocateOperationContext(out context)) { context.OpenReadTransaction(); if (Server.ServerStore.Read(context, Constants.Database.Prefix + name) != null) { throw new InvalidOperationException($"Database '{name}' already exists"); } } var store = new DocumentStore { Url = UseFiddler(Server.Configuration.Core.ServerUrl), DefaultDatabase = name, ApiKey = apiKey }; ModifyStore(store); store.Initialize(); var createDatabaseOperation = new CreateDatabaseOperation(context); var command = createDatabaseOperation.CreateRequest(store, doc); if (command != null) { store.GetRequestExecuter(name).Execute(command, context); } store.AfterDispose += (sender, args) => { var databaseTask = Server.ServerStore.DatabasesLandlord.TryGetOrCreateResourceStore(name); if (databaseTask != null && databaseTask.IsCompleted == false) { databaseTask.Wait(); // if we are disposing store before database had chance to load then we need to wait } Server.ServerStore.DatabasesLandlord.UnloadAndLock(name, () => { if (deleteDbAfterDispose) { var dbId = Constants.Database.Prefix + name; using (Server.ServerStore.ContextPool.AllocateOperationContext(out context)) using (var tx = context.OpenWriteTransaction()) { Server.ServerStore.Delete(context, dbId); tx.Commit(); } if (databaseTask != null) { DatabaseHelper.DeleteDatabaseFiles(databaseTask.Result.Configuration); } } }); CreatedStores.TryRemove(store); }; CreatedStores.Add(store); return(store); }
private IRequestExecuter GetRequestExecuterForDatabase(AsyncServerClient serverClient, string databaseName, bool incrementStrippingBase) { var key = Url; if (string.IsNullOrEmpty(databaseName) == false) { key = MultiDatabase.GetRootDatabaseUrl(Url) + "/databases/" + databaseName; } var originalKey = MultiDatabase.GetRootDatabaseUrl(Url); IRequestExecuter requestExecuter; IRequestExecuter originalRequestExecuter = null; if (Conventions.FailoverBehavior == FailoverBehavior.ReadFromLeaderWriteToLeader || Conventions.FailoverBehavior == FailoverBehavior.ReadFromLeaderWriteToLeaderWithFailovers || Conventions.FailoverBehavior == FailoverBehavior.ReadFromAllWriteToLeader || Conventions.FailoverBehavior == FailoverBehavior.ReadFromAllWriteToLeaderWithFailovers) { requestExecuter = clusterAwareRequestExecuters.GetOrAdd(key, url => new ClusterAwareRequestExecuter()); if (originalKey != key) { originalRequestExecuter = clusterAwareRequestExecuters.GetOrAdd(originalKey, url => new ClusterAwareRequestExecuter()); } } else { requestExecuter = new ReplicationAwareRequestExecuter(replicationInformers.GetOrAdd(key, url => Conventions.ReplicationInformerFactory(url, jsonRequestFactory, GetRequestTimeMetricForUrl))); if (originalKey != key) { originalRequestExecuter = new ReplicationAwareRequestExecuter(replicationInformers.GetOrAdd(originalKey, url => Conventions.ReplicationInformerFactory(url, jsonRequestFactory, GetRequestTimeMetricForUrl))); } } if (incrementStrippingBase || originalRequestExecuter == null) { requestExecuter.GetReadStripingBase(incrementStrippingBase); } else { requestExecuter.SetReadStripingBase(originalRequestExecuter.GetReadStripingBase(false)); } if (FailoverServers == null) { return(requestExecuter); } if (databaseName == DefaultDatabase) { if (FailoverServers.IsSetForDefaultDatabase && requestExecuter.FailoverServers == null) { requestExecuter.FailoverServers = FailoverServers.ForDefaultDatabase; } } else { if (FailoverServers.IsSetForDatabase(databaseName) && requestExecuter.FailoverServers == null) { requestExecuter.FailoverServers = FailoverServers.GetForDatabase(databaseName); } } return(requestExecuter); }
public async Task Should_not_be_able_to_create_time_series_with_the_same_name_twice() { using (var store = NewRemoteTimeSeriesStore()) { await store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument(TimeSeriesName)); var exception = await AssertAsync.Throws <InvalidOperationException>(() => store.Admin.CreateTimeSeriesAsync(MultiDatabase.CreateTimeSeriesDocument(TimeSeriesName))); } }