コード例 #1
0
        private bool CleanupServers(IADToplogyConfigurationSession adSession, IClusterDB clusdb, HashSet <Guid> serverGuids, Dictionary <Guid, IADServer> validServers)
        {
            if (validServers.Count == 0)
            {
                ReplayCrimsonEvents.ClusdbPeriodicCleanupSkipped.Log <string, string>("Server", "Could not find a single valid server in the cached list");
                return(false);
            }
            IADServer value = validServers.First <KeyValuePair <Guid, IADServer> >().Value;

            if (adSession.FindServerByName(value.Name) == null)
            {
                ReplayCrimsonEvents.ClusdbPeriodicCleanupSkipped.Log <string, string>("Server", "Could not find a single valid server in AD");
                return(false);
            }
            bool result = false;

            try
            {
                this.RemoveStaleServerGuids(clusdb, serverGuids);
                serverGuids.ExceptWith(this.staleServers);
                result = true;
            }
            catch (Exception ex)
            {
                ReplayCrimsonEvents.ClusdbPeriodicCleanupFailed.Log <string, string>("Server", ex.ToString());
            }
            this.staleServers = serverGuids;
            return(result);
        }
コード例 #2
0
        private bool CleanupDatabases(IADToplogyConfigurationSession adSession, IClusterDB clusdb, HashSet <Guid> dbGuidsToDelete, HashSet <Guid> validDatabaseGuids)
        {
            if (validDatabaseGuids.Count == 0)
            {
                ReplayCrimsonEvents.ClusdbPeriodicCleanupSkipped.Log <string, string>("Database", "Could not find a single valid database in cached list");
                return(false);
            }
            if (adSession.FindDatabaseByGuid(validDatabaseGuids.First <Guid>()) == null)
            {
                ReplayCrimsonEvents.ClusdbPeriodicCleanupSkipped.Log <string, string>("Database", "Could not find a single valid database in AD");
                return(false);
            }
            bool result = false;

            try
            {
                this.RemoveStaleDatabaseGuids(clusdb, dbGuidsToDelete);
                dbGuidsToDelete.ExceptWith(this.staleDatabases);
                result = true;
            }
            catch (Exception ex)
            {
                ReplayCrimsonEvents.ClusdbPeriodicCleanupFailed.Log <string, string>("Database", ex.ToString());
            }
            this.staleDatabases = dbGuidsToDelete;
            return(result);
        }
コード例 #3
0
        internal Dictionary <Guid, AmDbStateInfo> GetAllDbStatesFromClusdb(IClusterDB clusdb)
        {
            Dictionary <Guid, AmDbStateInfo> dictionary = new Dictionary <Guid, AmDbStateInfo>();

            if (!DistributedStore.Instance.IsKeyExist("ExchangeActiveManager\\DbState", null))
            {
                return(dictionary);
            }
            IEnumerable <Tuple <string, RegistryValueKind> > valueInfos = clusdb.GetValueInfos("ExchangeActiveManager\\DbState");

            if (valueInfos != null)
            {
                foreach (Tuple <string, RegistryValueKind> tuple in valueInfos)
                {
                    string item  = tuple.Item1;
                    string value = clusdb.GetValue <string>("ExchangeActiveManager\\DbState", item, string.Empty);
                    Guid   guid;
                    if (!string.IsNullOrEmpty(value) && Guid.TryParse(item, out guid))
                    {
                        AmDbStateInfo value2 = AmDbStateInfo.Parse(guid, value);
                        dictionary.Add(guid, value2);
                    }
                }
            }
            return(dictionary);
        }
コード例 #4
0
        public static void ReadServerDatabaseSchemaVersionRange(IClusterDB iClusterDB, Guid serverGuid, int defaultMinimum, int defaultMaximum, out int minVersion, out int maxVersion)
        {
            string keyName = string.Format("Exchange\\Servers\\{0}\\Schema", serverGuid);

            minVersion = iClusterDB.GetValue <int>(keyName, "Minimum Version", defaultMinimum);
            maxVersion = iClusterDB.GetValue <int>(keyName, "Maximum Version", defaultMaximum);
        }
