コード例 #1
0
		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;
			}
		}
コード例 #2
0
 public WebSocketsRequestParser(DatabasesLandlord databasesLandlord, CountersLandlord countersLandlord, FileSystemsLandlord fileSystemsLandlord, MixedModeRequestAuthorizer authorizer, string expectedRequestSuffix)
 {
     DatabasesLandlord = databasesLandlord;
     this.countersLandlord = countersLandlord;
     this.fileSystemsLandlord = fileSystemsLandlord;
     this.authorizer = authorizer;
     this.expectedRequestSuffix = expectedRequestSuffix;
 }
コード例 #3
0
		private void CleanupFileSystems(DatabasesLandlord databaseLandlord, FileSystemsLandlord fileSystemLandlord)
		{
			var systemDatabase = databaseLandlord.SystemDatabase;

			int nextStart = 0;
			var fileSystemDocuments = systemDatabase
				.Documents
                .GetDocumentsWithIdStartingWith(Constants.FileSystem.Prefix, null, null, 0, int.MaxValue, CancellationToken.None, ref nextStart);

			var fileSystemIds = fileSystemDocuments
				.Select(x => ((RavenJObject)x)["@metadata"])
				.Where(x => x != null)
				.Select(x => x.Value<string>("@id"))
				.Where(x => x != null && x != Constants.SystemDatabase)
				.ToList();

			foreach (var fileSystemId in fileSystemIds)
			{
				try
				{
					var key = fileSystemId;
                    if (key.StartsWith(Constants.FileSystem.Prefix))
                        key = key.Substring(Constants.FileSystem.Prefix.Length);

					var shouldCleanup = false;

					DateTime value;
					if (fileSystemLandlord.IsFileSystemLoaded(key) == false) 
						shouldCleanup = true;
					else if (fileSystemLandlord.LastRecentlyUsed.TryGetValue(key, out value) == false || (SystemTime.UtcNow - value) > maxTimeResourceCanBeIdle) 
						shouldCleanup = true;

					if (shouldCleanup == false) 
						continue;

					var configuration = fileSystemLandlord.CreateTenantConfiguration(key, true);

					fileSystemLandlord.Cleanup(key, maxTimeResourceCanBeIdle, database => false);

                    var docKey = Constants.FileSystem.Prefix + key;
					systemDatabase.Documents.Delete(docKey, null, null);

					if (configuration == null)
						continue;

					IOExtensions.DeleteDirectory(configuration.FileSystem.DataDirectory);
				}
				catch (Exception e)
				{
					log.WarnException(string.Format("Failed to cleanup '{0}' filesystem.", fileSystemId), e);
				}
			}
		}
コード例 #4
0
ファイル: RequestManager.cs プロジェクト: jrusbatch/ravendb
		public RequestManager(DatabasesLandlord landlord)
		{

			BeforeRequest += OnBeforeRequest;
			cancellationTokenSource = new CancellationTokenSource();
			this.landlord = landlord;
			
			maxTimeDatabaseCanBeIdle = TimeSpan.FromSeconds(landlord.MaxIdleTimeForTenantDatabaseInSec);
			frequencyToCheckForIdleDatabases = TimeSpan.FromSeconds(landlord.FrequencyToCheckForIdleDatabasesInSec);

			Init();
			cancellationToken = cancellationTokenSource.Token;
		}
コード例 #5
0
	    public RequestManager(DatabasesLandlord landlord)
		{
            BeforeRequest+=OnBeforeRequest;
		    cancellationTokenSource = new CancellationTokenSource();
		    this.landlord = landlord;
			int val;
			if (int.TryParse(landlord.SystemConfiguration.Settings["Raven/Tenants/MaxIdleTimeForTenantDatabase"], out val) == false)
				val = 900;
			maxTimeDatabaseCanBeIdle = TimeSpan.FromSeconds(val);

			if (int.TryParse(landlord.SystemConfiguration.Settings["Raven/Tenants/FrequencyToCheckForIdleDatabases"], out val) == false)
				val = 60;
			frequencyToCheckForIdleDatabases = TimeSpan.FromSeconds(val);

			Init();
		    cancellationToken = cancellationTokenSource.Token;
		}
