public void GetSubscriptionTaskInfo()
{
var subscriptionOption = new SubscriptionCreationOptions <Query.Order>
{
Name = "sub",
Filter = x => x.Employee.StartsWith("e"),
MentorNode = "B"
};
using (var store = GetDocumentStore())
{
var sub = store.Subscriptions.Create(subscriptionOption);
var op = new GetOngoingTaskInfoOperation(subscriptionOption.Name, OngoingTaskType.Subscription);
var subscriptionResult = (OngoingTaskSubscription)store.Maintenance.Send(op);
Assert.Equal(subscriptionOption.MentorNode, subscriptionResult.MentorNode);
Assert.NotNull(subscriptionResult.Query);
var state = store.Subscriptions.GetSubscriptionState(subscriptionOption.Name);
op = new GetOngoingTaskInfoOperation(state.SubscriptionId, OngoingTaskType.Subscription);
subscriptionResult = (OngoingTaskSubscription)store.Maintenance.Send(op);
Assert.Equal(subscriptionOption.MentorNode, subscriptionResult.MentorNode);
Assert.Equal(subscriptionOption.Name, subscriptionResult.SubscriptionName);
Assert.NotNull(subscriptionResult.Query);
op = new GetOngoingTaskInfoOperation(state.SubscriptionId - 1, OngoingTaskType.Subscription);
Assert.Throws <SubscriptionDoesNotExistException>(() => store.Maintenance.Send(op));
}
}
public void GetBackupTaskInfo()
{
var backupConfig = Backup.CreateBackupConfiguration(backupPath: NewDataPath(suffix: "BackupFolder"), fullBackupFrequency: "* */1 * * *", incrementalBackupFrequency: "* */2 * * *", azureSettings: new AzureSettings
{
StorageContainer = "abc"
}, disabled: true, name: "backup1");
using (var store = GetDocumentStore())
{
var updateBackupResult = store.Maintenance.Send(new UpdatePeriodicBackupOperation(backupConfig));
var taskId = updateBackupResult.TaskId;
var op = new GetOngoingTaskInfoOperation(taskId, OngoingTaskType.Backup);
var backupResult = (OngoingTaskBackup)store.Maintenance.Send(op);
Assert.Equal("Local", backupResult.BackupDestinations[0]);
Assert.Equal("Azure", backupResult.BackupDestinations[1]);
Assert.Equal("backup1", backupResult.TaskName);
Assert.Equal(OngoingTaskState.Disabled, backupResult.TaskState);
op = new GetOngoingTaskInfoOperation("backup1", OngoingTaskType.Backup);
backupResult = (OngoingTaskBackup)store.Maintenance.Send(op);
Assert.Equal("Local", backupResult.BackupDestinations[0]);
Assert.Equal("Azure", backupResult.BackupDestinations[1]);
Assert.Equal(taskId, backupResult.TaskId);
Assert.Equal(OngoingTaskState.Disabled, backupResult.TaskState);
}
}
protected static async Task <OngoingTask> GetTaskInfo(
DocumentStore store,
string taskName, OngoingTaskType type)
{
var op = new GetOngoingTaskInfoOperation(taskName, type);
return(await store.Maintenance.SendAsync(op));
}
protected static async Task <OngoingTask> GetTaskInfo(
DocumentStore store,
long taskId, OngoingTaskType type)
{
var op = new GetOngoingTaskInfoOperation(store.Database, taskId, type);
return(await store.Admin.Server.SendAsync(op));
}
public void GetRavenEtlTaskInfo()
{
var etlConfiguration = new RavenEtlConfiguration()
{
Name = "test",
ConnectionStringName = "cs",
Transforms =
{
new Transformation()
{
Name = "loadAll",
Collections ={ "Users" },
Script = "loadToUsers(this)"
}
}
};
using (var store = GetDocumentStore())
{
var result = store.Maintenance.Send(new PutConnectionStringOperation <RavenConnectionString>(new RavenConnectionString
{
Name = "cs",
TopologyDiscoveryUrls = new[] { "http://127.0.0.1:8080" },
Database = "Northwind",
}));
Assert.NotNull(result.RaftCommandIndex);
var ravenEtlResult = store.Maintenance.Send(new AddEtlOperation <RavenConnectionString>(etlConfiguration));
var taskId = ravenEtlResult.TaskId;
var op = new GetOngoingTaskInfoOperation(taskId, OngoingTaskType.RavenEtl);
var etlResult = (OngoingTaskRavenEtlDetails)store.Maintenance.Send(op);
Assert.Equal("cs", etlResult.Configuration.ConnectionStringName);
Assert.Equal("test", etlResult.Configuration.Name);
Assert.Equal("loadAll", etlResult.Configuration.Transforms[0].Name);
Assert.Equal("loadToUsers(this)", etlResult.Configuration.Transforms[0].Script);
Assert.Equal("Users", etlResult.Configuration.Transforms[0].Collections[0]);
Assert.Equal(etlConfiguration.Name, etlResult?.TaskName);
op = new GetOngoingTaskInfoOperation("test", OngoingTaskType.RavenEtl);
etlResult = (OngoingTaskRavenEtlDetails)store.Maintenance.Send(op);
Assert.Equal("cs", etlResult.Configuration.ConnectionStringName);
Assert.Equal(taskId, etlResult.TaskId);
Assert.Equal("loadAll", etlResult.Configuration.Transforms[0].Name);
Assert.Equal("loadToUsers(this)", etlResult.Configuration.Transforms[0].Script);
Assert.Equal("Users", etlResult.Configuration.Transforms[0].Collections[0]);
Assert.Equal(etlConfiguration.Name, etlResult?.TaskName);
}
}
public void GetExternalReplicationTaskInfo()
{
var watcher = new ExternalReplication("Watcher1", "Connection")
{
Name = "MyExternalReplication"
};
using (var store = GetDocumentStore())
{
var result = store.Maintenance.Send(new PutConnectionStringOperation <RavenConnectionString>(new RavenConnectionString
{
Name = watcher.ConnectionStringName,
Database = watcher.Database,
TopologyDiscoveryUrls = store.Urls
}));
Assert.NotNull(result.RaftCommandIndex);
var replicationOperation = new UpdateExternalReplicationOperation(watcher);
var replication = store.Maintenance.Send(replicationOperation);
var taskId = replication.TaskId;
var op = new GetOngoingTaskInfoOperation(taskId, OngoingTaskType.Replication);
var replicationResult = (OngoingTaskReplication)store.Maintenance.Send(op);
Assert.Equal(watcher.Database, replicationResult.DestinationDatabase);
Assert.Equal(watcher.Url, replicationResult.DestinationUrl);
Assert.Equal(watcher.Name, replicationResult.TaskName);
op = new GetOngoingTaskInfoOperation("MyExternalReplication", OngoingTaskType.Replication);
replicationResult = (OngoingTaskReplication)store.Maintenance.Send(op);
Assert.Equal(watcher.Database, replicationResult.DestinationDatabase);
Assert.Equal(watcher.Url, replicationResult.DestinationUrl);
Assert.Equal(taskId, replicationResult.TaskId);
}
}
public void GetSqlEtlTaskInfo()
{
var sqlScript = @"
var orderData = {
Id: __document_id,
OrderLinesCount: this.OrderLines.length,
TotalCost: 0
};
loadToOrders(orderData);
";
var sqlConfiguration = new SqlEtlConfiguration()
{
Name = "abc",
ConnectionStringName = "abc",
SqlTables =
{
new SqlEtlTable {
TableName = "Orders", DocumentIdColumn = "Id", InsertOnlyMode = false
},
new SqlEtlTable {
TableName = "OrderLines", DocumentIdColumn = "OrderId", InsertOnlyMode = false
},
},
Transforms =
{
new Transformation()
{
Name = "OrdersAndLines",
Collections = new List <string>{
"Orders"
},
Script = sqlScript
}
}
};
using (var store = GetDocumentStore())
{
var sqlConnectionString = new SqlConnectionString
{
Name = "abc",
ConnectionString = @"Data Source=localhost\sqlexpress;Integrated Security=SSPI;Connection Timeout=3" + $";Initial Catalog=SqlReplication-{store.Database};",
FactoryName = "System.Data.SqlClient"
};
var result = store.Maintenance.Send(new PutConnectionStringOperation <SqlConnectionString>(sqlConnectionString));
Assert.NotNull(result.RaftCommandIndex);
var sqlEtlResult = store.Maintenance.Send(new AddEtlOperation <SqlConnectionString>(sqlConfiguration));
var taskId = sqlEtlResult.TaskId;
var op = new GetOngoingTaskInfoOperation(taskId, OngoingTaskType.SqlEtl);
var sqlResult = (OngoingTaskSqlEtlDetails)store.Maintenance.Send(op);
Assert.Equal("abc", sqlResult.Configuration.ConnectionStringName);
Assert.Equal("abc", sqlResult.Configuration.Name);
Assert.Equal("OrdersAndLines", sqlResult.Configuration.Transforms[0].Name);
Assert.Equal(sqlScript, sqlResult.Configuration.Transforms[0].Script);
Assert.Equal("Orders", sqlResult.Configuration.Transforms[0].Collections[0]);
Assert.NotNull(sqlResult.Configuration.SqlTables);
Assert.Equal(sqlConfiguration.Name, sqlResult?.TaskName);
op = new GetOngoingTaskInfoOperation("abc", OngoingTaskType.SqlEtl);
sqlResult = (OngoingTaskSqlEtlDetails)store.Maintenance.Send(op);
Assert.Equal("abc", sqlResult.Configuration.ConnectionStringName);
Assert.Equal("abc", sqlResult.Configuration.Name);
Assert.Equal("OrdersAndLines", sqlResult.Configuration.Transforms[0].Name);
Assert.Equal(sqlScript, sqlResult.Configuration.Transforms[0].Script);
Assert.Equal("Orders", sqlResult.Configuration.Transforms[0].Collections[0]);
Assert.NotNull(sqlResult.Configuration.SqlTables);
Assert.Equal(taskId, sqlResult.TaskId);
}
}
public async Task BackupTaskShouldStayOnTheOriginalNode()
{
var backupPath = NewDataPath(suffix: "BackupFolder");
var cluster = await CreateRaftCluster(5);
using (var store = GetDocumentStore(new Options
{
ReplicationFactor = 5,
Server = cluster.Leader
}))
{
using (var session = store.OpenAsyncSession())
{
await session.StoreAsync(new User { Name = "oren" }, "users/1");
await session.SaveChangesAsync();
Assert.True(await WaitForDocumentInClusterAsync <User>(session.Advanced.RequestExecutor.TopologyNodes, "users/1", u => u.Name == "oren",
TimeSpan.FromSeconds(15)));
}
var config = new PeriodicBackupConfiguration
{
LocalSettings = new LocalSettings
{
FolderPath = backupPath
},
IncrementalBackupFrequency = "* * * * *" //every minute
};
var operation = new UpdatePeriodicBackupOperation(config);
var result = await store.Maintenance.SendAsync(operation);
var periodicBackupTaskId = result.TaskId;
await WaitForRaftIndexToBeAppliedInCluster(periodicBackupTaskId, TimeSpan.FromSeconds(15));
await store.Maintenance.SendAsync(new StartBackupOperation(true, result.TaskId));
var getPeriodicBackupStatus = new GetPeriodicBackupStatusOperation(periodicBackupTaskId);
var done = SpinWait.SpinUntil(() => store.Maintenance.Send(getPeriodicBackupStatus).Status?.LastFullBackup != null, TimeSpan.FromSeconds(180));
Assert.True(done, "Failed to complete the backup in time");
var backupInfo = new GetOngoingTaskInfoOperation(result.TaskId, OngoingTaskType.Backup);
var backupInfoResult = await store.Maintenance.SendAsync(backupInfo);
var originalNode = backupInfoResult.ResponsibleNode.NodeTag;
var toDelete = cluster.Nodes.First(n => n.ServerStore.NodeTag != originalNode);
await store.Maintenance.Server.SendAsync(new DeleteDatabasesOperation(store.Database, hardDelete : true, fromNode : toDelete.ServerStore.NodeTag, timeToWaitForConfirmation : TimeSpan.FromSeconds(30)));
var nodesCount = await WaitForValueAsync(async() =>
{
var res = await store.Maintenance.Server.SendAsync(new GetDatabaseRecordOperation(store.Database));
if (res == null)
{
return(-1);
}
return(res.Topology.Count);
}, 4);
Assert.Equal(4, nodesCount);
backupInfoResult = await store.Maintenance.SendAsync(backupInfo);
await store.Maintenance.SendAsync(new StartBackupOperation(true, backupInfoResult.TaskId));
getPeriodicBackupStatus = new GetPeriodicBackupStatusOperation(periodicBackupTaskId);
done = SpinWait.SpinUntil(() => store.Maintenance.Send(getPeriodicBackupStatus).Status?.LastFullBackup != null, TimeSpan.FromSeconds(180));
Assert.True(done, "Failed to complete the backup in time");
backupInfoResult = await store.Maintenance.SendAsync(backupInfo);
Assert.Equal(originalNode, backupInfoResult.ResponsibleNode.NodeTag);
}
}