コード例 #5
0
        public static void GetSupporableDatabaseSchemaVersionRange(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database, out int minVersion, out int maxVersion, out int currentRequestedVersion)
        {
            currentRequestedVersion = 0;
            int num  = int.MaxValue;
            int num2 = 0;
            DatabaseAvailabilityGroup databaseAvailabilityGroup;

            using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase(taskSession, writeLog, writeWarning, writeError, database, false, out databaseAvailabilityGroup))
            {
                if (clusterDB != null && clusterDB.IsInitialized)
                {
                    ClusterDBHelpers.ReadRequestedDatabaseSchemaVersion(clusterDB, database.Guid, 0, out currentRequestedVersion);
                    foreach (ADObjectId adobjectId in databaseAvailabilityGroup.Servers)
                    {
                        int num3;
                        int num4;
                        ClusterDBHelpers.ReadServerDatabaseSchemaVersionRange(clusterDB, adobjectId.ObjectGuid, 121, 121, out num3, out num4);
                        writeLog(Strings.ServerSchemaVersionRange(adobjectId.ObjectGuid.ToString(), num3, num4));
                        num2 = Math.Max(num3, num2);
                        num  = Math.Min(num4, num);
                    }
                }
            }
            if (num2 > num)
            {
                writeError(new IncompatibleDatabaseSchemaVersionsInDAGException(), ErrorCategory.MetadataError, database);
            }
            minVersion = num2;
            maxVersion = num;
        }
コード例 #6
0
 protected override void TimerCallbackInternal()
 {
     try
     {
         if (AmSystemManager.Instance.Config.IsPAM)
         {
             using (IClusterDB clusterDB = ClusterDB.Open())
             {
                 this.CleanupStaleEntries(clusterDB);
             }
         }
     }
     catch (Exception ex)
     {
         ReplayCrimsonEvents.ClusdbPeriodicCleanupFailed.Log <string, string>("Common", ex.ToString());
     }
     finally
     {
         if (this.staleDatabases.Count > 0 || this.staleServers.Count > 0)
         {
             ReplayCrimsonEvents.ClusdbPeriodicCleanupFoundStale.Log <int, int>(this.staleDatabases.Count, this.staleServers.Count);
         }
         else
         {
             ReplayCrimsonEvents.ClusdbPeriodicCleanupNoStale.Log();
         }
     }
 }
コード例 #7
0
 public static void RemoveServerSchemaVersionRange(IClusterDB iClusterDB, Guid serverGuid)
 {
     using (IClusterDBWriteBatch clusterDBWriteBatch = iClusterDB.CreateWriteBatch("Exchange\\Servers"))
     {
         clusterDBWriteBatch.DeleteKey(serverGuid.ToString());
         clusterDBWriteBatch.Execute();
     }
 }
コード例 #8
0
 public static void RemoveDatabaseRequestedSchemaVersion(IClusterDB iClusterDB, Guid databaseGuid)
 {
     using (IClusterDBWriteBatch clusterDBWriteBatch = iClusterDB.CreateWriteBatch("Exchange\\Databases"))
     {
         clusterDBWriteBatch.DeleteKey(databaseGuid.ToString());
         clusterDBWriteBatch.Execute();
     }
 }
コード例 #9
0
 private void RemoveStaleServerGuids(IClusterDB clusdb, HashSet <Guid> serverGuids)
 {
     this.staleServers.IntersectWith(serverGuids);
     if (this.staleServers.Count == 0)
     {
         return;
     }
     this.RemoveItemsFromClusdb("Database", clusdb, "Exchange\\Servers", true, this.staleServers, null, 200);
 }
コード例 #10
0
        internal static void RemoveEntryFromClusdb(string serverName, string actionName)
        {
            using (IClusterDB clusterDB = ClusterDB.Open())
            {
                string keyName = AmThrottledActionTracker <TData> .ConstructRegKeyName(serverName);

                clusterDB.DeleteValue(keyName, actionName);
            }
        }
コード例 #11
0
        public static void WriteRequestedDatabaseSchemaVersion(IClusterDB iClusterDB, Guid databaseGuid, int requestedVersion)
        {
            string registryKey = string.Format("Exchange\\Databases\\{0}\\Schema", databaseGuid);

            using (IClusterDBWriteBatch clusterDBWriteBatch = iClusterDB.CreateWriteBatch(registryKey))
            {
                clusterDBWriteBatch.SetValue("Requested Version", requestedVersion);
                clusterDBWriteBatch.Execute();
            }
        }
コード例 #12
0
        public static void WriteServerDatabaseSchemaVersionRange(IClusterDB iClusterDB, Guid serverGuid, int minVersion, int maxVersion)
        {
            string registryKey = string.Format("Exchange\\Servers\\{0}\\Schema", serverGuid);

            using (IClusterDBWriteBatch clusterDBWriteBatch = iClusterDB.CreateWriteBatch(registryKey))
            {
                clusterDBWriteBatch.SetValue("Minimum Version", minVersion);
                clusterDBWriteBatch.SetValue("Maximum Version", maxVersion);
                clusterDBWriteBatch.Execute();
            }
        }
