// Token: 0x06000068 RID: 104 RVA: 0x00003979 File Offset: 0x00001B79
public MigrationMailboxCache(AnchorContext context)
{
AnchorUtil.ThrowOnNullArgument(context, "context");
this.Context = context;
this.LastRefreshed = DateTime.MinValue;
this.MigrationMailboxes = new Dictionary <Guid, BatchCreatorScheduler.MigrationMailbox>();
}
public DirectoryObject(IDirectoryProvider directory, DirectoryIdentity identity)
{
AnchorUtil.ThrowOnNullArgument(directory, "directory");
AnchorUtil.ThrowOnNullArgument(identity, "identity");
this.directory = directory;
this.Identity = identity;
}
public RegularLoadBalancingExtractorFactory(Band[] bands, IList <Guid> nonMovableOrganizations, ILogger logger) : base(logger)
{
AnchorUtil.ThrowOnNullArgument(bands, "bands");
AnchorUtil.ThrowOnNullArgument(nonMovableOrganizations, "nonMovableOrganizations");
this.Bands = bands;
this.NonMovableOrganizations = nonMovableOrganizations;
}
// Token: 0x0600005F RID: 95 RVA: 0x00003901 File Offset: 0x00001B01
public MigrationMailbox(ADUser user, DateTime lastRefreshed)
{
AnchorUtil.ThrowOnNullArgument(user, "user");
this.User = user;
this.LastRefreshed = lastRefreshed;
this.Exception = null;
}
public virtual bool TryLoad(IAnchorDataProvider dataProvider, StoreObjectId id, Action <IAnchorStoreObject> streamAction)
{
AnchorUtil.ThrowOnNullArgument(dataProvider, "dataProvider");
AnchorUtil.ThrowOnNullArgument(id, "id");
bool success = true;
AnchorUtil.RunTimedOperation(dataProvider.AnchorContext, delegate()
{
using (IAnchorStoreObject anchorStoreObject = this.FindStoreObject(dataProvider, id, this.PropertyDefinitions))
{
if (anchorStoreObject.GetValueOrDefault <string>(MigrationBatchMessageSchema.MigrationPersistableDictionary, null) == null)
{
success = false;
}
else
{
anchorStoreObject.Load(this.PropertyDefinitions);
if (!this.ReadFromMessageItem(anchorStoreObject))
{
success = false;
}
else
{
if (streamAction != null)
{
streamAction(anchorStoreObject);
}
this.LoadLinkedStoredObjects(anchorStoreObject, dataProvider);
}
}
}
}, this);
return(success);
}
public LoadEntity(DirectoryObject directoryObject)
{
AnchorUtil.ThrowOnNullArgument(directoryObject, "directoryObject");
this.DirectoryObject = directoryObject;
this.DirectoryObjectIdentity = directoryObject.Identity;
this.ConsumedLoad = new LoadMetricStorage();
}
// Token: 0x0600025C RID: 604 RVA: 0x00008ED4 File Offset: 0x000070D4
private void Initialize(MailboxSession mailboxSession, StoreObjectId id, PropertyDefinition[] properties)
{
bool flag = false;
try
{
AnchorUtil.ThrowOnNullArgument(mailboxSession, "dataProvider");
AnchorUtil.ThrowOnNullArgument(id, "id");
AnchorUtil.ThrowOnNullArgument(properties, "properties");
this.Message = MessageItem.Bind(mailboxSession, id, properties);
flag = true;
}
catch (ArgumentException ex)
{
base.AnchorContext.Logger.Log(MigrationEventType.Error, ex, "Encountered an argument exception when trying to find message with id={0}", new object[]
{
id.ToString()
});
throw new ObjectNotFoundException(ServerStrings.ExItemNotFound, ex);
}
finally
{
if (!flag)
{
this.Dispose();
}
}
}
private static ADObjectId GetADObjectIdImpl(IAnchorStoreObject item, StorePropertyDefinition propertyDefinition, bool useTryGet)
{
AnchorUtil.ThrowOnNullArgument(item, "item");
AnchorUtil.ThrowOnNullArgument(propertyDefinition, "propertyDefinition");
Exception innerException = null;
try
{
byte[] array;
if (useTryGet)
{
array = item.GetValueOrDefault <byte[]>(propertyDefinition, null);
if (array == null)
{
return(null);
}
}
else
{
array = (byte[])item[propertyDefinition];
}
return(new ADObjectId(array));
}
catch (CorruptDataException ex)
{
innerException = ex;
}
catch (ArgumentNullException ex2)
{
innerException = ex2;
}
throw new InvalidDataException(AnchorHelper.GetPropertyErrorMessage(propertyDefinition, null), innerException);
}
public InjectMoveRequest(string batchName, DirectoryMailbox mailbox, ILogger logger, bool protect, RequestPriority requestPriority, ADObjectId mailboxObjectId, DirectoryIdentity targetDatabaseIdentity, ILoadBalanceSettings settings, CmdletExecutionPool cmdletPool) : base("New-MoveRequest", cmdletPool, logger)
{
this.settings = settings;
this.TargetDatabase = targetDatabaseIdentity;
this.BatchName = batchName;
this.Mailbox = mailbox;
this.Protect = protect;
AnchorUtil.ThrowOnNullArgument(mailbox, "mailbox");
base.Command.AddParameter("Identity", mailboxObjectId);
base.Command.AddParameter("WorkloadType", RequestWorkloadType.LoadBalancing);
if (!string.IsNullOrWhiteSpace(batchName))
{
base.Command.AddParameter("BatchName", batchName);
}
if (targetDatabaseIdentity != null)
{
DatabaseIdParameter value = new DatabaseIdParameter(targetDatabaseIdentity.ADObjectId);
if (mailbox.IsArchiveOnly)
{
base.Command.AddParameter("ArchiveTargetDatabase", value);
base.Command.AddParameter("ArchiveOnly");
}
else
{
base.Command.AddParameter("TargetDatabase", value);
base.Command.AddParameter("PrimaryOnly");
}
}
base.Command.AddParameter("CompletedRequestAgeLimit", 0);
base.Command.AddParameter("Priority", requestPriority);
if (protect)
{
base.Command.AddParameter("Protect");
}
}
internal static void SetDictionaryProperty(IPropertyBag item, PropertyDefinition propertyDefinition, PersistableDictionary persistDictionary)
{
AnchorUtil.ThrowOnNullArgument(item, "item");
AnchorUtil.ThrowOnNullArgument(propertyDefinition, "propertyDefinition");
AnchorUtil.ThrowOnNullArgument(persistDictionary, "persistDictionary");
item[propertyDefinition] = persistDictionary.Serialize();
}
public virtual bool ReadFromMessageItem(IAnchorStoreObject message)
{
AnchorUtil.ThrowOnNullArgument(message, "message");
this.ExtendedProperties = AnchorHelper.GetDictionaryProperty(message, MigrationBatchMessageSchema.MigrationPersistableDictionary, true);
this.ReadStoreObjectIdProperties(message);
return(true);
}
internal AnchorFolder(AnchorContext context, Folder folder)
{
AnchorUtil.ThrowOnNullArgument(context, "context");
AnchorUtil.ThrowOnNullArgument(folder, "folder");
base.AnchorContext = context;
this.Folder = folder;
}
// Token: 0x060001DF RID: 479 RVA: 0x00006E88 File Offset: 0x00005088
public static AnchorDataProvider CreateProviderForMigrationMailboxFolder(AnchorContext context, AnchorADProvider activeDirectoryProvider, string folderName)
{
AnchorUtil.ThrowOnNullArgument(context, "context");
AnchorUtil.ThrowOnNullArgument(activeDirectoryProvider, "activeDirectoryProvider");
AnchorUtil.ThrowOnNullArgument(folderName, "folderName");
return(AnchorDataProvider.CreateProviderForMailboxSession(context, activeDirectoryProvider, folderName, new Func <ExchangePrincipal, MailboxSession>(AnchorDataProvider.OpenMailboxSession)));
}
private static Folder GetFolder(AnchorContext context, MailboxSession mailboxSession, StoreObjectId rootFolderId, string folderName)
{
AnchorUtil.ThrowOnNullArgument(mailboxSession, "mailboxSession");
AnchorUtil.ThrowOnNullArgument(rootFolderId, "rootFolderId");
AnchorUtil.ThrowOnNullArgument(folderName, "folderName");
Folder result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
Folder folder = null;
StoreObjectId storeObjectId = AnchorFolder.GetFolderId(context, mailboxSession, rootFolderId, folderName);
if (storeObjectId == null)
{
folder = Folder.Create(mailboxSession, rootFolderId, StoreObjectType.Folder, folderName, CreateMode.OpenIfExists);
disposeGuard.Add <Folder>(folder);
folder.Save();
folder.Load(AnchorFolder.FolderIdPropertyDefinition);
storeObjectId = folder.Id.ObjectId;
}
if (folder == null)
{
folder = Folder.Bind(mailboxSession, storeObjectId, AnchorFolder.FolderIdPropertyDefinition);
disposeGuard.Add <Folder>(folder);
}
disposeGuard.Success();
result = folder;
}
return(result);
}
protected TopologyExtractor(DirectoryObject directoryObject, TopologyExtractorFactory extractorFactory)
{
AnchorUtil.ThrowOnNullArgument(directoryObject, "directoryObject");
AnchorUtil.ThrowOnNullArgument(extractorFactory, "extractorFactory");
this.DirectoryObject = directoryObject;
this.ExtractorFactory = extractorFactory;
}
public MailboxProcessorDispatcher(LoadBalanceAnchorContext context, Func <IRequestQueueManager, IList <MailboxProcessor> > processors)
{
AnchorUtil.ThrowOnNullArgument(context, "context");
AnchorUtil.ThrowOnNullArgument(processors, "processors");
this.context = context;
this.processors = processors;
}
public DirectoryObject GetDirectoryObject(DirectoryIdentity directoryObjectIdentity)
{
AnchorUtil.ThrowOnNullArgument(directoryObjectIdentity, "directoryObjectIdentity");
switch (directoryObjectIdentity.ObjectType)
{
case DirectoryObjectType.Forest:
return(this.GetLocalForest());
case DirectoryObjectType.DatabaseAvailabilityGroup:
return(this.GetDatabaseAvailabilityGroups().FirstOrDefault((DirectoryDatabaseAvailabilityGroup d) => d.Guid == directoryObjectIdentity.Guid));
case DirectoryObjectType.Server:
return(this.GetServer(directoryObjectIdentity.Guid));
case DirectoryObjectType.Database:
return(this.GetDatabase(directoryObjectIdentity.Guid));
case DirectoryObjectType.Mailbox:
case DirectoryObjectType.CloudArchive:
case DirectoryObjectType.ConsumerMailbox:
return(this.GetMailboxObject(directoryObjectIdentity));
case DirectoryObjectType.ConstraintSet:
return(this.GetConstraintSetObject(directoryObjectIdentity));
}
throw new NotSupportedException(string.Format("ObjectType '{0}' is not supported.", directoryObjectIdentity.ObjectType));
}
internal ClientFactory(ILogger logger, LoadBalanceAnchorContext serviceContext)
{
AnchorUtil.ThrowOnNullArgument(serviceContext, "serviceContext");
AnchorUtil.ThrowOnNullArgument(logger, "logger");
this.logger = logger;
this.serviceContext = serviceContext;
}
public void ProcessRebalanceRequest(BandMailboxRebalanceData rebalanceRequest)
{
AnchorUtil.ThrowOnNullArgument(rebalanceRequest, "rebalanceRequest");
BandRebalanceRequest request = new BandRebalanceRequest(rebalanceRequest, this.clientFactory, this.logger);
LoadContainer sourceDatabase = rebalanceRequest.SourceDatabase;
IRequestQueue processingQueue = this.GetProcessingQueue(sourceDatabase);
processingQueue.EnqueueRequest(request);
}
protected BandRandomEntitySelector(Band band, LoadContainer sourceContainer, string constraintSetIdentity)
{
AnchorUtil.ThrowOnNullArgument(band, "band");
AnchorUtil.ThrowOnNullArgument(sourceContainer, "sourceContainer");
this.band = band;
this.SourceEntities = (from x in sourceContainer.Children
where x.DirectoryObjectIdentity.Name == constraintSetIdentity
select x).Cast <LoadContainer>().SelectMany((LoadContainer x) => x.Children).Where(new Func <LoadEntity, bool>(this.IsAcceptedEntity));
}
protected AnchorAttachment(AnchorContext anchorContext, Stream stream, ExDateTime lastModifiedTime, string id)
{
AnchorUtil.ThrowOnNullArgument(anchorContext, "anchorContext");
AnchorUtil.ThrowOnNullArgument(stream, "stream");
this.anchorContext = anchorContext;
this.stream = stream;
this.lastModifiedTime = lastModifiedTime;
this.Id = id;
}
public ProcessMailboxRequest(DirectoryMailbox mailbox, MailboxProcessor processor, ILogger logger, CmdletExecutionPool cmdletPool)
{
AnchorUtil.ThrowOnNullArgument(mailbox, "mailbox");
AnchorUtil.ThrowOnNullArgument(processor, "processor");
this.Mailbox = mailbox;
this.Processor = processor;
this.logger = logger;
this.cmdletPool = cmdletPool;
}
public FactorBasedBatchSizeReducer(double factor, ILogger logger)
{
AnchorUtil.ThrowOnNullArgument(logger, "logger");
if (factor > 1.0 || factor < 0.0)
{
throw new ArgumentOutOfRangeException("factor", factor, "Factor must be between 0 and 1.");
}
this.logger = logger;
this.factor = factor;
}
public CachingTopologyExtractor(TopologyExtractorFactory topologyExtractorFactory, DirectoryObject directoryObject, ILogger logger, TopologyExtractor topologyExtractor, ITimer timer) : base(directoryObject, topologyExtractorFactory)
{
AnchorUtil.ThrowOnNullArgument(logger, "logger");
AnchorUtil.ThrowOnNullArgument(timer, "timer");
this.directoryObject = directoryObject;
this.logger = logger;
this.timer = timer;
this.topologyExtractor = (topologyExtractor ?? base.ExtractorFactory.GetExtractor(this.directoryObject));
this.timer.SetAction(new Action(this.RefreshCachedValue), true);
}
public ForestLoadBalanceRequest(ILoadBalance loadBalancer, bool startMoves, ILogger logger, IRebalancingRequestProcessor moveStarter, LoadContainer forestTopology, PartitionExtractor partitionExtractor)
{
AnchorUtil.ThrowOnNullArgument(loadBalancer, "loadBalancer");
AnchorUtil.ThrowOnNullArgument(logger, "logger");
this.loadBalancer = loadBalancer;
this.startMoves = startMoves;
this.logger = logger;
this.moveStarter = moveStarter;
this.forestTopology = forestTopology;
this.partitionExtractor = partitionExtractor;
}
public DatabaseDrainRequest(DirectoryDatabase directoryDatabase, MoveInjector moveInjector, LoadBalanceAnchorContext serviceContext, BatchName batchName)
{
AnchorUtil.ThrowOnNullArgument(directoryDatabase, "directoryDatabase");
AnchorUtil.ThrowOnNullArgument(moveInjector, "moveInjector");
AnchorUtil.ThrowOnNullArgument(serviceContext, "serviceContext");
AnchorUtil.ThrowOnNullArgument(batchName, "batchName");
this.directoryDatabase = directoryDatabase;
this.moveInjector = moveInjector;
this.serviceContext = serviceContext;
this.logger = serviceContext.Logger;
this.batchName = batchName;
}
// Token: 0x060001D4 RID: 468 RVA: 0x00006D20 File Offset: 0x00004F20
private AnchorDataProvider(AnchorContext anchorContext, AnchorADProvider activeDirectoryProvider, MailboxSession mailboxSession, AnchorFolder folder, bool ownSession)
{
AnchorUtil.ThrowOnNullArgument(anchorContext, "anchorContext");
AnchorUtil.ThrowOnNullArgument(activeDirectoryProvider, "activeDirectoryProvider");
AnchorUtil.ThrowOnNullArgument(mailboxSession, "mailboxSession");
AnchorUtil.ThrowOnNullArgument(folder, "folder");
this.anchorContext = anchorContext;
this.activeDirectoryProvider = activeDirectoryProvider;
this.MailboxSession = mailboxSession;
this.folder = folder;
this.ownSession = ownSession;
}
public PhysicalDatabase(DirectoryDatabase database, IStorePort storePort, ILogger logger)
{
AnchorUtil.ThrowOnNullArgument(database, "database");
AnchorUtil.ThrowOnNullArgument(storePort, "storePort");
this.databaseLoadLock = new object();
this.database = database;
this.logger = logger;
this.DatabaseGuid = database.Guid;
this.physicalMailboxes = new Dictionary <Guid, IPhysicalMailbox>();
this.nonConnectedMailboxes = new List <IPhysicalMailbox>();
this.storePort = storePort;
}
internal PersistedBandDefinition(Band band, bool isEnabled = false)
{
AnchorUtil.ThrowOnNullArgument(band, "band");
this.BandProfile = band.Profile;
this.MaxSize = band.MaxSize.ToBytes();
this.MinSize = band.MinSize.ToBytes();
this.IsEnabled = isEnabled;
this.IncludeOnlyPhysicalMailboxes = band.IncludeOnlyPhysicalMailboxes;
this.MinLastLogonAgeTicks = PersistedBandDefinition.GetPersistableLogonAge(band.MinLastLogonAge);
this.MaxLastLogonAgeTicks = PersistedBandDefinition.GetPersistableLogonAge(band.MaxLastLogonAge);
this.WeightFactor = band.MailboxSizeWeightFactor;
}
private ServiceHost StartServiceEndpoint(object serviceInstance, ServiceEndpointAddress serviceAddress)
{
AnchorUtil.ThrowOnNullArgument(serviceInstance, "serviceInstance");
ServiceHost result;
try
{
ServiceHost serviceHost = new ServiceHost(serviceInstance, serviceAddress.GetBaseUris());
serviceHost.AddDefaultEndpoints();
this.logger.Log(MigrationEventType.Verbose, "Opening service host for {0}, with service type {1} and namespace {2}.", new object[]
{
serviceHost.Description.Name,
serviceHost.Description.ServiceType.FullName,
serviceHost.Description.Namespace
});
ServiceDebugBehavior serviceDebugBehavior = serviceHost.Description.Behaviors.Find <ServiceDebugBehavior>();
if (serviceDebugBehavior == null)
{
serviceDebugBehavior = new ServiceDebugBehavior();
serviceHost.Description.Behaviors.Add(serviceDebugBehavior);
}
serviceDebugBehavior.IncludeExceptionDetailInFaults = true;
foreach (System.ServiceModel.Description.ServiceEndpoint serviceEndpoint in serviceHost.Description.Endpoints)
{
NetTcpBinding netTcpBinding = serviceEndpoint.Binding as NetTcpBinding;
if (netTcpBinding != null)
{
netTcpBinding.MaxReceivedMessageSize = 10485760L;
netTcpBinding.ReceiveTimeout = TimeSpan.FromMinutes(10.0);
netTcpBinding.SendTimeout = TimeSpan.FromMinutes(10.0);
}
this.logger.LogVerbose("Using binging: {0} ({1})", new object[]
{
serviceEndpoint.Binding.Name,
serviceEndpoint.Binding.MessageVersion
});
LoadBalanceUtils.UpdateAndLogServiceEndpoint(this.logger, serviceEndpoint);
}
serviceHost.Open();
result = serviceHost;
}
catch (Exception exception)
{
this.logger.LogError(exception, "Failed to register endpoint for service {0}", new object[]
{
serviceInstance.GetType().Name
});
throw;
}
return(result);
}