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>
		/// 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;
		}

		/// <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);
		}

 public HiLoKeyGenerator(IDatabaseCommands commands, string tag, long capacity)
 {
     currentHi = 0;
     this.commands = commands;
     this.tag = tag;
     this.capacity = capacity;
     currentLo = capacity + 1;
 }

		/// <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);
			}
		}

 static WindowsAuthDocument GetWindowsAuthDocument(IDatabaseCommands systemCommands)
 {
     var existing = systemCommands.Get("Raven/Authorization/WindowsSettings");
     if (existing == null)
     {
         return new WindowsAuthDocument();
     }
     return existing
         .DataAsJson
         .JsonDeserialization<WindowsAuthDocument>();
 }

		/// <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));
		}

		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");
		}

        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);
        }

		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());
		}

 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;
     }
 }

		/// <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);
		}

		private void PutDocument(IDatabaseCommands databaseCommands,JsonDocument document)
		{
			databaseCommands.Put(HiLoDocumentKey, document.Etag,
								 document.DataAsJson,
								 document.Metadata);
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="MultiTypeHiLoKeyGenerator"/> class.
		/// </summary>
		public MultiTypeHiLoKeyGenerator(IDatabaseCommands databaseCommands, int capacity)
		{
			this.databaseCommands = databaseCommands;
			this.capacity = capacity;
		}

		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);
		}

 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 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");
        }

        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");
        }