コード例 #6
0
ファイル: RavenDBOptions.cs プロジェクト: IdanHaim/ravendb
        public RavenDBOptions(InMemoryRavenConfiguration configuration, DocumentDatabase db = null)
        {
            if (configuration == null)
                throw new ArgumentNullException("configuration");
            
            try
            {
                HttpEndpointRegistration.RegisterHttpEndpointTarget();
                HttpEndpointRegistration.RegisterAdminLogsTarget();
                ThreadPool.SetMinThreads(configuration.MinThreadPoolWorkerThreads, configuration.MinThreadPoolCompletionThreads);
                if (db == null)
                {
                    configuration.UpdateDataDirForLegacySystemDb();
                    systemDatabase = new DocumentDatabase(configuration);
                    systemDatabase.SpinBackgroundWorkers(false);
                }
                else
                {
                    systemDatabase = db;
                }

                WebSocketBufferPool.Initialize(configuration.WebSockets.InitialBufferPoolSize);
                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));

                serverStartupTasks = configuration.Container.GetExportedValues<IServerStartupTask>();

                foreach (var task in serverStartupTasks)
                {
                    toDispose.Add(task);
                    task.Execute(this);
                }
            }
            catch
            {
                if (systemDatabase != null)
                    systemDatabase.Dispose();
                throw;
            }
        }
コード例 #7
0
		private static HttpConfiguration CreateHttpCfg(
            DatabasesLandlord databasesLandlord, 
            FileSystemsLandlord fileSystemsLandlord,
            MixedModeRequestAuthorizer mixedModeRequestAuthorizer, 
            RequestManager requestManager)
		{
			var cfg = new HttpConfiguration();
			cfg.Properties[typeof(DatabasesLandlord)] = databasesLandlord;
            cfg.Properties[typeof(FileSystemsLandlord)] = fileSystemsLandlord;
			cfg.Properties[typeof(MixedModeRequestAuthorizer)] = mixedModeRequestAuthorizer;
			cfg.Properties[typeof(RequestManager)] = requestManager;
			cfg.Formatters.Remove(cfg.Formatters.XmlFormatter);
			cfg.Formatters.JsonFormatter.SerializerSettings.Converters.Add(new NaveValueCollectionJsonConverterOnlyForConfigFormatters());

			cfg.Services.Replace(typeof(IAssembliesResolver), new MyAssemblyResolver());
			cfg.Filters.Add(new RavenExceptionFilterAttribute());
			cfg.MapHttpAttributeRoutes();

			cfg.Routes.MapHttpRoute(
				"RavenFs", "ravenfs/{controller}/{action}",
				new {id = RouteParameter.Optional});

			cfg.Routes.MapHttpRoute(
				"API Default", "{controller}/{action}",
				new { id = RouteParameter.Optional });

			cfg.Routes.MapHttpRoute(
				"Database Route", "databases/{databaseName}/{controller}/{action}",
				new { id = RouteParameter.Optional });

			cfg.MessageHandlers.Add(new GZipToJsonAndCompressHandler());

			cfg.Services.Replace(typeof(IHostBufferPolicySelector), new SelectiveBufferPolicySelector());
			cfg.EnsureInitialized();
			return cfg;
		}
コード例 #8
0
 protected DatabaseBundleScalarObjectBase(string databaseName, string bundleName, DatabasesLandlord landlord, int databaseIndex, int bundleIndex, string dots)
     : base(databaseName, landlord, string.Format("5.2.{0}.6.{{0}}.{1}", databaseIndex, dots), bundleIndex)
 {
     BundleName = bundleName;
 }
コード例 #9
0
 public DatabaseLoaded(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, "5.2.{0}.1.13", index)
 {
     this.databaseName = databaseName;
 }