コード例 #13
0
        protected override void InternalValidate()
        {
            TaskLogger.LogEnter();
            base.InternalValidate();
            Server server = this.DataObject.GetServer();
            bool   flag   = false;

            if (server == null)
            {
                base.WriteError(new InvalidOperationException(Strings.ErrorDBOwningServerNotFound(this.DataObject.Identity.ToString())), ErrorCategory.InvalidOperation, this.DataObject.Identity);
            }
            else
            {
                flag = server.IsE15OrLater;
            }
            if (!flag)
            {
                base.WriteError(new InvalidOperationException(Strings.ErrorModifyE14DatabaseNotAllowed), ErrorCategory.InvalidOperation, this.DataObject.Identity);
            }
            DatabaseAvailabilityGroup databaseAvailabilityGroup;

            using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), this.DataObject, false, out databaseAvailabilityGroup))
            {
                if (clusterDB == null || !clusterDB.IsInstalled)
                {
                    base.WriteError(new InvalidOperationException(Strings.ErrorSchemaVersionDoesntApply(this.DataObject.Name)), ErrorCategory.InvalidOperation, this.DataObject.Identity);
                }
            }
            if (base.Fields.IsModified("MajorVersion"))
            {
                this.version = UpdateDatabaseSchema.VersionFromComponents(this.MajorVersion, this.MinorVersion);
                int num;
                int num2;
                int num3;
                DatabaseTasksHelper.GetSupporableDatabaseSchemaVersionRange((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), this.DataObject, out num, out num2, out num3);
                if (this.version < num || this.version > num2)
                {
                    base.WriteError(new InvalidOperationException(Strings.ErrorSchemaVersionOutOfRange(UpdateDatabaseSchema.VersionString(num), UpdateDatabaseSchema.VersionString(num2))), ErrorCategory.InvalidOperation, this.DataObject.Identity);
                }
                if (num3 > this.version)
                {
                    this.WriteWarning(Strings.RequestedVersionIsLowerThanCurrentVersion(num3));
                }
            }
            else
            {
                this.version = DatabaseTasksHelper.GetMaximumSupportedDatabaseSchemaVersion((ITopologyConfigurationSession)base.DataSession, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError), this.DataObject);
            }
            TaskLogger.LogExit();
        }
コード例 #14
0
 private void RemoveStaleDatabaseGuids(IClusterDB clusdb, HashSet <Guid> dbGuids)
 {
     this.staleDatabases.IntersectWith(dbGuids);
     if (this.staleDatabases.Count == 0)
     {
         return;
     }
     this.RemoveItemsFromClusdb("Database", clusdb, "ExchangeActiveManager\\LastLog", false, this.staleDatabases, null, 200);
     this.RemoveItemsFromClusdb("Database", clusdb, "ExchangeActiveManager\\LastLog", false, this.staleDatabases, (string s) => s + "_Time", 200);
     this.RemoveItemsFromClusdb("Database", clusdb, "ExchangeActiveManager\\Dumpster", true, this.staleDatabases, null, 200);
     this.RemoveItemsFromClusdb("Database", clusdb, "ExchangeActiveManager\\SafetyNet2", true, this.staleDatabases, null, 200);
     this.RemoveItemsFromClusdb("Database", clusdb, "Exchange\\Databases", true, this.staleDatabases, null, 200);
     this.RemoveItemsFromClusdb("Database", clusdb, "MsExchangeIs", true, this.staleDatabases, (string s) => "Private_" + s, 200);
     this.RemoveItemsFromClusdb("Database", clusdb, "ExchangeActiveManager\\DbState", false, this.staleDatabases, null, 200);
 }
コード例 #15
0
        private HashSet <Guid> GetServersToBeDeleted(IMonitoringADConfig adConfig, IClusterDB clusdb, out Dictionary <Guid, IADServer> validServers)
        {
            validServers = new Dictionary <Guid, IADServer>();
            HashSet <Guid> allServersInClusdb       = this.GetAllServersInClusdb(clusdb);
            Dictionary <Guid, IADServer> dictionary = adConfig.Servers.ToDictionary((IADServer s) => s.Guid);

            foreach (Guid key in allServersInClusdb)
            {
                IADServer value;
                if (dictionary.TryGetValue(key, out value))
                {
                    validServers.Add(key, value);
                }
            }
            allServersInClusdb.ExceptWith(validServers.Keys);
            return(allServersInClusdb);
        }
