Esempio n. 1
0
        private XElement GetQueueDiagnosticInfo(MRSDiagnosticArgument arguments)
        {
            DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(this.MdbGuid, null, null, FindServerFlags.AllowMissing);
            string argument = arguments.GetArgument <string>("queues");

            if (!string.IsNullOrEmpty(argument) && (databaseInformation.IsMissing || !CommonUtils.IsValueInWildcardedList(databaseInformation.DatabaseName, argument)))
            {
                return(null);
            }
            MRSQueueDiagnosticInfoXML mrsqueueDiagnosticInfoXML = new MRSQueueDiagnosticInfoXML
            {
                MdbGuid                  = this.MdbGuid,
                MdbName                  = databaseInformation.DatabaseName,
                LastJobPickup            = this.LastJobPickup,
                LastInteractiveJobPickup = this.LastInteractiveJobPickup,
                QueuedJobsCount          = this.QueuedJobsCount,
                InProgressJobsCount      = this.InProgressJobsCount,
                LastScanFailure          = this.LastScanFailure,
                MdbDiscoveryTimestamp    = this.MdbDiscoveryTimestamp,
                LastScanTimestamp        = this.LastScanTimestamp,
                LastScanDurationMs       = (int)this.LastScanDuration.TotalMilliseconds,
                NextRecommendedScan      = this.NextRecommendedScan,
                LastActiveJobFinishTime  = this.LastActiveJobFinishTime,
                LastActiveJobFinished    = this.LastActiveJobFinished
            };

            if (arguments.HasArgument("pickupresults"))
            {
                mrsqueueDiagnosticInfoXML.LastScanResults = this.LastScanResults;
            }
            return(mrsqueueDiagnosticInfoXML.ToDiagnosticInfo(null));
        }
Esempio n. 2
0
        public static DatabaseInformation FindServerForMdb(ADObjectId database, string dcName, NetworkCredential cred, FindServerFlags flags)
        {
            if (!ConfigBase <MRSConfigSchema> .GetConfig <bool>("CrossResourceForestEnabled"))
            {
                return(MapiUtils.FindServerForMdb(database.ObjectGuid, dcName, cred, flags));
            }
            Guid empty = Guid.Empty;
            DatabaseInformation result;

            try
            {
                if (database.GetPartitionId().IsLocalForestPartition())
                {
                    result = MapiUtils.FindServerForMdb(database.ObjectGuid, dcName, cred, flags);
                }
                else
                {
                    BackEndServer backEndServer = BackEndLocator.GetBackEndServer(database);
                    result = DatabaseInformation.FromBackEndServer(database, backEndServer);
                }
            }
            catch (BackEndLocatorException)
            {
                MrsTracer.Common.Debug("BE Locator was unable to locate MDB {0}.", new object[]
                {
                    database.ObjectGuid
                });
                if ((flags & FindServerFlags.AllowMissing) == FindServerFlags.None)
                {
                    throw;
                }
                result = DatabaseInformation.Missing(database.ObjectGuid, database.PartitionFQDN);
            }
            return(result);
        }
Esempio n. 3
0
        public static List <Guid> GetDatabasesOnThisServer()
        {
            if (MapiUtils.localMDBs != null && DateTime.UtcNow - MapiUtils.LocalMDBRefreshInterval < MapiUtils.lastLocalMDBRefresh)
            {
                return(MapiUtils.localMDBs);
            }
            List <Guid> list = new List <Guid>();

            MdbStatus[] mdbStatuses = null;
            CommonUtils.ProcessKnownExceptions(delegate
            {
                using (ExRpcAdmin exRpcAdmin = ExRpcAdmin.Create("Client=MSExchangeMigration", null, null, null, null))
                {
                    mdbStatuses = exRpcAdmin.ListMdbStatus(true);
                }
            }, delegate(Exception failure)
            {
                LocalizedString localizedString = CommonUtils.FullExceptionMessage(failure);
                CommonUtils.LogEvent(MRSEventLogConstants.Tuple_UnableToDetermineHostedMdbsOnServer, new object[]
                {
                    CommonUtils.LocalComputerName,
                    localizedString.ToString()
                });
                return(false);
            });
            if (mdbStatuses == null)
            {
                MrsTracer.Common.Debug("MapiUtils.GetDatabasesOnServer() returned null.", new object[0]);
                return(list);
            }
            foreach (MdbStatus mdbStatus in mdbStatuses)
            {
                if (mdbStatus.Status.HasFlag(MdbStatusFlags.Online))
                {
                    list.Add(mdbStatus.MdbGuid);
                }
            }
            if (list.Count == 0)
            {
                MrsTracer.Common.Debug("MapiUtils.GetDatabasesOnServer() found {0} databases, but none of them are online.", new object[]
                {
                    mdbStatuses.Length
                });
            }
            foreach (Guid mdbGuid in list)
            {
                DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.AllowMissing);
                if (!databaseInformation.IsMissing && !databaseInformation.IsOnThisServer)
                {
                    databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.ForceRediscovery | FindServerFlags.AllowMissing);
                }
            }
            MapiUtils.localMDBs           = list;
            MapiUtils.lastLocalMDBRefresh = DateTime.UtcNow;
            return(list);
        }