コード例 #10
0
        private static bool IsIncrementalBackupIsAllowed(DatabasesLandlord databaseLandlord,DatabaseDocument dbDoc)
        {
            // check if DatabaseDocument contains either of the incremental flags
            bool isVoronIncrementalBackup = dbDoc.Settings.ContainsKey("Raven/Voron/AllowIncrementalBackups");
            bool isEsentCircularLog = dbDoc.Settings.ContainsKey("Raven/Esent/CircularLog");
            if ( isVoronIncrementalBackup || isEsentCircularLog)
            {
                if (isEsentCircularLog && bool.TryParse(dbDoc.Settings["Raven/Esent/CircularLog"], out isEsentCircularLog))
                {
                    return (isEsentCircularLog) ? false : true;

                }
                else if (isVoronIncrementalBackup && bool.TryParse(dbDoc.Settings["Raven/Voron/AllowIncrementalBackups"], out isVoronIncrementalBackup))
                {
                    return isVoronIncrementalBackup;
                }
            }
            // if not check if system configuration has one of the incremental flags up.
            string isVoronIncrementalBackupStr = databaseLandlord.SystemConfiguration.Settings["Raven/Voron/AllowIncrementalBackups"];
            string isEsentCircularLogStr = databaseLandlord.SystemConfiguration.Settings["Raven/Esent/CircularLog"];
            if (isVoronIncrementalBackupStr != null || isEsentCircularLogStr != null)
            {
                if (isEsentCircularLogStr != null && bool.TryParse(isEsentCircularLogStr, out isEsentCircularLog))
                {
                    return (isEsentCircularLog) ? false : true;

                }
                else if (isVoronIncrementalBackupStr != null && bool.TryParse(isVoronIncrementalBackupStr, out isVoronIncrementalBackup))
                {
                    return isVoronIncrementalBackup;
                }
            }
            return false;

        }
コード例 #11
0
 public DatabaseDataWrittenPerSecond(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, SnmpOids.Databases.DataWrittenPerSecond, index)
 {
 }
