/// <summary>
/// Initializes a new instance of the <see cref="HiLoKeyGenerator"/> class.
/// </summary>
public HiLoKeyGenerator(IDatabaseCommands databaseCommands, string tag, long capacity)
{
this.databaseCommands = databaseCommands;
this.tag = tag;
this.capacity = capacity;
current = 0;
}
public string GenerateDocumentKey(IDatabaseCommands databaseCommands, DocumentConvention conventions, object entity)
{
var shardId = shardedDocumentStore.ShardStrategy.ShardResolutionStrategy.MetadataShardIdFor(entity);
if (shardId == null)
throw new InvalidOperationException(string.Format(
"ShardResolutionStrategy.MetadataShardIdFor cannot return null. You must specify where to store the metadata documents for the entity type '{0}'.", entity.GetType().FullName));
MultiTypeHiLoKeyGenerator value;
if (generatorsByShard.TryGetValue(shardId, out value))
{
return value.GenerateDocumentKey(databaseCommands, conventions, entity);
}
lock (this)
{
if (generatorsByShard.TryGetValue(shardId, out value) == false)
{
value = new MultiTypeHiLoKeyGenerator(capacity);
generatorsByShard = new Dictionary<string, MultiTypeHiLoKeyGenerator>(generatorsByShard)
{
{shardId, value}
};
}
}
return value.GenerateDocumentKey(databaseCommands, conventions, entity);
}
/// <summary>
/// Generates the document key.
/// </summary>
/// <param name="conventions">The conventions.</param>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public string GenerateDocumentKey(IDatabaseCommands databaseCommands, DocumentConvention conventions, object entity)
{
var typeTagName = conventions.GetDynamicTagName(entity);
if (string.IsNullOrEmpty(typeTagName)) //ignore empty tags
return null;
var tag = conventions.TransformTypeTagNameToDocumentKeyPrefix(typeTagName);
HiLoKeyGenerator value;
if (keyGeneratorsByTag.TryGetValue(tag, out value))
return value.GenerateDocumentKey(databaseCommands, conventions, entity);
lock(generatorLock)
{
if (keyGeneratorsByTag.TryGetValue(tag, out value))
return value.GenerateDocumentKey(databaseCommands, conventions, entity);
value = new HiLoKeyGenerator(tag, capacity);
// doing it this way for thread safety
keyGeneratorsByTag = new Dictionary<string, HiLoKeyGenerator>(keyGeneratorsByTag)
{
{tag, value}
};
}
return value.GenerateDocumentKey(databaseCommands, conventions, entity);
}
/// <summary>
/// Creates the indexes found in the specified catalog
/// </summary>
/// <param name="catalogToGetnIndexingTasksFrom">The catalog to get indexing tasks from.</param>
public static void CreateIndexes(ExportProvider catalogToGetnIndexingTasksFrom, IDatabaseCommands databaseCommands, DocumentConvention conventions)
{
var tasks = catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>();
foreach (var task in tasks)
{
task.Execute(databaseCommands, conventions);
}
}
public HiLoKeyGenerator(IDatabaseCommands commands, string tag, long capacity)
{
currentHi = 0;
this.commands = commands;
this.tag = tag;
this.capacity = capacity;
currentLo = capacity + 1;
}
public WhatAreCommands()
{
using (var store = new DocumentStore())
{
#region what_are_commands_1
IDatabaseCommands commands = store.DatabaseCommands;
IAsyncDatabaseCommands asyncCommands = store.AsyncDatabaseCommands;
#endregion
}
}
public static Operation DeleteByIndex <T>(
this IDatabaseCommands databaseCommands,
IndexQuery queryToDelete,
BulkOperationOptions options = null)
where T : AbstractIndexCreationTask
{
var indexName = typeof(T).Name.Replace("_", "/");
return(databaseCommands.DeleteByIndex(indexName, queryToDelete, options));
}
protected bool WaitForDocument(IDatabaseCommands commands, string expectedId, int timeoutInMs)
{
var cts = new CancellationTokenSource();
var waitingTask = Task.Run(() => WaitForDocument(commands, expectedId, null, cts.Token), cts.Token);
Task.WaitAny(waitingTask, Task.Delay(timeoutInMs, cts.Token));
cts.Cancel();
return(AsyncHelpers.RunSync(() => waitingTask.ContinueWith(t => commands.Head(expectedId) != null)));
}
/// <summary>
/// Executes the index creation against the specified document database using the specified conventions
/// </summary>
public virtual void Execute(IDatabaseCommands databaseCommands, 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.
databaseCommands.PutIndex(IndexName, indexDefinition, true);
}
public static void WaitForDocument(IDatabaseCommands databaseCommands, string id)
{
var done = SpinWait.SpinUntil(() =>
{
var doc = databaseCommands.Get(id);
return(doc != null);
}, TimeSpan.FromMinutes(1));
Assert.True(done);
}
public BulkInsertOperation(string database, IDocumentStore documentStore, DocumentSessionListeners listeners, BulkInsertOptions options)
{
this.documentStore = documentStore;
databaseCommands = database == null
? documentStore.DatabaseCommands.ForSystemDatabase()
: documentStore.DatabaseCommands.ForDatabase(database);
generateEntityIdOnTheClient = new GenerateEntityIdOnTheClient(documentStore, entity => documentStore.Conventions.GenerateDocumentKey(database, databaseCommands, entity));
operation = databaseCommands.GetBulkInsertOperation(options);
entityToJson = new EntityToJson(documentStore, listeners);
}
/// <summary>
/// Executes the index creation using in side-by-side mode.
/// </summary>
/// <param name="databaseCommands"></param>
/// <param name="documentConvention"></param>
/// <param name="minimumEtagBeforeReplace">The minimum etag after which indexes will be swapped.</param>
/// <param name="replaceTimeUtc">The minimum time after which indexes will be swapped.</param>
public virtual void SideBySideExecute(IDatabaseCommands databaseCommands, DocumentConvention documentConvention, Etag minimumEtagBeforeReplace = null, DateTime?replaceTimeUtc = null)
{
Conventions = documentConvention;
var indexDefinition = CreateIndexDefinition();
var replaceIndexName = Constants.SideBySideIndexNamePrefix + IndexName;
//check if side by side index exists
var sideBySideDef = databaseCommands.GetIndex(replaceIndexName);
if (sideBySideDef != null)
{
if (CurrentOrLegacyIndexDefinitionEquals(documentConvention, sideBySideDef, indexDefinition))
{
return;
}
UpdateSideBySideIndex(databaseCommands, minimumEtagBeforeReplace, replaceTimeUtc, replaceIndexName, indexDefinition, documentConvention);
return;
}
//check if "regular" index exists
var serverDef = databaseCommands.GetIndex(IndexName);
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));
}
UpdateSideBySideIndex(databaseCommands, minimumEtagBeforeReplace, replaceTimeUtc, replaceIndexName, indexDefinition, documentConvention);
}
else
{
// since index doesn't exist yet - create it in normal mode
databaseCommands.PutIndex(IndexName, indexDefinition);
AfterExecute(databaseCommands, documentConvention);
}
}
protected void WaitForDocument(IDatabaseCommands databaseCommands, string id)
{
var done = SpinWait.SpinUntil(() =>
{
// We expect to get the doc from the <system> database
var doc = databaseCommands.Get(id);
return(doc != null);
}, TimeSpan.FromMinutes(5));
Assert.True(done);
}
static WindowsAuthDocument GetWindowsAuthDocument(IDatabaseCommands systemCommands)
{
var existing = systemCommands.Get("Raven/Authorization/WindowsSettings");
if (existing == null)
{
return new WindowsAuthDocument();
}
return existing
.DataAsJson
.JsonDeserialization<WindowsAuthDocument>();
}
public SwitchCommandsCredentials()
{
using (var store = new DocumentStore())
{
#region with_2
IDatabaseCommands commands = store
.DatabaseCommands
.With(new NetworkCredential("otherUserName", "otherPassword"));
#endregion
}
}
public BulkInsertOperation(string database, IDocumentStore documentStore, DocumentSessionListeners listeners, BulkInsertOptions options)
{
this.documentStore = documentStore;
databaseCommands = database == null
? documentStore.DatabaseCommands.ForSystemDatabase()
: documentStore.DatabaseCommands.ForDatabase(database);
generateEntityIdOnTheClient = new GenerateEntityIdOnTheClient(documentStore, entity => documentStore.Conventions.GenerateDocumentKey(database, databaseCommands, entity));
operation = databaseCommands.GetBulkInsertOperation(options);
entityToJson = new EntityToJson(documentStore, listeners);
}
/// <summary>
/// Generates the document key.
/// </summary>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public string GenerateDocumentKey(IDatabaseCommands databaseCommands, object entity)
{
var type = entity.GetType();
foreach (var typeToRegisteredIdConvention in listOfRegisteredIdConventions
.Where(typeToRegisteredIdConvention => typeToRegisteredIdConvention.Item1.IsAssignableFrom(type)))
{
return(typeToRegisteredIdConvention.Item2(databaseCommands, entity));
}
return(DocumentKeyGenerator(databaseCommands, entity));
}
protected void SetupReplication(IDatabaseCommands source, IEnumerable <RavenJObject> destinations)
{
Assert.NotEmpty(destinations);
source.Put(Constants.RavenReplicationDestinations,
null, new RavenJObject
{
{
"Destinations", new RavenJArray(destinations)
}
}, new RavenJObject());
}
private static void WaitForDocument(IDatabaseCommands commands, string expectedId)
{
for (int i = 0; i < RetriesCount; i++)
{
if (commands.Head(expectedId) != null)
break;
Thread.Sleep(100);
}
if(commands.Head(expectedId) == null)
throw new Exception("Document not replicated");
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentQuery{T}"/> class.
/// </summary>
public DocumentQuery(InMemoryDocumentSessionOperations session
#if !SILVERLIGHT
, IDatabaseCommands databaseCommands
#endif
, IAsyncDatabaseCommands asyncDatabaseCommands, string indexName, string[] fieldsToFetch, string[] projectionFields, IDocumentQueryListener[] queryListeners)
: base(session
#if !SILVERLIGHT
, databaseCommands
#endif
, asyncDatabaseCommands, indexName, fieldsToFetch, projectionFields, queryListeners)
{
}
/// <summary>
/// Executes the index creation against the specified document database using the specified conventions
/// </summary>
public virtual void Execute(IDatabaseCommands databaseCommands, DocumentConvention documentConvention)
{
Conventions = documentConvention;
var transformerDefinition = CreateTransformerDefinition();
// 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.
databaseCommands.PutTransformer(TransformerName, transformerDefinition);
UpdateIndexInReplication(databaseCommands, documentConvention, (commands, url) =>
commands.PutTransformer(TransformerName, transformerDefinition));
}
static WindowsAuthDocument GetWindowsAuthDocument(IDatabaseCommands systemCommands)
{
var existing = systemCommands.Get("Raven/Authorization/WindowsSettings");
if (existing == null)
{
return(new WindowsAuthDocument());
}
return(existing
.DataAsJson
.JsonDeserialization <WindowsAuthDocument>());
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncDocumentQuery{T}"/> class.
/// </summary>
public AsyncDocumentQuery(InMemoryDocumentSessionOperations session,
#if !SILVERLIGHT
IDatabaseCommands databaseCommands,
#endif
IAsyncDatabaseCommands asyncDatabaseCommands, string indexName, string[] fieldsToFetch, string[] projectionFields, IDocumentQueryListener[] queryListeners, bool isMapReduce)
: base(session,
#if !SILVERLIGHT
databaseCommands,
#endif
asyncDatabaseCommands, indexName, fieldsToFetch, projectionFields, queryListeners, isMapReduce)
{
}
public static void AddUserToDatabase(IDocumentStore documentStore, string username)
{
IDatabaseCommands systemCommands = documentStore
.DatabaseCommands
.ForSystemDatabase();
WindowsAuthDocument windowsAuthDocument = GetWindowsAuthDocument(systemCommands);
AddOrUpdateAuthUser(windowsAuthDocument, username, "<system>");
RavenJObject ravenJObject = RavenJObject.FromObject(windowsAuthDocument);
systemCommands.Put("Raven/Authorization/WindowsSettings", null, ravenJObject, new RavenJObject());
}
protected void UpdateReplication(IDatabaseCommands source, params DocumentStore[] destinations)
{
Assert.NotEmpty(destinations);
var destinationDocs = destinations.Select(destination => new RavenJObject
{
{ "Url", destination.Url },
{ "Database", destination.DefaultDatabase }
}).ToList();
UpdateReplication(source, destinationDocs);
}
private static void SetupReplication(IDatabaseCommands source, params string[] urls)
{
source.Put(Constants.RavenReplicationDestinations,
null, new RavenJObject
{
{
"Destinations", new RavenJArray(urls.Select(url => new RavenJObject
{
{"Url", url}
}))
}
}, new RavenJObject());
}
/// <summary>
/// Executes the index creation against the specified document database using the specified conventions
/// </summary>
public virtual void Execute(IDatabaseCommands databaseCommands, DocumentConvention documentConvention)
{
Conventions = documentConvention;
var transformerDefinition = CreateTransformerDefinition(documentConvention.PrettifyGeneratedLinqExpressions);
// 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.
databaseCommands.PutTransformer(TransformerName, transformerDefinition);
UpdateIndexInReplication(databaseCommands, documentConvention, (commands, url) =>
commands.PutTransformer(TransformerName, transformerDefinition));
}
public SwitchCommandsToDifferentDatabase()
{
using (var store = new DocumentStore())
{
#region for_database_3
IDatabaseCommands commands = store.DatabaseCommands.ForDatabase("otherDatabase");
#endregion
#region for_database_4
IDatabaseCommands systemCommands = store.DatabaseCommands.ForSystemDatabase();
#endregion
}
}
internal static void AfterExecute(IDatabaseCommands databaseCommands, string indexName, ScriptedIndexResults scripts)
{
var documentId = GetScriptedIndexResultsDocumentId(indexName);
scripts.Id = documentId;
var oldDocument = databaseCommands.Get(documentId);
var newDocument = RavenJObject.FromObject(scripts);
if (oldDocument != null && RavenJToken.DeepEquals(oldDocument.DataAsJson, newDocument))
return;
databaseCommands.Put(documentId, null, newDocument, null);
databaseCommands.ResetIndex(indexName);
}
protected void RemoveReplication(IDatabaseCommands source)
{
source.Put(
Constants.RavenReplicationDestinations,
null,
new RavenJObject
{
{
"Destinations", new RavenJArray()
}
},
new RavenJObject());
}
private static void SetupReplication(IDatabaseCommands source, params string[] urls)
{
source.Put(Constants.RavenReplicationDestinations,
null, new RavenJObject
{
{
"Destinations", new RavenJArray(urls.Select(url => new RavenJObject
{
{ "Url", url }
}))
}
}, new RavenJObject());
}
protected void SetupReplication(IDatabaseCommands source, Dictionary <string, string> specifiedCollections, params DocumentStore[] destinations)
{
Assert.NotEmpty(destinations);
var destinationDocs = destinations.Select(destination => new RavenJObject
{
{ "Url", destination.Url },
{ "Database", destination.DefaultDatabase },
{ "SpecifiedCollections", RavenJObject.FromObject(specifiedCollections) }
}).ToList();
SetupReplication(source, destinationDocs);
}
protected void SetupReplication(IDatabaseCommands source, params string[] urls)
{
Assert.NotEmpty(urls);
source.Put(replication::Raven.Bundles.Replication.ReplicationConstants.RavenReplicationDestinations,
null, new RavenJObject
{
{
"Destinations", new RavenJArray(urls.Select(url => new RavenJObject
{
{ "Url", url }
}))
}
}, new RavenJObject());
}
private void UpdateSideBySideIndex(IDatabaseCommands databaseCommands, Etag minimumEtagBeforeReplace, DateTime?replaceTimeUtc, string replaceIndexName, IndexDefinition indexDefinition, DocumentConvention documentConvention)
{
databaseCommands.PutIndex(replaceIndexName, indexDefinition, true);
databaseCommands
.Put(Constants.IndexReplacePrefix + replaceIndexName,
null,
RavenJObject.FromObject(new IndexReplaceDocument {
IndexToReplace = IndexName, MinimumEtagBeforeReplace = minimumEtagBeforeReplace, ReplaceTimeUtc = replaceTimeUtc
}),
new RavenJObject());
AfterExecute(databaseCommands, documentConvention);
}
public virtual IQueryable <T> GetAll()
{
using (IDocumentStore store = new DocumentStore
{
Url = "http://localhost:8080/"
}.Initialize())
{
IDatabaseCommands commands = store.DatabaseCommands;
using (IDocumentSession session = store.OpenSession())
{
return(session.Query <T>());
}
}
}
public void WaitForDelete(IDatabaseCommands commands, string key, TimeSpan?timeout = null)
{
var done = SpinWait.SpinUntil(() =>
{
// We expect to get the doc from the <system> database
var doc = commands.Get(key);
return(doc == null);
}, timeout ?? TimeSpan.FromMinutes(5));
if (!done)
{
throw new Exception("WaitForDelete failed");
}
}
protected virtual void WaitForDocument(IDatabaseCommands databaseCommands, string id)
{
var done = SpinWait.SpinUntil(() =>
{
// We expect to get the doc from the <system> database
var doc = databaseCommands.Get(id);
return(doc != null);
}, TimeSpan.FromMinutes(5));
if (!done)
{
throw new Exception("WaitForDocument failed");
}
}
/// <summary>
/// Executes the index creation against the specified document database using the specified conventions
/// </summary>
public virtual void Execute(IDatabaseCommands databaseCommands, DocumentConvention documentConvention)
{
Conventions = documentConvention;
var transformerDefinition = CreateTransformerDefinition(documentConvention.PrettifyGeneratedLinqExpressions);
// 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.
databaseCommands.PutTransformer(TransformerName, transformerDefinition);
if (documentConvention.IndexAndTransformerReplicationMode.HasFlag(IndexAndTransformerReplicationMode.Transformers))
{
ReplicateTransformerIfNeeded(databaseCommands);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="DocumentSession"/> class.
/// </summary>
public DocumentSession(DocumentStore documentStore,
DocumentSessionListeners listeners,
Guid id,
IDatabaseCommands databaseCommands
#if !NET_3_5
, IAsyncDatabaseCommands asyncDatabaseCommands
#endif
)
: base(documentStore, listeners, id)
{
#if !NET_3_5
this.asyncDatabaseCommands = asyncDatabaseCommands;
#endif
DatabaseCommands = databaseCommands;
}
protected override void WaitForDocument(IDatabaseCommands commands, string expectedId)
{
for (int i = 0; i < RetriesCount; i++)
{
if (commands.Head(expectedId) != null)
{
break;
}
Thread.Sleep(100);
}
var jsonDocumentMetadata = commands.Head(expectedId);
Assert.NotNull(jsonDocumentMetadata);
}
static bool InvokePut(IDatabaseCommands systemCommands, RavenJObject ravenJObject)
{
try
{
systemCommands.Put("Raven/Authorization/WindowsSettings", null, ravenJObject, new RavenJObject());
return true;
}
catch (ErrorResponseException exception)
{
if (exception.Message.Contains("Cannot setup Windows Authentication without a valid commercial license."))
{
throw new Exception("RavenDB requires a Commercial license to configure windows authentication. Please either install your RavenDB license or contact [email protected] if you need a copy of the RavenDB license.");
}
throw;
}
}
private static IDatabaseCommands SetupCommands(IDatabaseCommands databaseCommands, string database, ICredentials credentialsForSession, OpenSessionOptions options)
{
if (database != null)
{
databaseCommands = databaseCommands.ForDatabase(database);
}
if (credentialsForSession != null)
{
databaseCommands = databaseCommands.With(credentialsForSession);
}
if (options.ForceReadFromMaster)
{
databaseCommands.ForceReadFromMaster();
}
return(databaseCommands);
}
/// <summary>
/// Creates the indexes found in the specified catalog
/// </summary>
public static void CreateIndexes(ExportProvider catalogToGetnIndexingTasksFrom, IDatabaseCommands databaseCommands, DocumentConvention conventions)
{
var indexCompilationExceptions = new List<IndexCompilationException>();
try
{
var tasks = catalogToGetnIndexingTasksFrom
.GetExportedValues<AbstractIndexCreationTask>()
.ToList();
var indexesToAdd = tasks
.Select(x => new IndexToAdd
{
Definition = x.CreateIndexDefinition(),
Name = x.IndexName,
Priority = x.Priority ?? IndexingPriority.Normal
})
.ToArray();
databaseCommands.PutIndexes(indexesToAdd);
foreach (var task in tasks)
task.AfterExecute(databaseCommands, conventions);
}
// For old servers that don't have the new entrypoint for executing multiple indexes
catch (Exception)
{
foreach (var task in catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>())
{
try
{
task.Execute(databaseCommands, conventions);
}
catch (IndexCompilationException e)
{
indexCompilationExceptions.Add(new IndexCompilationException("Failed to compile index name = " + task.IndexName, e));
}
}
}
foreach (var task in catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractTransformerCreationTask>())
{
task.Execute(databaseCommands, conventions);
}
if (indexCompilationExceptions.Any())
throw new AggregateException("Failed to create one or more indexes. Please see inner exceptions for more details.", indexCompilationExceptions);
}
///<summary>
/// Create the next id (numeric)
///</summary>
public long NextId(IDatabaseCommands commands)
{
while (true)
{
var myRange = Range; // thread safe copy
var current = Interlocked.Increment(ref myRange.Current);
if (current <= myRange.Max)
return current;
lock (generatorLock)
{
if (Range != myRange)
// Lock was contended, and the max has already been changed. Just get a new id as usual.
continue;
Range = GetNextRange(commands);
}
}
}
/// <summary>
/// Creates the indexes found in the specified catalog
/// </summary>
public static void CreateIndexes(ExportProvider catalogToGetnIndexingTasksFrom, IDatabaseCommands databaseCommands, DocumentConvention conventions)
{
var indexCompilationExceptions = new List<IndexCompilationException>();
foreach (var task in catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractIndexCreationTask>())
{
try
{
task.Execute(databaseCommands, conventions);
}
catch (IndexCompilationException e)
{
indexCompilationExceptions.Add(new IndexCompilationException("Failed to compile index name = " + task.IndexName, e));
}
}
foreach (var task in catalogToGetnIndexingTasksFrom.GetExportedValues<AbstractTransformerCreationTask>())
{
task.Execute(databaseCommands, conventions);
}
if (indexCompilationExceptions.Any())
throw new AggregateException("Failed to create one or more indexes. Please see inner exceptions for more details.", indexCompilationExceptions);
}
protected PeriodicExportStatus GetPerodicBackupStatus(IDatabaseCommands commands)
{
return GetPerodicBackupStatus(commands.Get);
}
public void Execute(Guid myResourceManagerId, IDatabaseCommands commands)
{
var resourceManagersRequiringRecovery = new HashSet<Guid>();
using (var store = IsolatedStorageFile.GetMachineStoreForDomain())
{
var filesToDelete = new List<string>();
foreach (var file in store.GetFileNames("*.recovery-information"))
{
var txId = Guid.Empty;
try
{
IsolatedStorageFileStream stream;
try
{
stream = store.OpenFile(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
}
catch (Exception e)
{
logger.WarnException("Could not open recovery information: " + file +", this is expected if it is an active transaction / held by another server", e);
continue;
}
using (stream)
using(var reader = new BinaryReader(stream))
{
var resourceManagerId = new Guid(reader.ReadString());
if(myResourceManagerId != resourceManagerId)
continue; // it doesn't belong to us, ignore
filesToDelete.Add(file);
txId = new Guid(reader.ReadString());
var db = reader.ReadString();
var dbCmds = string.IsNullOrEmpty(db) == false ?
commands.ForDatabase(db) :
commands.ForSystemDatabase();
TransactionManager.Reenlist(resourceManagerId, stream.ReadData(), new InternalEnlistment(dbCmds, txId));
resourceManagersRequiringRecovery.Add(resourceManagerId);
logger.Info("Recovered transaction {0}", txId);
}
}
catch (Exception e)
{
logger.WarnException("Could not re-enlist in DTC transaction for tx: " + txId, e);
}
}
foreach (var rm in resourceManagersRequiringRecovery)
{
try
{
TransactionManager.RecoveryComplete(rm);
}
catch (Exception e)
{
logger.WarnException("Could not properly complete recovery of resource manager: " + rm, e);
}
}
var errors = new List<Exception>();
foreach (var file in filesToDelete)
{
try
{
if (store.FileExists(file))
store.DeleteFile(file);
}
catch (Exception e)
{
errors.Add(e);
}
}
if (errors.Count > 0)
throw new AggregateException(errors);
}
}
public InternalEnlistment(IDatabaseCommands database, Guid txId)
{
this.database = database;
this.txId = txId;
}
public object ExecuteEmbedded(IDatabaseCommands commands)
{
return commands.Suggest(index, suggestionQuery);
}
private void PutDocument(IDatabaseCommands databaseCommands,JsonDocument document)
{
databaseCommands.Put(HiLoDocumentKey, document.Etag,
document.DataAsJson,
document.Metadata);
}
private JsonDocument GetDocument(IDatabaseCommands databaseCommands)
{
var documents = databaseCommands.Get(new[] { HiLoDocumentKey, RavenKeyServerPrefix }, new string[0]);
return HandleGetDocumentResult(documents);
}
protected virtual void WaitForDocument(IDatabaseCommands databaseCommands, string id)
{
var done = SpinWait.SpinUntil(() =>
{
// We expect to get the doc from the <system> database
var doc = databaseCommands.Get(id);
return doc != null;
}, TimeSpan.FromMinutes(5));
if (!done) throw new Exception("WaitForDocument failed");
}
public string GenerateDocumentKey(string dbName, IDatabaseCommands databaseCommands, DocumentConvention conventions, object entity)
{
var multiTypeHiLoKeyGenerator = generators.GetOrAdd(dbName ?? Constants.SystemDatabase, s => new MultiTypeHiLoKeyGenerator(capacity));
return multiTypeHiLoKeyGenerator.GenerateDocumentKey(databaseCommands, conventions, entity);
}
protected void WaitForPeriodicExport(IDatabaseCommands commands, PeriodicExportStatus previousStatus)
{
WaitForPeriodicExport(commands.Get, previousStatus);
}
private static IDatabaseCommands SetupCommands(IDatabaseCommands databaseCommands, string database, ICredentials credentialsForSession, OpenSessionOptions options)
{
if (database != null)
databaseCommands = databaseCommands.ForDatabase(database);
if (credentialsForSession != null)
databaseCommands = databaseCommands.With(credentialsForSession);
if (options.ForceReadFromMaster)
databaseCommands.ForceReadFromMaster();
return databaseCommands;
}
protected void WaitForBackup(IDatabaseCommands commands, bool checkError)
{
WaitForBackup(commands.Get, checkError);
}
/// <summary>
/// Generates the document key.
/// </summary>
/// <param name="convention">The convention.</param>
/// <param name="entity">The entity.</param>
/// <returns></returns>
public string GenerateDocumentKey(IDatabaseCommands databaseCommands, DocumentConvention convention, object entity)
{
return GetDocumentKeyFromId(convention, NextId(databaseCommands));
}
protected void WaitForRestore(IDatabaseCommands databaseCommands)
{
var systemDatabaseCommands = databaseCommands.ForSystemDatabase(); // need to be sure that we are checking system database
var failureMessages = new[]
{
"Esent Restore: Failure! Could not restore database!",
"Error: Restore Canceled",
"Restore Operation: Failure! Could not restore database!"
};
var restoreFinishMessages = new[]
{
"The new database was created",
"Esent Restore: Restore Complete",
"Restore ended but could not create the datebase document, in order to access the data create a database with the appropriate name",
};
var done = SpinWait.SpinUntil(() =>
{
// We expect to get the doc from the <system> database
var doc = systemDatabaseCommands.Get(RestoreStatus.RavenRestoreStatusDocumentKey);
if (doc == null)
return false;
var status = doc.DataAsJson.Deserialize<RestoreStatus>(new DocumentConvention());
if (failureMessages.Any(status.Messages.Contains))
throw new InvalidOperationException("Restore failure: " + status.Messages.Aggregate(string.Empty, (output, message) => output + (message + Environment.NewLine)));
return restoreFinishMessages.Any(status.Messages.Contains);
}, TimeSpan.FromMinutes(5));
if (!done) throw new Exception("WaitForRestore failed");
}
/// <summary>
/// Initializes a new instance of the <see cref="MultiTypeHiLoKeyGenerator"/> class.
/// </summary>
public MultiTypeHiLoKeyGenerator(IDatabaseCommands databaseCommands, int capacity)
{
this.databaseCommands = databaseCommands;
this.capacity = capacity;
}
private RangeValue GetNextRange(IDatabaseCommands databaseCommands)
{
#if !NETFX_CORE
using (new TransactionScope(TransactionScopeOption.Suppress))
{
#endif
ModifyCapacityIfRequired();
while (true)
{
try
{
var minNextMax = Range.Max;
JsonDocument document;
try
{
document = GetDocument(databaseCommands);
}
catch (ConflictException e)
{
// resolving the conflict by selecting the highest number
var highestMax = e.ConflictedVersionIds
.Select(conflictedVersionId => GetMaxFromDocument(databaseCommands.Get(conflictedVersionId), minNextMax))
.Max();
PutDocument(databaseCommands, new JsonDocument
{
Etag = e.Etag,
Metadata = new RavenJObject(),
DataAsJson = RavenJObject.FromObject(new { Max = highestMax }),
Key = HiLoDocumentKey
});
continue;
}
long min, max;
if (document == null)
{
min = minNextMax + 1;
max = minNextMax + capacity;
document = new JsonDocument
{
Etag = Etag.Empty,
// sending empty etag means - ensure the that the document does NOT exists
Metadata = new RavenJObject(),
DataAsJson = RavenJObject.FromObject(new { Max = max }),
Key = HiLoDocumentKey
};
}
else
{
var oldMax = GetMaxFromDocument(document, minNextMax);
min = oldMax + 1;
max = oldMax + capacity;
document.DataAsJson["Max"] = max;
}
PutDocument(databaseCommands, document);
return new RangeValue(min, max);
}
catch (ConcurrencyException)
{
// expected, we need to retry
}
}
#if !NETFX_CORE
}
#endif
}