Esempio n. 4
0
        private static bool ShouldRemovePerfCounter(Guid mdbGuid, MDBPerfCounterHelper perfCounter)
        {
            bool result = false;

            CommonUtils.CatchKnownExceptions(delegate
            {
                DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.AllowMissing);
                result = (databaseInformation.IsMissing || !databaseInformation.IsOnThisServer);
            }, null);
            return(result);
        }
        internal static MailboxReplicationServiceClient Create(IConfigurationSession session, MRSJobType jobType, Guid mdbGuid, List <string> unreachableMrsServers)
        {
            MRSCapabilities     requiredCapability = RequestJobXML.MapJobTypeToCapability(jobType);
            string              text = null;
            DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.None);

            if (!string.IsNullOrEmpty(databaseInformation.ServerFqdn))
            {
                text = databaseInformation.ServerFqdn.ToLower(CultureInfo.InvariantCulture);
            }
            List <string> mrsServers = MailboxReplicationServiceClient.GetMrsServers(session, mdbGuid);
            List <string> list       = new List <string>(mrsServers.Count);

            foreach (string text2 in mrsServers)
            {
                string text3 = text2.ToLower(CultureInfo.InvariantCulture);
                if (string.Compare(text3, text, CultureInfo.InvariantCulture, CompareOptions.Ordinal) != 0 && !unreachableMrsServers.Contains(text3))
                {
                    list.Add(text2);
                }
            }
            List <string> list2 = CommonUtils.RandomizeSequence <string>(list);

            if (text != null)
            {
                list2.Insert(0, text);
            }
            foreach (string text4 in list2)
            {
                try
                {
                    return(MailboxReplicationServiceClient.Create(text4, requiredCapability));
                }
                catch (MailboxReplicationPermanentException ex)
                {
                    MrsTracer.Common.Warning("Attempt to connect to CAS Server {0} failed with error: {1}", new object[]
                    {
                        text4,
                        CommonUtils.FullExceptionMessage(ex)
                    });
                }
                catch (MailboxReplicationTransientException ex2)
                {
                    MrsTracer.Common.Warning("Attempt to connect to CAS Server {0} failed with error: {1}", new object[]
                    {
                        text4,
                        CommonUtils.FullExceptionMessage(ex2)
                    });
                }
                unreachableMrsServers.Add(text4.ToLower(CultureInfo.InvariantCulture));
            }
            throw new NoMRSAvailableTransientException();
        }
 public static void CleanADOrphanAndInconsistency()
 {
     PartitionId[] allAccountPartitionIds = ADAccountPartitionLocator.GetAllAccountPartitionIds();
     for (int i = 0; i < allAccountPartitionIds.Length; i++)
     {
         PartitionId partitionId = allAccountPartitionIds[i];
         CommonUtils.CheckForServiceStopping();
         ADSessionSettings adsessionSettings = ADSessionSettings.FromAllTenantsPartitionId(partitionId);
         adsessionSettings.IncludeSoftDeletedObjects = true;
         adsessionSettings.IncludeInactiveMailbox    = true;
         IRecipientSession     recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, false, ConsistencyMode.PartiallyConsistent, null, adsessionSettings, 45, "CleanADOrphanAndInconsistency", "f:\\15.00.1497\\sources\\dev\\mrs\\src\\Service\\ADInconsistencyCheck.cs");
         IConfigurationSession configSession    = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(null, false, ConsistencyMode.PartiallyConsistent, null, adsessionSettings, 52, "CleanADOrphanAndInconsistency", "f:\\15.00.1497\\sources\\dev\\mrs\\src\\Service\\ADInconsistencyCheck.cs");
         using (List <Guid> .Enumerator enumerator = MapiUtils.GetDatabasesOnThisServer().GetEnumerator())
         {
             while (enumerator.MoveNext())
             {
                 Guid dbGuid = enumerator.Current;
                 CommonUtils.CheckForServiceStopping();
                 DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(dbGuid, null, null, FindServerFlags.AllowMissing);
                 if (databaseInformation.IsMissing)
                 {
                     MrsTracer.Service.Debug("CleanADOrphanAndInconsistency Database {0} in Forest {1} is missing, skip it", new object[]
                     {
                         dbGuid,
                         databaseInformation.ForestFqdn
                     });
                 }
                 else
                 {
                     CommonUtils.CatchKnownExceptions(delegate
                     {
                         ADInconsistencyCheck.CleanADOrphanAndInconsistencyForRequests(recipientSession, configSession, dbGuid);
                     }, delegate(Exception f)
                     {
                         MrsTracer.Service.Error("CleanADOrphanAndInconsistency() failed for DB {0}. Error: {1}", new object[]
                         {
                             dbGuid,
                             CommonUtils.FullExceptionMessage(f, true)
                         });
                         MRSService.LogEvent(MRSEventLogConstants.Tuple_ScanADInconsistencyRequestFailEvent, new object[]
                         {
                             dbGuid,
                             string.Empty,
                             string.Empty,
                             CommonUtils.FullExceptionMessage(f, true)
                         });
                     });
                 }
             }
         }
     }
 }
        private bool InitializeIdentity()
        {
            DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(this.DatabaseGuid, null, null, FindServerFlags.AllowMissing);

            if (databaseInformation.IsMissing)
            {
                this.databaseName = string.Format("LegacyMdblCiUnresolved({0}{1})", this.DatabaseGuid.ToString(), databaseInformation.ForestFqdn);
            }
            else
            {
                this.databaseName = string.Format("LegacyMdblCi({0})", databaseInformation.DatabaseName);
            }
            return(!databaseInformation.IsMissing);
        }