コード例 #12
0
ファイル: AdminController.cs プロジェクト: tryadiadi/ravendb
        public async Task <HttpResponseMessage> Restore()
        {
            if (EnsureSystemDatabase() == false)
            {
                return(GetMessageWithString("Restore is only possible from the system database", HttpStatusCode.BadRequest));
            }

            var restoreStatus = new RestoreStatus {
                State = RestoreStatusState.Running, Messages = new List <string>()
            };

            var restoreRequest = await ReadJsonObjectAsync <DatabaseRestoreRequest>();

            DatabaseDocument databaseDocument = null;

            var databaseDocumentPath = MaintenanceActions.FindDatabaseDocument(restoreRequest.BackupLocation);

            if (File.Exists(databaseDocumentPath))
            {
                var databaseDocumentText = File.ReadAllText(databaseDocumentPath);
                databaseDocument = RavenJObject.Parse(databaseDocumentText).JsonDeserialization <DatabaseDocument>();
            }

            var databaseName = !string.IsNullOrWhiteSpace(restoreRequest.DatabaseName) ? restoreRequest.DatabaseName
                                                                   : databaseDocument == null ? null : databaseDocument.Id;

            if (string.IsNullOrWhiteSpace(databaseName))
            {
                var errorMessage = (databaseDocument == null || String.IsNullOrWhiteSpace(databaseDocument.Id))
                                                                ? "Database.Document file is invalid - database name was not found and not supplied in the request (Id property is missing or null). This is probably a bug - should never happen."
                                                                : "A database name must be supplied if the restore location does not contain a valid Database.Document file";

                restoreStatus.Messages.Add(errorMessage);
                DatabasesLandlord.SystemDatabase.Documents.Put(RestoreStatus.RavenRestoreStatusDocumentKey, null, RavenJObject.FromObject(new { restoreStatus }), new RavenJObject(), null);

                return(GetMessageWithString(errorMessage, HttpStatusCode.BadRequest));
            }

            if (databaseName == Constants.SystemDatabase)
            {
                return(GetMessageWithString("Cannot do an online restore for the <system> database", HttpStatusCode.BadRequest));
            }

            var existingDatabase = Database.Documents.GetDocumentMetadata("Raven/Databases/" + databaseName, null);

            if (existingDatabase != null)
            {
                return(GetMessageWithString("Cannot do an online restore for an existing database, delete the database " + databaseName + " and restore again.", HttpStatusCode.BadRequest));
            }

            var ravenConfiguration = new RavenConfiguration
            {
                DatabaseName     = databaseName,
                IsTenantDatabase = true
            };

            if (databaseDocument != null)
            {
                foreach (var setting in databaseDocument.Settings)
                {
                    ravenConfiguration.Settings[setting.Key] = setting.Value;
                }
            }

            if (File.Exists(Path.Combine(restoreRequest.BackupLocation, BackupMethods.Filename)))
            {
                ravenConfiguration.DefaultStorageTypeName = typeof(Raven.Storage.Voron.TransactionalStorage).AssemblyQualifiedName;
            }
            else if (Directory.Exists(Path.Combine(restoreRequest.BackupLocation, "new")))
            {
                ravenConfiguration.DefaultStorageTypeName = typeof(Raven.Storage.Esent.TransactionalStorage).AssemblyQualifiedName;
            }

            ravenConfiguration.CustomizeValuesForDatabaseTenant(databaseName);
            ravenConfiguration.Initialize();

            string documentDataDir;

            ravenConfiguration.DataDirectory = ResolveTenantDataDirectory(restoreRequest.DatabaseLocation, databaseName, out documentDataDir);
            restoreRequest.DatabaseLocation  = ravenConfiguration.DataDirectory;

            string anotherRestoreResourceName;

            if (IsAnotherRestoreInProgress(out anotherRestoreResourceName))
            {
                if (restoreRequest.RestoreStartTimeout.HasValue)
                {
                    try
                    {
                        using (var cts = new CancellationTokenSource())
                        {
                            cts.CancelAfter(TimeSpan.FromSeconds(restoreRequest.RestoreStartTimeout.Value));
                            var token = cts.Token;
                            do
                            {
                                await Task.Delay(500, token);
                            }while (IsAnotherRestoreInProgress(out anotherRestoreResourceName));
                        }
                    }
                    catch (OperationCanceledException)
                    {
                        return(GetMessageWithString(string.Format("Another restore is still in progress (resource name = {0}). Waited {1} seconds for other restore to complete.", anotherRestoreResourceName, restoreRequest.RestoreStartTimeout.Value), HttpStatusCode.ServiceUnavailable));
                    }
                }
                else
                {
                    return(GetMessageWithString(string.Format("Another restore is in progress (resource name = {0})", anotherRestoreResourceName), HttpStatusCode.ServiceUnavailable));
                }
            }
            Database.Documents.Put(RestoreInProgress.RavenRestoreInProgressDocumentKey, null, RavenJObject.FromObject(new RestoreInProgress
            {
                Resource = databaseName
            }), new RavenJObject(), null);

            DatabasesLandlord.SystemDatabase.Documents.Delete(RestoreStatus.RavenRestoreStatusDocumentKey, null, null);

            bool defrag;

            if (bool.TryParse(GetQueryStringValue("defrag"), out defrag))
            {
                restoreRequest.Defrag = defrag;
            }

            var task = Task.Factory.StartNew(() =>
            {
                try
                {
                    MaintenanceActions.Restore(ravenConfiguration, restoreRequest,
                                               msg =>
                    {
                        restoreStatus.Messages.Add(msg);
                        DatabasesLandlord.SystemDatabase.Documents.Put(RestoreStatus.RavenRestoreStatusDocumentKey, null,
                                                                       RavenJObject.FromObject(restoreStatus), new RavenJObject(), null);
                    });

                    if (databaseDocument == null)
                    {
                        return;
                    }

                    databaseDocument.Settings[Constants.RavenDataDir] = documentDataDir;
                    if (restoreRequest.IndexesLocation != null)
                    {
                        databaseDocument.Settings[Constants.RavenIndexPath] = restoreRequest.IndexesLocation;
                    }
                    if (restoreRequest.JournalsLocation != null)
                    {
                        databaseDocument.Settings[Constants.RavenTxJournalPath] = restoreRequest.JournalsLocation;
                    }

                    bool replicationBundleRemoved = false;
                    if (restoreRequest.DisableReplicationDestinations)
                    {
                        replicationBundleRemoved = TryRemoveReplicationBundle(databaseDocument);
                    }

                    databaseDocument.Id = databaseName;
                    DatabasesLandlord.Protect(databaseDocument);
                    DatabasesLandlord
                    .SystemDatabase
                    .Documents
                    .Put("Raven/Databases/" + databaseName, null, RavenJObject.FromObject(databaseDocument), new RavenJObject(), null);

                    restoreStatus.Messages.Add("The new database was created");
                    restoreStatus.State = RestoreStatusState.Completed;
                    DatabasesLandlord.SystemDatabase.Documents.Put(RestoreStatus.RavenRestoreStatusDocumentKey, null,
                                                                   RavenJObject.FromObject(restoreStatus), new RavenJObject(), null);

                    if (restoreRequest.GenerateNewDatabaseId)
                    {
                        GenerateNewDatabaseId(databaseName);
                    }

                    if (replicationBundleRemoved)
                    {
                        AddReplicationBundleAndDisableReplicationDestinations(databaseName);
                    }
                }
                catch (Exception e)
                {
                    restoreStatus.State = RestoreStatusState.Faulted;
                    restoreStatus.Messages.Add("Unable to restore database " + e.Message);
                    DatabasesLandlord.SystemDatabase.Documents.Put(RestoreStatus.RavenRestoreStatusDocumentKey, null,
                                                                   RavenJObject.FromObject(restoreStatus), new RavenJObject(), null);
                    throw;
                }
                finally
                {
                    Database.Documents.Delete(RestoreInProgress.RavenRestoreInProgressDocumentKey, null, null);
                }
            }, TaskCreationOptions.LongRunning);

            long id;

            Database.Tasks.AddTask(task, new TaskBasedOperationState(task), new TaskActions.PendingTaskDescription
            {
                StartTime = SystemTime.UtcNow,
                TaskType  = TaskActions.PendingTaskType.RestoreDatabase,
                Payload   = "Restoring database " + databaseName + " from " + restoreRequest.BackupLocation
            }, out id);


            return(GetMessageWithObject(new
            {
                OperationId = id
            }));
        }