コード例 #16
0
 public static void RemoveDatabaseFromClusterDB(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database)
 {
     try
     {
         DatabaseAvailabilityGroup databaseAvailabilityGroup;
         using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase(taskSession, writeLog, writeWarning, writeError, database, true, out databaseAvailabilityGroup))
         {
             if (clusterDB != null && clusterDB.IsInitialized)
             {
                 writeLog(Strings.DeleteClusterDBKey(database.Name));
                 ClusterDBHelpers.RemoveDatabaseRequestedSchemaVersion(clusterDB, database.Guid);
             }
         }
     }
     catch (ClusterException)
     {
         writeWarning(Strings.FailedToRemoveDatabaseSection(database.Name));
     }
 }
コード例 #17
0
        private void CleanupStaleEntries(IClusterDB clusdb)
        {
            IMonitoringADConfig          config = Dependencies.MonitoringADConfigProvider.GetConfig(true);
            HashSet <Guid>               validDatabaseGuids;
            HashSet <Guid>               databasesToBeDeleted = this.GetDatabasesToBeDeleted(config, clusdb, out validDatabaseGuids);
            Dictionary <Guid, IADServer> validServers;
            HashSet <Guid>               serversToBeDeleted = this.GetServersToBeDeleted(config, clusdb, out validServers);

            if (databasesToBeDeleted.Count == 0 && serversToBeDeleted.Count == 0)
            {
                this.staleDatabases.Clear();
                this.staleServers.Clear();
                return;
            }
            IADToplogyConfigurationSession adSession = ADSessionFactory.CreateIgnoreInvalidRootOrgSession(true);

            this.CleanupDatabases(adSession, clusdb, databasesToBeDeleted, validDatabaseGuids);
            this.CleanupServers(adSession, clusdb, serversToBeDeleted, validServers);
        }
コード例 #18
0
        private HashSet <Guid> GetDatabasesToBeDeleted(IMonitoringADConfig adConfig, IClusterDB clusdb, out HashSet <Guid> validDatabaseGuids)
        {
            validDatabaseGuids = new HashSet <Guid>();
            Dictionary <Guid, AmDbStateInfo> allDbStatesFromClusdb = this.GetAllDbStatesFromClusdb(clusdb);

            foreach (KeyValuePair <Guid, AmDbStateInfo> keyValuePair in allDbStatesFromClusdb)
            {
                Guid        key             = keyValuePair.Key;
                DateTime    lastMountedTime = keyValuePair.Value.LastMountedTime;
                IADDatabase iaddatabase;
                bool        flag  = adConfig.DatabaseByGuidMap.TryGetValue(key, out iaddatabase);
                bool        flag2 = lastMountedTime > DateTime.UtcNow.AddDays(-5.0);
                if (flag || flag2)
                {
                    validDatabaseGuids.Add(key);
                }
            }
            return(new HashSet <Guid>(allDbStatesFromClusdb.Keys.Except(validDatabaseGuids)));
        }
コード例 #19
0
        // Token: 0x06001BD8 RID: 7128 RVA: 0x00078450 File Offset: 0x00076650
        internal static ExDateTime GetLastServerUpdateTimeFromClusdb()
        {
            ExDateTime exDateTimeMinValueUtc = SharedHelper.ExDateTimeMinValueUtc;

            try
            {
                using (IClusterDB clusterDB = ClusterDB.Open())
                {
                    string value = clusterDB.GetValue <string>("ExchangeActiveManager\\LastLog", AmServerName.LocalComputerName.NetbiosName, string.Empty);
                    if (!string.IsNullOrEmpty(value) && !ExDateTime.TryParse(value, out exDateTimeMinValueUtc))
                    {
                        exDateTimeMinValueUtc = SharedHelper.ExDateTimeMinValueUtc;
                    }
                }
            }
            catch (ClusterException ex)
            {
                ClusterBatchWriter.Tracer.TraceError <string>(0L, "GetLastServerUpdateTimeFromClusdb() failed with {0}", ex.Message);
            }
            return(exDateTimeMinValueUtc);
        }