Esempio n. 8
0
        protected override ICollection <ServiceIssue> RunFullIssueScan()
        {
            ICollection <ServiceIssue> collection = new List <ServiceIssue>();

            foreach (Guid mdbGuid in MapiUtils.GetDatabasesOnThisServer())
            {
                using (new DatabaseSettingsContext(mdbGuid, null).Activate())
                {
                    try
                    {
                        DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.None);
                        string databaseName = databaseInformation.DatabaseName;
                        if (!databaseInformation.IsOnThisServer)
                        {
                            return(null);
                        }
                        using (MapiStore systemMailbox = MapiUtils.GetSystemMailbox(mdbGuid, false))
                        {
                            using (MapiFolder requestJobsFolder = RequestJobXML.GetRequestJobsFolder(systemMailbox))
                            {
                                using (MapiTable contentsTable = requestJobsFolder.GetContentsTable(ContentsTableFlags.DeferredErrors))
                                {
                                    if (contentsTable.GetRowCount() > 0)
                                    {
                                        RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(systemMailbox);
                                        contentsTable.SetColumns(requestJobNamedPropertySet.PropTags);
                                        Restriction    restriction = Restriction.GT(requestJobNamedPropertySet.PropTags[23], ConfigBase <MRSConfigSchema> .GetConfig <int>("PoisonLimit"));
                                        List <MoveJob> allMoveJobs = SystemMailboxJobs.GetAllMoveJobs(restriction, null, contentsTable, mdbGuid, null);
                                        if (allMoveJobs != null)
                                        {
                                            foreach (MoveJob job in allMoveJobs)
                                            {
                                                collection.Add(new MRSPoisonedJobIssue(job));
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    catch (LocalizedException lastScanError)
                    {
                        base.LastScanError = lastScanError;
                    }
                }
            }
            return(collection);
        }
Esempio n. 9
0
        public static MDBPerfCounterHelper GetMDBHelper(Guid mdbGuid, bool createIfNotPresent)
        {
            MDBPerfCounterHelper mdbperfCounterHelper = null;
            MDBPerfCounterHelper result;

            lock (MDBPerfCounterHelperCollection.locker)
            {
                if (!MDBPerfCounterHelperCollection.data.TryGetValue(mdbGuid, out mdbperfCounterHelper) && createIfNotPresent)
                {
                    DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.AllowMissing);
                    mdbperfCounterHelper = new MDBPerfCounterHelper(databaseInformation.DatabaseName ?? MrsStrings.MissingDatabaseName2(mdbGuid, databaseInformation.ForestFqdn));
                    MDBPerfCounterHelperCollection.data.TryInsertSliding(mdbGuid, mdbperfCounterHelper, MDBPerfCounterHelperCollection.RefreshInterval);
                }
                result = mdbperfCounterHelper;
            }
            return(result);
        }
Esempio n. 10
0
        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));
        }
Esempio n. 11
0
        protected override IEnumerable <ResourceBase> GetDependentResources()
        {
            if (MapiUtils.FindServerForMdb(base.ResourceId, null, null, FindServerFlags.None).IsOnThisServer)
            {
                yield return(DatabaseWriteResource.Cache.GetInstance(base.ResourceId, base.WorkloadType));

                yield return(LocalServerWriteResource.Cache.GetInstance(LocalServerResource.ResourceId, base.WorkloadType));
            }
            if (base.Flags.HasFlag(ReservationFlags.Move))
            {
                yield return(MailboxMoveTargetResource.Cache.GetInstance(base.MailboxGuid));
            }
            if (base.Flags.HasFlag(ReservationFlags.Merge))
            {
                yield return(MailboxMergeTargetResource.Cache.GetInstance(base.MailboxGuid));
            }
            yield break;
        }
        internal static List <string> GetMrsServers(IConfigurationSession session, Guid mdbGuid)
        {
            DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.None);

            if (databaseInformation.ServerSite == null)
            {
                throw new UnableToDetermineMDBSitePermanentException(mdbGuid);
            }
            MrsTracer.Common.Debug("MDB '{0}' ({1}) found to belong to Site: '{2}'", new object[]
            {
                databaseInformation.DatabaseName,
                mdbGuid,
                databaseInformation.ServerSite
            });
            ServerVersion serverVersion = MailboxReplicationServiceClient.minRequiredVersion;
            QueryFilter   filter        = new AndFilter(new QueryFilter[]
            {
                new BitMaskAndFilter(ServerSchema.CurrentServerRole, 4UL),
                new ComparisonFilter(ComparisonOperator.NotEqual, ActiveDirectoryServerSchema.IsOutOfService, true),
                new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ServerSchema.VersionNumber, serverVersion.ToInt()),
                new ComparisonFilter(ComparisonOperator.Equal, ServerSchema.ServerSite, databaseInformation.ServerSite.DistinguishedName)
            });

            Server[] array = session.Find <Server>(null, QueryScope.SubTree, filter, null, 0);
            if (array == null || array.Length == 0)
            {
                MrsTracer.Common.Error("No Client Access servers running an appropriate version of Exchange 2010 (or later) were found in site '{0}'.", new object[]
                {
                    databaseInformation.ServerSite.ToString()
                });
                throw new ErrorNoCASServersInSitePermanentException(databaseInformation.ServerSite.ToString(), serverVersion.ToString());
            }
            List <string> list = new List <string>(array.Length);

            foreach (Server server in array)
            {
                string fqdn = server.Fqdn;
                if (!string.IsNullOrEmpty(fqdn))
                {
                    list.Add(fqdn);
                }
            }
            return(list);
        }