コード例 #13
0
ファイル: DatabaseIndexName.cs プロジェクト: yitaom2/ravendb
 public DatabaseIndexName(string databaseName, string indexName, DatabasesLandlord landlord, int databaseIndex, int indexIndex)
     : base(databaseName, indexName, landlord, databaseIndex, indexIndex, SnmpOids.Databases.Indexes.Name)
 {
     _name = new OctetString(indexName);
 }
コード例 #14
0
 public DatabaseIndexExists(string databaseName, string indexName, DatabasesLandlord landlord, int databaseIndex, int indexIndex)
     : base(databaseName, indexName, landlord, databaseIndex, indexIndex, SnmpOids.Databases.Indexes.Exists)
 {
 }
コード例 #15
0
 public DatabaseDeletedCommandHandler(DocumentDatabase database, DatabasesLandlord landlord)
     : base(database, landlord)
 {
 }
コード例 #16
0
 public DatabaseIndexTimeSinceLastQuery(string databaseName, string indexName, DatabasesLandlord landlord, int databaseIndex, int indexIndex)
     : base(databaseName, indexName, landlord, databaseIndex, indexIndex, "11")
 {
 }
コード例 #17
0
 public AdminLogsWebSocketsRequestParser(DatabasesLandlord databasesLandlord, CountersLandlord countersLandlord, FileSystemsLandlord fileSystemsLandlord, MixedModeRequestAuthorizer authorizer, string expectedRequestSuffix)
     : base(databasesLandlord, countersLandlord, fileSystemsLandlord, authorizer, expectedRequestSuffix)
 {
 }
コード例 #18
0
 public DatabaseRequestsCount(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, SnmpOids.Databases.RequestsCount, index)
 {
 }
コード例 #19
0
 public DatabaseIndexTimeSinceLastIndexing(string databaseName, string indexName, DatabasesLandlord landlord, int databaseIndex, int indexIndex)
     : base(databaseName, indexName, landlord, databaseIndex, indexIndex, SnmpOids.Databases.Indexes.TimeSinceLastIndexing)
 {
 }