コード例 #20
0
        private void InitializeFromClusdbInternal()
        {
            AmConfig config = AmSystemManager.Instance.Config;

            if (config.IsPAM)
            {
                AmDagConfig dagConfig = config.DagConfig;
                using (IClusterDB clusterDB = ClusterDB.Open())
                {
                    foreach (AmServerName amServerName in dagConfig.MemberServers)
                    {
                        string keyName = AmThrottledActionTracker <TData> .ConstructRegKeyName(amServerName.NetbiosName);

                        string[] value = clusterDB.GetValue <string[]>(keyName, this.ActionName, null);
                        if (value != null && value.Length > 0)
                        {
                            LinkedList <TData> linkedList = new LinkedList <TData>();
                            foreach (string text in value)
                            {
                                int num = text.IndexOf('=');
                                if (num != -1)
                                {
                                    string s       = text.Substring(0, num);
                                    string dataStr = null;
                                    if (num < text.Length - 1)
                                    {
                                        dataStr = text.Substring(num + 1);
                                    }
                                    ExDateTime actionTime = ExDateTime.Parse(s);
                                    TData      value2     = Activator.CreateInstance <TData>();
                                    value2.Initialize(actionTime, dataStr);
                                    linkedList.AddFirst(value2);
                                }
                            }
                            this.actionHistory[amServerName] = linkedList;
                        }
                    }
                }
            }
        }
コード例 #21
0
 public static void SetRequestedDatabaseSchemaVersion(ITopologyConfigurationSession taskSession, Task.TaskVerboseLoggingDelegate writeLog, Task.TaskWarningLoggingDelegate writeWarning, Task.TaskErrorLoggingDelegate writeError, Database database, int version)
 {
     try
     {
         DatabaseAvailabilityGroup databaseAvailabilityGroup;
         using (IClusterDB clusterDB = DatabaseTasksHelper.OpenClusterDatabase(taskSession, writeLog, writeWarning, writeError, database, false, out databaseAvailabilityGroup))
         {
             if (clusterDB != null && clusterDB.IsInitialized)
             {
                 writeLog(Strings.SetDatabaseRequestedSchemaVersion(database.Name, version));
                 ClusterDBHelpers.WriteRequestedDatabaseSchemaVersion(clusterDB, database.Guid, version);
             }
         }
     }
     catch (ClusterException)
     {
         if (writeError != null)
         {
             writeError(new FailedToSetRequestedDatabaseSchemaVersionException(database.Name), ErrorCategory.WriteError, database);
         }
     }
 }
コード例 #22
0
        private void Persist(AmServerName node)
        {
            LinkedList <TData> linkedList;

            if (this.actionHistory.TryGetValue(node, out linkedList) && linkedList != null && linkedList.Count > 0)
            {
                using (IClusterDB clusterDB = ClusterDB.Open())
                {
                    List <string> list = new List <string>();
                    foreach (TData tdata in linkedList)
                    {
                        string arg     = tdata.Time.UniversalTime.ToString("o");
                        string dataStr = tdata.DataStr;
                        string item    = string.Format("{0}{1}{2}", arg, '=', dataStr);
                        list.Add(item);
                    }
                    string[] propetyValue = list.ToArray();
                    string   keyName      = AmThrottledActionTracker <TData> .ConstructRegKeyName(node.NetbiosName);

                    clusterDB.SetValue <string[]>(keyName, this.ActionName, propetyValue);
                }
            }
        }
コード例 #23
0
        internal HashSet <Guid> GetAllServersInClusdb(IClusterDB clusdb)
        {
            HashSet <Guid> hashSet = new HashSet <Guid>();

            if (!DistributedStore.Instance.IsKeyExist("Exchange\\Servers", null))
            {
                return(hashSet);
            }
            IEnumerable <string> subKeyNames = clusdb.GetSubKeyNames("Exchange\\Servers");

            if (subKeyNames != null)
            {
                foreach (string input in subKeyNames)
                {
                    Guid item;
                    if (Guid.TryParse(input, out item))
                    {
                        hashSet.Add(item);
                    }
                }
            }
            return(hashSet);
        }
コード例 #24
0
        public static void ReadRequestedDatabaseSchemaVersion(IClusterDB iClusterDB, Guid databaseGuid, int defaultVersion, out int requestedVersion)
        {
            string keyName = string.Format("Exchange\\Databases\\{0}\\Schema", databaseGuid);

            requestedVersion = iClusterDB.GetValue <int>(keyName, "Requested Version", defaultVersion);
        }
