public void Create_and_initialize_operation()
{
var createDatabaseOperation = new CreateDatabaseOperation("MyDatabase");
Assert.Equal("MyDatabase", createDatabaseOperation.DatabaseName);
Assert.False(createDatabaseOperation.IsDestructiveChange);
}
public void CanGetGoodErrorForBadTopologies()
{
UseNewLocalServer(new Dictionary <string, string>
{
["PublicServerUrl"] = "http://invalid.example.com" // intentionally broken!
});
var url = Server.WebUrl;
var reqExec = RequestExecutor.CreateForSingleNodeWithoutConfigurationUpdates(url, "Foo", null, DocumentConventions.Default);
var op = new CreateDatabaseOperation(new Raven.Client.ServerWide.DatabaseRecord("Foo"));
using (reqExec.ContextPool.AllocateOperationContext(out var ctx))
{
Assert.Throws <RavenException>(() => reqExec.Execute(op.GetCommand(DocumentConventions.Default, ctx), ctx));
}
using (var store = new DocumentStore
{
Urls = new[] { url },
Database = "Foo",
})
{
store.Initialize();
using (var session = store.OpenSession())
{
var e = Assert.Throws <RavenException>(() => session.Load <object>("users/1-a"));
Assert.Contains("invalid.example.com", e.Message);
}
}
}
public override void Generate(
CreateDatabaseOperation createDatabaseOperation,
IndentedStringBuilder stringBuilder)
{
throw new NotSupportedException(Strings.FormatMigrationOperationNotSupported(
GetType(), createDatabaseOperation.GetType()));
}
public void CreateFreshTestDatabase()
{
if (string.IsNullOrWhiteSpace(RavenDbSettings.TestDatabaseName))
{
throw new ArgumentNullException(nameof(RavenDbSettings.TestDatabaseName));
}
try
{
Store.Maintenance.ForDatabase(RavenDbSettings.TestDatabaseName).Send(new GetStatisticsOperation());
//it didn't throw so it exists and we can delete it
var deleteOperation = new DeleteDatabasesOperation(RavenDbSettings.TestDatabaseName, true);
Store.Maintenance.Server.Send(deleteOperation);
}
catch (DatabaseDoesNotExistException)
{
}
try
{
var createOperation = new CreateDatabaseOperation(new DatabaseRecord(RavenDbSettings.TestDatabaseName));
Store.Maintenance.Server.Send(createOperation);
}
catch (ConcurrencyException)
{
// Something created the database already
}
}
public static DocumentStore GetDocumentStore(string url = null)
{
if (url is null)
{
url = "http://localhost:8080";
}
var dataBase = "kairos";
var store = new DocumentStore {
Urls = new[] { url }, Database = dataBase
};
store.Initialize();
var operation = new GetDatabaseNamesOperation(0, 10);
var databases = store.Maintenance.Server.Send(operation);
if (!databases.Contains(dataBase))
{
var createDb = new CreateDatabaseOperation(new DatabaseRecord(dataBase));
store.Maintenance.Server.Send(createDb);
}
new ListFeedEventAggregatedIndex().Execute(store);
return(store);
}
public async Task Smuggler_Export_And_Import_Should_Work_With_ForDatabase()
{
using (var server = GetNewServer())
{
using (var store = new DocumentStore
{
Urls = new[] { server.WebUrl }
}.Initialize())
{
var createSrcDatabase = new CreateDatabaseOperation(new DatabaseRecord("SrcDatabase"));
await store.Maintenance.Server.SendAsync(createSrcDatabase);
var createDestDatabase = new CreateDatabaseOperation(new DatabaseRecord("DestDatabase"));
await store.Maintenance.Server.SendAsync(createDestDatabase);
const int documentCount = 10000;
using (var session = store.OpenAsyncSession("SrcDatabase"))
{
for (var i = 0; i < documentCount; i++)
{
var user = new User {
Name = $"User {i}"
};
await session.StoreAsync(user);
}
await session.SaveChangesAsync();
}
var exportOptions = new DatabaseSmugglerExportOptions
{
OperateOnTypes = DatabaseItemType.Documents
};
var destination = store.Smuggler.ForDatabase("DestDatabase");
var operation = await store.Smuggler.ForDatabase("SrcDatabase").ExportAsync(exportOptions, destination);
await operation.WaitForCompletionAsync();
var stats = await store.Maintenance.ForDatabase("DestDatabase").SendAsync(new GetStatisticsOperation());
Assert.True(stats.CountOfDocuments >= documentCount);
await store.Maintenance.Server.SendAsync(new CreateDatabaseOperation(new DatabaseRecord("ImportDest")));
using (var stream = GetDump("RavenDB_11664.1.ravendbdump"))
{
await store.Smuggler.ForDatabase("ImportDest").ImportAsync(new DatabaseSmugglerImportOptions(), stream);
}
using (var session = store.OpenAsyncSession("ImportDest"))
{
var employee = await session.LoadAsync <Employee>("employees/9-A");
Assert.NotNull(employee);
}
}
}
}
public void Generate_with_create_database_not_supported()
{
var operation = new CreateDatabaseOperation("Bronies");
Assert.Equal(
Strings.FormatMigrationOperationNotSupported(typeof(SQLiteMigrationOperationSqlGenerator), operation.GetType()),
Assert.Throws <NotSupportedException>(() => Generate(operation)).Message);
}
public virtual void Generate([NotNull] CreateDatabaseOperation createDatabaseOperation, [NotNull] IndentedStringBuilder stringBuilder, bool generateIdempotentSql)
{
Check.NotNull(createDatabaseOperation, "createDatabaseOperation");
Check.NotNull(stringBuilder, "stringBuilder");
stringBuilder
.Append("CREATE DATABASE ")
.Append(DelimitIdentifier(createDatabaseOperation.DatabaseName));
}
public virtual void Generate([NotNull] CreateDatabaseOperation createDatabaseOperation, [NotNull] SqlBatchBuilder batchBuilder)
{
Check.NotNull(createDatabaseOperation, "createDatabaseOperation");
Check.NotNull(batchBuilder, "batchBuilder");
batchBuilder
.Append("CREATE DATABASE ")
.Append(DelimitIdentifier(createDatabaseOperation.DatabaseName));
}
public void Dispatches_visitor()
{
var createDatabaseOperation = new CreateDatabaseOperation("MyDatabase");
var mockVisitor = MigrationsTestHelpers.MockSqlGenerator();
var builder = new Mock <SqlBatchBuilder>();
createDatabaseOperation.GenerateSql(mockVisitor.Object, builder.Object);
mockVisitor.Verify(g => g.Generate(createDatabaseOperation, builder.Object), Times.Once());
}
public void Dispatches_visitor()
{
var createDatabaseOperation = new CreateDatabaseOperation("MyDatabase");
var mockVisitor = new Mock <MigrationOperationSqlGenerator>(new RelationalTypeMapper());
var builder = new Mock <IndentedStringBuilder>();
createDatabaseOperation.GenerateSql(mockVisitor.Object, builder.Object, false);
mockVisitor.Verify(g => g.Generate(createDatabaseOperation, builder.Object, false), Times.Once());
}
public override void Generate([NotNull] CreateDatabaseOperation createDatabaseOperation, [NotNull] IndentedStringBuilder stringBuilder)
{
Check.NotNull(createDatabaseOperation, "createDatabaseOperation");
Check.NotNull(stringBuilder, "stringBuilder");
stringBuilder
.Append("CreateDatabase(")
.Append(GenerateLiteral(createDatabaseOperation.DatabaseName))
.Append(")");
}
public void Generate_when_create_database_operation()
{
var operation = new CreateDatabaseOperation("MyDatabase");
Assert.Equal(
@"CreateDatabase(""MyDatabase"")",
CSharpMigrationCodeGenerator.Generate(operation));
GenerateAndValidateCode(operation);
}
public IDocumentStore GetDocumentStore(GetDocumentStoreOptions options = null, [CallerMemberName] string database = null)
{
options = options ?? GetDocumentStoreOptions.Default;
var name = database + "_" + Interlocked.Increment(ref _index);
ReportInfo($"GetDocumentStore for db ${ database }.");
var documentStore = GlobalServer.Value;
var createDatabaseOperation = new CreateDatabaseOperation(new DatabaseRecord(name));
documentStore.Maintenance.Server.Send(createDatabaseOperation);
var store = new DocumentStore
{
Urls = documentStore.Urls,
Database = name
};
PreInitialize(store);
store.Initialize();
store.AfterDispose += (sender, args) =>
{
if (_documentStores.TryRemove(store, out _) == false)
{
return;
}
try
{
store.Maintenance.Server.Send(new DeleteDatabasesOperation(store.Database, true));
}
catch (DatabaseDoesNotExistException)
{
}
catch (NoLeaderException)
{
}
};
ImportDatabase(store, name);
SetupDatabase(store);
if (options.WaitForIndexingTimeout.HasValue)
{
WaitForIndexing(store, name, options.WaitForIndexingTimeout);
}
_documentStores[store] = null;
return(store);
}
public void EnsureCreated(IDocumentStore documentStore)
{
var getDbOp = new GetDatabaseRecordOperation(documentStore.Database);
var record = documentStore.Admin.Server.Send(getDbOp);
if (record == null)
{
var createDatabaseOperation = new CreateDatabaseOperation(new Raven.Client.ServerWide.DatabaseRecord(documentStore.Database));
documentStore.Admin.Server.Send(createDatabaseOperation);
}
}
private void CreateDatabaseIfNotExists(string databaseName)
{
var operation = new GetDatabaseRecordOperation(databaseName);
if (_documentStore.Maintenance.Server.Send(operation) == null)
{
var dbRecord = new DatabaseRecord(databaseName);
var createDatabaseOperation = new CreateDatabaseOperation(dbRecord);
_documentStore.Maintenance.Server.Send(createDatabaseOperation);
}
}
public MethodResult CreateDatabase(string databaseName)
{
var operation = new GetDatabaseRecordOperation(databaseName);
if (_documentStore.Maintenance.Server.Send(operation) == null)
{
var dbRecord = new DatabaseRecord(databaseName);
var createDatabaseOperation = new CreateDatabaseOperation(dbRecord);
_documentStore.Maintenance.Server.Send(createDatabaseOperation);
}
return(new MethodResult(MethodResultStates.Successful));
}
public async Task CanGetValueAfterDbFirstCreation_WithPreviousError(bool waitForDatabaseChangesFailure)
{
DoNotReuseServer();
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60)))
using (var store = GetDocumentStore())
using (var documentStore = new DocumentStore
{
Urls = store.Urls,
Database = store.Database + "-" + Guid.NewGuid() // Ensure this doesn't exist before testing
})
{
documentStore.Initialize();
// Subscribing to Changes API before database is created causes the DatabaseDoesNotExistException later on.
var changes = documentStore.Changes();
if (waitForDatabaseChangesFailure)
{
await AssertChangesApiTaskFailure(changes);
}
var t = changes.ForDocumentsInCollection <Version>();
var e = await Assert.ThrowsAnyAsync <Exception>(() => t.EnsureSubscribedNow().WithCancellation(cts.Token));
e = e.ExtractSingleInnerException();
Assert.True(e is DatabaseDoesNotExistException);
_ = t.Subscribe(x => { });
// Check if the database exists.
var getResult = await documentStore.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(documentStore.Database), cts.Token).ConfigureAwait(false);
Assert.Null(getResult);
var dbRecord = new DatabaseRecord(documentStore.Database);
var operation = new CreateDatabaseOperation(dbRecord);
try
{
await documentStore.Maintenance.Server.SendAsync(operation, cts.Token).ConfigureAwait(false);
Version dbVersion;
using (var session = documentStore.OpenAsyncSession())
{
// should work
dbVersion = await session.LoadAsync <Version>("TheVersion", cts.Token).ConfigureAwait(false);
}
}
finally
{
await documentStore.Maintenance.Server.SendAsync(new DeleteDatabasesOperation(documentStore.Database, true), cts.Token);
}
}
}
public virtual void Generate(
[NotNull] CreateDatabaseOperation operation,
[CanBeNull] IModel model,
[NotNull] SqlBatchBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE DATABASE ")
.Append(_sql.DelimitIdentifier(operation.Name))
.EndBatch();
}
public async Task CreateDatabase(IDocumentStore documentStore)
{
try
{
var databaseRecord = new DatabaseRecord(documentStore.Database);
var operation = new CreateDatabaseOperation(databaseRecord);
await documentStore.Maintenance.Server.SendAsync(operation);
}
catch (ConcurrencyException)
{
// The database was already created before calling CreateDatabaseOperation
}
}
public virtual void Generate(
[NotNull] CreateDatabaseOperation operation,
[CanBeNull] IModel model,
[NotNull] SqlBatchBuilder builder)
{
Check.NotNull(operation, nameof(operation));
Check.NotNull(builder, nameof(builder));
builder
.Append("CREATE DATABASE ")
.Append(_sql.DelimitIdentifier(operation.Name))
.EndBatch()
.Append("IF SERVERPROPERTY('EngineEdition') <> 5 EXECUTE sp_executesql N'ALTER DATABASE ")
.Append(_sql.DelimitIdentifier(operation.Name))
.Append(" SET READ_COMMITTED_SNAPSHOT ON'");
}
public override void Generate(CreateDatabaseOperation createDatabaseOperation, SqlBatchBuilder batchBuilder)
{
base.Generate(createDatabaseOperation, batchBuilder);
batchBuilder.EndBatch();
batchBuilder
.Append("IF SERVERPROPERTY('EngineEdition') <> 5 EXECUTE sp_executesql N")
.Append(
GenerateLiteral(
string.Concat(
"ALTER DATABASE ",
DelimitIdentifier(createDatabaseOperation.DatabaseName),
" SET READ_COMMITTED_SNAPSHOT ON")));
batchBuilder.EndBatch();
}
public override void Generate(CreateDatabaseOperation createDatabaseOperation, IndentedStringBuilder stringBuilder, bool generateIdempotentSql)
{
Check.NotNull(createDatabaseOperation, "createDatabaseOperation");
Check.NotNull(stringBuilder, "stringBuilder");
if (generateIdempotentSql)
{
GenerateDatabasePresenceCheck(createDatabaseOperation.DatabaseName, negative: true, builder: stringBuilder);
using (stringBuilder.AppendLine().Indent())
{
base.Generate(createDatabaseOperation, stringBuilder, generateIdempotentSql: false);
}
}
else
{
base.Generate(createDatabaseOperation, stringBuilder, generateIdempotentSql);
}
}
public async Task CanGetValueAfterDbFirstCreation_WithPreviousError()
{
using (var store = GetDocumentStore())
using (var documentStore = new DocumentStore
{
Urls = store.Urls,
Database = store.Database + "-" + Guid.NewGuid() // Ensure this doesn't exist before testing
})
{
documentStore.Initialize();
// Subscribing to Changes API before database is created causes the DatabaseDoesNotExistException later on.
var t = documentStore.Changes()
.ForDocumentsInCollection <Version>();
await Assert.ThrowsAnyAsync <Exception>(() => t.EnsureSubscribedNow());
t.Subscribe(x => { });
// Check if the database exists.
var getResult = await documentStore.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(documentStore.Database)).ConfigureAwait(false);
Assert.Null(getResult);
var dbRecord = new DatabaseRecord(documentStore.Database);
var operation = new CreateDatabaseOperation(dbRecord);
try
{
await documentStore.Maintenance.Server.SendAsync(operation).ConfigureAwait(false);
Version dbVersion;
using (var session = documentStore.OpenAsyncSession())
{
// should work
dbVersion = await session.LoadAsync <Version>("TheVersion").ConfigureAwait(false);
}
}
finally
{
await documentStore.Maintenance.Server.SendAsync(new DeleteDatabasesOperation(documentStore.Database, true));
}
}
}
private static async Task SetupDatabaseTenantAsync(IDocumentStore documentStore,
bool doesDatabaseExist,
ILogger logger,
CancellationToken cancellationToken)
{
if (documentStore == null)
{
throw new ArgumentNullException(nameof(documentStore));
}
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
if (doesDatabaseExist)
{
logger.LogDebug(" - Database exists: no need to create one.");
return;
}
// Create the db if it doesn't exist.
// This will mainly occur for in memory localhost development.
logger.LogDebug(" - ** No database tenant found so creating a new database tenant ....");
var databaseRecord = new DatabaseRecord(documentStore.Database);
var createDbOperation = new CreateDatabaseOperation(databaseRecord);
// Race condition might occur. Meaning, two services might have both seen that the Database-tenant
// didn't exist but then they both try and create the Database-tenant, now.
// Database-tenant can only be created once.
try
{
await documentStore.Maintenance.Server.SendAsync(createDbOperation, cancellationToken);
}
catch (ConcurrencyException)
{
logger.LogInformation($" - !!! Race-condition captured :: tried to create a database tenant '{documentStore.Database}' but another service already created it.");
}
}
public static void LoadDatabase(string url = null)
{
if (url is null)
{
url = "http://raven_db:8080";
}
var store = new DocumentStore {
Urls = new[] { url }, Database = DataBase
};
store.Initialize();
var operation = new GetDatabaseNamesOperation(0, 100);
var databases = store.Maintenance.Server.Send(operation);
if (!databases.Contains(DataBase))
{
var createDb = new CreateDatabaseOperation(new DatabaseRecord(DataBase));
store.Maintenance.Server.Send(createDb);
}
new LimitUsedIndex().Execute(store);
}
public IActionResult Run()
{
string databaseName = _databaseName.For(UserId);
#region Demo
try
{
#region Step_1
DatabaseRecord databaseRecord = new DatabaseRecord(databaseName);
CreateDatabaseOperation createDatabaseOperation = new CreateDatabaseOperation(databaseRecord);
#endregion
#region Step_2
DocumentStoreHolder.Store.Maintenance.Server.Send(createDatabaseOperation);
#endregion
}
catch (ConcurrencyException)
{
// Database already exists
}
#endregion
return(Ok($"Database {databaseName} was created successfully"));
}
public void AggressivelyCacheWorksWhenTopologyUpdatesIsDisable()
{
using (var server = GetNewServer(runInMemory: false))
{
using (var documentStore = new DocumentStore
{
Urls = UseFiddler(server.WebUrl),
Database = "RavenDB_9055"
})
{
documentStore.Conventions.DisableTopologyUpdates = true;
documentStore.Conventions.UseOptimisticConcurrency = true;
documentStore.Initialize();
var operation = new CreateDatabaseOperation(new DatabaseRecord(documentStore.Database));
documentStore.Admin.Server.Send(operation);
using (var session = documentStore.OpenSession())
{
session.Store(new User
{
Name = "Idan"
}, "users/1");
session.SaveChanges();
}
string changeVector;
using (documentStore.AggressivelyCache())
using (var session = documentStore.OpenSession())
{
documentStore.Changes().ForAllDocuments().EnsureSubscribedNow().Wait();
var user = session.Load <User>("users/1");
user.Name = "Shalom";
session.SaveChanges();
changeVector = session.Advanced.GetMetadataFor(user)?.GetString(Constants.Documents.Metadata.ChangeVector);
}
Assert.NotNull(changeVector);
string updateChangeVector = null;
for (int i = 0; i < 15; i++)
{
using (documentStore.AggressivelyCache())
using (var session = documentStore.OpenSession())
{
var user = session.Load <User>("users/1");
updateChangeVector = session.Advanced.GetMetadataFor(user)?
.GetString(Constants.Documents.Metadata.ChangeVector);
if (updateChangeVector != null && updateChangeVector.Equals(changeVector))
{
break;
}
Thread.Sleep(100);
}
}
Assert.NotNull(updateChangeVector);
Assert.Equal(changeVector, updateChangeVector);
}
}
}
public override void Generate(
CreateDatabaseOperation createDatabaseOperation,
IndentedStringBuilder stringBuilder)
{
throw new NotSupportedException();
}
public abstract void Generate([NotNull] CreateDatabaseOperation createDatabaseOperation, [NotNull] IndentedStringBuilder stringBuilder);