コード例 #20
0
ファイル: RavenDBOptions.cs プロジェクト: thorhalvor/ravendb
        public RavenDBOptions(InMemoryRavenConfiguration configuration, DocumentDatabase db = null)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            try
            {
                ThreadPool.SetMinThreads(configuration.MinThreadPoolWorkerThreads, configuration.MinThreadPoolCompletionThreads);
                HttpEndpointRegistration.RegisterHttpEndpointTarget();
                HttpEndpointRegistration.RegisterAdminLogsTarget();
                if (db == null)
                {
                    configuration.UpdateDataDirForLegacySystemDb();
                    systemDatabase = new DocumentDatabase(configuration, null, null, (sender, exception) =>
                    {
                        if (log.IsInfoEnabled)
                        {
                            log.ErrorException(
                                @"Found errors in the system database while loading it for the first time.
                                    This is recoverable error, since we will simply ingore transactions after the faulted one.", exception);
                        }
                    });
                    systemDatabase.SpinBackgroundWorkers(false);
                }
                else
                {
                    systemDatabase = db;
                }

                WebSocketBufferPool.Initialize(configuration.WebSockets.InitialBufferPoolSize);
                fileSystemLandlord            = new FileSystemsLandlord(systemDatabase);
                databasesLandlord             = new DatabasesLandlord(systemDatabase);
                countersLandlord              = new CountersLandlord(systemDatabase);
                timeSeriesLandlord            = new TimeSeriesLandlord(systemDatabase);
                requestManager                = new RequestManager(databasesLandlord);
                systemDatabase.RequestManager = requestManager;
                ClusterManager                = new Reference <ClusterManager>();
                systemDatabase.ClusterManager = ClusterManager;
                mixedModeRequestAuthorizer    = new MixedModeRequestAuthorizer();
                mixedModeRequestAuthorizer.Initialize(systemDatabase, new RavenServer(databasesLandlord.SystemDatabase, configuration));

                serverStartupTasks = configuration.Container.GetExportedValues <IServerStartupTask>();

                foreach (var task in serverStartupTasks)
                {
                    toDispose.Add(task);
                    try
                    {
                        task.Execute(this);
                    }
                    catch (Exception e)
                    {
                        systemDatabase.LogErrorAndAddAlertOnStartupTaskException(task.GetType().FullName, e);
                    }
                }
            }
            catch (Exception e)
            {
                if (systemDatabase != null)
                {
                    systemDatabase.Dispose();
                }
                throw;
            }
        }
コード例 #21
0
 public WatchTrafficWebSocketsRequestParser(DatabasesLandlord databasesLandlord, TimeSeriesLandlord timeSeriesLandlord, CountersLandlord countersLandlord, FileSystemsLandlord fileSystemsLandlord, MixedModeRequestAuthorizer authorizer, string expectedRequestSuffix)
     : base(databasesLandlord, timeSeriesLandlord, countersLandlord, fileSystemsLandlord, authorizer, expectedRequestSuffix)
 {
 }
コード例 #22
0
        private void OnProposingCandidacy(object sender, ProposingCandidacyResult e)
        {
            var clusterConfigurationsDoc = DatabasesLandlord.SystemDatabase.Documents.Get(Constants.Cluster.ClusterConfigurationDocumentKey, null);

            if (clusterConfigurationsDoc == null)
            {
                return;
            }
            var clusterConfigurations = clusterConfigurationsDoc.DataAsJson.JsonDeserialization <ClusterConfiguration>();

            if (clusterConfigurations == null)
            {
                return;
            }
            if (clusterConfigurations.DisableReplicationStateChecks == true)
            {
                return;
            }
            var replicationStateDoc = DatabasesLandlord.SystemDatabase.Documents.Get(Constants.Cluster.ClusterReplicationStateDocumentKey, null);

            if (replicationStateDoc == null)
            {
                //This is a case of a node loading for the first time and just never got any replication state.
                //If we prevent this than a cluster will be non-respnosive when loaded (mostly a test senario but could be a real issue)
                if (clusterManagerStartTime + maxReplicationLatency + maxReplicationLatency < DateTime.UtcNow)
                {
                    e.VetoCandidacy = true;
                    e.Reason        = "Could not find replication state document";
                }
                return;
            }
            var replicationState = replicationStateDoc.DataAsJson.ToObject <ReplicationState>();

            if (replicationState == null)
            {
                e.VetoCandidacy = true;
                e.Reason        = "Could not deserialize replication state document";
                return;
            }

            var anyDatabaseUptodate = false;
            //preventing the case where all databases are inactive (long overnight inactivity).
            var anyDatabaseUp = false;

            DatabasesLandlord.ForAllDatabases(database =>
            {
                anyDatabaseUp = true;
                LastModificationTimeAndTransactionalId modification;
                //if the source document doesn't contain this databse it means it was not active in the source
                //nothing we can do but ignore this.
                if (replicationState.DatabasesToLastModification.TryGetValue(database.Name, out modification) == false)
                {
                    return;
                }
                var docKey = $"{Constants.RavenReplicationSourcesBasePath}/{modification.DatabaseId}";
                var doc    = database.Documents.Get(docKey, null);
                if (doc == null)
                {
                    return;
                }
                var sourceInformation = doc.DataAsJson.JsonDeserialization <SourceReplicationInformation>();
                if (sourceInformation == null)
                {
                    return;
                }
                var lastUpdate = sourceInformation.LastModifiedAtSource ?? DateTime.MaxValue;
                if (lastUpdate == DateTime.MaxValue || lastUpdate + maxReplicationLatency >= modification.LastModified)
                {
                    anyDatabaseUptodate = true;
                }
            }, true);
            if (anyDatabaseUptodate == false && anyDatabaseUp)
            {
                e.VetoCandidacy = true;
                e.Reason        = "None of the active databases are up to date with the leader last replication state";
            }
        }