コード例 #25
0
        private int RemoveItemsFromClusdb(string objectName, IClusterDB clusdb, string keyName, bool isDeleteKey, IEnumerable <Guid> collection, Func <string, string> nameGenerator = null, int batchSize = 200)
        {
            if (!DistributedStore.Instance.IsKeyExist(keyName, null))
            {
                return(0);
            }
            int num  = 0;
            int num2 = 0;
            HashSet <string> hashSet = new HashSet <string>(collection.Select(delegate(Guid id)
            {
                string text2 = id.ToString();
                if (nameGenerator != null)
                {
                    return(nameGenerator(text2));
                }
                return(text2);
            }));

            num2 = hashSet.Count;
            try
            {
                if (isDeleteKey)
                {
                    IEnumerable <string> subKeyNames = clusdb.GetSubKeyNames(keyName);
                    hashSet.IntersectWith(subKeyNames);
                }
                else
                {
                    IEnumerable <string> other = from vi in clusdb.GetValueInfos(keyName)
                                                 select vi.Item1;
                    hashSet.IntersectWith(other);
                }
            }
            catch (Exception ex)
            {
                ReplayCrimsonEvents.ClusdbPeriodicCleanupFailed.Log <string, string>(objectName, ex.ToString());
                return(0);
            }
            if (hashSet.Count == 0)
            {
                return(0);
            }
            int       num3      = 0;
            int       num4      = 0;
            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();
            foreach (IEnumerable <string> enumerable in hashSet.Batch(batchSize))
            {
                num++;
                int num5 = 0;
                try
                {
                    using (IClusterDBWriteBatch clusterDBWriteBatch = clusdb.CreateWriteBatch(keyName))
                    {
                        foreach (string text in enumerable)
                        {
                            num5++;
                            if (isDeleteKey)
                            {
                                clusterDBWriteBatch.DeleteKey(text);
                            }
                            else
                            {
                                clusterDBWriteBatch.DeleteValue(text);
                            }
                        }
                        clusterDBWriteBatch.Execute();
                        num3 += num5;
                    }
                }
                catch (Exception ex2)
                {
                    num4++;
                    ReplayCrimsonEvents.ClusdbCleanupBatchOperationFailed.Log <string, string, string, bool, int, int, int, int>(objectName, ex2.Message, keyName, isDeleteKey, num, num5, num2, hashSet.Count);
                }
            }
            long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;

            ReplayCrimsonEvents.ClusdbPeriodicCleanupCompleted.Log <string, string, int, string, int, int, long>(objectName, keyName, num3, isDeleteKey ? "Key" : "Property", num, num4, elapsedMilliseconds);
            return(num3);
        }
コード例 #26
0
 // Token: 0x060000B2 RID: 178 RVA: 0x00005148 File Offset: 0x00003348
 internal void Flush()
 {
     if (AmSystemManager.Instance.Config.IsPAM)
     {
         Dictionary <AmServerName, AmCachedLastLogUpdater.ServerRequestInfo> dictionary = this.Cleanup();
         if (dictionary.Count > 0)
         {
             Exception ex = null;
             try
             {
                 using (IClusterDB clusterDB = ClusterDB.Open())
                 {
                     if (clusterDB.IsInitialized)
                     {
                         using (IClusterDBWriteBatch clusterDBWriteBatch = clusterDB.CreateWriteBatch("ExchangeActiveManager\\LastLog"))
                         {
                             this.PopulateBatch(clusterDBWriteBatch, dictionary);
                             clusterDBWriteBatch.Execute();
                             ExDateTime now = ExDateTime.Now;
                             foreach (AmServerName key in dictionary.Keys)
                             {
                                 this.serverUpdateTimeMap[key] = now;
                             }
                             goto IL_BA;
                         }
                     }
                     ExTraceGlobals.ClusterTracer.TraceError((long)this.GetHashCode(), "Flush(): clusdb is not initialized");
                     IL_BA :;
                 }
             }
             catch (ADExternalException ex2)
             {
                 ex = ex2;
             }
             catch (ADOperationException ex3)
             {
                 ex = ex3;
             }
             catch (ADTransientException ex4)
             {
                 ex = ex4;
             }
             catch (ClusterException ex5)
             {
                 ex = ex5;
             }
             catch (AmServerException ex6)
             {
                 ex = ex6;
             }
             catch (AmServerTransientException ex7)
             {
                 ex = ex7;
             }
             if (ex != null)
             {
                 ReplayCrimsonEvents.CachedLastLogUpdateFailed.LogPeriodic <int, string>(AmServerName.LocalComputerName.NetbiosName, TimeSpan.FromMinutes(5.0), dictionary.Count, ex.Message);
             }
         }
     }
 }