Esempio n. 13
0
        public static MapiStore GetSystemMailbox(Guid mdbGuid, string dcName, NetworkCredential cred, bool allowCrossSiteLogon)
        {
            bool        flag        = false;
            ConnectFlag connectFlag = ConnectFlag.UseAdminPrivilege | ConnectFlag.AllowLegacyStore;
            string      userName;
            string      password;
            string      domainName;
            TimeSpan    connectionTimeout;
            TimeSpan    callTimeout;

            if (cred != null)
            {
                userName          = cred.UserName;
                password          = cred.Password;
                domainName        = cred.Domain;
                connectionTimeout = TestIntegration.Instance.RemoteMailboxConnectionTimeout;
                callTimeout       = TestIntegration.Instance.RemoteMailboxCallTimeout;
            }
            else
            {
                userName          = null;
                password          = null;
                domainName        = null;
                connectFlag      |= ConnectFlag.UseRpcContextPool;
                connectionTimeout = TestIntegration.Instance.LocalMailboxConnectionTimeout;
                callTimeout       = TestIntegration.Instance.LocalMailboxCallTimeout;
            }
            DatabaseInformation databaseInformation;

            for (;;)
            {
                FindServerFlags findServerFlags = FindServerFlags.FindSystemMailbox;
                if (flag)
                {
                    findServerFlags |= FindServerFlags.ForceRediscovery;
                }
                databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, dcName, cred, findServerFlags);
                if (!allowCrossSiteLogon && !databaseInformation.IsInLocalSite)
                {
                    break;
                }
                MapiStore result;
                try
                {
                    MapiStore mapiStore = MapiStore.OpenMailbox(databaseInformation.ServerFqdn, Server.GetSystemAttendantLegacyDN(databaseInformation.ServerDN), databaseInformation.SystemMailboxGuid, mdbGuid, userName, domainName, password, connectFlag, OpenStoreFlag.UseAdminPrivilege | OpenStoreFlag.TakeOwnership | OpenStoreFlag.MailboxGuid, CultureInfo.InvariantCulture, null, "Client=MSExchangeMigration", connectionTimeout, callTimeout, null);
                    MapiUtils.StartMapiDeadSessionChecking(mapiStore, mdbGuid.ToString());
                    result = mapiStore;
                }
                catch (MapiExceptionWrongServer)
                {
                    if (!flag)
                    {
                        MrsTracer.Common.Debug("OpenMailbox returned WrongServer, forcing AM rediscovery", new object[0]);
                        flag = true;
                        continue;
                    }
                    throw;
                }
                catch (MapiExceptionLogonFailed)
                {
                    if (!flag)
                    {
                        MrsTracer.Common.Debug("OpenMailbox returned LogonFailed, forcing AM rediscovery", new object[0]);
                        flag = true;
                        continue;
                    }
                    throw;
                }
                catch (MapiExceptionUnknownUser)
                {
                    if (!flag)
                    {
                        MrsTracer.Common.Debug("OpenMailbox returned UnknownUser, forcing AM rediscovery", new object[0]);
                        flag = true;
                        continue;
                    }
                    throw;
                }
                return(result);
            }
            throw new CrossSiteLogonTransientException(mdbGuid, databaseInformation.ServerGuid, databaseInformation.ServerSite.ToString(), CommonUtils.LocalSiteId.ToString());
        }
