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