コード例 #23
0
 public DatabaseIndexMapsPerSec(string databaseName, string indexName, DatabasesLandlord landlord, int databaseIndex, int indexIndex)
     : base(databaseName, indexName, landlord, databaseIndex, indexIndex, SnmpOids.Databases.Indexes.MapsPerSec)
 {
 }
コード例 #24
0
 public DatabaseIndexPriority(string databaseName, string indexName, DatabasesLandlord landlord, int databaseIndex, int indexIndex)
     : base(databaseName, indexName, landlord, databaseIndex, indexIndex, SnmpOids.Databases.Indexes.Priority)
 {
 }
コード例 #25
0
 public DatabaseTotalStorageSize(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, "5.2.{0}.2.4", index)
 {
 }
コード例 #26
0
 public DatabaseNumberOfAutoIndexes(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, "5.2.{0}.5.3", index)
 {
 }
コード例 #27
0
 public DatabaseTransactionalStorageDiskRemainingSpace(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, "5.2.{0}.2.5", index)
 {
 }
コード例 #28
0
ファイル: AdminController.cs プロジェクト: tryadiadi/ravendb
        public HttpResponseMessage Compact()
        {
            var db = InnerRequest.RequestUri.ParseQueryString()["database"];

            if (string.IsNullOrWhiteSpace(db))
            {
                return(GetMessageWithString("Compact request requires a valid database parameter", HttpStatusCode.BadRequest));
            }

            var configuration = DatabasesLandlord.CreateTenantConfiguration(db);

            if (configuration == null)
            {
                return(GetMessageWithString("No database named: " + db, HttpStatusCode.NotFound));
            }

            var task = Task.Factory.StartNew(() =>
            {
                var compactStatus = new CompactStatus {
                    State = CompactStatusState.Running, Messages = new List <string>()
                };
                DatabasesLandlord.SystemDatabase.Documents.Delete(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null, null);

                try
                {
                    var targetDb = DatabasesLandlord.GetDatabaseInternal(db).ResultUnwrap();

                    DatabasesLandlord.Lock(db, () => targetDb.TransactionalStorage.Compact(configuration, msg =>
                    {
                        compactStatus.Messages.Add(msg);
                        DatabasesLandlord.SystemDatabase.Documents.Put(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null,
                                                                       RavenJObject.FromObject(compactStatus), new RavenJObject(), null);
                    }));
                    compactStatus.State = CompactStatusState.Completed;
                    compactStatus.Messages.Add("Database compaction completed.");
                    DatabasesLandlord.SystemDatabase.Documents.Put(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null,
                                                                   RavenJObject.FromObject(compactStatus), new RavenJObject(), null);
                }
                catch (Exception e)
                {
                    compactStatus.Messages.Add("Unable to compact database " + e.Message);
                    compactStatus.State = CompactStatusState.Faulted;
                    DatabasesLandlord.SystemDatabase.Documents.Put(CompactStatus.RavenDatabaseCompactStatusDocumentKey(db), null,
                                                                   RavenJObject.FromObject(compactStatus), new RavenJObject(), null);
                    throw;
                }
                return(GetEmptyMessage());
            });
            long id;

            Database.Tasks.AddTask(task, new TaskBasedOperationState(task), new TaskActions.PendingTaskDescription
            {
                StartTime = SystemTime.UtcNow,
                TaskType  = TaskActions.PendingTaskType.CompactDatabase,
                Payload   = "Compact database " + db,
            }, out id);

            return(GetMessageWithObject(new
            {
                OperationId = id
            }));
        }
