public virtual async Task SideBySideExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null, CancellationToken token = default(CancellationToken))
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
var serverDef = await asyncDatabaseCommands.GetIndexAsync(IndexName, token).ConfigureAwait(false);
if (serverDef != null)
{
if (CurrentOrLegacyIndexDefinitionEquals(documentConvention, serverDef, indexDefinition))
{
return;
}
var replaceIndexName = "ReplacementOf/" + IndexName;
await asyncDatabaseCommands.PutIndexAsync(replaceIndexName, indexDefinition, token).ConfigureAwait(false);
await asyncDatabaseCommands
.PutAsync(Constants.IndexReplacePrefix + replaceIndexName,
null,
RavenJObject.FromObject(new IndexReplaceDocument {
IndexToReplace = serverDef.Name, MinimumEtagBeforeReplace = minimumEtagBeforeReplace, ReplaceTimeUtc = replaceTimeUtc
}),
new RavenJObject(),
token).ConfigureAwait(false);
}
else
{
// since index doesn't exist yet - create it in normal mode
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, token).ConfigureAwait(false);
}
}
/// <summary>
/// Executes the index creation against the specified document store.
/// </summary>
public virtual async Task ExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, CancellationToken token = default(CancellationToken))
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
#if !DNXCORE50
if (documentConvention.PrettifyGeneratedLinqExpressions)
{
var serverDef = await asyncDatabaseCommands.GetIndexAsync(IndexName, token).ConfigureAwait(false);
if (serverDef != null && CurrentOrLegacyIndexDefinitionEquals(documentConvention, serverDef, indexDefinition))
{
await AfterExecuteAsync(asyncDatabaseCommands, documentConvention, token).ConfigureAwait(false);
return;
}
}
#endif
// This code take advantage on the fact that RavenDB will turn an index PUT
// to a noop of the index already exists and the stored definition matches
// the new definition.
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, true, token).ConfigureAwait(false);
if (Priority != null)
{
await asyncDatabaseCommands.SetIndexPriorityAsync(IndexName, Priority.Value, token).ConfigureAwait(false);
}
await AfterExecuteAsync(asyncDatabaseCommands, documentConvention, token).ConfigureAwait(false);
}
/// <summary>
/// Executes the index creation against the specified document store.
/// </summary>
public virtual async Task ExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention)
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
if (documentConvention.PrettifyGeneratedLinqExpressions)
{
var serverDef = await asyncDatabaseCommands.GetIndexAsync(IndexName);
if (serverDef != null)
{
if (serverDef.Equals(indexDefinition))
{
return;
}
// now we need to check if this is a legacy index...
var legacyIndexDefinition = GetLegacyIndexDefinition(documentConvention);
if (serverDef.Equals(legacyIndexDefinition))
{
return; // if it matches the legacy definition, do not change that (to avoid re-indexing)
}
}
}
// This code take advantage on the fact that RavenDB will turn an index PUT
// to a noop of the index already exists and the stored definition matches
// the new definition.
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, true);
await UpdateIndexInReplicationAsync(asyncDatabaseCommands, documentConvention, (client, operationMetadata) => client.DirectPutIndexAsync(IndexName, indexDefinition, true, operationMetadata));
}
/// <summary>
/// Executes the index creation against the specified document store.
/// </summary>
public virtual async Task ExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, CancellationToken token = default(CancellationToken))
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
if (documentConvention.PrettifyGeneratedLinqExpressions)
{
var serverDef = await asyncDatabaseCommands.GetIndexAsync(IndexName, token);
if (serverDef != null && CurrentOrLegacyIndexDefinitionEquals(documentConvention, serverDef, indexDefinition))
{
return;
}
}
// This code take advantage on the fact that RavenDB will turn an index PUT
// to a noop of the index already exists and the stored definition matches
// the new definition.
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, true, token);
if (Priority != null)
{
await asyncDatabaseCommands.SetIndexPriorityAsync(IndexName, Priority.Value, token);
}
if (Conventions.IndexAndTransformerReplicationMode.HasFlag(IndexAndTransformerReplicationMode.Indexes))
{
await ReplicateIndexesIfNeededAsync(asyncDatabaseCommands);
}
}
private Task WriteIndexes(JsonTextReader jsonReader)
{
while (jsonReader.Read() && jsonReader.TokenType != JsonToken.EndArray)
{
var json = JToken.ReadFrom(jsonReader);
var indexName = json.Value <string>("name");
if (indexName.StartsWith("Temp/"))
{
continue;
}
var index = JsonConvert.DeserializeObject <IndexDefinition>(json.Value <JObject>("definition").ToString());
totalIndexes++;
output(string.Format("Importing index: {0}", indexName));
return(asyncDatabaseCommands.PutIndexAsync(indexName, index, overwrite: true)
.ContinueOnSuccess(() => WriteIndexes(jsonReader)));
}
var tcs = new TaskCompletionSource <object>();
tcs.SetResult(null);
return(tcs.Task);
}
/// <summary>
/// Executes the index creation against the specified document store.
/// </summary>
public virtual async Task ExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, CancellationToken token = default(CancellationToken))
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
if (documentConvention.PrettifyGeneratedLinqExpressions)
{
var serverDef = await asyncDatabaseCommands.GetIndexAsync(IndexName, token);
if (serverDef != null)
{
if (serverDef.Equals(indexDefinition))
{
return;
}
// now we need to check if this is a legacy index...
var legacyIndexDefinition = GetLegacyIndexDefinition(documentConvention);
if (serverDef.Equals(legacyIndexDefinition))
{
return; // if it matches the legacy definition, do not change that (to avoid re-indexing)
}
}
}
// This code take advantage on the fact that RavenDB will turn an index PUT
// to a noop of the index already exists and the stored definition matches
// the new definition.
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, true, token);
if (Conventions.IndexAndTransformerReplicationMode.HasFlag(IndexAndTransformerReplicationMode.Indexes))
{
await ReplicateIndexesIfNeededAsync(asyncDatabaseCommands);
}
}
public virtual async Task SideBySideExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null, CancellationToken token = default(CancellationToken))
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
if (minimumEtagBeforeReplace != null && indexDefinition.IsMapReduce)
{
throw new InvalidOperationException("We do not support side-by-side execution for Map-Reduce indexes when 'minimum last indexed etag' scenario is used.");
}
var replaceIndexName = Constants.SideBySideIndexNamePrefix + IndexName;
//check if side by side index exists
var sideBySideDef = await asyncDatabaseCommands.GetIndexAsync(replaceIndexName, token).ConfigureAwait(false);
if (sideBySideDef != null)
{
if (CurrentOrLegacyIndexDefinitionEquals(documentConvention, sideBySideDef, indexDefinition))
{
return;
}
await UpdateSideBySideIndexAsync(asyncDatabaseCommands, minimumEtagBeforeReplace, replaceTimeUtc, token, replaceIndexName, indexDefinition, documentConvention).ConfigureAwait(false);
return;
}
var serverDef = await asyncDatabaseCommands.GetIndexAsync(IndexName, token).ConfigureAwait(false);
if (serverDef != null)
{
if (CurrentOrLegacyIndexDefinitionEquals(documentConvention, serverDef, indexDefinition))
{
return;
}
switch (serverDef.LockMode)
{
case IndexLockMode.SideBySide:
//keep the SideBySide lock mode from the replaced index
indexDefinition.LockMode = IndexLockMode.SideBySide;
break;
case IndexLockMode.LockedIgnore:
//Nothing to do we just ignore this index
return;
case IndexLockMode.LockedError:
throw new InvalidOperationException(string.Format("Can't replace locked index {0} its lock mode is set to: LockedError", serverDef.IndexId));
}
await UpdateSideBySideIndexAsync(asyncDatabaseCommands, minimumEtagBeforeReplace, replaceTimeUtc, token, replaceIndexName, indexDefinition, documentConvention).ConfigureAwait(false);
}
else
{
// since index doesn't exist yet - create it in normal mode
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, token).ConfigureAwait(false);
await AfterExecuteAsync(asyncDatabaseCommands, documentConvention, token).ConfigureAwait(false);
}
}
/// <summary>
/// Asynchronously creates an index
/// </summary>
/// <typeparam name="T">The type that defines the index to be create.</typeparam>
/// <param name="commands">The hook to the database commands.</param>
/// <param name="overwrite">Should the index be overwritten if it already exists.</param>
/// <returns></returns>
public static Task <string> PutIndexAsync <T>(this IAsyncDatabaseCommands commands, bool overwrite)
where T : AbstractIndexCreationTask, new()
{
var indexCreationTask = new T();
return(commands.PutIndexAsync(
indexCreationTask.IndexName,
indexCreationTask.CreateIndexDefinition(), overwrite));
}
/// <summary>
/// Executes the index creation against the specified document store.
/// </summary>
public virtual Task ExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention)
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
// This code take advantage on the fact that RavenDB will turn an index PUT
// to a noop of the index already exists and the stored definition matches
// the new defintion.
return(asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, true));
}
protected override Task PutIndex(string indexName, RavenJToken index)
{
if (index != null)
{
var indexDefinition = JsonConvert.DeserializeObject <IndexDefinition>(index.Value <RavenJObject>("definition").ToString());
return(Commands.PutIndexAsync(indexName, indexDefinition, overwrite: true));
}
return(FlushBatch());
}
/// <summary>
/// Executes the index creation against the specified document store.
/// </summary>
public virtual async Task ExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention)
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
// This code take advantage on the fact that RavenDB will turn an index PUT
// to a noop of the index already exists and the stored definition matches
// the new definition.
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, true);
await UpdateIndexInReplicationAsync(asyncDatabaseCommands, documentConvention, (client, operationMetadata) => client.DirectPutIndexAsync(IndexName, indexDefinition, true, operationMetadata));
}
/// <summary>
/// Executes the index creation against the specified document store.
/// </summary>
public virtual Task ExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention)
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
// This code take advantage on the fact that RavenDB will turn an index PUT
// to a noop of the index already exists and the stored definition matches
// the new definition.
return(asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, true)
.ContinueWith(task => UpdateIndexInReplicationAsync(asyncDatabaseCommands, documentConvention, (client, url) =>
client.DirectPutIndexAsync(IndexName, indexDefinition, true, url)))
.Unwrap());
}
private async Task UpdateSideBySideIndexAsync(IAsyncDatabaseCommands asyncDatabaseCommands, Etag minimumEtagBeforeReplace, DateTime?replaceTimeUtc, CancellationToken token, string replaceIndexName, IndexDefinition indexDefinition, DocumentConvention documentConvention)
{
await asyncDatabaseCommands.PutIndexAsync(replaceIndexName, indexDefinition, true, token).ConfigureAwait(false);
await asyncDatabaseCommands
.PutAsync(Constants.IndexReplacePrefix + replaceIndexName,
null,
RavenJObject.FromObject(new IndexReplaceDocument {
IndexToReplace = IndexName, MinimumEtagBeforeReplace = minimumEtagBeforeReplace, ReplaceTimeUtc = replaceTimeUtc
}),
new RavenJObject(),
token).ConfigureAwait(false);
await AfterExecuteAsync(asyncDatabaseCommands, documentConvention, token).ConfigureAwait(false);
}
private IEnumerable <Task> CreateSampleData()
{
// this code assumes a small enough dataset, and doesn't do any sort
// of paging or batching whatsoever.
HomeModel.ShowCreateSampleData.Value = false;
model.IsGeneratingSampleData = true;
using (var sampleData = typeof(HomeModel).Assembly.GetManifestResourceStream("Raven.Studio.Assets.EmbeddedData.MvcMusicStore_Dump.json"))
using (var streamReader = new StreamReader(sampleData))
{
var musicStoreData = (RavenJObject)RavenJToken.ReadFrom(new JsonTextReader(streamReader));
foreach (var index in musicStoreData.Value <RavenJArray>("Indexes"))
{
var indexName = index.Value <string>("name");
var ravenJObject = index.Value <RavenJObject>("definition");
var putDoc = databaseCommands
.PutIndexAsync(indexName,
ravenJObject.JsonDeserialization <IndexDefinition>(),
true);
yield return(putDoc);
}
var batch = databaseCommands.BatchAsync(
musicStoreData.Value <RavenJArray>("Docs").OfType <RavenJObject>().Select(
doc =>
{
var metadata = doc.Value <RavenJObject>("@metadata");
doc.Remove("@metadata");
return(new PutCommandData
{
Document = doc,
Metadata = metadata,
Key = metadata.Value <string>("@id"),
});
}).ToArray()
);
yield return(batch);
model.IsGeneratingSampleData = false;
}
}
public virtual async Task SideBySideExecuteAsync(IAsyncDatabaseCommands asyncDatabaseCommands, DocumentConvention documentConvention, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null, CancellationToken token = default(CancellationToken))
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
var replaceIndexName = Constants.SideBySideIndexNamePrefix + IndexName;
//check if side by side index exists
var sideBySideDef = await asyncDatabaseCommands.GetIndexAsync(replaceIndexName, token).ConfigureAwait(false);
if (sideBySideDef != null)
{
if (CurrentOrLegacyIndexDefinitionEquals(documentConvention, sideBySideDef, indexDefinition))
{
return;
}
await UpdateSideBySideIndexAsync(asyncDatabaseCommands, minimumEtagBeforeReplace, replaceTimeUtc, token, replaceIndexName, indexDefinition, documentConvention);
return;
}
var serverDef = await asyncDatabaseCommands.GetIndexAsync(IndexName, token).ConfigureAwait(false);
if (serverDef != null)
{
if (CurrentOrLegacyIndexDefinitionEquals(documentConvention, serverDef, indexDefinition))
{
return;
}
await UpdateSideBySideIndexAsync(asyncDatabaseCommands, minimumEtagBeforeReplace, replaceTimeUtc, token, replaceIndexName, indexDefinition, documentConvention);
}
else
{
// since index doesn't exist yet - create it in normal mode
await asyncDatabaseCommands.PutIndexAsync(IndexName, indexDefinition, token).ConfigureAwait(false);
await AfterExecuteAsync(asyncDatabaseCommands, documentConvention, token);
}
}