Esempio n. 14
0
        public void PickupJobs(out string failure)
        {
            string dbName      = null;
            string scanFailure = null;

            failure = null;
            using (new DatabaseSettingsContext(this.MdbGuid, null).Activate())
            {
                CommonUtils.CatchKnownExceptions(delegate
                {
                    DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(this.MdbGuid, null, null, FindServerFlags.None);
                    dbName = databaseInformation.DatabaseName;
                    if (!databaseInformation.IsOnThisServer)
                    {
                        scanFailure = string.Format("MDB is mounted on remote server {0}", databaseInformation.ServerFqdn);
                        MRSQueue.RemoveQueue(this.MdbGuid);
                        return;
                    }
                    MrsTracer.Service.Debug("Picking up jobs from '{0}' ({1})", new object[]
                    {
                        dbName,
                        this.MdbGuid
                    });
                    using (MapiStore systemMailbox = MapiUtils.GetSystemMailbox(this.MdbGuid, false))
                    {
                        using (MapiFolder requestJobsFolder = RequestJobXML.GetRequestJobsFolder(systemMailbox))
                        {
                            using (MapiTable contentsTable = requestJobsFolder.GetContentsTable(ContentsTableFlags.DeferredErrors))
                            {
                                if (contentsTable.GetRowCount() > 0)
                                {
                                    RequestJobNamedPropertySet requestJobNamedPropertySet = RequestJobNamedPropertySet.Get(systemMailbox);
                                    contentsTable.SetColumns(requestJobNamedPropertySet.PropTags);
                                    this.ProcessJobs(systemMailbox, contentsTable, requestJobNamedPropertySet);
                                }
                            }
                        }
                    }
                    MrsTracer.Service.Debug("Pick up jobs from Mdb: '{0}' - complete.", new object[]
                    {
                        dbName
                    });
                }, delegate(Exception f)
                {
                    if (dbName == null)
                    {
                        dbName = MrsStrings.MissingDatabaseName(this.MdbGuid).ToString();
                    }
                    MrsTracer.Service.Debug("PickupJobs() failed for mdb '{0}'. Error: {1}", new object[]
                    {
                        dbName,
                        CommonUtils.FullExceptionMessage(f)
                    });
                    scanFailure = CommonUtils.FullExceptionMessage(f, true);
                    MRSService.LogEvent(MRSEventLogConstants.Tuple_UnableToProcessJobsInDatabase, new object[]
                    {
                        dbName,
                        CommonUtils.FullExceptionMessage(f)
                    });
                });
            }
            failure = scanFailure;
        }
 internal static string GetMrsServer(Guid mdbGuid)
 {
     return(MapiUtils.FindServerForMdb(mdbGuid, null, null, FindServerFlags.None).ServerFqdn);
 }
