public DatabaseBulkOperations(DocumentDatabase database, TransactionInformation transactionInformation, CancellationTokenSource tokenSource, CancellationTimeout timeout)
{
this.database = database;
this.transactionInformation = transactionInformation;
this.tokenSource = tokenSource;
this.timeout = timeout;
}
protected override bool TryGetOrCreateResourceStore(string tenantId, out IResourceStore database)
{
if (ResourcesStoresCache.TryGetValue(tenantId, out database))
return true;
JsonDocument jsonDocument;
using (DocumentRetriever.DisableReadTriggers())
jsonDocument = DefaultDatabase.Get("Raven/Databases/" + tenantId, null);
if (jsonDocument == null)
return false;
var document = jsonDocument.DataAsJson.JsonDeserialization<DatabaseDocument>();
database = ResourcesStoresCache.GetOrAdd(tenantId, s =>
{
var config = new InMemoryRavenConfiguration
{
Settings = DefaultConfiguration.Settings,
};
config.Settings["Raven/VirtualDir"] = config.Settings["Raven/VirtualDir"] + "/" + tenantId;
foreach (var setting in document.Settings)
{
config.Settings[setting.Key] = setting.Value;
}
config.Initialize();
var documentDatabase = new DocumentDatabase(config);
documentDatabase.SpinBackgroundWorkers();
return documentDatabase;
});
return true;
}
public BackupOperation(DocumentDatabase database, string backupSourceDirectory, string backupDestinationDirectory, bool incrementalBackup,
DatabaseDocument databaseDocument)
: base(database, backupSourceDirectory, backupDestinationDirectory, incrementalBackup, databaseDocument)
{
instance = ((TransactionalStorage) database.TransactionalStorage).Instance;
backupConfigPath = Path.Combine(backupDestinationDirectory, "RavenDB.Backup");
}
public void SilverlightWasRequested(DocumentDatabase database)
{
if (database.GetIndexDefinition("Raven/DocumentsByEntityName") == null)
{
database.PutIndex("Raven/DocumentsByEntityName", new IndexDefinition
{
Map =
@"from doc in docs
let Tag = doc[""@metadata""][""Raven-Entity-Name""]
select new { Tag, LastModified = (DateTime)doc[""@metadata""][""Last-Modified""] };",
Indexes =
{
{"Tag", FieldIndexing.NotAnalyzed},
{"LastModified", FieldIndexing.NotAnalyzed},
},
Stores =
{
{"Tag", FieldStorage.No},
{"LastModified", FieldStorage.No}
},
TermVectors =
{
{"Tag", FieldTermVector.No},
{"LastModified", FieldTermVector.No}
}
});
}
}
private void OnTransformerChange(DocumentDatabase documentDatabase, TransformerChangeNotification notification)
{
var transformerName = notification.Name;
switch (notification.Type)
{
case TransformerChangeTypes.TransformerAdded:
//if created transformer with the same name as deleted one, we should prevent its deletion replication
Database.TransactionalStorage.Batch(accessor =>
accessor.Lists.Remove(Constants.RavenReplicationTransformerTombstones, transformerName));
break;
case TransformerChangeTypes.TransformerRemoved:
//If we don't have any destination to replicate to (we are probably slave node)
//we shouldn't keep a tombstone since we are not going to remove it anytime
//and keeping it prevents us from getting that transformer created again.
if (GetReplicationDestinations().Count == 0)
return;
var metadata = new RavenJObject
{
{Constants.RavenTransformerDeleteMarker, true},
{Constants.RavenReplicationSource, Database.TransactionalStorage.Id.ToString()},
{Constants.RavenReplicationVersion, ReplicationHiLo.NextId(Database)},
{"TransformerVersion", notification.Version }
};
Database.TransactionalStorage.Batch(accessor =>
accessor.Lists.Set(Constants.RavenReplicationTransformerTombstones, transformerName, metadata, UuidType.Transformers));
break;
}
}
public BackupOperation(DocumentDatabase database, string src, string to)
{
instance = database.TransactionalStorage.Instance;
this.database = database;
this.to = to;
this.src = src;
}
public CurrentIndexingScope(DocumentDatabase database, string index)
{
this.database = database;
this.index = index;
LoadDocumentCount = 0;
LoadDocumentDuration = new Stopwatch();
}
public void Execute(DocumentDatabase database)
{
HashSet<Guid> resourceManagersRequiringRecovery = new HashSet<Guid>();
database.TransactionalStorage.Batch(actions =>
{
foreach (var txId in actions.Transactions.GetTransactionIds())
{
var attachment = actions.Attachments.GetAttachment("transactions/recoveryInformation/" + txId);
if (attachment == null)//Prepare was not called, there is no recovery information
{
actions.Transactions.RollbackTransaction(txId);
}
else
{
Guid resourceManagerId;
if (Guid.TryParse(attachment.Metadata.Value<string>("Resource-Manager-Id"), out resourceManagerId) == false)
{
actions.Transactions.RollbackTransaction(txId);
}
else
{
resourceManagersRequiringRecovery.Add(resourceManagerId);
TransactionManager.Reenlist(resourceManagerId, attachment.Data, new InternalEnlistment(database, txId));
}
}
}
});
foreach (var rm in resourceManagersRequiringRecovery)
{
TransactionManager.RecoveryComplete(rm);
}
}
public OwinHttpServer(InMemoryRavenConfiguration config, DocumentDatabase db = null, bool useHttpServer = true, Action<RavenDBOptions> configure = null)
{
startup = new Startup(config, db);
if (configure != null)
configure(startup.Options);
owinEmbeddedHost = OwinEmbeddedHost.Create(app => startup.Configuration(app));
if (!useHttpServer)
{
return;
}
server = WebApp.Start("http://+:" + config.Port, app => //TODO DH: configuration.ServerUrl doesn't bind properly
{
var listener = (HttpListener) app.Properties["System.Net.HttpListener"];
if (listener != null)
{
new WindowsAuthConfigureHttpListener().Configure(listener, config);
}
startup.Configuration(app);
app.Use(async (context, _) =>
{
context.Response.StatusCode = 404;
context.Response.ReasonPhrase = "Not Found";
await context.Response.Body.WriteAsync(NotFoundBody, 0, NotFoundBody.Length);
});
});
}
public static void Execute(this ICommandData self, DocumentDatabase database)
{
var deleteCommandData = self as DeleteCommandData;
if (deleteCommandData != null)
{
database.Delete(deleteCommandData.Key, deleteCommandData.Etag, deleteCommandData.TransactionInformation);
return;
}
var putCommandData = self as PutCommandData;
if (putCommandData != null)
{
var putResult = database.Put(putCommandData.Key, putCommandData.Etag, putCommandData.Document, putCommandData.Metadata, putCommandData.TransactionInformation);
putCommandData.Etag = putResult.ETag;
putCommandData.Key = putResult.Key;
return;
}
var patchCommandData = self as PatchCommandData;
if (patchCommandData != null)
{
database.ApplyPatch(patchCommandData.Key, patchCommandData.Etag, patchCommandData.Patches, patchCommandData.TransactionInformation);
var doc = database.Get(patchCommandData.Key, patchCommandData.TransactionInformation);
if (doc != null)
{
patchCommandData.Metadata = doc.Metadata;
patchCommandData.Etag = doc.Etag;
}
return;
}
}
protected ActionsBase(DocumentDatabase database, SizeLimitedConcurrentDictionary<string, TouchedDocumentInfo> recentTouches, IUuidGenerator uuidGenerator, ILog log)
{
Database = database;
RecentTouches = recentTouches;
UuidGenerator = uuidGenerator;
Log = log;
}
public AnonymousObjectToLuceneDocumentConverter(DocumentDatabase database, IndexDefinition indexDefinition, AbstractViewGenerator viewGenerator, ILog log)
{
this.database = database;
this.indexDefinition = indexDefinition;
this.viewGenerator = viewGenerator;
this.log = log;
}
public IndexReplacer(DocumentDatabase database)
{
Database = database;
database.Notifications.OnDocumentChange += (db, notification, metadata) =>
{
if (notification.Id == null)
return;
if (notification.Id.StartsWith(Constants.IndexReplacePrefix, StringComparison.OrdinalIgnoreCase) == false)
return;
var replaceIndexName = notification.Id.Substring(Constants.IndexReplacePrefix.Length);
if (notification.Type == DocumentChangeTypes.Delete)
{
HandleIndexReplaceDocumentDelete(replaceIndexName);
return;
}
var document = db.Documents.Get(notification.Id, null);
var replaceIndexId = HandleIndexReplaceDocument(document);
if (replaceIndexId != null)
ReplaceIndexes(new []{ replaceIndexId.Value });
};
Initialize();
}
public void Execute(DocumentDatabase database)
{
if (database.Configuration.RunInMemory)
return;
var dataDirectory = Path.GetFullPath(database.Configuration.DataDirectory);
var desktopIni = Path.Combine(dataDirectory, "desktop.ini");
var icon = Path.Combine(dataDirectory, "raven-data.ico");
if (File.Exists(desktopIni) && File.Exists(icon))
return;
using (var iconFile = typeof(CreateFolderIcon).Assembly.GetManifestResourceStream("Raven.Database.Server.WebUI.raven-data.ico"))
{
File.WriteAllBytes(icon, iconFile.ReadData());
}
File.WriteAllText(desktopIni, string.Format(@"
[.ShellClassInfo]
IconResource={0},0
[ViewState]
Mode=
Vid=
FolderType=Generic
",
icon));
File.SetAttributes(desktopIni, FileAttributes.Hidden | FileAttributes.System | FileAttributes.Archive);
File.SetAttributes(dataDirectory, FileAttributes.ReadOnly);
}
public IndexReplicationTask(DocumentDatabase database, HttpRavenRequestFactory httpRavenRequestFactory, ReplicationTask replication)
: base(database, httpRavenRequestFactory, replication)
{
replicationFrequency = TimeSpan.FromSeconds(database.Configuration.IndexAndTransformerReplicationLatencyInSec); //by default 10 min
lastQueriedFrequency = TimeSpan.FromSeconds(database.Configuration.TimeToWaitBeforeRunningIdleIndexes.TotalSeconds / 2);
TimeToWaitBeforeSendingDeletesOfIndexesToSiblings = TimeSpan.FromMinutes(1);
}
public void Execute(DocumentDatabase database)
{
if (database.Configuration.IsSystemDatabase() == false)
return;
if (ValidateLicense.CurrentLicense.IsCommercial && ValidateLicense.CurrentLicense.Error == false)
{
SetValidCommercialLicenseMarker(database);
ValidateLicense.CurrentLicense.ValidCommercialLicenseSeen = true;
}
else
{
var marker = GetLastSeenValidCommercialLicenseMarker(database);
if (marker != null)
{
ValidateLicense.CurrentLicense.ValidCommercialLicenseSeen = true;
}
}
if (Authentication.IsEnabled == false && database.Configuration.AnonymousUserAccessMode != AnonymousUserAccessMode.Admin)
{
throw new InvalidOperationException("Cannot set Raven/AnonymousAccess to '" + database.Configuration.AnonymousUserAccessMode+"' without a valid license.\r\n" +
"This RavenDB instance doesn't have a license, and the only valid Raven/AnonymousAccess setting is: Admin\r\n" +
"Please change to Raven/AnonymousAccess to Admin, or install a valid license.");
}
}
public void RecordWriteError(Exception e, DocumentDatabase database, int count = 1, DateTime? newErrorTime = null)
{
WriteErrorCount += count;
if (WriteErrorCount < 100)
return;
if (WriteErrorCount <= SuccessCount)
return;
if (newErrorTime != null)
{
LastErrorTime = newErrorTime.Value;
return;
}
database.AddAlert(LastAlert = new Alert
{
AlertLevel = AlertLevel.Error,
CreatedAt = SystemTime.UtcNow,
Message = "Could not tolerate write error ratio and stopped current replication cycle for " + name + Environment.NewLine + this,
Title = "Sql Replication write error hit ratio too high",
Exception = e.ToString(),
UniqueKey = "Sql Replication Write Error Ratio: " + name
});
throw new InvalidOperationException("Could not tolerate write error ratio and stopped current replication cycle for " + name + Environment.NewLine + this, e);
}
public ScriptedJsonPatcher(DocumentDatabase database = null)
{
if (database == null)
{
maxSteps = 10 * 1000;
additionalStepsPerSize = 5;
loadDocument = (s =>
{
throw new InvalidOperationException(
"Cannot load by id without database context");
});
}
else
{
maxSteps = database.Configuration.MaxStepsForScript;
additionalStepsPerSize = database.Configuration.AdditionalStepsForScriptBasedOnDocumentSize;
loadDocument = id =>
{
JsonDocument jsonDocument;
if (!createdDocDict.TryGetValue(id, out jsonDocument))
jsonDocument = database.Get(id, null);
return jsonDocument == null ? null : jsonDocument.ToJson();
};
}
}
public IndexStorage(IndexDefinitionStorage indexDefinitionStorage, InMemoryRavenConfiguration configuration, DocumentDatabase documentDatabase)
{
this.indexDefinitionStorage = indexDefinitionStorage;
this.configuration = configuration;
path = configuration.IndexStoragePath;
if (Directory.Exists(path) == false && configuration.RunInMemory == false)
Directory.CreateDirectory(path);
if (configuration.RunInMemory == false)
{
var crashMarkerPath = Path.Combine(path, "indexing.crash-marker");
if (File.Exists(crashMarkerPath))
{
// the only way this can happen is if we crashed because of a power outage
// in this case, we consider all open indexes to be corrupt and force them
// to be reset. This is because to get better perf, we don't flush the files to disk,
// so in the case of a power outage, we can't be sure that there wasn't still stuff in
// the OS buffer that wasn't written yet.
configuration.ResetIndexOnUncleanShutdown = true;
}
// The delete on close ensures that the only way this file will exists is if there was
// a power outage while the server was running.
crashMarker = File.Create(crashMarkerPath, 16, FileOptions.DeleteOnClose);
}
foreach (var indexName in indexDefinitionStorage.IndexNames)
{
OpenIndexOnStartup(documentDatabase, indexName);
}
}
public SmugglerExporter(DocumentDatabase database, ExportOptions options)
{
this.database = database;
this.options = options;
FillExportTypes();
}
public void Execute(DocumentDatabase database)
{
Database = database;
Database.OnDocumentChange += (sender, notification) =>
{
if (notification.Id == null)
return;
if (!notification.Id.StartsWith("Raven/SqlReplication/Configuration/", StringComparison.InvariantCultureIgnoreCase))
return;
replicationConfigs = null;
statistics.Clear();
};
GetReplicationStatus();
prefetchingBehavior = new PrefetchingBehavior(Database.WorkContext, new IndexBatchSizeAutoTuner(Database.WorkContext));
var task = Task.Factory.StartNew(() =>
{
using (LogContext.WithDatabase(database.Name))
{
try
{
BackgroundSqlReplication();
}
catch (Exception e)
{
log.ErrorException("Fatal failure when replicating to SQL. All SQL Replication activity STOPPED", e);
}
}
}, TaskCreationOptions.LongRunning);
database.ExtensionsState.GetOrAdd(typeof(SqlReplicationTask).FullName, k => new DisposableAction(task.Wait));
}
public BackupOperation(DocumentDatabase systemDatabase, RavenFileSystem filesystem, string backupSourceDirectory, string backupDestinationDirectory, bool incrementalBackup,
FileSystemDocument filesystemDocument)
: base(systemDatabase, filesystem, backupSourceDirectory, backupDestinationDirectory, incrementalBackup, filesystemDocument)
{
instance = ((TransactionalStorage)filesystem.Storage).Instance;
backupConfigPath = Path.Combine(backupDestinationDirectory, "RavenDB.Backup");
}
public RavenDBOptions(InMemoryRavenConfiguration configuration, DocumentDatabase db = null)
{
if (configuration == null)
throw new ArgumentNullException("configuration");
try
{
HttpEndpointRegistration.RegisterHttpEndpointTarget();
HttpEndpointRegistration.RegisterAdminLogsTarget();
if (db == null)
{
configuration.UpdateDataDirForLegacySystemDb();
systemDatabase = new DocumentDatabase(configuration);
systemDatabase.SpinBackgroundWorkers();
}
else
{
systemDatabase = db;
}
fileSystemLandlord = new FileSystemsLandlord(systemDatabase);
databasesLandlord = new DatabasesLandlord(systemDatabase);
countersLandlord = new CountersLandlord(systemDatabase);
requestManager = new RequestManager(databasesLandlord);
mixedModeRequestAuthorizer = new MixedModeRequestAuthorizer();
mixedModeRequestAuthorizer.Initialize(systemDatabase, new RavenServer(databasesLandlord.SystemDatabase, configuration));
}
catch
{
if (systemDatabase != null)
systemDatabase.Dispose();
throw;
}
}
public ReplicationTopologyDiscoverer(DocumentDatabase database, RavenJArray @from, int ttl, ILog log)
{
this.database = database;
this.ttl = ttl;
this.log = log;
this.@from = @from;
requestFactory = new HttpRavenRequestFactory();
}
private void SetValidCommercialLicenseMarker(DocumentDatabase database)
{
database.TransactionalStorage.Batch(
accessor => accessor.Lists.Set(LicensingListName, ValidationMarkerName, new RavenJObject()
{
{"ValidationTime", SystemTime.UtcNow}
}, UuidType.Documents));
}
public EsentInFlightTransactionalState(DocumentDatabase database, TransactionalStorage storage, CommitTransactionGrbit txMode, Func<string, Etag, RavenJObject, RavenJObject, TransactionInformation, PutResult> databasePut, Func<string, Etag, TransactionInformation, bool> databaseDelete)
: base(databasePut, databaseDelete)
{
_database = database;
this.storage = storage;
this.txMode = txMode;
timer = database.TimerManager.NewTimer(CleanupOldTransactions, TimeSpan.FromSeconds(30), TimeSpan.FromSeconds(30));
}
public void Initialize(DocumentDatabase database, IRavenServer theServer)
{
this.database = database;
this.settings = database.Configuration;
this.server = theServer;
Initialize();
}
public void Execute(DocumentDatabase database)
{
var oldBackup = database.Documents.Get(RestoreInProgress.RavenRestoreInProgressDocumentKey,null);
if (oldBackup == null)
return;
database.Documents.Delete(RestoreInProgress.RavenRestoreInProgressDocumentKey, null, null);
}
private ListItem GetLastSeenValidCommercialLicenseMarker(DocumentDatabase database)
{
ListItem lastSeenValidCommercialLicense = null;
database.TransactionalStorage.Batch(
accessor => { lastSeenValidCommercialLicense = accessor.Lists.Read(LicensingListName, ValidationMarkerName); });
return lastSeenValidCommercialLicense;
}
public CurrentTransformationScope(DocumentDatabase database, DocumentRetriever documentRetriever)
{
this.database = database;
retriever = documentRetriever;
old = current;
current = this;
}
private static void ActualTest(int numberOfUsers, string[] locations, Index index,
MapReduceIndexingContext mapReduceContext, IIndexingWork reducer, DocumentDatabase database, string outputToCollectionName)
{
using (index._contextPool.AllocateOperationContext(out TransactionOperationContext indexContext))
{
ulong hashOfReduceKey = 73493;
using (var tx = indexContext.OpenWriteTransaction())
{
mapReduceContext.MapPhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .MapPhaseTreeName);
mapReduceContext.ReducePhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .ReducePhaseTreeName);
var store = new MapReduceResultsStore(hashOfReduceKey, MapResultsStorageType.Tree, indexContext, mapReduceContext, true);
for (int i = 0; i < numberOfUsers; i++)
{
using (var mappedResult = indexContext.ReadObject(new DynamicJsonValue
{
["Count"] = 1,
["Location"] = locations[i % locations.Length]
}, $"users/{i}"))
{
store.Add(i, mappedResult);
}
}
mapReduceContext.StoreByReduceKeyHash.Add(hashOfReduceKey, store);
var writeOperation =
new Lazy <IndexWriteOperation>(() => index.IndexPersistence.OpenIndexWriter(tx.InnerTransaction, indexContext));
var stats = new IndexingStatsScope(new IndexingRunStats());
reducer.Execute(null, indexContext,
writeOperation,
stats, CancellationToken.None);
using (var indexWriteOperation = writeOperation.Value)
{
indexWriteOperation.Commit(stats);
}
index.IndexPersistence.RecreateSearcher(tx.InnerTransaction);
mapReduceContext.Dispose();
tx.Commit();
}
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
using (context.OpenReadTransaction())
{
var results = database.DocumentsStorage.GetDocumentsFrom(context, outputToCollectionName, 0, 0, int.MaxValue).ToList();
Assert.Equal(locations.Length, results.Count);
for (int i = 0; i < locations.Length; i++)
{
Assert.Equal(locations[i], results[i].Data["Location"].ToString());
long expected = numberOfUsers / locations.Length + numberOfUsers % (locations.Length - i);
Assert.Equal(expected, results[i].Data["Count"]);
}
}
// update
using (var tx = indexContext.OpenWriteTransaction())
{
mapReduceContext.MapPhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .MapPhaseTreeName);
mapReduceContext.ReducePhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .ReducePhaseTreeName);
var store = new MapReduceResultsStore(hashOfReduceKey, MapResultsStorageType.Tree, indexContext, mapReduceContext, true);
for (int i = 0; i < locations.Length; i++)
{
using (var mappedResult = indexContext.ReadObject(new DynamicJsonValue
{
["Count"] = 2, // increased by 1
["Location"] = locations[i % locations.Length]
}, $"users/{i}"))
{
store.Add(i, mappedResult);
}
}
mapReduceContext.StoreByReduceKeyHash.Add(hashOfReduceKey, store);
var writeOperation =
new Lazy <IndexWriteOperation>(() => index.IndexPersistence.OpenIndexWriter(tx.InnerTransaction, indexContext));
try
{
var stats = new IndexingStatsScope(new IndexingRunStats());
reducer.Execute(null, indexContext,
writeOperation,
stats, CancellationToken.None);
using (var indexWriteOperation = writeOperation.Value)
{
indexWriteOperation.Commit(stats);
}
index.IndexPersistence.RecreateSearcher(tx.InnerTransaction);
mapReduceContext.Dispose();
}
finally
{
if (writeOperation.IsValueCreated)
{
writeOperation.Value.Dispose();
}
}
tx.Commit();
}
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
using (context.OpenReadTransaction())
{
var results = database.DocumentsStorage.GetDocumentsFrom(context, outputToCollectionName, 0, 0, int.MaxValue).ToList();
Assert.Equal(locations.Length, results.Count);
for (int i = 0; i < locations.Length; i++)
{
Assert.Equal(locations[i], results[i].Data["Location"].ToString());
long expected = numberOfUsers / locations.Length + numberOfUsers % (locations.Length - i);
Assert.Equal(expected + 1, results[i].Data["Count"]);
}
}
// delete
using (var tx = indexContext.OpenWriteTransaction())
{
mapReduceContext.MapPhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .MapPhaseTreeName);
mapReduceContext.ReducePhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .ReducePhaseTreeName);
var store = new MapReduceResultsStore(hashOfReduceKey, MapResultsStorageType.Tree, indexContext, mapReduceContext, true);
for (int i = 0; i < locations.Length; i++)
{
store.Delete(i);
}
mapReduceContext.StoreByReduceKeyHash.Add(hashOfReduceKey, store);
var writeOperation =
new Lazy <IndexWriteOperation>(() => index.IndexPersistence.OpenIndexWriter(tx.InnerTransaction, indexContext));
try
{
var stats = new IndexingStatsScope(new IndexingRunStats());
reducer.Execute(null, indexContext,
writeOperation,
stats, CancellationToken.None);
using (var indexWriteOperation = writeOperation.Value)
{
indexWriteOperation.Commit(stats);
}
index.IndexPersistence.RecreateSearcher(tx.InnerTransaction);
mapReduceContext.Dispose();
tx.Commit();
}
finally
{
if (writeOperation.IsValueCreated)
{
writeOperation.Value.Dispose();
}
}
}
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
using (context.OpenReadTransaction())
{
var results = database.DocumentsStorage.GetDocumentsFrom(context, outputToCollectionName, 0, 0, int.MaxValue).ToList();
Assert.Equal(locations.Length, results.Count);
for (int i = 0; i < locations.Length; i++)
{
Assert.Equal(locations[i], results[i].Data["Location"].ToString());
long expected = numberOfUsers / locations.Length + numberOfUsers % (locations.Length - i);
Assert.Equal(expected - 1, results[i].Data["Count"]);
}
}
// delete entries for one reduce key
using (var tx = indexContext.OpenWriteTransaction())
{
mapReduceContext.MapPhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .MapPhaseTreeName);
mapReduceContext.ReducePhaseTree = tx.InnerTransaction.CreateTree(MapReduceIndexBase <MapIndexDefinition, IndexField> .ReducePhaseTreeName);
var store = new MapReduceResultsStore(hashOfReduceKey, MapResultsStorageType.Tree, indexContext, mapReduceContext, true);
for (int i = 0; i < numberOfUsers; i++)
{
if (i % locations.Length == 0)
{
store.Delete(i);
}
}
mapReduceContext.StoreByReduceKeyHash.Add(hashOfReduceKey, store);
var writeOperation =
new Lazy <IndexWriteOperation>(() => index.IndexPersistence.OpenIndexWriter(tx.InnerTransaction, indexContext));
try
{
var stats = new IndexingStatsScope(new IndexingRunStats());
reducer.Execute(null, indexContext,
writeOperation,
stats, CancellationToken.None);
using (var indexWriteOperation = writeOperation.Value)
{
indexWriteOperation.Commit(stats);
}
index.IndexPersistence.RecreateSearcher(tx.InnerTransaction);
mapReduceContext.Dispose();
tx.Commit();
}
finally
{
if (writeOperation.IsValueCreated)
{
writeOperation.Value.Dispose();
}
}
}
using (var context = DocumentsOperationContext.ShortTermSingleUse(database))
using (context.OpenReadTransaction())
{
var results = database.DocumentsStorage.GetDocumentsFrom(context, outputToCollectionName, 0, 0, int.MaxValue).ToList();
Assert.Equal(locations.Length - 1, results.Count);
}
}
}
public async Task <IOperationResult> Execute(Action <IOperationProgress> onProgress)
{
var databaseName = RestoreFromConfiguration.DatabaseName;
var result = new RestoreResult
{
DataDirectory = RestoreFromConfiguration.DataDirectory
};
try
{
var filesToRestore = await GetOrderedFilesToRestore();
using (_serverStore.ContextPool.AllocateOperationContext(out JsonOperationContext serverContext))
{
if (onProgress == null)
{
onProgress = _ => { }
}
;
Stopwatch sw = null;
RestoreSettings restoreSettings = null;
var firstFile = filesToRestore[0];
var extension = Path.GetExtension(firstFile);
var snapshotRestore = false;
if ((extension == Constants.Documents.PeriodicBackup.SnapshotExtension) ||
(extension == Constants.Documents.PeriodicBackup.EncryptedSnapshotExtension))
{
onProgress.Invoke(result.Progress);
snapshotRestore = true;
sw = Stopwatch.StartNew();
if (extension == Constants.Documents.PeriodicBackup.EncryptedSnapshotExtension)
{
_hasEncryptionKey = RestoreFromConfiguration.EncryptionKey != null ||
RestoreFromConfiguration.BackupEncryptionSettings?.Key != null;
}
// restore the snapshot
restoreSettings = await SnapshotRestore(serverContext, firstFile, onProgress, result);
if (restoreSettings != null && RestoreFromConfiguration.SkipIndexes)
{
// remove all indexes from the database record
restoreSettings.DatabaseRecord.AutoIndexes = null;
restoreSettings.DatabaseRecord.Indexes = null;
}
// removing the snapshot from the list of files
filesToRestore.RemoveAt(0);
}
else
{
result.SnapshotRestore.Skipped = true;
result.SnapshotRestore.Processed = true;
onProgress.Invoke(result.Progress);
}
if (restoreSettings == null)
{
restoreSettings = new RestoreSettings
{
DatabaseRecord = new DatabaseRecord(databaseName)
{
// we only have a smuggler restore
// use the encryption key to encrypt the database
Encrypted = _hasEncryptionKey
}
};
DatabaseHelper.Validate(databaseName, restoreSettings.DatabaseRecord, _serverStore.Configuration);
}
var databaseRecord = restoreSettings.DatabaseRecord;
databaseRecord.Settings ??= new Dictionary <string, string>();
var runInMemoryConfigurationKey = RavenConfiguration.GetKey(x => x.Core.RunInMemory);
databaseRecord.Settings.Remove(runInMemoryConfigurationKey);
if (_serverStore.Configuration.Core.RunInMemory)
{
databaseRecord.Settings[runInMemoryConfigurationKey] = "false";
}
var dataDirectoryConfigurationKey = RavenConfiguration.GetKey(x => x.Core.DataDirectory);
databaseRecord.Settings.Remove(dataDirectoryConfigurationKey); // removing because we want to restore to given location, not to serialized in backup one
if (_restoringToDefaultDataDirectory == false)
{
databaseRecord.Settings[dataDirectoryConfigurationKey] = RestoreFromConfiguration.DataDirectory;
}
if (_hasEncryptionKey)
{
// save the encryption key so we'll be able to access the database
_serverStore.PutSecretKey(RestoreFromConfiguration.EncryptionKey,
databaseName, overwrite: false);
}
var addToInitLog = new Action <string>(txt => // init log is not save in mem during RestoreBackup
{
var msg = $"[RestoreBackup] {DateTime.UtcNow} :: Database '{databaseName}' : {txt}";
if (Logger.IsInfoEnabled)
{
Logger.Info(msg);
}
});
var configuration = _serverStore
.DatabasesLandlord
.CreateDatabaseConfiguration(databaseName, ignoreDisabledDatabase: true, ignoreBeenDeleted: true, ignoreNotRelevant: true, databaseRecord);
using (var database = new DocumentDatabase(databaseName, configuration, _serverStore, addToInitLog))
{
// smuggler needs an existing document database to operate
var options = InitializeOptions.SkipLoadingDatabaseRecord;
if (snapshotRestore)
{
options |= InitializeOptions.GenerateNewDatabaseId;
}
database.Initialize(options);
databaseRecord.Topology = new DatabaseTopology();
// restoring to the current node only
databaseRecord.Topology.Members.Add(_nodeTag);
// we are currently restoring, shouldn't try to access it
databaseRecord.DatabaseState = DatabaseStateStatus.RestoreInProgress;
await SaveDatabaseRecordAsync(databaseName, databaseRecord, restoreSettings.DatabaseValues, result, onProgress);
database.ClusterTransactionId = databaseRecord.Topology.ClusterTransactionIdBase64;
database.DatabaseGroupId = databaseRecord.Topology.DatabaseTopologyIdBase64;
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
{
if (snapshotRestore)
{
await RestoreFromSmugglerFile(onProgress, database, firstFile, context);
await SmugglerRestore(database, filesToRestore, context, databaseRecord, onProgress, result);
result.SnapshotRestore.Processed = true;
var summary = database.GetDatabaseSummary();
result.Documents.ReadCount += summary.DocumentsCount;
result.Documents.Attachments.ReadCount += summary.AttachmentsCount;
result.Counters.ReadCount += summary.CounterEntriesCount;
result.RevisionDocuments.ReadCount += summary.RevisionsCount;
result.Conflicts.ReadCount += summary.ConflictsCount;
result.Indexes.ReadCount += databaseRecord.GetIndexesCount();
result.CompareExchange.ReadCount += summary.CompareExchangeCount;
result.CompareExchangeTombstones.ReadCount += summary.CompareExchangeTombstonesCount;
result.Identities.ReadCount += summary.IdentitiesCount;
result.TimeSeries.ReadCount += summary.TimeSeriesSegmentsCount;
result.AddInfo($"Successfully restored {result.SnapshotRestore.ReadCount} files during snapshot restore, took: {sw.ElapsedMilliseconds:#,#;;0}ms");
onProgress.Invoke(result.Progress);
}
else
{
await SmugglerRestore(database, filesToRestore, context, databaseRecord, onProgress, result);
}
DisableOngoingTasksIfNeeded(databaseRecord);
Raven.Server.Smuggler.Documents.DatabaseSmuggler.EnsureProcessed(result, skipped: false);
onProgress.Invoke(result.Progress);
}
if (snapshotRestore)
{
RegenerateDatabaseIdInIndexes(configuration, database);
}
}
// after the db for restore is done, we can safely set the db state to normal and write the DatabaseRecord
databaseRecord.DatabaseState = DatabaseStateStatus.Normal;
await SaveDatabaseRecordAsync(databaseName, databaseRecord, null, result, onProgress);
return(result);
}
}
catch (Exception e)
{
if (Logger.IsOperationsEnabled)
{
Logger.Operations("Failed to restore database", e);
}
var alert = AlertRaised.Create(
RestoreFromConfiguration.DatabaseName,
"Failed to restore database",
$"Could not restore database named {RestoreFromConfiguration.DatabaseName}",
AlertType.RestoreError,
NotificationSeverity.Error,
details: new ExceptionDetails(e));
_serverStore.NotificationCenter.Add(alert);
using (_serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context))
{
bool databaseExists;
using (context.OpenReadTransaction())
{
databaseExists = _serverStore.Cluster.DatabaseExists(context, RestoreFromConfiguration.DatabaseName);
}
if (databaseExists == false)
{
// delete any files that we already created during the restore
IOExtensions.DeleteDirectory(RestoreFromConfiguration.DataDirectory);
}
else
{
try
{
var deleteResult = await _serverStore.DeleteDatabaseAsync(RestoreFromConfiguration.DatabaseName, true, new[] { _serverStore.NodeTag },
RaftIdGenerator.DontCareId);
await _serverStore.Cluster.WaitForIndexNotification(deleteResult.Index, TimeSpan.FromSeconds(60));
}
catch (TimeoutException te)
{
result.AddError($"Failed to delete the database {databaseName} after a failed restore. " +
$"In order to restart the restore process this database needs to be deleted manually. Exception: {te}.");
onProgress.Invoke(result.Progress);
}
}
}
result.AddError($"Error occurred during restore of database {databaseName}. Exception: {e}");
onProgress.Invoke(result.Progress);
throw;
}
finally
{
Dispose();
}
void RegenerateDatabaseIdInIndexes(RavenConfiguration configuration, DocumentDatabase database)
{
// this code will generate new DatabaseId for each index.
// This is something that we need to do when snapshot restore is executed to match the newly generated database id
var indexesPath = configuration.Indexing.StoragePath.FullPath;
if (Directory.Exists(indexesPath) == false)
{
return;
}
foreach (var indexPath in Directory.GetDirectories(indexesPath))
{
Index index = null;
try
{
index = Index.Open(indexPath, database, generateNewDatabaseId: true);
}
catch (Exception e)
{
result.AddError($"Could not open index from path '{indexPath}'. Error: {e.Message}");
}
finally
{
index?.Dispose();
}
}
}
}
private bool TryAuthorize(RouteInformation route, HttpContext context, DocumentDatabase database, out RavenServer.AuthenticationStatus authenticationStatus)
{
var feature = context.Features.Get <IHttpAuthenticationFeature>() as RavenServer.AuthenticateConnection;
if (feature.WrittenToAuditLog == 0) // intentionally racy, we'll check it again later
{
var auditLog = LoggingSource.AuditLog.IsInfoEnabled ? LoggingSource.AuditLog.GetLogger("RequestRouter", "Audit") : null;
if (auditLog != null)
{
// only one thread will win it, technically, there can't really be threading
// here, because there is a single connection, but better to be safe
if (Interlocked.CompareExchange(ref feature.WrittenToAuditLog, 1, 0) == 0)
{
if (feature.WrongProtocolMessage != null)
{
auditLog.Info($"Connection from {context.Connection.RemoteIpAddress}:{context.Connection.RemotePort} " +
$"used the wrong protocol and will be rejected. {feature.WrongProtocolMessage}");
}
else
{
auditLog.Info($"Connection from {context.Connection.RemoteIpAddress}:{context.Connection.RemotePort} " +
$"with certificate '{feature.Certificate?.Subject} ({feature.Certificate?.Thumbprint})', status: {feature.StatusForAudit}, " +
$"databases: [{string.Join(", ", feature.AuthorizedDatabases.Keys)}]");
var conLifetime = context.Features.Get <IConnectionLifetimeFeature>();
if (conLifetime != null)
{
var msg = $"Connection {context.Connection.RemoteIpAddress}:{context.Connection.RemotePort} closed. Was used with: " +
$"with certificate '{feature.Certificate?.Subject} ({feature.Certificate?.Thumbprint})', status: {feature.StatusForAudit}, " +
$"databases: [{string.Join(", ", feature.AuthorizedDatabases.Keys)}]";
CancellationTokenRegistration cancellationTokenRegistration = default;
cancellationTokenRegistration = conLifetime.ConnectionClosed.Register(() =>
{
auditLog.Info(msg);
cancellationTokenRegistration.Dispose();
});
}
}
}
}
}
authenticationStatus = feature?.Status ?? RavenServer.AuthenticationStatus.None;
switch (route.AuthorizationStatus)
{
case AuthorizationStatus.UnauthenticatedClients:
var userWantsToAccessStudioMainPage = context.Request.Path == "/studio/index.html";
if (userWantsToAccessStudioMainPage)
{
switch (authenticationStatus)
{
case RavenServer.AuthenticationStatus.NoCertificateProvided:
case RavenServer.AuthenticationStatus.Expired:
case RavenServer.AuthenticationStatus.NotYetValid:
case RavenServer.AuthenticationStatus.None:
case RavenServer.AuthenticationStatus.UnfamiliarCertificate:
case RavenServer.AuthenticationStatus.UnfamiliarIssuer:
UnlikelyFailAuthorization(context, database?.Name, feature, route.AuthorizationStatus);
return(false);
}
}
return(true);
case AuthorizationStatus.ClusterAdmin:
case AuthorizationStatus.Operator:
case AuthorizationStatus.ValidUser:
case AuthorizationStatus.DatabaseAdmin:
case AuthorizationStatus.RestrictedAccess:
switch (authenticationStatus)
{
case RavenServer.AuthenticationStatus.NoCertificateProvided:
case RavenServer.AuthenticationStatus.Expired:
case RavenServer.AuthenticationStatus.NotYetValid:
case RavenServer.AuthenticationStatus.None:
UnlikelyFailAuthorization(context, database?.Name, feature, route.AuthorizationStatus);
return(false);
case RavenServer.AuthenticationStatus.UnfamiliarCertificate:
case RavenServer.AuthenticationStatus.UnfamiliarIssuer:
// we allow an access to the restricted endpoints with an unfamiliar certificate, since we will authorize it at the endpoint level
if (route.AuthorizationStatus == AuthorizationStatus.RestrictedAccess)
{
return(true);
}
goto case RavenServer.AuthenticationStatus.None;
case RavenServer.AuthenticationStatus.Allowed:
if (route.AuthorizationStatus == AuthorizationStatus.Operator || route.AuthorizationStatus == AuthorizationStatus.ClusterAdmin)
{
goto case RavenServer.AuthenticationStatus.None;
}
if (database == null)
{
return(true);
}
if (feature.CanAccess(database.Name, route.AuthorizationStatus == AuthorizationStatus.DatabaseAdmin))
{
return(true);
}
goto case RavenServer.AuthenticationStatus.None;
case RavenServer.AuthenticationStatus.Operator:
if (route.AuthorizationStatus == AuthorizationStatus.ClusterAdmin)
{
goto case RavenServer.AuthenticationStatus.None;
}
return(true);
case RavenServer.AuthenticationStatus.ClusterAdmin:
return(true);
default:
throw new ArgumentOutOfRangeException();
}
default:
ThrowUnknownAuthStatus(route);
return(false); // never hit
}
}
public InFlightTransactionalState GetInFlightTransactionalState(DocumentDatabase self, Func <string, Etag, RavenJObject, RavenJObject, TransactionInformation, PutResult> put, Func <string, Etag, TransactionInformation, bool> delete)
{
return(new DtcNotSupportedTransactionalState(FriendlyName, put, delete));
}
///<summary>
/// Create a new instance
///</summary>
public EmbeddedDatabaseCommands(DocumentDatabase database, DocumentConvention convention)
{
this.database = database;
this.convention = convention;
OperationsHeaders = new NameValueCollection();
}
protected void SetupDatabase(DocumentDatabase documentDatabase)
{
DocumentDatabase = documentDatabase;
}
public RavenServer(DocumentDatabase systemDatabase, InMemoryRavenConfiguration systemConfiguration)
{
this.systemDatabase = systemDatabase;
this.systemConfiguration = systemConfiguration;
}
public IndexActions(DocumentDatabase database, SizeLimitedConcurrentDictionary <string, TouchedDocumentInfo> recentTouches, IUuidGenerator uuidGenerator, ILog log)
: base(database, recentTouches, uuidGenerator, log)
{
}
public OutgoingReplicationHandler.UpdateSiblingCurrentEtag ToCommand(DocumentsOperationContext context, DocumentDatabase database)
{
var command = new OutgoingReplicationHandler.UpdateSiblingCurrentEtag(ReplicationBatchReply, new AsyncManualResetEvent());
command.Init();
return(command);
}
public void Initialize([CallerMemberName] string caller = null)
{
_documentDatabase = CreateDocumentDatabase(caller: caller);
_sut = new DynamicQueryToIndexMatcher(_documentDatabase.IndexStore);
}
protected async Task SmugglerRestore(DocumentDatabase database, List <string> filesToRestore, DocumentsOperationContext context,
DatabaseRecord databaseRecord, Action <IOperationProgress> onProgress, RestoreResult result)
{
Debug.Assert(onProgress != null);
// the files are already ordered by name
// take only the files that are relevant for smuggler restore
if (filesToRestore.Count == 0)
{
return;
}
// we do have at least one smuggler backup, we'll take the indexes from the last file
databaseRecord.AutoIndexes = new Dictionary <string, AutoIndexDefinition>();
databaseRecord.Indexes = new Dictionary <string, IndexDefinition>();
// restore the smuggler backup
var options = new DatabaseSmugglerOptionsServerSide
{
AuthorizationStatus = AuthorizationStatus.DatabaseAdmin,
SkipRevisionCreation = true
};
options.OperateOnTypes |= DatabaseItemType.LegacyDocumentDeletions;
options.OperateOnTypes |= DatabaseItemType.LegacyAttachments;
options.OperateOnTypes |= DatabaseItemType.LegacyAttachmentDeletions;
#pragma warning disable 618
options.OperateOnTypes |= DatabaseItemType.Counters;
#pragma warning restore 618
var oldOperateOnTypes = Raven.Client.Documents.Smuggler.DatabaseSmuggler.ConfigureOptionsForIncrementalImport(options);
var destination = new DatabaseDestination(database);
for (var i = 0; i < filesToRestore.Count - 1; i++)
{
result.AddInfo($"Restoring file {(i + 1):#,#;;0}/{filesToRestore.Count:#,#;;0}");
onProgress.Invoke(result.Progress);
var filePath = GetBackupPath(filesToRestore[i]);
await ImportSingleBackupFile(database, onProgress, result, filePath, context, destination, options, isLastFile : false,
onDatabaseRecordAction : smugglerDatabaseRecord =>
{
// need to enable revisions before import
database.DocumentsStorage.RevisionsStorage.InitializeFromDatabaseRecord(smugglerDatabaseRecord);
});
}
options.OperateOnTypes = oldOperateOnTypes;
var lastFilePath = GetBackupPath(filesToRestore.Last());
result.AddInfo($"Restoring file {filesToRestore.Count:#,#;;0}/{filesToRestore.Count:#,#;;0}");
onProgress.Invoke(result.Progress);
await ImportSingleBackupFile(database, onProgress, result, lastFilePath, context, destination, options, isLastFile : true,
onIndexAction : indexAndType =>
{
if (this.RestoreFromConfiguration.SkipIndexes)
{
return;
}
switch (indexAndType.Type)
{
case IndexType.AutoMap:
case IndexType.AutoMapReduce:
var autoIndexDefinition = (AutoIndexDefinitionBaseServerSide)indexAndType.IndexDefinition;
databaseRecord.AutoIndexes[autoIndexDefinition.Name] =
PutAutoIndexCommand.GetAutoIndexDefinition(autoIndexDefinition, indexAndType.Type);
break;
case IndexType.Map:
case IndexType.MapReduce:
case IndexType.JavaScriptMap:
case IndexType.JavaScriptMapReduce:
var indexDefinition = (IndexDefinition)indexAndType.IndexDefinition;
databaseRecord.Indexes[indexDefinition.Name] = indexDefinition;
break;
case IndexType.None:
case IndexType.Faulty:
break;
default:
throw new ArgumentOutOfRangeException();
}
},
onDatabaseRecordAction : smugglerDatabaseRecord =>
{
databaseRecord.ConflictSolverConfig = smugglerDatabaseRecord.ConflictSolverConfig;
foreach (var setting in smugglerDatabaseRecord.Settings)
{
databaseRecord.Settings[setting.Key] = setting.Value;
}
databaseRecord.SqlEtls = smugglerDatabaseRecord.SqlEtls;
databaseRecord.RavenEtls = smugglerDatabaseRecord.RavenEtls;
databaseRecord.PeriodicBackups = smugglerDatabaseRecord.PeriodicBackups;
databaseRecord.ExternalReplications = smugglerDatabaseRecord.ExternalReplications;
databaseRecord.Sorters = smugglerDatabaseRecord.Sorters;
databaseRecord.Analyzers = smugglerDatabaseRecord.Analyzers;
databaseRecord.SinkPullReplications = smugglerDatabaseRecord.SinkPullReplications;
databaseRecord.HubPullReplications = smugglerDatabaseRecord.HubPullReplications;
databaseRecord.Revisions = smugglerDatabaseRecord.Revisions;
databaseRecord.Expiration = smugglerDatabaseRecord.Expiration;
databaseRecord.RavenConnectionStrings = smugglerDatabaseRecord.RavenConnectionStrings;
databaseRecord.SqlConnectionStrings = smugglerDatabaseRecord.SqlConnectionStrings;
databaseRecord.Client = smugglerDatabaseRecord.Client;
databaseRecord.TimeSeries = smugglerDatabaseRecord.TimeSeries;
databaseRecord.DocumentsCompression = smugglerDatabaseRecord.DocumentsCompression;
databaseRecord.LockMode = smugglerDatabaseRecord.LockMode;
databaseRecord.OlapConnectionStrings = smugglerDatabaseRecord.OlapConnectionStrings;
databaseRecord.OlapEtls = smugglerDatabaseRecord.OlapEtls;
// need to enable revisions before import
database.DocumentsStorage.RevisionsStorage.InitializeFromDatabaseRecord(smugglerDatabaseRecord);
});
}
protected AbstractQueryRunner(DocumentDatabase database)
{
Database = database;
}
public static bool IsAdministrator(this IPrincipal principal, DocumentDatabase database)
{
return(IsAdministrator(principal, database.Name));
}
public DatabaseLiveIoStatsCollector(DocumentDatabase database) : base(database.IoChanges, database.GetAllStoragesEnvironment().ToList(), database.GetAllPerformanceMetrics(), database.DocumentsStorage.ContextPool, database.DatabaseShutdown)
{
}
public static MapReduceIndex CreateNew <TStaticIndex>(IndexDefinition definition, DocumentDatabase documentDatabase, bool isIndexReset = false)
where TStaticIndex : MapReduceIndex
{
TStaticIndex instance;
if (typeof(TStaticIndex) == typeof(MapReduceIndex))
{
instance = (TStaticIndex)CreateIndexInstance <MapReduceIndex>(definition, documentDatabase.Configuration, IndexDefinitionBaseServerSide.IndexVersion.CurrentVersion, (staticMapIndexDefinition, staticIndex) => new MapReduceIndex(staticMapIndexDefinition, staticIndex));
}
else if (typeof(TStaticIndex) == typeof(MapReduceTimeSeriesIndex))
{
instance = (TStaticIndex)(MapReduceIndex)CreateIndexInstance <MapReduceTimeSeriesIndex>(definition, documentDatabase.Configuration, IndexDefinitionBaseServerSide.IndexVersion.CurrentVersion, (staticMapIndexDefinition, staticIndex) => new MapReduceTimeSeriesIndex(staticMapIndexDefinition, staticIndex));
}
else if (typeof(TStaticIndex) == typeof(MapReduceCountersIndex))
{
instance = (TStaticIndex)(MapReduceIndex)CreateIndexInstance <MapReduceCountersIndex>(definition, documentDatabase.Configuration, IndexDefinitionBaseServerSide.IndexVersion.CurrentVersion, (staticMapIndexDefinition, staticIndex) => new MapReduceCountersIndex(staticMapIndexDefinition, staticIndex));
}
else
{
throw new NotSupportedException($"Not supported index type {typeof(TStaticIndex).Name}");
}
ValidateReduceResultsCollectionName(definition, instance._compiled, documentDatabase,
checkIfCollectionEmpty: isIndexReset == false);
instance.Initialize(documentDatabase,
new SingleIndexConfiguration(definition.Configuration, documentDatabase.Configuration),
documentDatabase.Configuration.PerformanceHints);
return(instance);
}
public static void ValidateReduceResultsCollectionName(IndexDefinition definition, AbstractStaticIndexBase index, DocumentDatabase database, bool checkIfCollectionEmpty)
{
var outputReduceToCollection = definition.OutputReduceToCollection;
if (string.IsNullOrWhiteSpace(outputReduceToCollection))
{
return;
}
if (outputReduceToCollection.Equals(definition.PatternReferencesCollectionName, StringComparison.OrdinalIgnoreCase))
{
throw new IndexInvalidException($"Collection defined in {nameof(definition.PatternReferencesCollectionName)} must not be the same as in {nameof(definition.OutputReduceToCollection)}. Collection name: '{outputReduceToCollection}'");
}
var collections = index.Maps.Keys.ToHashSet(StringComparer.OrdinalIgnoreCase);
if (collections.Contains(Constants.Documents.Collections.AllDocumentsCollection))
{
throw new IndexInvalidException($"It is forbidden to create the '{definition.Name}' index " +
$"which would output reduce results to documents in the '{outputReduceToCollection}' collection, " +
$"as this index is mapping all documents " +
$"and this will result in an infinite loop.");
}
foreach (var referencedCollection in index.ReferencedCollections)
{
foreach (var collectionName in referencedCollection.Value)
{
collections.Add(collectionName.Name);
}
}
if (collections.Contains(outputReduceToCollection))
{
throw new IndexInvalidException($"It is forbidden to create the '{definition.Name}' index " +
$"which would output reduce results to documents in the '{outputReduceToCollection}' collection, " +
$"as this index is mapping or referencing the '{outputReduceToCollection}' collection " +
$"and this will result in an infinite loop.");
}
var indexes = database.IndexStore.GetIndexes()
.Where(x => x.Type.IsStatic() && x.Type.IsMapReduce())
.Cast <MapReduceIndex>()
.Where(mapReduceIndex =>
{
// we have handling for side by side indexing with OutputReduceToCollection so we're checking only other indexes
string existingIndexName = mapReduceIndex.Name.Replace(Constants.Documents.Indexing.SideBySideIndexNamePrefix, string.Empty,
StringComparison.OrdinalIgnoreCase);
string newIndexName = definition.Name.Replace(Constants.Documents.Indexing.SideBySideIndexNamePrefix, string.Empty,
StringComparison.OrdinalIgnoreCase);
return(string.IsNullOrWhiteSpace(mapReduceIndex.Definition.OutputReduceToCollection) == false && string.Equals(existingIndexName, newIndexName, StringComparison.OrdinalIgnoreCase) == false);
})
.ToList();
foreach (var otherIndex in indexes)
{
if (otherIndex.Definition.OutputReduceToCollection.Equals(outputReduceToCollection, StringComparison.OrdinalIgnoreCase))
{
throw new IndexInvalidException($"It is forbidden to create the '{definition.Name}' index " +
$"which would output reduce results to documents in the '{outputReduceToCollection}' collection, " +
$"as there is another index named '{otherIndex.Name}' " +
$"which also output reduce results to documents in the same '{outputReduceToCollection}' collection. " +
$"{nameof(IndexDefinition.OutputReduceToCollection)} must by set to unique value for each index or be null.");
}
var otherIndexCollections = new HashSet <string>(otherIndex.Collections);
foreach (var referencedCollection in otherIndex.GetReferencedCollections())
{
foreach (var collectionName in referencedCollection.Value)
{
otherIndexCollections.Add(collectionName.Name);
}
}
if (otherIndexCollections.Contains(outputReduceToCollection) &&
CheckIfThereIsAnIndexWhichWillOutputReduceDocumentsWhichWillBeUsedAsMapOnTheSpecifiedIndex(otherIndex, collections, indexes, out string description))
{
description += Environment.NewLine + $"--> {definition.Name}: {string.Join(",", collections)} => *{outputReduceToCollection}*";
throw new IndexInvalidException($"It is forbidden to create the '{definition.Name}' index " +
$"which would output reduce results to documents in the '{outputReduceToCollection}' collection, " +
$"as '{outputReduceToCollection}' collection is consumed by other index in a way that would " +
$"lead to an infinite loop." +
Environment.NewLine + description);
}
}
var existingIndexOrSideBySide = database.IndexStore.GetIndexes()
.Where(x => x.Type.IsStatic() && x.Type.IsMapReduce())
.Cast <MapReduceIndex>()
.FirstOrDefault(x =>
{
var name = definition.Name.Replace(Constants.Documents.Indexing.SideBySideIndexNamePrefix, string.Empty,
StringComparison.OrdinalIgnoreCase);
return(x.Name.Equals(name, StringComparison.OrdinalIgnoreCase) &&
x.Definition.ReduceOutputIndex != null); // legacy index definitions don't have this field - side by side indexing isn't supported then
});
if (existingIndexOrSideBySide != null)
{
if (definition.OutputReduceToCollection.Equals(existingIndexOrSideBySide.Definition.OutputReduceToCollection, StringComparison.OrdinalIgnoreCase)) // we have handling for side by side indexing with OutputReduceToCollection
{
checkIfCollectionEmpty = false;
}
}
if (checkIfCollectionEmpty)
{
using (database.DocumentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext context))
using (context.OpenReadTransaction())
{
var stats = database.DocumentsStorage.GetCollection(outputReduceToCollection, context);
if (stats.Count > 0)
{
throw new IndexInvalidException(
$"Index '{definition.Name}' is defined to output the Reduce results to documents in Collection '{outputReduceToCollection}'. " +
$"This collection currently has {stats.Count} document{(stats.Count == 1 ? ' ' : 's')}. " +
$"All documents in Collection '{stats.Name}' must be deleted first.");
}
}
}
}
public CreateUpdateDeleteDocuments()
{
store = NewDocumentStore();
db = store.DocumentDatabase;
}
public long StartMigratingSingleDatabase(DatabaseMigrationSettings databaseMigrationSettings, DocumentDatabase database)
{
var operationId = database.Operations.GetNextOperationId();
var cancelToken = new OperationCancelToken(database.DatabaseShutdown);
var result = new SmugglerResult();
var databaseName = databaseMigrationSettings.DatabaseName;
database.Operations.AddOperation(null,
$"Database name: '{databaseName}' from url: {_serverUrl}",
Operations.OperationType.DatabaseMigrationRavenDb,
taskFactory: onProgress => Task.Run(async() =>
{
onProgress?.Invoke(result.Progress);
var message = $"Importing from RavenDB {EnumHelper.GetDescription(_buildMajorVersion)}";
result.AddInfo(message);
using (cancelToken)
{
try
{
var migrationStateKey = $"{MigrationStateKeyBase}" +
$"{EnumHelper.GetDescription(_buildMajorVersion)}/" +
$"{databaseName}/" +
$"{_serverUrl}";
var options = new MigratorOptions
{
MigrationStateKey = migrationStateKey,
ServerUrl = _serverUrl,
DatabaseName = databaseName,
HttpClient = _httpClient,
ApiKey = _apiKey,
EnableBasicAuthenticationOverUnsecuredHttp = _enableBasicAuthenticationOverUnsecuredHttp,
SkipServerCertificateValidation = _skipServerCertificateValidation,
OperateOnTypes = databaseMigrationSettings.OperateOnTypes,
RemoveAnalyzers = databaseMigrationSettings.RemoveAnalyzers,
ImportRavenFs = databaseMigrationSettings.ImportRavenFs,
Result = result,
OnProgress = onProgress,
Database = database,
CancelToken = cancelToken
};
AbstractMigrator migrator;
switch (_buildMajorVersion)
{
case MajorVersion.V2:
migrator = new Migrator_V2(database, options);
break;
case MajorVersion.V30:
case MajorVersion.V35:
migrator = new Migrator_V3(database, options, _buildMajorVersion, _buildVersion);
break;
case MajorVersion.V4:
migrator = new Importer(options);
break;
default:
throw new ArgumentOutOfRangeException(nameof(_buildMajorVersion), _buildMajorVersion, null);
}
await migrator.Execute();
}
catch (Exception e)
{
result.AddError($"Error occurred during database migration named: {databaseName}." +
$"Exception: {e.Message}");
throw;
}
}
return((IOperationResult)result);
}, cancelToken.Token), id: operationId, token: cancelToken);
return(operationId);
}
protected virtual void ConfigureDatabase(DocumentDatabase database)
{
}
private static BackupInfo GetBackupInfo(DocumentDatabase db)
{
var periodicBackupRunner = db?.PeriodicBackupRunner;
return(periodicBackupRunner?.GetBackupInfo());
}
public GeneralStorage()
{
store = NewDocumentStore();
db = store.SystemDatabase;
}
private static TimeSpan GetUptime(DocumentDatabase db)
{
return(SystemTime.UtcNow - db.StartTime);
}
/// <summary>
/// Restore CompareExchange, Identities and Subscriptions from smuggler file when restoring snapshot.
/// </summary>
/// <param name="onProgress"></param>
/// <param name="database"></param>
/// <param name="smugglerFile"></param>
/// <param name="context"></param>
protected async Task RestoreFromSmugglerFile(Action <IOperationProgress> onProgress, DocumentDatabase database, string smugglerFile, DocumentsOperationContext context)
{
var destination = new DatabaseDestination(database);
var smugglerOptions = new DatabaseSmugglerOptionsServerSide
{
AuthorizationStatus = AuthorizationStatus.DatabaseAdmin,
OperateOnTypes = DatabaseItemType.CompareExchange | DatabaseItemType.Identities | DatabaseItemType.Subscriptions,
SkipRevisionCreation = true
};
var lastPath = GetSmugglerBackupPath(smugglerFile);
using (var zip = await GetZipArchiveForSnapshot(lastPath))
{
foreach (var entry in zip.Entries)
{
if (entry.Name == RestoreSettings.SmugglerValuesFileName)
{
await using (var input = entry.Open())
await using (var inputStream = GetSnapshotInputStream(input, database.Name))
await using (var uncompressed = new GZipStream(inputStream, CompressionMode.Decompress))
{
var source = new StreamSource(uncompressed, context, database);
var smuggler = new Smuggler.Documents.DatabaseSmuggler(database, source, destination,
database.Time, smugglerOptions, onProgress: onProgress, token: _operationCancelToken.Token);
await smuggler.ExecuteAsync(ensureStepsProcessed : true, isLastFile : true);
}
break;
}
}
}
}
public static bool IsSystemDatabase(this DocumentDatabase database)
{
return(database.Name == null || database.Name == Constants.SystemDatabase);
}
public void Execute(DocumentDatabase database)
{
Database = database;
Initialize();
Task.Factory.StartNew(BackgroundTask, TaskCreationOptions.LongRunning);
}
public DeleteIndexes()
{
store = NewDocumentStore();
db = store.SystemDatabase;
}
public virtual void Initialize(DocumentDatabase database)
{
}
public static AutoMapReduceIndex CreateNew(AutoMapReduceIndexDefinition definition, DocumentDatabase documentDatabase)
{
var instance = new AutoMapReduceIndex(definition);
instance.Initialize(documentDatabase, documentDatabase.Configuration.Indexing, documentDatabase.Configuration.PerformanceHints);
return(instance);
}
public SnapshotShoppingCartBatcher(string indexName, DocumentDatabase database)
{
this.indexName = indexName;
this.database = database;
}
private bool TryAuthorize(RouteInformation route, HttpContext context, DocumentDatabase database)
{
var feature = context.Features.Get <IHttpAuthenticationFeature>() as RavenServer.AuthenticateConnection;
switch (route.AuthorizationStatus)
{
case AuthorizationStatus.UnauthenticatedClients:
var userWantsToAccessStudioMainPage = context.Request.Path == "/studio/index.html";
if (userWantsToAccessStudioMainPage)
{
switch (feature?.Status)
{
case null:
case RavenServer.AuthenticationStatus.NoCertificateProvided:
case RavenServer.AuthenticationStatus.Expired:
case RavenServer.AuthenticationStatus.NotYetValid:
case RavenServer.AuthenticationStatus.None:
case RavenServer.AuthenticationStatus.UnfamiliarCertificate:
UnlikelyFailAuthorization(context, database?.Name, feature);
return(false);
}
}
return(true);
case AuthorizationStatus.ClusterAdmin:
case AuthorizationStatus.Operator:
case AuthorizationStatus.ValidUser:
case AuthorizationStatus.DatabaseAdmin:
switch (feature?.Status)
{
case null:
case RavenServer.AuthenticationStatus.NoCertificateProvided:
case RavenServer.AuthenticationStatus.Expired:
case RavenServer.AuthenticationStatus.NotYetValid:
case RavenServer.AuthenticationStatus.None:
case RavenServer.AuthenticationStatus.UnfamiliarCertificate:
UnlikelyFailAuthorization(context, database?.Name, feature);
return(false);
case RavenServer.AuthenticationStatus.Allowed:
if (route.AuthorizationStatus == AuthorizationStatus.Operator || route.AuthorizationStatus == AuthorizationStatus.ClusterAdmin)
{
goto case RavenServer.AuthenticationStatus.None;
}
if (database == null)
{
return(true);
}
if (feature.CanAccess(database.Name, route.AuthorizationStatus == AuthorizationStatus.DatabaseAdmin))
{
return(true);
}
goto case RavenServer.AuthenticationStatus.None;
case RavenServer.AuthenticationStatus.Operator:
if (route.AuthorizationStatus == AuthorizationStatus.ClusterAdmin)
{
goto case RavenServer.AuthenticationStatus.None;
}
return(true);
case RavenServer.AuthenticationStatus.ClusterAdmin:
return(true);
default:
throw new ArgumentOutOfRangeException();
}
default:
ThrowUnknownAuthStatus(route);
return(false); // never hit
}
}