protected override void InternalProcessRecord()
{
TaskLogger.LogEnter(new object[]
{
this.Identity
});
DatabaseAvailabilityGroup databaseAvailabilityGroup = null;
ITopologyConfigurationSession globalConfigSession = base.GlobalConfigSession;
if (this.DatabaseAvailabilityGroup != null)
{
databaseAvailabilityGroup = this.LookupDag(this.DatabaseAvailabilityGroup);
}
else if (this.Identity != null)
{
ADObjectId adobjectId = this.LookupIdentityObjectAndGetDagId();
databaseAvailabilityGroup = globalConfigSession.Read <DatabaseAvailabilityGroup>(adobjectId);
if (databaseAvailabilityGroup == null)
{
base.WriteError(new ManagementObjectNotFoundException(Strings.ErrorDagNotFound(adobjectId.Name)), ErrorCategory.InvalidData, adobjectId);
}
}
string serverToQueryFqdn = this.DiscoverServerToQuery(this.ServerToContact, databaseAvailabilityGroup);
HealthInfoPersisted dagHealthInfo = this.GetDagHealthInfo(serverToQueryFqdn);
this.WriteResultsFromHealthInfo(dagHealthInfo, serverToQueryFqdn);
}
private AmServerName GetPrimaryActiveManager(DatabaseAvailabilityGroup dag)
{
Exception ex = null;
AmServerName result = null;
try
{
result = DagTaskHelper.GetPrimaryActiveManagerNode(dag);
}
catch (AmFailedToDeterminePAM amFailedToDeterminePAM)
{
ex = amFailedToDeterminePAM;
}
catch (AmServerException ex2)
{
ex = ex2;
}
catch (AmServerTransientException ex3)
{
ex = ex3;
}
if (ex != null)
{
base.WriteError(new PAMCouldNotBeDeterminedException(dag.Name, ex.Message, ex), ErrorCategory.ConnectionError, dag);
return(null);
}
return(result);
}
private void CheckDagMembership()
{
ADObjectId databaseAvailabilityGroup = this.m_server.DatabaseAvailabilityGroup;
if (ADObjectId.IsNullOrEmpty(databaseAvailabilityGroup))
{
base.WriteError(new AddDatabaseCopyNewCopyMustBeInDagException(this.m_server.Name, this.DataObject.Name), ErrorCategory.InvalidArgument, null);
}
DatabaseAvailabilityGroup databaseAvailabilityGroup2 = (DatabaseAvailabilityGroup)base.DataSession.Read <DatabaseAvailabilityGroup>(databaseAvailabilityGroup);
if (databaseAvailabilityGroup2 == null)
{
base.WriteError(new AddDatabaseCopyNewCopyMustBeInDagException(this.m_server.Name, this.DataObject.Name), ErrorCategory.InvalidArgument, null);
}
if (ThirdPartyReplicationMode.Enabled == databaseAvailabilityGroup2.ThirdPartyReplication)
{
this.m_isThirdPartyReplicationEnabled = true;
}
ITopologyConfigurationSession topologyConfigurationSession = (ITopologyConfigurationSession)base.DataSession;
foreach (DatabaseCopy databaseCopy in this.m_databaseCopies)
{
ADObjectId hostServer = databaseCopy.HostServer;
MiniServer miniServer = topologyConfigurationSession.ReadMiniServer(hostServer, AddMailboxDatabaseCopy.s_miniServerProperties);
ADObjectId databaseAvailabilityGroup3 = miniServer.DatabaseAvailabilityGroup;
if (ADObjectId.IsNullOrEmpty(databaseAvailabilityGroup3))
{
base.WriteError(new AddDatabaseCopyAllCopiesMustBeInTheDagException(this.DataObject.Name, this.m_server.Name, databaseAvailabilityGroup2.Name, miniServer.Name), ErrorCategory.InvalidArgument, null);
}
else if (!databaseAvailabilityGroup3.Equals(databaseAvailabilityGroup))
{
base.WriteError(new AddDatabaseCopyAllCopiesMustBeInSameDagException(this.DataObject.Name, this.m_server.Name, databaseAvailabilityGroup2.Name, miniServer.Name, databaseAvailabilityGroup3.Name), ErrorCategory.InvalidArgument, null);
}
}
}
protected void PerformSeedIfNecessary()
{
TDataObject dataObject = this.DataObject;
IIdentityParameter id = new DatabaseIdParameter(dataObject.Id);
IConfigDataProvider dataSession = base.DataSession;
ObjectId rootId = this.RootId;
TDataObject dataObject2 = this.DataObject;
LocalizedString? notFoundError = new LocalizedString?(Strings.ErrorDatabaseNotFound(dataObject2.Name));
TDataObject dataObject3 = this.DataObject;
Database database = (Database)base.GetDataObject <Database>(id, dataSession, rootId, notFoundError, new LocalizedString?(Strings.ErrorDatabaseNotUnique(dataObject3.Name)));
IADDatabaseAvailabilityGroup dag = null;
if (this.m_server.DatabaseAvailabilityGroup != null)
{
DatabaseAvailabilityGroup dag2 = this.ConfigurationSession.Read <DatabaseAvailabilityGroup>(this.m_server.DatabaseAvailabilityGroup);
dag = ADObjectWrapperFactory.CreateWrapper(dag2);
}
ReplayConfiguration config = RemoteReplayConfiguration.TaskGetReplayConfig(dag, ADObjectWrapperFactory.CreateWrapper(database), ADObjectWrapperFactory.CreateWrapper(this.m_server));
if (this.m_fSeeding)
{
this.SeedDatabase(config);
}
this.SuspendDatabaseCopyIfNecessary(config);
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
DatabaseAvailabilityGroupNetwork dataObject = this.DataObject;
IConfigurationSession configSession = this.SetupAdSession();
DatabaseAvailabilityGroup databaseAvailabilityGroup = DagTaskHelper.DagIdParameterToDag(this.DatabaseAvailabilityGroup, configSession);
DagTaskHelper.VerifyDagAndServersAreWithinScopes <DatabaseAvailabilityGroupNetwork>(this, databaseAvailabilityGroup, true);
if (databaseAvailabilityGroup.IsDagEmpty())
{
base.WriteError(new DagNetworkEmptyDagException(databaseAvailabilityGroup.Name), ErrorCategory.InvalidArgument, null);
}
DagTaskHelper.PreventTaskWhenAutoNetConfigIsEnabled(databaseAvailabilityGroup, this);
DagNetworkObjectId identity = new DagNetworkObjectId(databaseAvailabilityGroup.Name, dataObject.Name);
dataObject.SetIdentity(identity);
DagNetworkConfigDataProvider dagNetworkConfigDataProvider = (DagNetworkConfigDataProvider)base.DataSession;
DagNetworkConfiguration dagNetworkConfiguration = dagNetworkConfigDataProvider.ReadNetConfig(databaseAvailabilityGroup);
DatabaseAvailabilityGroupNetwork databaseAvailabilityGroupNetwork = dagNetworkConfiguration.FindNetwork(dataObject.Name);
if (databaseAvailabilityGroupNetwork != null)
{
throw new DagNetworkManagementException(ServerStrings.DagNetworkCreateDupName(dataObject.Name));
}
DagNetworkValidation.ValidateSwitches(dataObject, new Task.TaskErrorLoggingDelegate(base.WriteError));
if (base.Fields["Subnets"] != null)
{
DagNetworkValidation.ValidateSubnets(this.Subnets, dagNetworkConfiguration, this.Name, null, new Task.TaskErrorLoggingDelegate(base.WriteError), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose));
dataObject.ReplaceSubnets(this.Subnets);
}
TaskLogger.LogExit();
}
public static MultiValuedProperty <ADObjectId> GetDagServers(object dagList, object dagIdentity)
{
if (dagList == null)
{
throw new ArgumentNullException("dagList");
}
if (!(dagList is IList))
{
throw new ArgumentException("dagList");
}
if (dagIdentity == null)
{
throw new ArgumentNullException("dagIdentity");
}
MultiValuedProperty <ADObjectId> multiValuedProperty = new MultiValuedProperty <ADObjectId>();
foreach (object obj in ((IList)dagList))
{
DatabaseAvailabilityGroup databaseAvailabilityGroup = (DatabaseAvailabilityGroup)obj;
if (databaseAvailabilityGroup != null && databaseAvailabilityGroup.Identity.Equals(dagIdentity))
{
using (MultiValuedProperty <ADObjectId> .Enumerator enumerator2 = databaseAvailabilityGroup.Servers.GetEnumerator())
{
while (enumerator2.MoveNext())
{
ADObjectId item = enumerator2.Current;
multiValuedProperty.Add(item);
}
break;
}
}
}
multiValuedProperty.ResetChangeTracking();
return(multiValuedProperty);
}
private ADDatabaseAvailabilityGroupWrapper(DatabaseAvailabilityGroup dag) : base(dag)
{
this.DatacenterActivationMode = (DatacenterActivationModeOption)dag[DatabaseAvailabilityGroupSchema.DataCenterActivationMode];
this.ThirdPartyReplication = (ThirdPartyReplicationMode)dag[DatabaseAvailabilityGroupSchema.ThirdPartyReplication];
this.Servers = (MultiValuedProperty <ADObjectId>)dag[DatabaseAvailabilityGroupSchema.Servers];
this.StoppedMailboxServers = (MultiValuedProperty <string>)dag[DatabaseAvailabilityGroupSchema.StoppedMailboxServers];
this.StartedMailboxServers = (MultiValuedProperty <string>)dag[DatabaseAvailabilityGroupSchema.StartedMailboxServers];
this.AutoDagVolumesRootFolderPath = (NonRootLocalLongFullPath)dag[DatabaseAvailabilityGroupSchema.AutoDagVolumesRootFolderPath];
this.AutoDagDatabasesRootFolderPath = (NonRootLocalLongFullPath)dag[DatabaseAvailabilityGroupSchema.AutoDagDatabasesRootFolderPath];
this.AutoDagDatabaseCopiesPerVolume = (int)dag[DatabaseAvailabilityGroupSchema.AutoDagDatabaseCopiesPerVolume];
this.AutoDagDatabaseCopiesPerDatabase = (int)dag[DatabaseAvailabilityGroupSchema.AutoDagDatabaseCopiesPerDatabase];
this.AutoDagTotalNumberOfDatabases = (int)dag[DatabaseAvailabilityGroupSchema.AutoDagTotalNumberOfDatabases];
this.AutoDagTotalNumberOfServers = (int)dag[DatabaseAvailabilityGroupSchema.AutoDagTotalNumberOfServers];
this.ReplayLagManagerEnabled = (bool)dag[DatabaseAvailabilityGroupSchema.ReplayLagManagerEnabled];
this.AutoDagAutoReseedEnabled = (bool)dag[DatabaseAvailabilityGroupSchema.AutoDagAutoReseedEnabled];
this.AutoDagDiskReclaimerEnabled = (bool)dag[DatabaseAvailabilityGroupSchema.AutoDagDiskReclaimerEnabled];
this.AutoDagBitlockerEnabled = (bool)dag[DatabaseAvailabilityGroupSchema.AutoDagBitlockerEnabled];
this.AutoDagFIPSCompliant = (bool)dag[DatabaseAvailabilityGroupSchema.AutoDagFIPSCompliant];
this.AllowCrossSiteRpcClientAccess = ((int)dag[DatabaseAvailabilityGroupSchema.AllowCrossSiteRpcClientAccess] != 0);
this.ReplicationPort = dag.ReplicationPort;
long networkSettings = (long)dag[DatabaseAvailabilityGroupSchema.NetworkSettings];
DatabaseAvailabilityGroup.NetworkOption networkCompression;
DatabaseAvailabilityGroup.NetworkOption networkEncryption;
bool manualDagNetworkConfiguration;
DatabaseAvailabilityGroup.DecodeNetworkSettings(networkSettings, out networkCompression, out networkEncryption, out manualDagNetworkConfiguration);
this.NetworkCompression = networkCompression;
this.NetworkEncryption = networkEncryption;
this.ManualDagNetworkConfiguration = manualDagNetworkConfiguration;
}
private void InternalValidateDatabaseMode()
{
base.InternalValidate();
if (base.HasErrors)
{
return;
}
this.m_database = this.DataObject.GetDatabase <Database>();
this.m_dbCopyName = string.Format("{0}\\{1}", this.m_database.Name, this.m_server.Name);
if (this.m_database.ReplicationType != ReplicationType.Remote)
{
base.WriteError(new InvalidRCROperationOnNonRcrDB(this.m_database.Name), ErrorCategory.InvalidOperation, this.Identity);
}
if (this.CancelSeed)
{
ExTraceGlobals.CmdletsTracer.TraceDebug <string>((long)this.GetHashCode(), "UpdateDatabaseCopy: CancelSeed called for database copy '{0}'", this.m_dbCopyName);
base.WriteVerbose(Strings.SeederCancelCalled(this.m_dbCopyName));
}
if (this.SourceServer != null)
{
this.m_sourceServer = (Server)base.GetDataObject <Server>(this.SourceServer, base.DataSession, null, new LocalizedString?(Strings.ErrorServerNotFound(this.SourceServer.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(this.SourceServer.ToString())));
if (!this.m_sourceServer.IsMailboxServer)
{
base.WriteError(new OperationOnlyOnMailboxServerException(this.m_sourceServer.Name), ErrorCategory.InvalidOperation, this.Identity);
}
if (this.m_sourceServer.MajorVersion != Microsoft.Exchange.Data.Directory.SystemConfiguration.Server.CurrentExchangeMajorVersion)
{
base.WriteError(new DagTaskErrorServerWrongVersion(this.m_sourceServer.Name), ErrorCategory.InvalidOperation, this.Identity);
}
}
DatabaseAvailabilityGroup dagForDatabase = DagTaskHelper.GetDagForDatabase(this.m_database, base.DataSession, new Task.TaskErrorLoggingDelegate(base.WriteError));
DagTaskHelper.PreventTaskWhenTPREnabled(dagForDatabase, this);
}
private void BuildReplayConfigurations(DatabaseAvailabilityGroup dag, IADServer server)
{
IADDatabaseAvailabilityGroup dag2 = null;
if (dag != null)
{
dag2 = ADObjectWrapperFactory.CreateWrapper(dag);
}
List <ReplayConfiguration> list;
List <ReplayConfiguration> list2;
ReplayConfigurationHelper.TaskConstructAllDatabaseConfigurations(dag2, server, out list, out list2);
if (list != null && list.Count > 0)
{
ExTraceGlobals.CmdletsTracer.TraceDebug((long)this.GetHashCode(), "BuildReplayConfigurations(): Found RCR Source Configurations.");
this.m_serverConfigBitfield |= ServerConfig.RcrSource;
this.m_replayConfigs.AddRange(list);
}
if (list2 != null && list2.Count > 0)
{
ExTraceGlobals.CmdletsTracer.TraceDebug((long)this.GetHashCode(), "BuildReplayConfigurations(): Found RCR Target Configurations.");
this.m_serverConfigBitfield |= ServerConfig.RcrTarget;
this.m_replayConfigs.AddRange(list2);
}
if (this.AreConfigBitsSet(ServerConfig.DagMember) && !this.AreConfigBitsSet(ServerConfig.RcrSource) && !this.AreConfigBitsSet(ServerConfig.RcrTarget))
{
ExTraceGlobals.CmdletsTracer.TraceDebug((long)this.GetHashCode(), "BuildReplayConfigurations(): Server is a DAG member but has no Database copies.");
this.m_serverConfigBitfield |= ServerConfig.DagMemberNoDatabases;
}
ExTraceGlobals.CmdletsTracer.TraceDebug <string>((long)this.GetHashCode(), "BuildReplayConfigurations(): The following bits are set on localConfigBitfield: {0}", this.m_serverConfigBitfield.ToString());
}
public static ADObjectId[] GetServersInDag(object dagList, object dagIdentity)
{
if (dagList == null)
{
throw new ArgumentNullException("dagList");
}
if (!(dagList is IList))
{
throw new ArgumentException("dagList");
}
if (dagIdentity == null)
{
throw new ArgumentNullException("dagIdentity");
}
List <ADObjectId> list = new List <ADObjectId>();
foreach (object obj in ((IList)dagList))
{
DatabaseAvailabilityGroup databaseAvailabilityGroup = (DatabaseAvailabilityGroup)obj;
if (databaseAvailabilityGroup != null && !databaseAvailabilityGroup.Identity.Equals(dagIdentity))
{
list.AddRange(databaseAvailabilityGroup.Servers);
}
}
return(list.ToArray());
}
private void ResolveDag()
{
foreach (DatabaseAvailabilityGroupIdParameter databaseAvailabilityGroupIdParameter in this.Dag)
{
DatabaseAvailabilityGroup dag = base.GetDataObject <DatabaseAvailabilityGroup>(databaseAvailabilityGroupIdParameter, this.session, null, new LocalizedString?(Strings.ErrorDagNotFound(databaseAvailabilityGroupIdParameter.ToString())), new LocalizedString?(Strings.ErrorDagNotUnique(databaseAvailabilityGroupIdParameter.ToString()))) as DatabaseAvailabilityGroup;
this.impl.ResolveDag(dag);
}
}
public static ADDatabaseAvailabilityGroupWrapper CreateWrapper(DatabaseAvailabilityGroup dag)
{
if (dag == null)
{
return(null);
}
return(new ADDatabaseAvailabilityGroupWrapper(dag));
}
private void ApplyLoadBalanceSettingValuesToDatabase(MailboxDatabase database, DirectoryDatabase directoryDatabase)
{
QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Id, database.MasterServerOrAvailabilityGroup);
DatabaseAvailabilityGroup ownerDag = this.ConfigurationSession.Find <DatabaseAvailabilityGroup>(null, QueryScope.SubTree, filter, null, 1).FirstOrDefault <DatabaseAvailabilityGroup>();
directoryDatabase.RelativeLoadCapacity = this.GetRelativeLoadCapacityForDatabase(database, ownerDag);
directoryDatabase.MaximumSize = this.GetMaximumFileSizeForDatabase(database, ownerDag);
}
public static DagNetworkConfiguration GetDagNetworkConfig(DatabaseAvailabilityGroup dag)
{
DagNetworkConfiguration dagNetworkConfiguration = null;
if (dag.Servers.Count == 0)
{
return(null);
}
Exception ex = null;
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 85, "GetDagNetworkConfig", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\Cluster\\DagNetworkClientRpc.cs");
topologyConfigurationSession.UseConfigNC = false;
topologyConfigurationSession.UseGlobalCatalog = true;
foreach (ADObjectId adobjectId in dag.Servers)
{
try
{
ADComputer adcomputer = topologyConfigurationSession.FindComputerByHostName(adobjectId.Name);
if (adcomputer != null && !string.IsNullOrEmpty(adcomputer.DnsHostName))
{
if (dag.DatacenterActivationMode != DatacenterActivationModeOption.DagOnly || !dag.StoppedMailboxServers.Contains(adcomputer.DnsHostName, StringComparer.OrdinalIgnoreCase))
{
dagNetworkConfiguration = DagNetworkRpc.GetDagNetworkConfig(adcomputer.DnsHostName);
if (dagNetworkConfiguration != null)
{
break;
}
}
}
}
catch (TaskServerTransientException ex2)
{
ex = ex2;
}
catch (TaskServerException ex3)
{
ex = ex3;
}
catch (ADTransientException ex4)
{
ex = ex4;
}
catch (ADExternalException ex5)
{
ex = ex5;
}
catch (ADOperationException ex6)
{
ex = ex6;
}
}
if (dagNetworkConfiguration == null && ex != null)
{
throw ex;
}
return(dagNetworkConfiguration);
}
private List <DatabaseAvailabilityGroupNetwork> Find(QueryFilter queryFilter, ObjectId rootId, bool deepSearch, SortBy sortBy)
{
List <DatabaseAvailabilityGroupNetwork> list = new List <DatabaseAvailabilityGroupNetwork>();
DagNetworkQueryFilter dagNetworkQueryFilter = null;
if (queryFilter != null)
{
dagNetworkQueryFilter = (queryFilter as DagNetworkQueryFilter);
}
IEnumerable <DatabaseAvailabilityGroup> enumerable;
if (this.TargetDag != null)
{
enumerable = new DatabaseAvailabilityGroup[]
{
this.TargetDag
};
}
else
{
string identity = "*";
if (dagNetworkQueryFilter != null && dagNetworkQueryFilter.NamesToMatch != null && dagNetworkQueryFilter.NamesToMatch.DagName != null)
{
identity = dagNetworkQueryFilter.NamesToMatch.DagName;
}
DatabaseAvailabilityGroupIdParameter databaseAvailabilityGroupIdParameter = DatabaseAvailabilityGroupIdParameter.Parse(identity);
enumerable = databaseAvailabilityGroupIdParameter.GetObjects <DatabaseAvailabilityGroup>(null, this.m_adSession);
}
if (enumerable != null)
{
Regex regex = null;
if (dagNetworkQueryFilter != null && dagNetworkQueryFilter.NamesToMatch != null && dagNetworkQueryFilter.NamesToMatch.NetName != null)
{
string pattern = Wildcard.ConvertToRegexPattern(dagNetworkQueryFilter.NamesToMatch.NetName);
regex = new Regex(pattern, RegexOptions.IgnoreCase);
}
foreach (DatabaseAvailabilityGroup databaseAvailabilityGroup in enumerable)
{
DagNetworkConfiguration dagNetworkConfiguration = (this.m_targetServer == null) ? DagNetworkRpc.GetDagNetworkConfig(databaseAvailabilityGroup) : DagNetworkRpc.GetDagNetworkConfig(this.m_targetServer);
if (dagNetworkConfiguration != null && dagNetworkConfiguration.Networks != null)
{
this.m_netConfig = dagNetworkConfiguration;
foreach (DatabaseAvailabilityGroupNetwork databaseAvailabilityGroupNetwork in dagNetworkConfiguration.Networks)
{
if (regex == null || regex.IsMatch(databaseAvailabilityGroupNetwork.Name))
{
DagNetworkObjectId identity2 = new DagNetworkObjectId(databaseAvailabilityGroup.Name, databaseAvailabilityGroupNetwork.Name);
databaseAvailabilityGroupNetwork.SetIdentity(identity2);
databaseAvailabilityGroupNetwork.ResetChangeTracking();
list.Add(databaseAvailabilityGroupNetwork);
}
}
}
}
}
return(list);
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
try
{
ExTraceGlobals.CmdletsTracer.TraceDebug <string, DatabaseCopyIdParameter>((long)this.GetHashCode(), "DatabaseCopyStateAction: enter InternalValidate(DB,ident): {0}, {1}", base.DatabaseName, this.Identity);
base.InternalValidate();
if (base.HasErrors)
{
TaskLogger.LogExit();
}
else
{
Database database = this.DataObject.GetDatabase <Database>();
DatabaseAvailabilityGroup dagForDatabase = DagTaskHelper.GetDagForDatabase(database, base.DataSession, new Task.TaskErrorLoggingDelegate(base.WriteError));
DagTaskHelper.PreventTaskWhenTPREnabled(dagForDatabase, this);
this.m_UseRpc = ReplayRpcVersionControl.IsSuspendRpcSupported(this.Server.AdminDisplayVersion);
ServerVersion serverVersion = this.IsReplayLagManagementOperation ? ReplayRpcVersionControl.GetCopyStatusEx4RpcSupportVersion : ReplayRpcVersionControl.SuspendRpcSupportVersion;
if (this.m_UseRpc)
{
if (this.IsSuspendOperation)
{
base.WriteVerbose(Strings.SuspendSgcUseRpc(this.Server.AdminDisplayVersion.ToString(), serverVersion.ToString()));
}
else
{
base.WriteVerbose(Strings.ResumeSgcUseRpc(this.Server.AdminDisplayVersion.ToString(), serverVersion.ToString()));
}
}
else if (this.IsReplayLagManagementOperation)
{
base.WriteError(new ReplayLagRpcUnsupportedException(this.Server.Name, this.Server.AdminDisplayVersion.ToString(), ReplayRpcVersionControl.GetCopyStatusEx4RpcSupportVersion.ToString()), ExchangeErrorCategory.ServerOperation, this.Server);
}
else if (this.IsSuspendOperation)
{
base.WriteVerbose(Strings.SuspendSgcUseState(this.Server.Name, this.Server.AdminDisplayVersion.ToString(), ReplayRpcVersionControl.SuspendRpcSupportVersion.ToString()));
}
else
{
base.WriteVerbose(Strings.ResumeSgcUseState(this.Server.Name, this.Server.AdminDisplayVersion.ToString(), ReplayRpcVersionControl.SuspendRpcSupportVersion.ToString()));
}
this.IsActivationRpcSupported = ReplayRpcVersionControl.IsActivationRpcSupported(this.Server.AdminDisplayVersion);
this.IsRequestSuspend3RpcSupported = ReplayRpcVersionControl.IsRequestSuspend3RpcSupported(this.Server.AdminDisplayVersion);
this.IsOperationRunOnSource = false;
DatabaseLocationInfo databaseLocationInfo;
if (database.ReplicationType == ReplicationType.Remote && RemoteReplayConfiguration.IsServerRcrSource(ADObjectWrapperFactory.CreateWrapper(database), ADObjectWrapperFactory.CreateWrapper(this.Server), out databaseLocationInfo))
{
this.IsOperationRunOnSource = true;
}
ExTraceGlobals.CmdletsTracer.TraceDebug <string>((long)this.GetHashCode(), "DatabaseCopyStateAction: leave InternalValidate: {0}", base.DatabaseName);
}
}
finally
{
TaskLogger.LogExit();
}
}
public override void ResolveDag(DatabaseAvailabilityGroup dag)
{
foreach (Server server in this.GetAllServersInForest())
{
if (dag.Id.Equals(server.DatabaseAvailabilityGroup))
{
this.ResolveServer(server);
}
}
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
if (this.preExistingDatabase != null)
{
TaskLogger.LogExit();
return;
}
if (this.PublicFolderDatabase == null)
{
if (base.OwnerServerPublicFolderDatabases != null && base.OwnerServerPublicFolderDatabases.Length > 0)
{
this.DataObject.PublicFolderDatabase = (ADObjectId)base.OwnerServerPublicFolderDatabases[0].Identity;
}
else
{
base.WriteVerbose(Strings.VerboseFindClosestPublicFolderDatabaseFromServer(base.OwnerServer.Id.ToString()));
this.DataObject.PublicFolderDatabase = Microsoft.Exchange.Data.Directory.SystemConfiguration.PublicFolderDatabase.FindClosestPublicFolderDatabase(base.DataSession, base.OwnerServer.Id);
}
}
else
{
this.PublicFolderDatabase.AllowLegacy = true;
IConfigurable dataObject = base.GetDataObject <PublicFolderDatabase>(this.PublicFolderDatabase, base.DataSession, null, new LocalizedString?(Strings.ErrorPublicFolderDatabaseNotFound(this.PublicFolderDatabase.ToString())), new LocalizedString?(Strings.ErrorPublicFolderDatabaseNotUnique(this.PublicFolderDatabase.ToString())));
this.DataObject.PublicFolderDatabase = (ADObjectId)dataObject.Identity;
}
if (this.OfflineAddressBook != null)
{
IConfigurable dataObject2 = base.GetDataObject <OfflineAddressBook>(this.OfflineAddressBook, base.DataSession, null, new LocalizedString?(Strings.ErrorOfflineAddressBookNotFound(this.OfflineAddressBook.ToString())), new LocalizedString?(Strings.ErrorOfflineAddressBookNotUnique(this.OfflineAddressBook.ToString())));
this.DataObject.OfflineAddressBook = (ADObjectId)dataObject2.Identity;
}
base.ValidateFilePaths(base.ParameterSetName == "Recovery");
if (base.Fields.IsModified("AutoDagExcludeFromMonitoring"))
{
this.DataObject.AutoDagExcludeFromMonitoring = this.AutoDagExcludeFromMonitoring;
}
else
{
DatabaseAvailabilityGroup databaseAvailabilityGroup = DagTaskHelper.ReadDag(this.DataObject.MasterServerOrAvailabilityGroup, this.ConfigurationSession);
if (databaseAvailabilityGroup != null)
{
DatabaseAvailabilityGroupConfiguration databaseAvailabilityGroupConfiguration = DagConfigurationHelper.ReadDagConfig(databaseAvailabilityGroup.DatabaseAvailabilityGroupConfiguration, this.ConfigurationSession);
if (databaseAvailabilityGroupConfiguration != null)
{
DagConfigurationHelper dagConfigurationHelper = DagConfigurationHelper.Deserialize(databaseAvailabilityGroupConfiguration.ConfigurationXML);
if (dagConfigurationHelper.MinCopiesPerDatabaseForMonitoring > 1)
{
this.DataObject.AutoDagExcludeFromMonitoring = true;
}
}
}
}
TaskLogger.LogExit();
}
internal ReplayConfiguration ConstructReplayConfiguration(Database database)
{
IADDatabaseAvailabilityGroup dag = null;
if (this.m_server.DatabaseAvailabilityGroup != null)
{
DatabaseAvailabilityGroup dag2 = this.ConfigurationSession.Read <DatabaseAvailabilityGroup>(this.m_server.DatabaseAvailabilityGroup);
dag = ADObjectWrapperFactory.CreateWrapper(dag2);
}
return(RemoteReplayConfiguration.TaskGetReplayConfig(dag, ADObjectWrapperFactory.CreateWrapper(database), ADObjectWrapperFactory.CreateWrapper(this.m_server)));
}
private int GetRelativeLoadCapacityForDatabase(MailboxDatabase database, DatabaseAvailabilityGroup ownerDag)
{
if (database.MailboxLoadBalanceRelativeLoadCapacity != null)
{
return(database.MailboxLoadBalanceRelativeLoadCapacity.Value);
}
if (ownerDag != null && ownerDag.MailboxLoadBalanceRelativeLoadCapacity != null)
{
return(ownerDag.MailboxLoadBalanceRelativeLoadCapacity.Value);
}
return(this.settings.DefaultDatabaseRelativeLoadCapacity);
}
public IADDatabaseAvailabilityGroup FindDagByServer(IADServer server)
{
if (server != null)
{
ADObjectId databaseAvailabilityGroup = server.DatabaseAvailabilityGroup;
if (databaseAvailabilityGroup != null && !databaseAvailabilityGroup.IsDeleted)
{
DatabaseAvailabilityGroup dag = this.m_session.Read <DatabaseAvailabilityGroup>(databaseAvailabilityGroup);
return(ADObjectWrapperFactory.CreateWrapper(dag));
}
}
return(null);
}
private ByteQuantifiedSize GetMaximumDatabaseFileSizeForDag(DatabaseAvailabilityGroup dag)
{
ByteQuantifiedSize result;
if (dag != null && dag.MailboxLoadBalanceMaximumEdbFileSize != null)
{
result = dag.MailboxLoadBalanceMaximumEdbFileSize.Value;
}
else
{
result = ByteQuantifiedSize.FromGB((ulong)this.settings.DefaultDatabaseMaxSizeGb);
}
return(result);
}
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);
}
public static void SetDagNetwork(DatabaseAvailabilityGroup dag, SetDagNetworkRequest change)
{
if (dag.Servers.Count == 0)
{
return;
}
AmPamInfo primaryActiveManager = AmRpcClientHelper.GetPrimaryActiveManager(ADObjectWrapperFactory.CreateWrapper(dag));
string targetServerName = primaryActiveManager.ServerName;
byte[] changeAsBytes = Serialization.ObjectToBytes(change);
DagNetworkRpc.RunRpcOperation(targetServerName, delegate(ReplayRpcClient rpcClient)
{
ExTraceGlobals.DatabaseAvailabilityGroupTracer.TraceDebug <string>(0L, "SetDagNetwork sending RPC to {0}", targetServerName);
return(rpcClient.SetDagNetwork(changeAsBytes));
});
}
// Token: 0x06000815 RID: 2069 RVA: 0x00020EB8 File Offset: 0x0001F0B8
private void ResolveMasterServerOrDag()
{
if (this.serversList == null)
{
Database database = this.InvokeResourceForest <Database>(() => this.configSession.FindDatabaseByGuid <Database>(this.DatabaseGuid));
if (database == null)
{
throw new DatabaseNotFoundException(this.DatabaseGuid.ToString());
}
ADObjectId masterServerOrDag = null;
if (database.ExchangeVersion.IsOlderThan(ExchangeObjectVersion.Exchange2010))
{
masterServerOrDag = database.Server;
}
else
{
masterServerOrDag = database.MasterServerOrAvailabilityGroup;
}
if (masterServerOrDag == null)
{
return;
}
if (database.MasterType == MasterType.DatabaseAvailabilityGroup)
{
DatabaseAvailabilityGroup databaseAvailabilityGroup = this.InvokeResourceForest <DatabaseAvailabilityGroup>(() => this.configSession.Read <DatabaseAvailabilityGroup>(masterServerOrDag));
this.Tracer.TraceDebug <Guid, string>((long)this.GetHashCode(), "[MailboxServerLocator.ResolveMasterServerOrDag] Database {0} is mastered by DatabaseAvailabilityGroup {1}.", this.DatabaseGuid, databaseAvailabilityGroup.Id.ToString());
this.serversList = new List <ADObjectId>(databaseAvailabilityGroup.Servers);
}
else
{
this.serversList = new List <ADObjectId>
{
masterServerOrDag
};
}
}
this.masterServer = this.InvokeResourceForest <MiniServer>(() => this.SelectServerFromDag(this.configSession, this.serversList, this.contactedServers));
this.Tracer.TraceDebug <string>((long)this.GetHashCode(), "[MailboxServerLocator.ResolveMasterServerOrDag] To ServerLocatorService host to use is {0}.", (this.masterServer != null) ? this.masterServer.Fqdn : null);
}
private static IList <string> GetDagMembers(IConfigurationSession globalConfigSession, ADObjectId databaseAvailabilityGroupId)
{
List <string> list = new List <string>(5);
DatabaseAvailabilityGroup databaseAvailabilityGroup = globalConfigSession.Read <DatabaseAvailabilityGroup>(databaseAvailabilityGroupId);
if (databaseAvailabilityGroup == null)
{
TraceWrapper.SearchLibraryTracer.TraceError <ADObjectId>(0, "Null DAG object read for ADObjectId: {0}", databaseAvailabilityGroupId);
return(list);
}
if (databaseAvailabilityGroup.Servers == null)
{
TraceWrapper.SearchLibraryTracer.TraceError <ADObjectId>(0, "Servers attribute set to null for DAG-Id: {0}", databaseAvailabilityGroupId);
return(list);
}
foreach (ADObjectId adobjectId in databaseAvailabilityGroup.Servers)
{
Server server = globalConfigSession.Read <Server>(adobjectId);
if (server == null)
{
TraceWrapper.SearchLibraryTracer.TraceError <ADObjectId, ADObjectId>(0, "Null Server attribute was read for server-ID: {0} for DAG-Id: {1}", adobjectId, databaseAvailabilityGroupId);
TrackingFatalException.RaiseED(ErrorCode.InvalidADData, "NonExistent Object: {0}", new object[]
{
adobjectId
});
}
if (string.IsNullOrEmpty(server.Fqdn))
{
TraceWrapper.SearchLibraryTracer.TraceError <ADObjectId, ADObjectId>(0, "Null/Empty FQDN for server with ID: {0} for DAG-Id: {1}", adobjectId, databaseAvailabilityGroupId);
TrackingFatalException.RaiseED(ErrorCode.InvalidADData, "Missing FQDN: {0}", new object[]
{
adobjectId
});
}
TraceWrapper.SearchLibraryTracer.TraceDebug <string>(0, "Found server: {0}", server.Fqdn);
list.Add(server.Fqdn);
}
return(list);
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
DatabaseAvailabilityGroupNetwork dataObject = this.DataObject;
DagNetworkObjectId dagNetworkObjectId = (DagNetworkObjectId)dataObject.Identity;
ExTraceGlobals.CmdletsTracer.TraceError <string>((long)this.GetHashCode(), "Validating SetDAGNetwork({0})", dagNetworkObjectId.FullName);
IConfigurationSession configSession = this.SetupAdSession();
DatabaseAvailabilityGroup dag = DagTaskHelper.ReadDagByName(dagNetworkObjectId.DagName, configSession);
DagTaskHelper.VerifyDagAndServersAreWithinScopes <DatabaseAvailabilityGroupNetwork>(this, dag, true);
DagTaskHelper.PreventTaskWhenAutoNetConfigIsEnabled(dag, this);
DagNetworkConfigDataProvider dagNetworkConfigDataProvider = (DagNetworkConfigDataProvider)base.DataSession;
DagNetworkConfiguration networkConfig = dagNetworkConfigDataProvider.NetworkConfig;
DatabaseAvailabilityGroupNetwork databaseAvailabilityGroupNetwork = (DatabaseAvailabilityGroupNetwork)dataObject.GetOriginalObject();
string name = databaseAvailabilityGroupNetwork.Name;
DatabaseAvailabilityGroupNetwork networkBeingChanged = null;
foreach (DatabaseAvailabilityGroupNetwork databaseAvailabilityGroupNetwork2 in networkConfig.Networks)
{
if (databaseAvailabilityGroupNetwork2 == dataObject)
{
networkBeingChanged = databaseAvailabilityGroupNetwork2;
}
else if (DatabaseAvailabilityGroupNetwork.NameComparer.Equals(databaseAvailabilityGroupNetwork2.Name, dataObject.Name))
{
throw new DagNetworkManagementException(ServerStrings.DagNetworkRenameDupName(name, dataObject.Name));
}
}
DagNetworkValidation.ValidateSwitches(dataObject, new Task.TaskErrorLoggingDelegate(base.WriteError));
if (base.Fields["Subnets"] != null)
{
DagNetworkValidation.ValidateSubnets(this.Subnets, networkConfig, dataObject.Name, networkBeingChanged, new Task.TaskErrorLoggingDelegate(base.WriteError), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose));
dataObject.ReplaceSubnets(this.Subnets);
}
DagNetworkValidation.WarnIfAllNetsAreDisabled(networkConfig, new Task.TaskWarningLoggingDelegate(this.WriteWarning));
TaskLogger.LogExit();
}
protected override void InternalValidate()
{
TaskLogger.LogEnter();
base.InternalValidate();
this.m_output = new HaTaskOutputHelper("remove-databaseavailabilitygroupnetwork", new Task.TaskErrorLoggingDelegate(base.WriteError), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskProgressLoggingDelegate(base.WriteProgress), this.GetHashCode());
DatabaseAvailabilityGroupNetwork dataObject = base.DataObject;
DagNetworkObjectId dagNetworkObjectId = (DagNetworkObjectId)dataObject.Identity;
ExTraceGlobals.CmdletsTracer.TraceError <string>((long)this.GetHashCode(), "Validating RemoveDAGNetwork({0})", dagNetworkObjectId.FullName);
IConfigurationSession configSession = this.SetupAdSession();
DatabaseAvailabilityGroup dag = DagTaskHelper.ReadDagByName(dagNetworkObjectId.DagName, configSession);
DagTaskHelper.VerifyDagAndServersAreWithinScopes <DatabaseAvailabilityGroupNetwork>(this, dag, true);
DagTaskHelper.PreventTaskWhenAutoNetConfigIsEnabled(dag, this);
foreach (DatabaseAvailabilityGroupNetworkSubnet databaseAvailabilityGroupNetworkSubnet in dataObject.Subnets)
{
if (databaseAvailabilityGroupNetworkSubnet.State != DatabaseAvailabilityGroupNetworkSubnet.SubnetState.Unknown)
{
this.m_output.WriteErrorSimple(new DagNetworkManagementException(ServerStrings.DagNetworkCannotRemoveActiveSubnet(dataObject.Name)));
}
}
TaskLogger.LogExit();
}
private void ResolveTargets()
{
if (base.Fields.IsChanged("Server") && this.Server != null)
{
foreach (ServerIdParameter serverIdParameter in this.Server)
{
Server item = (Server)base.GetDataObject <Server>(serverIdParameter, base.RootOrgGlobalConfigSession, null, new LocalizedString?(Strings.ErrorServerNotFound(serverIdParameter.ToString())), new LocalizedString?(Strings.ErrorServerNotUnique(serverIdParameter.ToString())));
if (!this.servers.Contains(item))
{
this.servers.Add(item);
}
}
}
if (base.Fields.IsChanged("Dag") && this.Dag != null)
{
foreach (DatabaseAvailabilityGroupIdParameter databaseAvailabilityGroupIdParameter in this.Dag)
{
DatabaseAvailabilityGroup item2 = (DatabaseAvailabilityGroup)base.GetDataObject <DatabaseAvailabilityGroup>(databaseAvailabilityGroupIdParameter, base.RootOrgGlobalConfigSession, null, new LocalizedString?(Strings.ErrorDagNotFound(databaseAvailabilityGroupIdParameter.ToString())), new LocalizedString?(Strings.ErrorDagNotUnique(databaseAvailabilityGroupIdParameter.ToString())));
if (!this.dags.Contains(item2))
{
this.dags.Add(item2);
}
}
}
if (base.Fields.IsChanged("Site") && this.Site != null)
{
foreach (AdSiteIdParameter adSiteIdParameter in this.Site)
{
ADSite item3 = (ADSite)base.GetDataObject <ADSite>(adSiteIdParameter, base.RootOrgGlobalConfigSession, null, new LocalizedString?(Strings.ErrorSiteNotFound(adSiteIdParameter.ToString())), new LocalizedString?(Strings.ErrorSiteNotUnique(adSiteIdParameter.ToString())));
if (!this.sites.Contains(item3))
{
this.sites.Add(item3);
}
}
}
}
protected string DiscoverServerToQuery(ServerIdParameter serverToContactParam, DatabaseAvailabilityGroup dag)
{
string fqdn;
if (serverToContactParam == null)
{
AmServerName primaryActiveManager = this.GetPrimaryActiveManager(dag);
fqdn = primaryActiveManager.Fqdn;
}
else
{
Server server = this.LookupServer(serverToContactParam);
ADObjectId databaseAvailabilityGroup = server.DatabaseAvailabilityGroup;
if (databaseAvailabilityGroup == null)
{
base.WriteError(new ServerMustBeInDagException(server.Fqdn), ErrorCategory.InvalidData, serverToContactParam);
return(null);
}
if (!databaseAvailabilityGroup.Equals(dag.Id))
{
base.WriteError(new ServerToContactMustBeInSameDagException(server.Name, dag.Name, databaseAvailabilityGroup.Name), ErrorCategory.InvalidData, serverToContactParam);
return(null);
}
fqdn = server.Fqdn;
}
return(fqdn);
}