コード例 #29
0
 public DatabaseReducedPerSecond(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, "5.2.{0}.3.3", index)
 {
 }
コード例 #30
0
 public DatabaseNumberOfStaticIndexes(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, SnmpOids.Databases.NumberOfStaticIndexes, index)
 {
 }
コード例 #31
0
ファイル: DatabaseUpTime.cs プロジェクト: ikvm/ravendb
 public DatabaseUpTime(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, SnmpOids.Databases.UpTime, index)
 {
 }
コード例 #32
0
        private void CleanupFileSystems(DatabasesLandlord databaseLandlord, FileSystemsLandlord fileSystemLandlord)
        {
            var systemDatabase = databaseLandlord.SystemDatabase;

            int nextStart           = 0;
            var fileSystemDocuments = systemDatabase
                                      .Documents
                                      .GetDocumentsWithIdStartingWith(Constants.FileSystem.Prefix, null, null, 0, int.MaxValue, CancellationToken.None, ref nextStart);

            var fileSystemIds = fileSystemDocuments
                                .Select(x => ((RavenJObject)x)["@metadata"])
                                .Where(x => x != null)
                                .Select(x => x.Value <string>("@id"))
                                .Where(x => x != null && x != Constants.SystemDatabase)
                                .ToList();

            foreach (var fileSystemId in fileSystemIds)
            {
                try
                {
                    var key = fileSystemId;
                    if (key.StartsWith(Constants.FileSystem.Prefix))
                    {
                        key = key.Substring(Constants.FileSystem.Prefix.Length);
                    }

                    var shouldCleanup = false;

                    DateTime value;
                    if (fileSystemLandlord.IsFileSystemLoaded(key) == false)
                    {
                        shouldCleanup = true;
                    }
                    else if (fileSystemLandlord.LastRecentlyUsed.TryGetValue(key, out value) == false || (SystemTime.UtcNow - value) > maxTimeResourceCanBeIdle)
                    {
                        shouldCleanup = true;
                    }

                    if (shouldCleanup == false)
                    {
                        continue;
                    }

                    var configuration = fileSystemLandlord.CreateTenantConfiguration(key, true);

                    fileSystemLandlord.Cleanup(key, maxTimeResourceCanBeIdle, database => false);

                    var docKey = Constants.FileSystem.Prefix + key;
                    systemDatabase.Documents.Delete(docKey, null, null);

                    if (configuration == null)
                    {
                        continue;
                    }

                    IOExtensions.DeleteDirectory(configuration.FileSystem.DataDirectory);
                }
                catch (Exception e)
                {
                    log.WarnException(string.Format("Failed to cleanup '{0}' filesystem.", fileSystemId), e);
                }
            }
        }
コード例 #33
0
 public DatabaseActiveBundles(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, "5.2.{0}.1.12", index)
 {
 }
コード例 #34
0
 public DatabaseCountOfUniqueAttachments(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, SnmpOids.Databases.CountOfUniqueAttachments, index)
 {
 }
コード例 #35
0
 public DatabaseMapIndexIndexedPerSecond(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, SnmpOids.Databases.MapIndexIndexesPerSecond, index)
 {
 }
コード例 #36
0
 public AdminLogsWebSocketsRequestParser(DatabasesLandlord databasesLandlord, CountersLandlord countersLandlord, FileSystemsLandlord fileSystemsLandlord, MixedModeRequestAuthorizer authorizer, string expectedRequestSuffix)
     : base(databasesLandlord, countersLandlord, fileSystemsLandlord, authorizer, expectedRequestSuffix)
 {
 }
コード例 #37
0
 public DatabaseStorageDiskRemainingSpace(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, SnmpOids.Databases.StorageDiskRemainingSpace, index)
 {
 }
 public DatabaseCurrentNumberOfItemsToIndexInSingleBatch(string databaseName, DatabasesLandlord landlord, int index)
     : base(databaseName, landlord, "5.2.{0}.1.8", index)
 {
 }
コード例 #39
0
 public DatabaseIndexLastQueryTime(string databaseName, string indexName, DatabasesLandlord landlord, int databaseIndex, int indexIndex)
     : base(databaseName, indexName, landlord, databaseIndex, indexIndex, SnmpOids.Databases.Indexes.LastQueryTime)
 {
 }