public static IEnumerable <string> GetMigrationMailboxLegacyDN(TenantPartitionHint tenantPartitionHint, string localServer, QueryFilter optionalFilter = null) { IRecipientSession recipientSession = MigrationHelperBase.CreateRecipientSession(tenantPartitionHint); string connectionInformation = string.Format("Accessing migration mailboxes for organization: {0}", tenantPartitionHint); List <QueryFilter> filters = new List <QueryFilter>(3); filters.Add(OrganizationMailbox.OrganizationMailboxFilterBase); filters.Add(new ComparisonFilter(ComparisonOperator.Equal, ADRecipientSchema.RawCapabilities, OrganizationCapability.Migration)); if (optionalFilter != null) { filters.Add(optionalFilter); } IEnumerable <ADUser> users = MigrationHelperBase.GetRecipients <ADUser>(recipientSession, QueryFilter.AndTogether(filters.ToArray()), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), connectionInformation); foreach (ADUser user in users) { string serverName = null; if (user.Database != null) { serverName = MigrationHelperBase.GetServerFqdn(user.Database.ObjectGuid); } if (string.Equals(serverName, localServer, StringComparison.OrdinalIgnoreCase)) { yield return(user.LegacyExchangeDN); } } yield break; }
private ISourceMailbox GetSourceMailbox() { ISourceMailbox result; using (DisposeGuard disposeGuard = default(DisposeGuard)) { ExchangePrincipal exchangePrincipal; if (!PublicFolderSession.TryGetPublicFolderMailboxPrincipal(this.OrganizationId, PublicFolderSession.HierarchyMailboxGuidAlias, true, out exchangePrincipal)) { throw new StoragePermanentException(PublicFolderSession.GetNoPublicFoldersProvisionedError(this.OrganizationId)); } ISourceMailbox sourceMailbox = new RemoteSourceMailbox(exchangePrincipal.MailboxInfo.Location.ServerFqdn, null, null, this.isSingleFolderSync ? ProxyControlFlags.SkipWLMThrottling : ProxyControlFlags.None, PublicFolderSynchronizerContext.RequiredCapabilities, false, LocalMailboxFlags.None); disposeGuard.Add <ISourceMailbox>(sourceMailbox); TenantPartitionHint partitionHint = CommonUtils.GetPartitionHint(this.OrganizationId); if (this.Logger != null) { this.Logger.LogEvent(LogEventType.Verbose, string.Format("Connecting to Primary Hierarchy. [Mailbox:{0}; Server:{1}; Database:{2}; PartitionHint:{3}]", new object[] { exchangePrincipal.MailboxInfo.MailboxGuid, exchangePrincipal.MailboxInfo.Location.ServerFqdn, exchangePrincipal.MailboxInfo.GetDatabaseGuid(), partitionHint })); } sourceMailbox.Config(null, exchangePrincipal.MailboxInfo.MailboxGuid, exchangePrincipal.MailboxInfo.MailboxGuid, partitionHint, exchangePrincipal.MailboxInfo.GetDatabaseGuid(), MailboxType.SourceMailbox, null); sourceMailbox.Connect(MailboxConnectFlags.PublicFolderHierarchyReplication); disposeGuard.Success(); result = sourceMailbox; } return(result); }
private static void FixTenantInfo(RequestJobXML requestJobXML) { if (!CommonUtils.IsMultiTenantEnabled()) { requestJobXML.OrganizationId = OrganizationId.ForestWideOrgId; return; } if (requestJobXML.OrganizationId == OrganizationId.ForestWideOrgId && requestJobXML.ExternalDirectoryOrganizationId == Guid.Empty && requestJobXML.PartitionHint == null) { return; } if (requestJobXML.OrganizationId != OrganizationId.ForestWideOrgId && requestJobXML.PartitionHint == null) { if (requestJobXML.ExternalDirectoryOrganizationId != Guid.Empty) { requestJobXML.OrganizationId = OrganizationId.FromExternalDirectoryOrganizationId(requestJobXML.ExternalDirectoryOrganizationId); } requestJobXML.PartitionHint = TenantPartitionHint.FromOrganizationId(requestJobXML.OrganizationId); requestJobXML.ExternalDirectoryOrganizationId = requestJobXML.PartitionHint.GetExternalDirectoryOrganizationId(); return; } if (requestJobXML.PartitionHint != null) { if (requestJobXML.ExternalDirectoryOrganizationId == Guid.Empty) { requestJobXML.ExternalDirectoryOrganizationId = requestJobXML.PartitionHint.GetExternalDirectoryOrganizationId(); } requestJobXML.OrganizationId = OrganizationId.FromExternalDirectoryOrganizationId(requestJobXML.ExternalDirectoryOrganizationId); } }
internal static void ApplyOrganization(TransactionalRequestJob dataObject, OrganizationId organizationId) { dataObject.OrganizationId = organizationId; if (organizationId != OrganizationId.ForestWideOrgId) { dataObject.PartitionHint = TenantPartitionHint.FromOrganizationId(organizationId); dataObject.ExternalDirectoryOrganizationId = dataObject.PartitionHint.GetExternalDirectoryOrganizationId(); } }
public override void RunNow(Guid mailboxGuid, string parameters) { StoreMailboxData mailboxData; using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=TBA", null, null, null, null)) { try { PropValue[][] mailboxTableInfo = exRpcAdmin.GetMailboxTableInfo(base.DatabaseInfo.Guid, mailboxGuid, new PropTag[] { PropTag.MailboxType, PropTag.PersistableTenantPartitionHint, PropTag.LastLogonTime }); if (mailboxTableInfo.Length != 1 || mailboxTableInfo[0].Length < 1) { throw new InvalidOperationException("Failed to get the mailbox property"); } PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(mailboxTableInfo[0], PropTag.PersistableTenantPartitionHint); TenantPartitionHint tenantPartitionHint = null; if (mailboxProperty.PropTag == PropTag.PersistableTenantPartitionHint) { byte[] bytes = mailboxProperty.GetBytes(); if (bytes != null && bytes.Length != 0) { tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes); } } if (string.IsNullOrEmpty(parameters)) { MailboxInformation mailboxInformation = MailboxInformation.Create(mailboxGuid.ToByteArray(), base.DatabaseInfo.Guid, mailboxGuid.ToString(), ControlData.Empty, mailboxTableInfo[0], MailboxInformation.GetLastLogonTime(mailboxTableInfo[0]), tenantPartitionHint); mailboxData = mailboxInformation.MailboxData; } else { mailboxData = new MailboxDataForDemandJob(mailboxGuid, base.DatabaseInfo.Guid, null, parameters, tenantPartitionHint); } } catch (MapiExceptionNotFound arg) { ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedStoreDatabaseDriver, MapiExceptionNotFound>((long)this.GetHashCode(), "{0}: Mailbox does not exist on the store: {1}", this, arg); if (string.IsNullOrEmpty(parameters)) { mailboxData = new StoreMailboxData(mailboxGuid, base.DatabaseInfo.Guid, mailboxGuid.ToString(), null); } else { mailboxData = new MailboxDataForDemandJob(mailboxGuid, base.DatabaseInfo.Guid, null, parameters); } } } ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug <TimeBasedStoreDatabaseDriver, Guid>((long)this.GetHashCode(), "{0}: RunNow: about to start processing mailbox {1} on this database.", this, mailboxGuid); base.RunNow(mailboxData); }
protected override IConfigDataProvider CreateSession() { base.CurrentOrganizationId = this.ResolveCurrentOrganization(); this.partitionMailbox = MigrationObjectTaskBase <MigrationConfigIdParameter> .ResolvePartitionMailbox(this.Partition, base.TenantGlobalCatalogSession, base.ServerSettings, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.ErrorLoggerDelegate(base.WriteError), base.CurrentOrganizationId == OrganizationId.ForestWideOrgId && MapiTaskHelper.IsDatacenter); TenantPartitionHint partitionHint = TenantPartitionHint.FromOrganizationId(base.CurrentOrganizationId); MigrationLogger.Initialize(); MigrationLogContext.Current.Source = "Set-MigrationConfig"; MigrationLogContext.Current.Organization = base.CurrentOrganizationId.OrganizationalUnit; return(MigrationSessionDataProvider.CreateDataProvider("SetMigrationConfig", MigrationHelperBase.CreateRecipientSession(partitionHint), this.partitionMailbox)); }
private static string GetTenantId(IStoreSession session) { string result = string.Empty; byte[] valueOrDefault = session.Mailbox.GetValueOrDefault <byte[]>(MailboxSchema.PersistableTenantPartitionHint, null); if (valueOrDefault != null && valueOrDefault.Length > 0) { TenantPartitionHint tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(valueOrDefault); Guid externalDirectoryOrganizationId = tenantPartitionHint.GetExternalDirectoryOrganizationId(); result = (Guid.Empty.Equals(externalDirectoryOrganizationId) ? string.Empty : externalDirectoryOrganizationId.ToString()); } return(result); }
public static ReservationBase CreateReservation(Guid mailboxGuid, TenantPartitionHint partitionHint, Guid resourceId, ReservationFlags flags, string clientName) { ReservationBase result; lock (ReservationManager.Locker) { ReservationBase reservationBase = ReservationBase.CreateReservation(mailboxGuid, partitionHint, resourceId, flags, clientName); ReservationManager.reservations.TryInsertSliding(reservationBase.ReservationId, reservationBase, ConfigBase <MRSConfigSchema> .GetConfig <TimeSpan>("ReservationExpirationInterval")); reservationBase.AddReleaseAction(new Action <ReservationBase>(ReservationManager.ReleaseReservation)); result = reservationBase; } return(result); }
public PublicFolderMailboxSynchronizer(OrganizationId organizationId, Guid mailboxGuid, string serverFqdn, bool onlyRefCounting) { ArgumentValidator.ThrowIfNull("organizationId", organizationId); ArgumentValidator.ThrowIfEmpty("mailboxGuid", mailboxGuid); ArgumentValidator.ThrowIfNull("server", serverFqdn); this.tenantPartitionHint = TenantPartitionHint.FromOrganizationId(organizationId); this.mailboxGuid = mailboxGuid; this.serverFqdn = serverFqdn; if (!onlyRefCounting) { this.ScheduleSynchronizeHierarchy(TimeSpan.FromMilliseconds(0.0)); } }
public static TenantPartitionHintAdapter FromPersistableTenantPartitionHint(byte[] persistedData) { TenantPartitionHint partitionHint; if (persistedData == null) { partitionHint = TenantPartitionHint.FromOrganizationId(OrganizationId.ForestWideOrgId); } else { partitionHint = TenantPartitionHint.FromPersistablePartitionHint(persistedData); } return(TenantPartitionHintAdapter.FromPartitionHint(partitionHint)); }
public static IRecipientSession CreateRecipientSession(TenantPartitionHint partitionHint) { ADSessionSettings sessionSettings; if (partitionHint != null) { sessionSettings = partitionHint.GetTenantScopedADSessionSettingsServiceOnly(); } else { sessionSettings = ADSessionSettings.FromRootOrgScopeSet(); } return(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, true, ConsistencyMode.IgnoreInvalid, sessionSettings, 189, "CreateRecipientSession", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\Management\\Migration\\MigrationHelperBase.cs")); }
// Token: 0x06001575 RID: 5493 RVA: 0x00079F80 File Offset: 0x00078180 public static ADUser GetADUserFromMailboxGuid(Guid mailboxGuid, TenantPartitionHint partitionHint) { IRecipientSession adRecipientSession; try { adRecipientSession = ADHelper.GetAdRecipientSession(partitionHint); } catch (ADTransientException ex) { MailboxProcessorAssistantType.Tracer.TraceError <string>(0L, "Caught AD exception: {0}", ex.Message); throw; } return(adRecipientSession.FindByExchangeGuidIncludingArchive(mailboxGuid) as ADUser); }
// Token: 0x06001561 RID: 5473 RVA: 0x00079BAC File Offset: 0x00077DAC public MailboxProcessorMailboxData(DatabaseInfo databaseInfo, Guid mailboxGuid, int mailboxNumber, PropValue[] row) : base(mailboxGuid, mailboxNumber, databaseInfo.Guid) { MailboxProcessorAssistantType.TraceInformation(0L, "Retrieving mailbox information for database {0}", new object[] { databaseInfo.Guid }); this.DatabaseName = databaseInfo.DatabaseName; PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(row, PropTag.MailboxMiscFlags); if (mailboxProperty.PropTag == PropTag.MailboxMiscFlags) { MailboxMiscFlags @int = (MailboxMiscFlags)mailboxProperty.GetInt(); this.IsMoveDestination = ((@int & MailboxMiscFlags.CreatedByMove) == MailboxMiscFlags.CreatedByMove); this.IsArchive = ((@int & MailboxMiscFlags.ArchiveMailbox) == MailboxMiscFlags.ArchiveMailbox); } else { MailboxProcessorAssistantType.TraceInformation(0L, "Cannot retrieve property MailboxMiscFlags for Mailbox with GUID {0}", new object[] { mailboxGuid }); this.IsMoveDestination = false; this.IsArchive = false; } PropValue mailboxProperty2 = MailboxTableQuery.GetMailboxProperty(row, PropTag.PersistableTenantPartitionHint); this.TenantPartitionHint = null; if (mailboxProperty2.PropTag == PropTag.PersistableTenantPartitionHint) { byte[] bytes = mailboxProperty2.GetBytes(); if (bytes != null && bytes.Length != 0) { this.TenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes); } } else { MailboxProcessorAssistantType.TraceInformation(0L, "Cannot retrieve property PersistableTenantPartitionHint for Mailbox with GUID {0}", new object[] { mailboxGuid }); } MailboxProcessorAssistantType.TraceInformation(0L, "Found mailbox with GUID {0}. Is archive: {1}", new object[] { mailboxGuid, this.IsArchive }); }
public static void GetManagementMailboxData(TenantPartitionHint tenantPartitionHint, out string mailboxLegacyDN, out string serverName) { IRecipientSession session = MigrationHelperBase.CreateRecipientSession(tenantPartitionHint); string connectionInformation = string.Format("Accessing management mailbox for organization: {0}", tenantPartitionHint); ADUser recipient = MigrationHelperBase.GetRecipient <ADUser>(session, MigrationHelperBase.ManagementMailboxFilter, (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MultipleMigrationMailboxesFoundException>(connectionInformation), (string msg) => MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation), connectionInformation); serverName = null; if (recipient.Database != null) { serverName = MigrationHelperBase.GetServerFqdn(recipient.Database.ObjectGuid); } mailboxLegacyDN = recipient.LegacyExchangeDN; if (serverName == null) { throw MigrationHelperBase.CreatePermanentExceptionWithInternalData <MigrationMailboxNotFoundException>(connectionInformation); } }
public void ReserveResource(Guid mailboxGuid, TenantPartitionHint partitionHint, ADObjectId resourceId, ReservationFlags flags) { string serverFQDN = null; if (!(resourceId.ObjectGuid == MRSResource.Id.ObjectGuid)) { DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(resourceId, null, null, FindServerFlags.None); if (databaseInformation.ServerVersion < Server.E15MinVersion) { return; } if (!databaseInformation.IsOnThisServer) { serverFQDN = databaseInformation.ServerFqdn; } } this.AddReservation(ReservationWrapper.CreateReservation(serverFQDN, null, mailboxGuid, partitionHint, resourceId.ObjectGuid, flags)); }
public static ReservationBase CreateReservation(Guid mailboxGuid, TenantPartitionHint partitionHint, Guid resourceId, ReservationFlags flags, string clientName) { ReservationBase result; using (DisposeGuard disposeGuard = default(DisposeGuard)) { SettingsContextBase settingsContextBase = new MailboxSettingsContext(mailboxGuid, null); if (partitionHint != null) { settingsContextBase = new OrganizationSettingsContext(OrganizationId.FromExternalDirectoryOrganizationId(partitionHint.GetExternalDirectoryOrganizationId()), settingsContextBase); } ReservationBase reservationBase; if (resourceId == MRSResource.Id.ObjectGuid) { reservationBase = new MRSReservation(); } else { if (flags.HasFlag(ReservationFlags.Read)) { reservationBase = new ReadReservation(); } else { reservationBase = new WriteReservation(); } settingsContextBase = new DatabaseSettingsContext(resourceId, settingsContextBase); } disposeGuard.Add <ReservationBase>(reservationBase); settingsContextBase = new GenericSettingsContext("WorkloadType", reservationBase.WorkloadType.ToString(), settingsContextBase); reservationBase.MailboxGuid = mailboxGuid; reservationBase.PartitionHint = partitionHint; reservationBase.ResourceId = resourceId; reservationBase.Flags = flags; reservationBase.ClientName = clientName; using (settingsContextBase.Activate()) { reservationBase.ReserveResources(); } disposeGuard.Success(); result = reservationBase; } return(result); }
private void LoadMailboxOwner(byte[] tenantPartitionHintBlob, string nonLocalizedAssistantName) { if (this.mailboxOwner == null) { this.InvokeAndMapException(delegate { ExTraceGlobals.EventDispatcherTracer.TraceDebug <MailboxDispatcher>((long)this.GetHashCode(), "{0}: Looking up ExchangePrincipal...", this); ADSessionSettings adSettings; if (tenantPartitionHintBlob != null && tenantPartitionHintBlob.Length != 0) { adSettings = ADSessionSettings.FromTenantPartitionHint(TenantPartitionHint.FromPersistablePartitionHint(tenantPartitionHintBlob)); } else { adSettings = ADSessionSettings.FromRootOrgScopeSet(); } this.mailboxOwner = ExchangePrincipal.FromLocalServerMailboxGuid(adSettings, this.DatabaseInfo.Guid, this.MailboxGuid); }, nonLocalizedAssistantName); } }
public MoveJob(PropValue[] properties, Guid requestQueueGuid) { this.JobType = MapiUtils.GetValue <MRSJobType>(properties[9], MRSJobType.Unknown); if (!RequestJobXML.IsKnownJobType(this.JobType)) { MrsTracer.Service.Debug("Skipping unknown jobType {0}", new object[] { (int)this.JobType }); return; } this.RequestGuid = MapiUtils.GetValue <Guid>(properties[26], Guid.Empty); this.ExchangeGuid = MapiUtils.GetValue <Guid>(properties[5], Guid.Empty); this.ArchiveGuid = MapiUtils.GetValue <Guid>(properties[6], Guid.Empty); this.CancelRequest = MapiUtils.GetValue <bool>(properties[4], false); this.MrsServerName = MapiUtils.GetValue <string>(properties[2], null); this.Status = MapiUtils.GetValue <RequestStatus>(properties[0], RequestStatus.None); this.JobState = MapiUtils.GetValue <JobProcessingState>(properties[1], JobProcessingState.NotReady); this.LastUpdateTimeStamp = MapiUtils.GetValue <DateTime>(properties[7], DateTime.MinValue); this.Flags = MapiUtils.GetValue <RequestFlags>(properties[10], RequestFlags.None); this.SourceDatabaseGuid = MapiUtils.GetValue <Guid>(properties[11], Guid.Empty); this.TargetDatabaseGuid = MapiUtils.GetValue <Guid>(properties[12], Guid.Empty); this.SourceArchiveDatabaseGuid = MapiUtils.GetValue <Guid>(properties[15], Guid.Empty); this.TargetArchiveDatabaseGuid = MapiUtils.GetValue <Guid>(properties[16], Guid.Empty); this.Priority = MapiUtils.GetValue <int>(properties[17], -1); this.DoNotPickUntilTimestamp = MapiUtils.GetValue <DateTime>(properties[13], DateTime.MinValue); this.RequestType = MapiUtils.GetValue <MRSRequestType>(properties[14], MRSRequestType.Move); this.MessageID = MapiUtils.GetValue <byte[]>(properties[27], null); this.SourceExchangeGuid = MapiUtils.GetValue <Guid>(properties[18], Guid.Empty); this.TargetExchangeGuid = MapiUtils.GetValue <Guid>(properties[19], Guid.Empty); this.RehomeRequest = MapiUtils.GetValue <bool>(properties[20], false); this.InternalFlags = MapiUtils.GetValue <RequestJobInternalFlags>(properties[21], RequestJobInternalFlags.None); this.PoisonCount = MapiUtils.GetValue <int>(properties[23], 0); this.FailureType = MapiUtils.GetValue <string>(properties[24], null); this.WorkloadType = MapiUtils.GetValue <RequestWorkloadType>(properties[25], RequestWorkloadType.None); byte[] value = MapiUtils.GetValue <byte[]>(properties[22], null); this.PartitionHint = ((value != null && value.Length > 0) ? TenantPartitionHint.FromPersistablePartitionHint(value) : null); this.RequestQueueGuid = requestQueueGuid; this.IsActiveOnThisMRSInstance = MRSService.JobIsActive(this.RequestGuid); this.isInteractive = MoveJob.IsInteractive(this.RequestType, this.WorkloadType); }
public static byte[] ConvertTenantHint(byte[] originalSignature, MailboxSignatureFlags originalSignatureFlags, TenantPartitionHint tenantHint) { MailboxSignatureSectionsContainer mailboxSignatureSectionsContainer; if (originalSignatureFlags == MailboxSignatureFlags.GetLegacy) { mailboxSignatureSectionsContainer = MailboxSignatureSectionsContainer.Create(MailboxSignatureSectionType.BasicInformation, new MailboxSignatureConverter.MailboxBasicInformationSectionCreator(originalSignature)); } else { mailboxSignatureSectionsContainer = MailboxSignatureSectionsContainer.Parse(originalSignature, NullMailboxSignatureSectionProcessor.Instance); } if (tenantHint == null) { tenantHint = TenantPartitionHint.FromOrganizationId(OrganizationId.ForestWideOrgId); } byte[] persistablePartitionHint = tenantHint.GetPersistablePartitionHint(); int num = TenantHintHelper.SerializeTenantHint(persistablePartitionHint, null, 0); byte[] array = new byte[num]; TenantHintHelper.SerializeTenantHint(persistablePartitionHint, array, 0); mailboxSignatureSectionsContainer.UpdateSection(new MailboxSignatureSectionMetadata(MailboxSignatureSectionType.TenantHint, 1, 1, persistablePartitionHint.Length), array); return(mailboxSignatureSectionsContainer.Serialize()); }
public TenantRelocationSyncData(OrganizationId sourceTenantOrganizationId, OrganizationId targetTenantOrganizationId, ADObjectId resourcePartitionRoot, TenantPartitionHint partitionHint, bool largeTenantModeEnabled) { if (targetTenantOrganizationId.ConfigurationUnit == null) { throw new ArgumentNullException("targetTenantConfigurationUnit"); } ADObjectId domainId = sourceTenantOrganizationId.OrganizationalUnit.DomainId; ADObjectId domainId2 = targetTenantOrganizationId.OrganizationalUnit.DomainId; PartitionId partitionId = sourceTenantOrganizationId.OrganizationalUnit.GetPartitionId(); PartitionId partitionId2 = targetTenantOrganizationId.OrganizationalUnit.GetPartitionId(); this.Source = new TenantRelocationSyncPartitionData(sourceTenantOrganizationId, domainId, partitionId); this.Target = new TenantRelocationSyncPartitionData(targetTenantOrganizationId, domainId2, partitionId2); this.ResourcePartitionRoot = resourcePartitionRoot; this.ResourcePartitionConfigNc = this.ResourcePartitionRoot.GetChildId("Configuration"); this.SourceTenantPartitionHint = partitionHint; this.SourceConfigContainer = this.Source.TenantConfigurationUnit.Parent; this.LargeTenantModeEnabled = largeTenantModeEnabled; }
// Token: 0x06000024 RID: 36 RVA: 0x000030E0 File Offset: 0x000012E0 public void HandleEvent(MapiEvent mapiEvent, MailboxSession itemStore, StoreObject item) { MailboxTransportSubmissionAssistant.IdentifyProbeMessage(mapiEvent); Thread currentThread = Thread.CurrentThread; try { Interlocked.Increment(ref this.concurrentEvents); this.SubmissionsInProgress[currentThread] = new SubmissionsInProgress.Entry(ExDateTime.UtcNow, this.databaseInfo.Guid, mapiEvent); using (new SenderGuidTraceFilter(this.databaseInfo.Guid, mapiEvent.MailboxGuid)) { bool flag = true; MailboxTransportSubmissionAssistant.LatencyRecord latencyRecord; LatencyTracker latencyTracker; if (MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.TryGetValue(mapiEvent.EventCounter, out latencyRecord)) { MailboxTransportSubmissionAssistant.eventCounterToLatencyMap.Remove(mapiEvent.EventCounter); latencyTracker = latencyRecord.LatencyTracker; LatencyTracker.EndTrackLatency(latencyRecord.LatencyComponent, latencyTracker, true); flag = false; } else { latencyTracker = LatencyTracker.CreateInstance(LatencyComponent.MailboxTransportSubmissionService); LatencyTracker.TrackPreProcessLatency(LatencyComponent.SubmissionAssistant, latencyTracker, mapiEvent.CreateTime); } LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker); string text = this.FormatMapiEventInfo(mapiEvent); this.LogMapiEventIntoCrimsonChannelPeriodically(text); this.SubmissionsInProgress[Thread.CurrentThread].LatencyTracker = latencyTracker; if (MailboxTransportSubmissionAssistant.ShouldLogNotifyEvents && (flag || MailboxTransportSubmissionAssistant.ShouldLogTemporaryFailures)) { LatencyFormatter latencyFormatter = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, mapiEvent.CreateTime, mapiEvent.CreateTime, true, false, false); MsgTrackMapiSubmitInfo msgTrackInfo = new MsgTrackMapiSubmitInfo(text, null, string.Empty, StoreDriverSubmission.LocalIPAddress, Components.Configuration.LocalServer.TransportServer.Name, string.Empty, string.Empty, MailboxTransportSubmissionAssistant.ItemEntryId(mapiEvent), latencyFormatter.FormatAndUpdatePerfCounters(), null, false, true); MessageTrackingLog.TrackNotify(msgTrackInfo, false); } MSExchangeSubmission.PendingSubmissions.Increment(); new HashSet <string>(); DateTime createTime = mapiEvent.CreateTime; MailboxTransportSubmissionService.StoreDriverTracer.ServiceTracer.TracePfdPass <int, Guid, long>(MailboxTransportSubmissionService.StoreDriverTracer.MessageProbeActivityId, (long)this.GetHashCode(), "PFD EMS {0} SubmitMail for mailbox {1} at entry {2}", 22427, mapiEvent.MailboxGuid, mapiEvent.EventCounter); LatencyFormatter latencyFormatter2 = new LatencyFormatter(latencyTracker, Components.Configuration.LocalServer.TransportServer.Fqdn, createTime, createTime, false, true, false); bool isPublicFolder = mapiEvent.ExtendedEventFlags.HasFlag(MapiExtendedEventFlags.PublicFolderMailbox); LatencyTracker.BeginTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker); ISubmissionProvider submissionProvider = (ISubmissionProvider)Components.StoreDriverSubmission; MailSubmissionResult mailSubmissionResult = submissionProvider.SubmitMessage(Components.Configuration.LocalServer.TransportServer.ExchangeLegacyDN, mapiEvent.MailboxGuid, this.databaseInfo.Guid, this.databaseInfo.DatabaseName, mapiEvent.EventCounter, mapiEvent.ItemEntryId, mapiEvent.ParentEntryId, Components.Configuration.LocalServer.TransportServer.Fqdn, new IPAddress(StoreDriverSubmission.LocalIPAddress.GetAddressBytes()), mapiEvent.CreateTime, isPublicFolder, (mapiEvent.TenantHint == null) ? null : TenantPartitionHint.FromPersistablePartitionHint(mapiEvent.TenantHint), latencyFormatter2.FormatAndUpdatePerfCounters(), MailboxTransportSubmissionService.QuarantineHandler, MailboxTransportSubmissionService.SubmissionPoisonHandler, latencyTracker); MailSubmissionResult result = mailSubmissionResult; LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionStoreDriverSubmission, latencyTracker); LatencyTracker.EndTrackLatency(LatencyComponent.MailboxTransportSubmissionService, latencyTracker); this.LogAndUpdateCounters(mapiEvent, latencyTracker, createTime, result); this.HandleEventError(mapiEvent, result, latencyTracker, text); } } finally { MSExchangeSubmission.PendingSubmissions.Decrement(); Interlocked.Decrement(ref this.concurrentEvents); this.SubmissionsInProgress.Remove(currentThread); } }
public MailSubmissionResult SubmitMessage(string serverDN, Guid mailboxGuid, Guid mdbGuid, string databaseName, long eventCounter, byte[] entryId, byte[] parentEntryId, string serverFqdn, IPAddress networkAddressBytes, DateTime originalCreateTime, bool isPublicFolder, TenantPartitionHint tenantHint, string mailboxHopLatency, QuarantineHandler quarantineHandler, SubmissionPoisonHandler submissionPoisonHandler, LatencyTracker latencyTracker) { ArgumentValidator.ThrowIfNullOrEmpty("serverDN", serverDN); ArgumentValidator.ThrowIfEmpty("mailboxGuid", mailboxGuid); ArgumentValidator.ThrowIfEmpty("mdbGuid", mdbGuid); ArgumentValidator.ThrowIfNullOrEmpty("databaseName", databaseName); ArgumentValidator.ThrowIfNull("entryId", entryId); ArgumentValidator.ThrowIfInvalidValue <int>("entryId", entryId.Length, (int value) => value > 0); ArgumentValidator.ThrowIfNull("parentEntryId", parentEntryId); ArgumentValidator.ThrowIfInvalidValue <int>("parentEntryId", parentEntryId.Length, (int value) => value > 0); ArgumentValidator.ThrowIfNullOrEmpty("serverFqdn", serverFqdn); ArgumentValidator.ThrowIfNull("networkAddressBytes", networkAddressBytes); ArgumentValidator.ThrowIfNullOrEmpty("mailboxHopLatency", mailboxHopLatency); ArgumentValidator.ThrowIfNull("quarantineHandler", quarantineHandler); ArgumentValidator.ThrowIfNull("submissionPoisonHandler", submissionPoisonHandler); bool shouldDeprioritize = false; if (SubmissionConfiguration.Instance.App.SenderRateDeprioritizationEnabled) { long num = this.rateTrackerForDeprioritization.IncrementSenderRate(mailboxGuid, originalCreateTime); if (num > (long)SubmissionConfiguration.Instance.App.SenderRateDeprioritizationThreshold) { shouldDeprioritize = true; } } bool shouldThrottle = false; if (SubmissionConfiguration.Instance.App.SenderRateThrottlingEnabled) { long num2 = this.rateTrackerForThrottling.IncrementSenderRate(mailboxGuid, originalCreateTime); if (num2 > (long)SubmissionConfiguration.Instance.App.SenderRateThrottlingThreshold) { shouldThrottle = true; this.rateTrackerForThrottling.ResetSenderRate(mailboxGuid, originalCreateTime); } } MapiSubmissionInfo submissionInfo = new MapiSubmissionInfo(serverDN, mailboxGuid, entryId, parentEntryId, eventCounter, serverFqdn, networkAddressBytes, mdbGuid, databaseName, originalCreateTime, isPublicFolder, tenantHint, mailboxHopLatency, latencyTracker, shouldDeprioritize, shouldThrottle, this.storeDriverTracer); return(this.SubmitMessageImpl(submissionInfo, submissionPoisonHandler, quarantineHandler)); }
public static DirectoryIdentity CreateMailboxIdentity(Guid guid, TenantPartitionHint tph, DirectoryObjectType objectType = DirectoryObjectType.Mailbox) { return(DirectoryIdentity.CreateMailboxIdentity(guid, TenantPartitionHintAdapter.FromPartitionHint(tph), objectType)); }
void IMailbox.Config(IReservation reservation, Guid primaryMailboxGuid, Guid physicalMailboxGuid, TenantPartitionHint partitionHint, Guid mdbGuid, MailboxType mbxType, Guid?mailboxContainerGuid) { throw new NotImplementedException(); }
internal static MailboxInformation Create(byte[] mailboxGuid, Guid databaseGuid, string displayName, ControlData controlData, PropValue[] mailboxProperties, DateTime lastLogonTime, TenantPartitionHint tenantPartitionHint = null) { MailboxInformation mailboxInformation = new MailboxInformation(new Guid(mailboxGuid), databaseGuid, displayName, true, lastLogonTime, tenantPartitionHint); if (controlData != null) { mailboxInformation.LastProcessedDate = controlData.LastProcessedDate; } else { mailboxInformation.LastProcessedDate = DateTime.MinValue; } mailboxInformation.mailboxProperties = mailboxProperties; mailboxInformation.MailboxData.IsPublicFolderMailbox = mailboxInformation.IsPublicFolderMailbox(); return(mailboxInformation); }
private MailboxInformation(Guid mailboxGuid, Guid databaseGuid, string displayName, bool active, DateTime lastLogonTime, TenantPartitionHint tenantPartitionHint) { this.MailboxData = new StoreMailboxDataExtended(mailboxGuid, databaseGuid, displayName, null, tenantPartitionHint, this.IsArchiveMailbox(), this.IsGroupMailbox(), this.IsTeamSiteMailbox(), this.IsSharedMailbox()); this.Active = active; this.LastLogonTime = lastLogonTime; }
public MailboxDataForDemandJob(Guid mailboxGuid, Guid databaseGuid, OrganizationId organizationId, string parameters, TenantPartitionHint tenantPartitionHint) : base(mailboxGuid, databaseGuid, "(unknown)", organizationId, tenantPartitionHint) { this.Parameters = parameters; }
public static TenantPartitionHintAdapter FromPartitionHint(TenantPartitionHint partitionHint) { return(new TenantPartitionHintAdapter(partitionHint.GetExternalDirectoryOrganizationId(), partitionHint.IsConsumer())); }
protected override List <MailboxData> GetMailboxesForCurrentWindow(out int totalMailboxOnDatabaseCount, out int notInterestingMailboxCount, out int filteredMailboxCount, out int failedFilteringCount) { Guid activityId = Guid.NewGuid(); PropTag[] mailboxProperties = this.GetMailboxProperties(); PropValue[][] mailboxes = MailboxTableQuery.GetMailboxes("Client=TBA", base.DatabaseInfo, mailboxProperties); totalMailboxOnDatabaseCount = ((mailboxes == null) ? 0 : mailboxes.Length); notInterestingMailboxCount = 0; filteredMailboxCount = 0; failedFilteringCount = 0; AssistantsLog.LogGetMailboxesQueryEvent(activityId, base.Assistant.NonLocalizedName, totalMailboxOnDatabaseCount, base.Assistant as AssistantBase); if (mailboxes == null) { return(new List <MailboxData>()); } List <MailboxInformation> list3 = new List <MailboxInformation>(mailboxes.Length); Guid mailboxGuid = Guid.Empty; VariantConfigurationSnapshot snapshot = VariantConfiguration.GetSnapshot(DatabaseSettingsContext.Get(base.DatabaseInfo.Guid), null, null); TimeSpan notInterestingLogInterval = snapshot.MailboxAssistants.GetObject <IMailboxAssistantSettings>(base.AssistantType.Identifier, new object[0]).MailboxNotInterestingLogInterval; int filteredMailboxCountLocal = 0; int notInterestingMailboxCountLocal = 0; string traceMessage; foreach (PropValue[] propertiesForDelegateClosure2 in mailboxes) { try { PropValue[] propertiesForDelegateClosure = propertiesForDelegateClosure2; List <MailboxInformation> list = list3; base.CatchMeIfYouCan(delegate { PropValue mailboxProperty = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.UserGuid); PropValue mailboxProperty2 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DisplayName); string mailboxDisplayNameTracingOnlyUsage = (mailboxProperty2.IsNull() || mailboxProperty2.Value == null) ? string.Empty : mailboxProperty2.Value.ToString(); if (mailboxProperty.PropTag != PropTag.UserGuid || mailboxProperty2.PropTag != PropTag.DisplayName) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNoGuidFilter, MailboxSlaFilterReasonType.NoGuid, new object[] { mailboxProperty.Value }); filteredMailboxCountLocal++; return; } byte[] bytes = mailboxProperty.GetBytes(); if (bytes != null && bytes.Length == 16) { mailboxGuid = new Guid(bytes); } if (MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.DateDiscoveredAbsentInDS).PropTag == PropTag.DateDiscoveredAbsentInDS) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotInDirectoryFilter, MailboxSlaFilterReasonType.NotInDirectory, new object[0]); filteredMailboxCountLocal++; return; } PropValue mailboxProperty3 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.MailboxMiscFlags); MailboxMiscFlags @int = (MailboxMiscFlags)mailboxProperty3.GetInt(0); if ((@int & MailboxMiscFlags.CreatedByMove) == MailboxMiscFlags.CreatedByMove) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxMoveDestinationFilter, MailboxSlaFilterReasonType.MoveDestination, new object[0]); filteredMailboxCountLocal++; return; } MailboxMiscFlags mailboxMiscFlags = @int & (MailboxMiscFlags.DisabledMailbox | MailboxMiscFlags.SoftDeletedMailbox | MailboxMiscFlags.MRSSoftDeletedMailbox); if (mailboxMiscFlags != MailboxMiscFlags.None) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInaccessibleFilter, MailboxSlaFilterReasonType.Inaccessible, new object[] { mailboxMiscFlags }); filteredMailboxCountLocal++; return; } IMailboxFilter mailboxFilter = this.AssistantType as IMailboxFilter; if (mailboxFilter != null && mailboxProperty3.PropTag == PropTag.MailboxMiscFlags) { MailboxMiscFlags int2 = (MailboxMiscFlags)mailboxProperty3.GetInt(); bool flag = (int2 & MailboxMiscFlags.ArchiveMailbox) == MailboxMiscFlags.ArchiveMailbox; if (flag && !mailboxFilter.MailboxType.Contains(MailboxType.Archive)) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxArchiveFilter, MailboxSlaFilterReasonType.Archive, new object[0]); filteredMailboxCountLocal++; return; } } ControlData controlData = ControlData.Empty; if (this.AssistantType.ControlDataPropertyDefinition != null) { PropValue mailboxProperty4 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag); if (mailboxProperty4.PropTag == (PropTag)this.AssistantType.ControlDataPropertyDefinition.PropertyTag) { controlData = ControlData.CreateFromByteArray(mailboxProperty4.GetBytes()); } } TenantPartitionHint tenantPartitionHint = null; PropValue mailboxProperty5 = MailboxTableQuery.GetMailboxProperty(propertiesForDelegateClosure, PropTag.PersistableTenantPartitionHint); if (mailboxProperty5.PropTag == PropTag.PersistableTenantPartitionHint) { byte[] bytes2 = mailboxProperty5.GetBytes(); if (bytes2 != null && bytes2.Length != 0) { tenantPartitionHint = TenantPartitionHint.FromPersistablePartitionHint(bytes2); } } MailboxInformation mailboxInformation2 = MailboxInformation.Create(mailboxProperty.GetBytes(), this.DatabaseInfo.Guid, mailboxProperty2.GetString(), controlData, propertiesForDelegateClosure, MailboxInformation.GetLastLogonTime(propertiesForDelegateClosure), tenantPartitionHint); if (!this.DatabaseInfo.IsUserMailbox(mailboxInformation2.MailboxGuid)) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxNotUserFilter, MailboxSlaFilterReasonType.NotUser, new object[0]); filteredMailboxCountLocal++; return; } if (mailboxInformation2.MailboxData.IsPublicFolderMailbox && (mailboxFilter == null || !mailboxFilter.MailboxType.Contains(MailboxType.PublicFolder))) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxPublicFolderFilter, MailboxSlaFilterReasonType.PublicFolder, new object[0]); filteredMailboxCountLocal++; return; } if (this.IsMailboxInDemandJob(mailboxInformation2.MailboxData)) { this.LogStoreDriverMailboxFilterEvent(notInterestingLogInterval, activityId, mailboxGuid, mailboxDisplayNameTracingOnlyUsage, Strings.MailboxInDemandJobFilter, MailboxSlaFilterReasonType.InDemandJob, new object[0]); filteredMailboxCountLocal++; return; } if (this.AssistantType.MailboxExtendedProperties != null) { if (!this.AssistantType.IsMailboxInteresting(mailboxInformation2)) { traceMessage = string.Format("{0}: {1} is not interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName); ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage); DateTime utcNow = DateTime.UtcNow; if (!this.notInterestingEventsLastLogDateTimes.ContainsKey(this.Assistant.NonLocalizedName) || utcNow - this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] >= notInterestingLogInterval) { AssistantsLog.LogMailboxNotInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, mailboxGuid, mailboxDisplayNameTracingOnlyUsage); this.notInterestingEventsLastLogDateTimes[this.Assistant.NonLocalizedName] = utcNow; } notInterestingMailboxCountLocal++; return; } } else { traceMessage = string.Format("{0}: {1} mailbox properties are null, IsMailboxInteresting was not called.", this, mailboxGuid); ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage); } traceMessage = string.Format("{0}: {1} is interesting for the assistant {2}.", this, mailboxGuid, this.Assistant.NonLocalizedName); ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage); AssistantsLog.LogMailboxInterestingEvent(activityId, this.Assistant.NonLocalizedName, this.Assistant as AssistantBase, null, mailboxGuid, mailboxDisplayNameTracingOnlyUsage); list.Add(mailboxInformation2); }, base.AssistantType.NonLocalizedName); } catch (AIException exception) { failedFilteringCount++; AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception, true); } catch (Exception exception2) { AssistantsLog.LogErrorEnumeratingMailboxes(base.Assistant, mailboxGuid, exception2, false); throw; } } traceMessage = string.Format("{0}: {1} mailboxes after filtering", this, list3.Count); ExTraceGlobals.TimeBasedDatabaseDriverTracer.TraceDebug((long)this.GetHashCode(), traceMessage); if (this.firstIteration || base.AssistantType.WorkCycleCheckpoint < base.AssistantType.WorkCycle) { int count = list3.Count; list3 = list3.FindAll((MailboxInformation mailbox) => DateTime.UtcNow - mailbox.LastProcessedDate > base.AssistantType.WorkCycle - base.AssistantType.WorkCycleCheckpoint); this.firstIteration = false; filteredMailboxCountLocal += count - list3.Count; } list3.Sort((MailboxInformation m1, MailboxInformation m2) => m1.LastProcessedDate.CompareTo(m2.LastProcessedDate)); List <MailboxData> list2 = new List <MailboxData>(); foreach (MailboxInformation mailboxInformation in list3) { list2.Add(mailboxInformation.MailboxData); } AssistantsLog.LogEndGetMailboxesEvent(activityId, base.Assistant.NonLocalizedName, list2.Count, base.Assistant as AssistantBase); filteredMailboxCount = filteredMailboxCountLocal; notInterestingMailboxCount = notInterestingMailboxCountLocal; return(list2); }
public static RemoteReservation Create(string serverFQDN, NetworkCredential credentials, Guid mailboxGuid, TenantPartitionHint partitionHint, Guid mdbGuid, ReservationFlags flags) { RemoteReservation result; using (MailboxReplicationProxyClient mailboxReplicationProxyClient = MailboxReplicationProxyClient.CreateWithoutThrottling(serverFQDN, credentials, mailboxGuid, mdbGuid)) { Guid reservationID; if (mailboxReplicationProxyClient.ServerVersion[37]) { byte[] partitionHintBytes = (partitionHint != null) ? partitionHint.GetPersistablePartitionHint() : null; reservationID = ((IMailboxReplicationProxyService)mailboxReplicationProxyClient).IReservationManager_ReserveResources(mailboxGuid, partitionHintBytes, mdbGuid, (int)flags); } else if (mailboxReplicationProxyClient.ServerVersion[28]) { reservationID = Guid.NewGuid(); LegacyReservationStatus legacyReservationStatus = (LegacyReservationStatus)((IMailboxReplicationProxyService)mailboxReplicationProxyClient).IMailbox_ReserveResources(reservationID, mdbGuid, (int)RemoteReservation.ConvertReservationFlagsToLegacy(flags, true)); if (legacyReservationStatus != LegacyReservationStatus.Success) { throw new CapacityExceededReservationException(string.Format("{0}:{1}:{2}", serverFQDN, mdbGuid, flags), 1); } } else { reservationID = RemoteReservation.DownlevelReservationId; } result = new RemoteReservation(reservationID, serverFQDN, credentials, mailboxGuid, mdbGuid, flags); } return(result); }