Esempio n. 16
0
        public override void Run()
        {
            Guid currentQueueGuid        = this.CurrentRequestQueue.ObjectGuid;
            Guid newQueueGuid            = this.NewRequestQueue.ObjectGuid;
            RequestJobObjectId currentId = new RequestJobObjectId(base.RequestGuid, currentQueueGuid, this.MessageId);
            RequestJobObjectId newId     = new RequestJobObjectId(base.RequestGuid, newQueueGuid, null);

            CommonUtils.CatchKnownExceptions(delegate
            {
                DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(this.NewRequestQueue, null, null, FindServerFlags.None);
                if (databaseInformation.ServerVersion < Server.E15MinVersion)
                {
                    throw new UnsupportedRehomeTargetVersionPermanentException(newQueueGuid.ToString(), new ServerVersion(databaseInformation.ServerVersion).ToString());
                }
                this.NewSystemMailbox = MapiUtils.GetSystemMailbox(newQueueGuid);
                using (RequestJobProvider currentQueueProvider = new RequestJobProvider(currentQueueGuid, this.CurrentSystemMailbox))
                {
                    using (RequestJobProvider newQueueProvider = new RequestJobProvider(newQueueGuid, this.NewSystemMailbox))
                    {
                        using (TransactionalRequestJob requestJob = (TransactionalRequestJob)currentQueueProvider.Read <TransactionalRequestJob>(currentId))
                        {
                            if (requestJob != null)
                            {
                                RequestJobProvider origProvider       = requestJob.Provider;
                                MoveObjectInfo <RequestJobXML> origMO = requestJob.MoveObject;
                                ReportData currentReport = new ReportData(requestJob.IdentifyingGuid, requestJob.ReportVersion);
                                currentReport.Load(currentQueueProvider.SystemMailbox);
                                ReportData newReport = new ReportData(currentReport.IdentifyingGuid, requestJob.ReportVersion);
                                newReport.Append(currentReport.Entries);
                                try
                                {
                                    requestJob.Provider           = null;
                                    requestJob.MoveObject         = null;
                                    requestJob.RequestQueue       = this.NewRequestQueue;
                                    requestJob.Identity           = newId;
                                    requestJob.OriginatingMDBGuid = Guid.Empty;
                                    requestJob.RehomeRequest      = false;
                                    if (requestJob.IndexEntries != null)
                                    {
                                        foreach (IRequestIndexEntry requestIndexEntry in requestJob.IndexEntries)
                                        {
                                            requestIndexEntry.StorageMDB = this.NewRequestQueue;
                                        }
                                    }
                                    newQueueProvider.Save(requestJob);
                                    CommonUtils.CatchKnownExceptions(delegate
                                    {
                                        newReport.Append(MrsStrings.ReportJobRehomed(currentQueueGuid.ToString(), newQueueGuid.ToString()));
                                        newReport.Flush(newQueueProvider.SystemMailbox);
                                    }, null);
                                    CommonUtils.CatchKnownExceptions(delegate
                                    {
                                        requestJob.Provider           = origProvider;
                                        requestJob.MoveObject         = origMO;
                                        requestJob.RequestQueue       = this.CurrentRequestQueue;
                                        requestJob.Identity           = currentId;
                                        requestJob.OriginatingMDBGuid = currentQueueGuid;
                                        requestJob.RehomeRequest      = true;
                                        MapiUtils.RetryOnObjectChanged(delegate
                                        {
                                            currentQueueProvider.Delete(requestJob);
                                        });
                                        currentReport.Delete(currentQueueProvider.SystemMailbox);
                                    }, null);
                                }
                                catch
                                {
                                    requestJob.Provider           = origProvider;
                                    requestJob.MoveObject         = origMO;
                                    requestJob.RequestQueue       = this.CurrentRequestQueue;
                                    requestJob.Identity           = currentId;
                                    requestJob.OriginatingMDBGuid = currentQueueGuid;
                                    requestJob.RehomeRequest      = true;
                                    throw;
                                }
                            }
                        }
                    }
                }
            }, delegate(Exception failure)
            {
                MrsTracer.Service.Warning("Failed to rehome request.", new object[0]);
                this.RehomeFailure = failure;
            });
            base.Run();
        }
