protected override void InternalProcessRecord() { TaskLogger.LogEnter(new object[] { this.DataObject }); TDataObject scratchPad = Activator.CreateInstance <TDataObject>(); scratchPad.CopyChangesFrom(this.DataObject); base.InternalProcessRecord(); TDataObject dataObject = this.DataObject; AmServerName amServerName = new AmServerName(dataObject.ServerName); TDataObject dataObject2 = this.DataObject; SystemConfigurationTasksHelper.DoubleWrite <TDataObject>(dataObject2.Identity, scratchPad, amServerName.Fqdn, base.DomainController, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); Database database = this.DataObject; if (database.Servers != null && database.Servers.Length > 0) { foreach (ADObjectId adobjectId in database.Servers) { DatabaseTasksHelper.RunConfigurationUpdaterRpcAsync(amServerName.Fqdn, database, ReplayConfigChangeHints.DbCopyAdded, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); } } TaskLogger.LogExit(); }
private void InternalValidateDatabaseMode() { base.InternalValidate(); if (base.HasErrors) { return; } this.m_database = this.DataObject; this.ResolveParameters(); this.CheckDatabaseObject(); if (this.m_database.MasterType != MasterType.DatabaseAvailabilityGroup) { this.m_output.WriteError(new InvalidOperationException(Strings.ErrorSingleDbCopyMove(this.m_database.Name, this.m_database.ServerName)), ErrorCategory.InvalidOperation, this.m_database.Identity); } this.m_dag = DagTaskHelper.ReadDag(this.m_database.MasterServerOrAvailabilityGroup, base.DataSession); if (this.m_dag == null) { this.m_output.WriteError(new InconsistentADException(Strings.InconsistentADDbMasterServerNotADag(this.m_database.Name, this.m_database.MasterServerOrAvailabilityGroup.ToString())), ErrorCategory.InvalidOperation, this.m_database.Identity); } if (this.m_dag.ThirdPartyReplication == ThirdPartyReplicationMode.Enabled) { this.m_output.WriteError(new InvalidTPRTaskException(base.MyInvocation.MyCommand.Name), ErrorCategory.InvalidOperation, this.m_database.Identity); } this.m_startingServer = this.GetCurrentActiveServer(this.m_database.Guid); base.VerifyIsWithinScopes((IConfigurationSession)base.DataSession, DatabaseTasksHelper.GetServerObject(new ServerIdParameter(Fqdn.Parse(this.m_startingServer.Fqdn)), (IConfigurationSession)base.DataSession, this.RootId, new DataAccessHelper.GetDataObjectDelegate(base.GetDataObject <Server>)), true, new DataAccessTask <Database> .ADObjectOutOfScopeString(Strings.ErrorServerOutOfScope)); this.PreventMoveOfActiveSeedingSource(this.m_startingServer, new Database[] { this.m_database }); if (this.TargetServerSpecified) { this.PerformTargetServerValidation(); } }
protected override void WriteResult() { TaskLogger.LogEnter(); this.dbCopy = base.SaveDBCopy(); if (this.preExistingDatabase != null) { TaskLogger.LogExit(); return; } MailboxDatabase mailboxDatabase = (MailboxDatabase)base.GetDataObject(new DatabaseIdParameter((ADObjectId)this.DataObject.Identity)); try { int maximumSupportedDatabaseSchemaVersion = DatabaseTasksHelper.GetMaximumSupportedDatabaseSchemaVersion((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), mailboxDatabase); DatabaseTasksHelper.SetRequestedDatabaseSchemaVersion((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), null, mailboxDatabase, maximumSupportedDatabaseSchemaVersion); } catch (ClusterException) { } mailboxDatabase.CompleteAllCalculatedProperties(); this.RunConfigurationUpdaterRpc(mailboxDatabase); this.systemMailbox = NewMailboxDatabase.SaveSystemMailbox(mailboxDatabase, base.OwnerServer, base.RootOrgContainerId, (ITopologyConfigurationSession)this.ConfigurationSession, this.RecipientSessionForSystemMailbox, this.forcedReplicationSites, new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose)); base.WriteObject(mailboxDatabase); TaskLogger.LogExit(); }
public static void GetSupporableDatabaseSchemaVersionRange(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database, out int minVersion, out int maxVersion, out int currentRequestedVersion) { currentRequestedVersion = 0; int num = int.MaxValue; int num2 = 0; DatabaseAvailabilityGroup databaseAvailabilityGroup; using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase(taskSession, writeLog, writeWarning, writeError, database, false, out databaseAvailabilityGroup)) { if (clusterDB != null && clusterDB.IsInitialized) { ClusterDBHelpers.ReadRequestedDatabaseSchemaVersion(clusterDB, database.Guid, 0, out currentRequestedVersion); foreach (ADObjectId adobjectId in databaseAvailabilityGroup.Servers) { int num3; int num4; ClusterDBHelpers.ReadServerDatabaseSchemaVersionRange(clusterDB, adobjectId.ObjectGuid, 121, 121, out num3, out num4); writeLog(Strings.ServerSchemaVersionRange(adobjectId.ObjectGuid.ToString(), num3, num4)); num2 = Math.Max(num3, num2); num = Math.Min(num4, num); } } } if (num2 > num) { writeError(new IncompatibleDatabaseSchemaVersionsInDAGException(), ErrorCategory.MetadataError, database); } minVersion = num2; maxVersion = num; }
public static void CheckReplayServiceRunningOnNode(AmServerName nodeName, Task.TaskErrorLoggingDelegate writeError) { if (!DatabaseTasksHelper.IsServiceRunningOnNode("msexchangerepl", nodeName)) { writeError(new ReplServiceNotRunningOnNodeException(nodeName.NetbiosName), ErrorCategory.InvalidOperation, null); } }
private void PerformTargetServerValidation() { DatabaseTasksHelper.CheckServerObjectForCopyTask(this.ActivateOnServer, new Task.TaskErrorLoggingDelegate(base.WriteError), this.m_targetServer); if (this.CommandType == MoveActiveMailboxDatabase.CommandTypes.MoveSingleDatabase) { DatabaseCopy databaseCopy; DatabaseCopy[] array; DatabaseTasksHelper.CheckDatabaseCopyForCopyTask(this.m_database, new Task.TaskErrorLoggingDelegate(this.m_output.WriteError), this.m_targetServer, out databaseCopy, out array); } if (this.m_dag == null) { this.m_dag = ((IConfigurationSession)base.DataSession).Read <DatabaseAvailabilityGroup>(this.m_targetServer.DatabaseAvailabilityGroup); } IADDatabaseAvailabilityGroup dag = ADObjectWrapperFactory.CreateWrapper(this.m_dag); if (AmBestCopySelectionHelper.IsServerInDacAndStopped(dag, new AmServerName(this.m_targetServer.Name))) { base.WriteError(new InvalidOperationException(Strings.ErrorServerDacedAndNotStarted(this.m_dag.Name, this.m_targetServer.Name)), ErrorCategory.InvalidOperation, null); } DatabaseTasksHelper.CheckReplayServiceRunningOnNode(this.m_targetAmServer, new Task.TaskErrorLoggingDelegate(base.WriteError)); DagTaskHelper.CheckStoreIsRunning(new Task.TaskErrorLoggingDelegate(base.WriteError), this.m_targetAmServer); if (this.MountDialOverride != DatabaseMountDialOverride.Lossless) { base.VerifyIsWithinScopes((IConfigurationSession)base.DataSession, this.m_targetServer, true, new DataAccessTask <Database> .ADObjectOutOfScopeString(Strings.ErrorServerOutOfScope)); } }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); if (base.HasErrors) { TaskLogger.LogExit(); return; } if (!this.ClearHostServer && this.m_dbCopy.HostServer != null) { base.VerifyIsWithinScopes((IConfigurationSession)base.DataSession, DatabaseTasksHelper.GetServerObject(new ServerIdParameter(this.m_dbCopy.HostServer), (IConfigurationSession)base.DataSession, this.RootId, new DataAccessHelper.GetDataObjectDelegate(base.GetDataObject <Server>)), true, new DataAccessTask <DatabaseCopy> .ADObjectOutOfScopeString(Strings.ErrorServerOutOfScope)); } Database database = this.m_dbCopy.GetDatabase <Database>(); if (database != null) { MapiTaskHelper.VerifyDatabaseIsWithinScope(base.SessionSettings, database, new Task.ErrorLoggerDelegate(base.WriteError)); if (database.Servers != null && database.Servers.Length > 0) { MapiTaskHelper.VerifyServerIsWithinScope(database, new Task.ErrorLoggerDelegate(base.WriteError), (ITopologyConfigurationSession)this.ConfigurationSession); } } if (this.DataObject.IsModified(DatabaseCopySchema.ReplayLag) && this.m_dbCopy.ReplayLagTime != TimeSpan.FromSeconds(0.0)) { this.WriteWarning(Strings.WarningReplayLagTimeMustBeLessThanSafetyNetHoldTime); } }
private void CheckDatabaseObject() { DatabaseTasksHelper.CheckDatabaseForCopyTask(this.m_database, new Task.TaskErrorLoggingDelegate(base.WriteError), Strings.ErrorSingleDbCopyMove(this.m_database.Name, this.m_database.ServerName)); if (this.m_database.Recovery) { base.WriteError(new InvalidOperationException(Strings.ErrorInvalidOperationOnRecoveryMailboxDatabase(this.m_database.Name)), ErrorCategory.InvalidOperation, this.m_database.Identity); } }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); MapiTaskHelper.VerifyDatabaseIsWithinScope(base.SessionSettings, this.DataObject, new Task.ErrorLoggerDelegate(base.WriteError)); TDataObject dataObject = this.DataObject; if (dataObject.Servers != null) { TDataObject dataObject2 = this.DataObject; if (dataObject2.Servers.Length > 0) { MapiTaskHelper.VerifyServerIsWithinScope(this.DataObject, new Task.ErrorLoggerDelegate(base.WriteError), (ITopologyConfigurationSession)this.ConfigurationSession); } } ADPropertyDefinition[] deprecatedProperties = this.GetDeprecatedProperties(); for (int i = 0; i < deprecatedProperties.Length; i++) { TDataObject dataObject3 = this.DataObject; if (dataObject3.IsModified(deprecatedProperties[i])) { this.WriteWarning(Strings.WarnAboutDeprecatedParameter(deprecatedProperties[i].Name)); } } TDataObject dataObject4 = this.DataObject; if (dataObject4.IsChanged(DatabaseSchema.DataMoveReplicationConstraintDefinition)) { TDataObject dataObject5 = this.DataObject; DataMoveReplicationConstraintParameter dataMoveReplicationConstraint = dataObject5.DataMoveReplicationConstraint; ITopologyConfigurationSession taskSession = (ITopologyConfigurationSession)base.DataSession; Database database = this.DataObject; TDataObject dataObject6 = this.DataObject; DatabaseTasksHelper.DataMoveReplicationConstraintFallBack(taskSession, database, dataObject6.DataMoveReplicationConstraint, out dataMoveReplicationConstraint); DataMoveReplicationConstraintParameter dataMoveReplicationConstraintParameter = dataMoveReplicationConstraint; TDataObject dataObject7 = this.DataObject; if (dataMoveReplicationConstraintParameter != dataObject7.DataMoveReplicationConstraint) { TDataObject dataObject8 = this.DataObject; DataMoveReplicationConstraintParameter dataMoveReplicationConstraint2 = dataObject8.DataMoveReplicationConstraint; TDataObject dataObject9 = this.DataObject; base.WriteError(new ConstraintErrorException(dataMoveReplicationConstraint2, dataObject9.Identity.ToString()), ErrorCategory.InvalidOperation, this.Identity); } } TDataObject dataObject10 = this.DataObject; if (dataObject10.IsChanged(DatabaseSchema.CircularLoggingEnabled)) { TDataObject dataObject11 = this.DataObject; DatabaseCopy[] databaseCopies = dataObject11.GetDatabaseCopies(); if (databaseCopies != null && databaseCopies.Length == 1) { TDataObject dataObject12 = this.DataObject; this.WriteWarning(Strings.WarningOperationOnDBWithJetCircularLogging(dataObject12.Identity.ToString())); } } TaskLogger.LogExit(); }
protected override void InternalValidate() { TaskLogger.LogEnter(); this.LogCommandLineParameters(); this.m_removeNode = false; this.m_destroyCluster = false; this.ResolveParameters(); DagTaskHelper.VerifyDagAndServersAreWithinScopes <DatabaseAvailabilityGroup>(this, this.m_dag, true); this.m_output.WriteProgress(Strings.ProgressStatusInProgress, Strings.DagTaskRemoveDagServerRunningChecks(this.m_mailboxServerName, this.m_dagName), 0); this.CheckDatabasesAreNotReplicated(); if (!this.m_configurationOnly) { DagTaskHelper.CheckServerDoesNotBelongToDifferentDag(new Task.TaskErrorLoggingDelegate(this.m_output.WriteError), base.DataSession, this.m_mailboxServer, this.m_dagName); this.CheckFswSettings(); this.CheckClusterStateForDagServerRemoval(); if (!this.m_configurationOnly) { using (IAmClusterGroup amClusterGroup = this.m_clusDag.FindCoreClusterGroup()) { AmServerName ownerNode = amClusterGroup.OwnerNode; this.m_output.AppendLogMessage("Checking if msexchangerepl is running on {0}.", new object[] { ownerNode.NetbiosName }); DatabaseTasksHelper.CheckReplayServiceRunningOnNode(ownerNode, new Task.TaskErrorLoggingDelegate(base.WriteError)); if (this.m_clusDag.CnoName != string.Empty) { using (IAmClusterResource amClusterResource = amClusterGroup.FindResourceByTypeName("Network Name")) { DagTaskHelper.LogCnoState(this.m_output, this.m_dagName, amClusterResource); } } } } } if (DagTaskHelper.FindServerAdObjectIdInDag(this.m_dag, this.m_mailboxAmServerName) == null) { StringBuilder stringBuilder = new StringBuilder(string.Format("{0}. srvToRemove={1} dagSvrs=(", this.m_dagName, this.m_mailboxAmServerName.NetbiosName)); bool flag = false; foreach (ADObjectId adobjectId in this.m_dag.Servers) { if (flag) { stringBuilder.Append(","); } else { flag = true; } stringBuilder.Append(adobjectId.Name); } stringBuilder.Append(")"); this.m_output.WriteErrorSimple(new DagTaskServerIsNotInDagException(this.m_mailboxServerName, stringBuilder.ToString())); } base.InternalValidate(); TaskLogger.LogExit(); }
public static int GetMaximumSupportedDatabaseSchemaVersion(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database) { int num; int result; int num2; DatabaseTasksHelper.GetSupporableDatabaseSchemaVersionRange(taskSession, writeLog, writeWarning, writeError, database, out num, out result, out num2); return(result); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(new object[] { this.DataObject }); DatabaseTasksHelper.SetRequestedDatabaseSchemaVersion((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), this.DataObject, this.version); TaskLogger.LogExit(); }
private void RunConfigurationUpdaterRpc() { if (this.m_server != null) { string fqdn = this.m_server.Fqdn; DatabaseTasksHelper.RunConfigurationUpdaterRpc(fqdn, this.m_database, this.m_server.AdminDisplayVersion, ReplayConfigChangeHints.DbCopyRemoved, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); } string serverFqdn = this.m_dbLocationInfo.ServerFqdn; DatabaseTasksHelper.RunConfigurationUpdaterRpc(serverFqdn, this.m_database, new ServerVersion(this.m_dbLocationInfo.ServerVersion), ReplayConfigChangeHints.DbCopyRemoved, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); base.InternalProcessRecord(); if (this.m_dbCopy.IsHostServerPresent) { Server server = (Server)base.DataSession.Read <Server>(this.m_dbCopy.HostServer); Database database = this.m_dbCopy.GetDatabase <Database>(); DatabaseTasksHelper.RunConfigurationUpdaterRpc(server.Fqdn, database, server.AdminDisplayVersion, ReplayConfigChangeHints.DbCopyAdded, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); } TaskLogger.LogExit(); }
public static void UpdateDataGuaranteeConstraint(ITopologyConfigurationSession taskSession, Database database, Task.TaskWarningLoggingDelegate writeWarning) { DataMoveReplicationConstraintParameter dataMoveReplicationConstraint = database.DataMoveReplicationConstraint; DatabaseTasksHelper.DataMoveReplicationConstraintFallBack(taskSession, database, database.DataMoveReplicationConstraint, out dataMoveReplicationConstraint); if (dataMoveReplicationConstraint != database.DataMoveReplicationConstraint) { writeWarning(Strings.ConstraintFallback(database.DataMoveReplicationConstraint, dataMoveReplicationConstraint, database.Identity.ToString())); } database.DataMoveReplicationConstraint = dataMoveReplicationConstraint; taskSession.Save(database); }
private void RunSourceConfigurationUpdaterRpc() { string text = this.DataObject.ServerName; MiniServer miniServer = (MiniServer)base.DataSession.Read <MiniServer>(this.DataObject.Server); if (miniServer == null) { this.WriteWarning(Strings.ErrorMailboxServerNotFound(text)); return; } text = miniServer.Fqdn; DatabaseTasksHelper.RunConfigurationUpdaterRpc(text, this.DataObject, miniServer.AdminDisplayVersion, ReplayConfigChangeHints.DbCopyAdded, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); }
protected override IConfigurable ResolveDataObject() { this.Identity.AllowInvalid = true; this.m_dbCopy = (DatabaseCopy)base.GetDataObject <DatabaseCopy>(this.Identity, base.DataSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(this.Identity.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(this.Identity.ToString()))); if (base.Fields["ActivationPreference"] != null && (this.m_dbCopy.HostServerUnlinked || this.ClearHostServer)) { base.WriteError(new ArgumentException(Strings.ErrorActivationPreferenceNotAllowedWhenHostServerUnlinked), ErrorCategory.InvalidOperation, this.m_dbCopy); } Server server; DatabaseTasksHelper.ValidateDatabaseCopyActionTask(this.m_dbCopy, true, false, base.DataSession, this.RootId, new Task.TaskErrorLoggingDelegate(base.WriteError), Strings.ErrorMailboxDatabaseNotUnique(this.m_dbCopy.Identity.ToString()), null, out server); this.m_databaseCopies = this.m_dbCopy.GetAllDatabaseCopies(); return(this.m_dbCopy); }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); Server server = this.DataObject.GetServer(); bool flag = false; if (server == null) { base.WriteError(new InvalidOperationException(Strings.ErrorDBOwningServerNotFound(this.DataObject.Identity.ToString())), ErrorCategory.InvalidOperation, this.DataObject.Identity); } else { flag = server.IsE15OrLater; } if (!flag) { base.WriteError(new InvalidOperationException(Strings.ErrorModifyE14DatabaseNotAllowed), ErrorCategory.InvalidOperation, this.DataObject.Identity); } DatabaseAvailabilityGroup databaseAvailabilityGroup; using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), this.DataObject, false, out databaseAvailabilityGroup)) { if (clusterDB == null || !clusterDB.IsInstalled) { base.WriteError(new InvalidOperationException(Strings.ErrorSchemaVersionDoesntApply(this.DataObject.Name)), ErrorCategory.InvalidOperation, this.DataObject.Identity); } } if (base.Fields.IsModified("MajorVersion")) { this.version = UpdateDatabaseSchema.VersionFromComponents(this.MajorVersion, this.MinorVersion); int num; int num2; int num3; DatabaseTasksHelper.GetSupporableDatabaseSchemaVersionRange((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), this.DataObject, out num, out num2, out num3); if (this.version < num || this.version > num2) { base.WriteError(new InvalidOperationException(Strings.ErrorSchemaVersionOutOfRange(UpdateDatabaseSchema.VersionString(num), UpdateDatabaseSchema.VersionString(num2))), ErrorCategory.InvalidOperation, this.DataObject.Identity); } if (num3 > this.version) { this.WriteWarning(Strings.RequestedVersionIsLowerThanCurrentVersion(num3)); } } else { this.version = DatabaseTasksHelper.GetMaximumSupportedDatabaseSchemaVersion((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), this.DataObject); } TaskLogger.LogExit(); }
private void InternalValidateServerMode() { this.ResolveServerParameters(); DatabaseTasksHelper.CheckServerObjectForCopyTask(this.Server, new Task.TaskErrorLoggingDelegate(base.WriteError), this.m_server); if (this.m_server.DatabaseAvailabilityGroup == null) { base.WriteError(new InvalidOperationException(Strings.ErrorSourceServerNotInDag(this.m_server.Name)), ErrorCategory.InvalidOperation, this.m_server); } DatabaseAvailabilityGroup databaseAvailabilityGroup = ((IConfigurationSession)base.DataSession).Read <DatabaseAvailabilityGroup>(this.m_server.DatabaseAvailabilityGroup); if (databaseAvailabilityGroup == null) { base.WriteError(new InconsistentADException(Strings.InconsistentServerNotInDag(this.m_server.Name, this.m_server.DatabaseAvailabilityGroup.ToString())), ErrorCategory.InvalidOperation, this.m_server); } DagTaskHelper.PreventTaskWhenTPREnabled(databaseAvailabilityGroup, this); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); DatabaseCopy dataObject = base.DataObject; base.InternalProcessRecord(); if (base.HasErrors) { TaskLogger.LogExit(); return; } this.m_database.InvalidDatabaseCopiesAllowed = true; this.RunConfigurationUpdaterRpc(); try { ReplayState.DeleteState((this.m_server != null) ? this.m_server.Fqdn : this.m_serverName, this.m_database); } catch (SecurityException ex) { this.WriteWarning(Strings.ErrorCannotDeleteReplayState(this.m_database.Name, this.m_serverName, ex.Message)); } catch (UnauthorizedAccessException ex2) { this.WriteWarning(Strings.ErrorCannotDeleteReplayState(this.m_database.Name, this.m_serverName, ex2.Message)); } catch (IOException ex3) { this.WriteWarning(Strings.ErrorCannotDeleteReplayState(this.m_database.Name, this.m_serverName, ex3.Message)); } catch (RemoteRegistryTimedOutException ex4) { this.WriteWarning(Strings.ErrorCannotDeleteReplayState(this.m_database.Name, this.m_serverName, ex4.Message)); } string pathName = this.m_database.EdbFilePath.PathName; if (string.IsNullOrEmpty(pathName)) { this.WriteWarning(Strings.NeedRemoveCopyLogFileManuallyAfterCopyDisabledRcr(this.m_database.Name, this.m_database.LogFolderPath.PathName, this.m_serverName)); } else { this.WriteWarning(Strings.NeedRemoveCopyFileManuallyAfterCopyDisabledRcr(this.m_database.Name, this.m_database.LogFolderPath.PathName, pathName, this.m_serverName)); } DatabaseTasksHelper.UpdateDataGuaranteeConstraint((ITopologyConfigurationSession)base.DataSession, this.m_database, new Task.TaskWarningLoggingDelegate(this.WriteWarning)); TaskLogger.LogExit(); }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); if (base.HasErrors) { TaskLogger.LogExit(); return; } this.m_databaseCopy = this.DataObject; DatabaseTasksHelper.ValidateDatabaseCopyActionTask(this.m_databaseCopy, false, true, base.DataSession, this.RootId, new Task.TaskErrorLoggingDelegate(base.WriteError), Strings.ErrorMailboxDatabaseNotUnique(this.Identity.ToString()), new LocalizedString?(Strings.ErrorSingleDatabaseCopy(this.Identity.ToString())), out this.m_server); Database database = this.DataObject.GetDatabase <Database>(); if (database != null) { MapiTaskHelper.VerifyDatabaseIsWithinScope(base.SessionSettings, database, new Task.ErrorLoggerDelegate(base.WriteError)); } }
public static void RemoveDatabaseFromClusterDB(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database) { try { DatabaseAvailabilityGroup databaseAvailabilityGroup; using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase(taskSession, writeLog, writeWarning, writeError, database, true, out databaseAvailabilityGroup)) { if (clusterDB != null && clusterDB.IsInitialized) { writeLog(Strings.DeleteClusterDBKey(database.Name)); ClusterDBHelpers.RemoveDatabaseRequestedSchemaVersion(clusterDB, database.Guid); } } } catch (ClusterException) { writeWarning(Strings.FailedToRemoveDatabaseSection(database.Name)); } }
protected override void InternalProcessRecord() { if (this.server != null) { this.DismountDatabase(); } this.RemoveSystemMailbox(); this.RemoveMonitoringMailboxes(); if (this.copies != null && this.copies.Length == 1) { base.DataSession.Delete(this.copies[0]); } base.InternalProcessRecord(); TDataObject dataObject = base.DataObject; string name = dataObject.Name; TDataObject dataObject2 = base.DataObject; this.WriteWarning(Strings.NeedRemoveDatabaseFileManually(name, dataObject2.EdbFilePath.ToString())); DatabaseTasksHelper.RemoveDatabaseFromClusterDB((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), base.DataObject); }
private void ValidateDatabaseCopy() { this.m_databaseCopy = base.DataObject; this.m_database = this.m_databaseCopy.GetDatabase <Database>(); DatabaseTasksHelper.ValidateDatabaseCopyActionTask(this.m_databaseCopy, true, true, base.DataSession, this.RootId, new Task.TaskErrorLoggingDelegate(base.WriteError), Strings.ErrorMailboxDatabaseNotUnique(this.m_database.Identity.ToString()), new LocalizedString?(Strings.ErrorSingleDatabaseCopyRemove(this.m_database.Identity.ToString(), this.m_databaseCopy.HostServerName)), out this.m_server); if (this.m_server == null) { this.m_serverName = this.m_databaseCopy.Name; } else { this.m_serverName = this.m_server.Name; } DatabaseCopy[] allDatabaseCopies = this.m_database.AllDatabaseCopies; this.m_originalCopiesLength = allDatabaseCopies.Length; if (this.m_originalCopiesLength == 2 && this.m_database.CircularLoggingEnabled) { base.WriteError(new InvalidOperationException(Strings.ErrorInvalidRemoveOperationOnDBCopyForCircularLoggingEnabledDB(this.m_database.Name)), ErrorCategory.InvalidOperation, base.DataObject.Identity); } }
private void InternalValidateServerMode() { this.ResolveParameters(); Server server; MailboxServerIdParameter serverIdParam; if (this.CommandType == MoveActiveMailboxDatabase.CommandTypes.MoveAwayFromServer) { server = this.m_sourceServer; serverIdParam = this.Server; } else { server = this.m_targetServer; serverIdParam = this.ActivatePreferredOnServer; } DatabaseTasksHelper.CheckServerObjectForCopyTask(serverIdParam, new Task.TaskErrorLoggingDelegate(base.WriteError), server); if (server.DatabaseAvailabilityGroup == null) { this.m_output.WriteError(new InvalidOperationException(Strings.ErrorSourceServerNotInDag(server.Name)), ErrorCategory.InvalidOperation, server.Identity); } this.m_dag = ((IConfigurationSession)base.DataSession).Read <DatabaseAvailabilityGroup>(server.DatabaseAvailabilityGroup); if (this.m_dag == null) { this.m_output.WriteError(new InconsistentADException(Strings.InconsistentServerNotInDag(server.Name, server.DatabaseAvailabilityGroup.ToString())), ErrorCategory.InvalidOperation, server.Identity); } if (this.m_dag.ThirdPartyReplication == ThirdPartyReplicationMode.Enabled) { this.m_output.WriteError(new InvalidTPRTaskException(base.MyInvocation.MyCommand.Name), ErrorCategory.InvalidOperation, server.Identity); } base.VerifyIsWithinScopes((IConfigurationSession)base.DataSession, server, true, new DataAccessTask <Database> .ADObjectOutOfScopeString(Strings.ErrorServerOutOfScope)); if (this.CommandType == MoveActiveMailboxDatabase.CommandTypes.MoveAwayFromServer) { Database[] databases = null; this.PreventMoveOfActiveSeedingSource(this.m_sourceAmServer, databases); if (this.TargetServerSpecified) { this.PerformTargetServerValidation(); } } }
public static void SetRequestedDatabaseSchemaVersion(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database, int version) { try { DatabaseAvailabilityGroup databaseAvailabilityGroup; using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase(taskSession, writeLog, writeWarning, writeError, database, false, out databaseAvailabilityGroup)) { if (clusterDB != null && clusterDB.IsInitialized) { writeLog(Strings.SetDatabaseRequestedSchemaVersion(database.Name, version)); ClusterDBHelpers.WriteRequestedDatabaseSchemaVersion(clusterDB, database.Guid, version); } } } catch (ClusterException) { if (writeError != null) { writeError(new FailedToSetRequestedDatabaseSchemaVersionException(database.Name), ErrorCategory.WriteError, database); } } }
public static void ValidateDatabaseCopyActionTask(DatabaseCopy databaseCopy, bool allowInvalidDbCopy, bool fCheckDbReplicated, IConfigDataProvider session, ObjectId rootId, Task.TaskErrorLoggingDelegate writeError, LocalizedString mdbNotUniqueError, LocalizedString?singleDbCopyError, out Server server) { string databaseName = databaseCopy.DatabaseName; server = null; Database database = databaseCopy.GetDatabase <Database>(); DatabaseTasksHelper.CheckDatabaseForCopyTaskImpl(database, fCheckDbReplicated, writeError, singleDbCopyError); if (database.Recovery) { writeError(new InvalidOperationException(Strings.ErrorInvalidOperationOnRecoveryMailboxDatabase(database.Name)), ErrorCategory.InvalidOperation, database.Identity); } if (databaseCopy.HostServer != null) { MailboxServerIdParameter serverIdParam = new MailboxServerIdParameter(databaseCopy.HostServer); server = databaseCopy.Session.Read <Server>(databaseCopy.HostServer); DatabaseTasksHelper.CheckServerObjectForCopyTask(serverIdParam, writeError, server); return; } if (!allowInvalidDbCopy && !databaseCopy.IsHostServerValid) { writeError(new InvalidOperationException(Strings.ErrorDbCopyHostServerInvalid(databaseCopy.Name)), ErrorCategory.InvalidData, databaseCopy); } }
private void RollbackOperation(MailboxDatabase mdb, DatabaseCopy dbCopy, ADSystemMailbox systemMailbox) { if (mdb == null || dbCopy == null) { if (systemMailbox != null) { try { base.WriteVerbose(Strings.VerboseDeleteSystemMailbox(systemMailbox.Id.ToString())); this.RecipientSessionForSystemMailbox.Delete(systemMailbox); } catch (DataSourceTransientException ex) { this.WriteWarning(Strings.FailedToDeleteSystemMailbox(systemMailbox.Identity.ToString(), ex.Message)); TaskLogger.Trace("Failed to delete System Mailbox {0} when rolling back created database object '{1}'. {2}", new object[] { systemMailbox.Identity, mdb.Identity, ex.ToString() }); } catch (DataSourceOperationException ex2) { this.WriteWarning(Strings.FailedToDeleteSystemMailbox(systemMailbox.Identity.ToString(), ex2.Message)); TaskLogger.Trace("Failed to delete System Mailbox {0} when rolling back created database object '{1}'. {2}", new object[] { systemMailbox.Identity, mdb.Identity, ex2.ToString() }); } } if (dbCopy != null) { try { base.WriteVerbose(Strings.VerboseDeleteDBCopy(dbCopy.Id.ToString())); base.DataSession.Delete(dbCopy); } catch (DataSourceTransientException ex3) { this.WriteWarning(Strings.FailedToDeleteDatabaseCopy(dbCopy.Identity.ToString(), ex3.Message)); TaskLogger.Trace("Failed to delete Database Copy {0} when rolling back created database object '{1}'. {2}", new object[] { dbCopy.Identity, mdb.Identity, ex3.ToString() }); } catch (DataSourceOperationException ex4) { this.WriteWarning(Strings.FailedToDeleteDatabaseCopy(dbCopy.Identity.ToString(), ex4.Message)); TaskLogger.Trace("Failed to delete Database Copy {0} when rolling back created database object '{1}'. {2}", new object[] { dbCopy.Identity, mdb.Identity, ex4.ToString() }); } } if (mdb != null) { try { base.WriteVerbose(Strings.VerboseDeleteMDB(mdb.Id.ToString())); base.DataSession.Delete(mdb); DatabaseTasksHelper.RemoveDatabaseFromClusterDB((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), mdb); } catch (DataSourceTransientException ex5) { this.WriteWarning(Strings.FailedToDeleteMailboxDatabase(mdb.Identity.ToString(), ex5.Message)); TaskLogger.Trace("Failed to delete Mailbox Database {0} when rolling back. {1}", new object[] { mdb.Identity, ex5.ToString() }); } catch (DataSourceOperationException ex6) { this.WriteWarning(Strings.FailedToDeleteMailboxDatabase(mdb.Identity.ToString(), ex6.Message)); TaskLogger.Trace("Failed to delete Mailbox Database {0} when rolling back. {1}", new object[] { mdb.Identity, ex6.ToString() }); } catch (ClusterException ex7) { this.WriteWarning(Strings.FailedToDeleteMailboxDatabase(mdb.Identity.ToString(), ex7.Message)); TaskLogger.Trace("Failed to delete Mailbox Database {0} when rolling back. {1}", new object[] { mdb.Identity, ex7.ToString() }); } } } }
private void RunConfigurationUpdaterRpc(Database db) { DatabaseTasksHelper.RunConfigurationUpdaterRpcAsync(base.OwnerServer.Fqdn, db, ReplayConfigChangeHints.DbCopyAdded, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); }
private void SendNotificationRpcToReplayService() { DatabaseTasksHelper.RunConfigurationUpdaterRpc(this.OwnerServer.Fqdn, this.DataObject, this.OwnerServer.AdminDisplayVersion, ReplayConfigChangeHints.MoveDatabasePathConfigChanged, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning)); }