Esempio n. 17
0
        public static MapiStore GetUserMailbox(Guid mailboxGuid, Guid mdbGuid, UserMailboxFlags umFlags)
        {
            OpenStoreFlag openStoreFlag = OpenStoreFlag.UseAdminPrivilege | OpenStoreFlag.TakeOwnership | OpenStoreFlag.NoLocalization | OpenStoreFlag.MailboxGuid;
            ConnectFlag   connectFlags  = ConnectFlag.UseAdminPrivilege | ConnectFlag.UseRpcContextPool | ConnectFlag.AllowLegacyStore;

            if (umFlags.HasFlag(UserMailboxFlags.RecoveryMDB))
            {
                openStoreFlag |= OpenStoreFlag.RestoreDatabase;
            }
            if (umFlags.HasFlag(UserMailboxFlags.Disconnected) || umFlags.HasFlag(UserMailboxFlags.SoftDeleted) || umFlags.HasFlag(UserMailboxFlags.MoveDestination))
            {
                openStoreFlag |= (OpenStoreFlag.OverrideHomeMdb | OpenStoreFlag.DisconnectedMailbox);
            }
            bool      flag = false;
            TimeSpan  localMailboxConnectionTimeout = TestIntegration.Instance.LocalMailboxConnectionTimeout;
            TimeSpan  localMailboxCallTimeout       = TestIntegration.Instance.LocalMailboxCallTimeout;
            MapiStore result;

            for (;;)
            {
                FindServerFlags findServerFlags = FindServerFlags.None;
                if (flag)
                {
                    findServerFlags |= FindServerFlags.ForceRediscovery;
                }
                DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(mdbGuid, null, null, findServerFlags);
                try
                {
                    MrsTracer.Common.Debug("Opening MapiStore: serverFqdn=\"{0}\", mailboxGuid=\"{1}\", mdbGuid=\"{2}\", flags=[{3}].", new object[]
                    {
                        databaseInformation.ServerFqdn,
                        mailboxGuid,
                        mdbGuid,
                        openStoreFlag
                    });
                    MapiStore mapiStore = MapiStore.OpenMailbox(databaseInformation.ServerFqdn, Server.GetSystemAttendantLegacyDN(databaseInformation.ServerDN), mailboxGuid, mdbGuid, null, null, null, connectFlags, openStoreFlag, null, null, "Client=MSExchangeMigration", localMailboxConnectionTimeout, localMailboxCallTimeout, null);
                    MapiUtils.StartMapiDeadSessionChecking(mapiStore, mailboxGuid.ToString());
                    result = mapiStore;
                }
                catch (MapiExceptionWrongServer)
                {
                    if (!flag)
                    {
                        MrsTracer.Common.Debug("OpenMailbox returned WrongServer, forcing AM rediscovery", new object[0]);
                        flag = true;
                        continue;
                    }
                    throw;
                }
                catch (MapiExceptionLogonFailed)
                {
                    if (!flag)
                    {
                        MrsTracer.Common.Debug("OpenMailbox returned LogonFailed, forcing AM rediscovery", new object[0]);
                        flag = true;
                        continue;
                    }
                    throw;
                }
                break;
            }
            return(result);
        }