internal static TransportRulePredicate CreateFromInternalCondition <T>(Condition condition, string propertyName) where T : SizeOverPredicate, new() { if (condition.ConditionType != ConditionType.Predicate) { return(null); } PredicateCondition predicateCondition = (PredicateCondition)condition; if (!predicateCondition.Name.Equals("greaterThanOrEqual") || !predicateCondition.Property.Name.Equals(propertyName) || predicateCondition.Value.RawValues.Count != 1) { return(null); } ulong num; if (!ulong.TryParse(predicateCondition.Value.RawValues[0], out num)) { return(null); } T t = Activator.CreateInstance <T>(); if (num == 0UL) { t.Size = ByteQuantifiedSize.FromKB(0UL); } else { t.Size = ByteQuantifiedSize.FromBytes(num); } return(t); }
public MailboxFolderConfiguration() : base(new MapiFolderConfigurationPropertyBag()) { this.DeletedItemsInFolder = 0; this.DeletedItemsInFolderAndSubfolders = 0; this.ItemsInFolder = 0; this.ItemsInFolderAndSubfolders = 0; this.FolderAndSubfolderSize = ByteQuantifiedSize.FromBytes(0UL); this.FolderSize = ByteQuantifiedSize.FromBytes(0UL); this.Date = DateTime.MinValue; this.NewestDeletedItemReceivedDate = null; this.NewestItemReceivedDate = null; this.OldestDeletedItemReceivedDate = null; this.OldestItemReceivedDate = null; this.NewestDeletedItemLastModifiedDate = null; this.NewestItemLastModifiedDate = null; this.OldestDeletedItemLastModifiedDate = null; this.OldestItemLastModifiedDate = null; this.FolderId = null; this.FolderPath = null; this.FolderType = null; this.Name = null; this.ManagedFolder = null; this.DeletePolicy = null; this.ArchivePolicy = null; this.TopSubjectCount = 0; this.TopSubjectSize = ByteQuantifiedSize.FromBytes(0UL); this.TopClientInfoForSubject = string.Empty; this.TopClientInfoCountForSubject = 0; this.TopSubjectPath = string.Empty; this.TopSubject = string.Empty; this.TopSubjectReceivedTime = null; this.TopSubjectFrom = string.Empty; this.TopSubjectClass = string.Empty; this.SearchFolders = null; }
protected override void LoadCustomSettings() { base.DirectoryPath = this.logConfig.Value.LoggingFolder; base.MaxDirectorySize = ByteQuantifiedSize.FromBytes((ulong)this.logConfig.Value.MaxLogDirSize); base.MaxFileSize = ByteQuantifiedSize.FromBytes((ulong)this.logConfig.Value.MaxLogFileSize); base.MaxAge = this.logConfig.Value.MaxLogAge; }
private void FillDatabaseSize(ExRpcAdmin rpcAdmin, Database database) { try { FaultInjectionUtils.FaultInjectionTracer.TraceTest(3395693885U); ulong bytesValue; ulong bytesValue2; rpcAdmin.GetDatabaseSize(database.Guid, out bytesValue, out bytesValue2); database.DatabaseSize = new ByteQuantifiedSize?(ByteQuantifiedSize.FromBytes(bytesValue)); database.AvailableNewMailboxSpace = new ByteQuantifiedSize?(ByteQuantifiedSize.FromBytes(bytesValue2)); } catch (MapiExceptionNoSupport) { } catch (MapiPermanentException ex) { TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillDatabaseSize(Database '{0}') raises exception: {1}", new object[] { database.Identity.ToString(), ex.Message }), new object[0]); this.WriteWarning(Strings.ErrorFailedToGetDatabaseSize(database.Identity.ToString())); } catch (MapiRetryableException ex2) { TaskLogger.Trace(string.Format(CultureInfo.InvariantCulture, "GetDatabase.FillDatabaseSize(Database '{0}') raises exception: {1}", new object[] { database.Identity.ToString(), ex2.Message }), new object[0]); this.WriteWarning(Strings.ErrorFailedToGetDatabaseSize(database.Identity.ToString())); } }
public void ProcessDatabase() { if (!this.settings.AutomaticDatabaseDrainEnabled) { return; } if (this.database == null) { return; } ByteQuantifiedSize currentPhysicalSize = this.database.GetSize().CurrentPhysicalSize; double num = 1.0 + (double)this.settings.AutomaticDrainStartFileSizePercent / 100.0; ulong bytesValue = (ulong)(this.database.MaximumSize.ToBytes() * num); if (currentPhysicalSize >= ByteQuantifiedSize.FromBytes(bytesValue)) { this.logger.LogInformation("Database {0} has {1} EDB file size, and the maximum allowed size is {2} with a {3}% tolerance. Starting drain process.", new object[] { this.database.Identity, currentPhysicalSize, this.database.MaximumSize, this.settings.AutomaticDrainStartFileSizePercent }); this.drainControl.BeginDrainDatabase(this.database); } }
public DatabaseSizeInfo GetDatabaseSize(DirectoryDatabase database) { DatabaseSizeInfo result; using (ExRpcAdmin exRpcAdminForDatabase = this.GetExRpcAdminForDatabase(database)) { ulong bytesValue; ulong bytesValue2; exRpcAdminForDatabase.GetDatabaseSize(database.Guid, out bytesValue, out bytesValue2); ByteQuantifiedSize byteQuantifiedSize = ByteQuantifiedSize.FromBytes(bytesValue); ByteQuantifiedSize byteQuantifiedSize2 = ByteQuantifiedSize.FromBytes(bytesValue2); if (byteQuantifiedSize2 > byteQuantifiedSize) { this.logger.LogWarning("Database {0} has more free space ({1}) than its total size ({2}), assuming sparse EDB file with no free pages.", new object[] { database.Name, byteQuantifiedSize2, byteQuantifiedSize }); byteQuantifiedSize2 = ByteQuantifiedSize.Zero; } result = new DatabaseSizeInfo { AvailableWhitespace = byteQuantifiedSize2, CurrentPhysicalSize = byteQuantifiedSize }; } return(result); }
public static object ExtractUnlimitedByteQuantifiedSizeFromPages(PropValue value, MapiPropertyDefinition propertyDefinition) { if (typeof(Unlimited <ByteQuantifiedSize>) == propertyDefinition.Type) { object obj = null; if (MapiPropValueConvertor.TryCastValueToExtract(value, typeof(int), out obj)) { long num = (long)((int)obj); if (0L > num) { return(Unlimited <ByteQuantifiedSize> .UnlimitedValue); } return(new Unlimited <ByteQuantifiedSize>(ByteQuantifiedSize.FromBytes(checked ((ulong)num * 32UL * 1024UL)))); } } throw MapiPropValueConvertor.ConstructExtractingException(value, propertyDefinition, Strings.ConstantNa); }
internal static byte[] PackAndValidateCompressedRulePackage(byte[] uncompressedSerializedRulePackageData, ValidationContext validationContext) { byte[] array; if (!ClassificationDefinitionUtils.TryCompressXmlBytes(uncompressedSerializedRulePackageData, out array)) { throw new ClassificationRuleCollectionStorageException(); } ByteQuantifiedSize value = (ByteQuantifiedSize)DataClassificationConfigSchema.MaxRulePackageSize.DefaultValue; if (validationContext != null && validationContext.DcValidationConfig != null) { value = validationContext.DcValidationConfig.MaxRulePackageSize; } ByteQuantifiedSize value2 = ByteQuantifiedSize.FromBytes((ulong)((long)array.Length)); if (value2 > value) { throw new ClassificationRuleCollectionPayloadSizeExceededLimitException(value2.ToKB(), value.ToKB()); } return(array); }
public static string FromMB(this string size) { if (string.IsNullOrWhiteSpace(size)) { throw new ArgumentNullException("size"); } string result; try { result = ByteQuantifiedSize.FromBytes(checked ((ulong)Math.Round(unchecked (Convert.ToDouble(size) * 1048576.0), 0))).ToString(); } catch (FormatException) { throw new ArgumentException("String '" + size + "' is not of the expected number format."); } catch (OverflowException) { throw new ArgumentException("String '" + size + "' is outside the allowable numeric range."); } return(result); }
public override IEnumerable<LoadEntity> GetEntities(LoadContainer targetContainer) { IAllocationConstraint allocationConstraint = targetContainer.Constraint ?? new AnyLoadConstraint(); List<LoadEntity> list = new List<LoadEntity>(base.SourceEntities); List<LoadEntity> list2 = new List<LoadEntity>(); ByteQuantifiedSize value = ByteQuantifiedSize.FromBytes(0UL); Random random = new Random(); while (list.Count > 0 && value < this.totalSize) { int index = random.Next(list.Count); LoadEntity loadEntity = list[index]; if (allocationConstraint.Accept(loadEntity)) { ByteQuantifiedSize byteQuantifiedSize = value + loadEntity.ConsumedLoad.GetSizeMetric(PhysicalSize.Instance); if (byteQuantifiedSize < this.totalSize) { list2.Add(loadEntity); value = byteQuantifiedSize; } } list.RemoveAt(index); } return list2; }
public IEnumerable <T> FindPaged <T>(QueryFilter filter, ObjectId rootId, bool deepSearch, SortBy sortBy, int pageSize) where T : IConfigurable, new() { base.CheckDisposed(); if (!typeof(PublicFolderStatistics).GetTypeInfo().IsAssignableFrom(typeof(T).GetTypeInfo())) { throw new NotSupportedException("FindPaged: " + typeof(T).FullName); } IEnumerable <PublicFolder> publicFolders = this.publicFolderDataProvider.FindPaged <PublicFolder>(filter, rootId, deepSearch, sortBy, pageSize); foreach (PublicFolder publicFolder in publicFolders) { PublicFolderSession contentSession = null; if (this.mailboxGuid == Guid.Empty) { contentSession = this.PublicFolderDataProvider.PublicFolderSessionCache.GetPublicFolderSession(publicFolder.InternalFolderIdentity.ObjectId); } else { contentSession = this.PublicFolderDataProvider.PublicFolderSessionCache.GetPublicFolderSession(this.mailboxGuid); } using (Folder contentFolder = Folder.Bind(contentSession, publicFolder.InternalFolderIdentity, PublicFolderStatisticsDataProvider.contentFolderProperties)) { PublicFolderStatistics publicFolderStatistics = new PublicFolderStatistics(); publicFolderStatistics.LoadDataFromXso(contentSession.MailboxPrincipal.ObjectId, contentFolder); uint ownerCount = 0U; uint contactCount = 0U; PermissionSet folderPermissionSet = contentFolder.GetPermissionSet(); foreach (Permission permission in folderPermissionSet) { if (permission.IsFolderContact) { contactCount += 1U; } if (permission.IsFolderOwner) { ownerCount += 1U; } } publicFolderStatistics.OwnerCount = ownerCount; publicFolderStatistics.ContactCount = contactCount; StoreObjectId dumpsterId = PublicFolderCOWSession.GetRecoverableItemsDeletionsFolderId((CoreFolder)contentFolder.CoreObject); checked { if (dumpsterId != null) { try { using (CoreFolder coreFolder = CoreFolder.Bind(contentSession, dumpsterId, PublicFolderStatisticsDataProvider.dumpsterProperties)) { publicFolderStatistics.DeletedItemCount = (uint)((int)coreFolder.PropertyBag[FolderSchema.ItemCount]); publicFolderStatistics.TotalDeletedItemSize = ByteQuantifiedSize.FromBytes((ulong)((long)coreFolder.PropertyBag[FolderSchema.ExtendedSize])); } } catch (ObjectNotFoundException) { } } yield return((T)((object)publicFolderStatistics)); } } } yield break; }
private MailboxFolderConfiguration GetFolderInformation(int folderIndex, List <object[]> allFolderRows, MailboxSession mailboxSession, IConfigurationSession adConfigSession) { MailboxFolderConfiguration mailboxFolderConfiguration = null; object[] array = allFolderRows[folderIndex]; if (GetMailboxFolderStatistics.PropertyExists(array[1]) && GetMailboxFolderStatistics.PropertyExists(array[15])) { mailboxFolderConfiguration = new MailboxFolderConfiguration(); string folderPath = (string)array[15]; mailboxFolderConfiguration.FolderPath = folderPath; mailboxFolderConfiguration.SetIdentity(new MailboxFolderId(this.Identity.ToString(), mailboxFolderConfiguration.FolderPath)); mailboxFolderConfiguration.Date = (DateTime)((ExDateTime)array[10]); if (GetMailboxFolderStatistics.PropertyExists(array[0])) { mailboxFolderConfiguration.Name = (string)array[0]; } else { this.WriteWarning(Strings.UnableToRetrieveFolderName(mailboxFolderConfiguration.FolderPath)); } StoreObjectId objectId = ((VersionedId)array[1]).ObjectId; mailboxFolderConfiguration.FolderId = objectId.ToBase64String(); long num = 0L; if (GetMailboxFolderStatistics.PropertyExists(array[6])) { num = (long)array[6]; } mailboxFolderConfiguration.FolderSize = ByteQuantifiedSize.FromBytes(checked ((ulong)num)); if (GetMailboxFolderStatistics.PropertyExists(array[4])) { mailboxFolderConfiguration.ItemsInFolder = (int)array[4]; mailboxFolderConfiguration.ItemsInFolderAndSubfolders = mailboxFolderConfiguration.ItemsInFolder; } if (GetMailboxFolderStatistics.PropertyExists(array[5])) { mailboxFolderConfiguration.ItemsInFolder += (int)array[5]; mailboxFolderConfiguration.ItemsInFolderAndSubfolders += (int)array[5]; } if (GetMailboxFolderStatistics.PropertyExists(array[11])) { mailboxFolderConfiguration.DeletedItemsInFolder = (int)array[11]; mailboxFolderConfiguration.DeletedItemsInFolderAndSubfolders = mailboxFolderConfiguration.DeletedItemsInFolder; } if (GetMailboxFolderStatistics.PropertyExists(array[12])) { mailboxFolderConfiguration.DeletedItemsInFolder += (int)array[12]; mailboxFolderConfiguration.DeletedItemsInFolderAndSubfolders += mailboxFolderConfiguration.DeletedItemsInFolder; } int num2 = -1; if (GetMailboxFolderStatistics.PropertyExists(array[3])) { num2 = (int)array[3]; } if (GetMailboxFolderStatistics.PropertyExists(array[2]) && (bool)array[2]) { bool flag = false; bool flag2 = false; for (int i = folderIndex + 1; i < allFolderRows.Count; i++) { object[] array2 = allFolderRows[i]; if (GetMailboxFolderStatistics.PropertyExists(array2[15]) && GetMailboxFolderStatistics.PropertyExists(array2[3])) { int num3 = (int)array2[3]; if (num3 <= num2) { break; } if (GetMailboxFolderStatistics.PropertyExists(array2[6])) { long num4 = (long)array2[6]; if (num4 > 0L) { num += num4; } } else { flag2 = true; } if (GetMailboxFolderStatistics.PropertyExists(array2[4])) { mailboxFolderConfiguration.ItemsInFolderAndSubfolders += (int)array2[4]; } else { flag = true; } if (GetMailboxFolderStatistics.PropertyExists(array2[5])) { mailboxFolderConfiguration.ItemsInFolderAndSubfolders += (int)array2[5]; } else { flag = true; } if (GetMailboxFolderStatistics.PropertyExists(array2[11])) { mailboxFolderConfiguration.DeletedItemsInFolderAndSubfolders += (int)array2[11]; } if (GetMailboxFolderStatistics.PropertyExists(array2[12])) { mailboxFolderConfiguration.DeletedItemsInFolderAndSubfolders += (int)array2[12]; } } } if (flag) { this.WriteWarning(Strings.TotalFolderCount(mailboxFolderConfiguration.FolderPath)); } if (flag2) { this.WriteWarning(Strings.TotalFolderSize(mailboxFolderConfiguration.FolderPath)); } } mailboxFolderConfiguration.FolderAndSubfolderSize = ByteQuantifiedSize.FromBytes(checked ((ulong)num)); if (GetMailboxFolderStatistics.PropertyExists(array[7])) { bool flag3 = ((int)array[7] & 1) != 0; mailboxFolderConfiguration.FolderType = (flag3 ? ElcFolderType.ManagedCustomFolder.ToString() : null); } if (mailboxFolderConfiguration.FolderType == null) { VersionedId folderId = (VersionedId)array[1]; DefaultFolderType defaultFolderType = mailboxSession.IsDefaultFolderType(folderId); if (defaultFolderType == DefaultFolderType.None) { if (GetMailboxFolderStatistics.PropertyExists(array[9])) { StoreObjectId folderId2 = (StoreObjectId)array[9]; defaultFolderType = mailboxSession.IsDefaultFolderType(folderId2); } switch (defaultFolderType) { case DefaultFolderType.AdminAuditLogs: case DefaultFolderType.Audits: mailboxFolderConfiguration.FolderType = defaultFolderType.ToString(); break; default: mailboxFolderConfiguration.FolderType = Strings.UserCreatedFolder; break; } } else { mailboxFolderConfiguration.FolderType = defaultFolderType.ToString(); } } if (GetMailboxFolderStatistics.PropertyExists(array[8])) { Guid guid = new Guid((string)array[8]); ADObjectId valueToSearch = new ADObjectId(guid.ToByteArray()); List <ELCFolder> list = ELCTaskHelper.FindELCFolder(adConfigSession, valueToSearch, FindByType.FolderAdObjectId); if (list == null || list.Count != 1) { this.WriteWarning(Strings.UnableToRetrieveManagedFolder); } else { mailboxFolderConfiguration.ManagedFolder = new ELCFolderIdParameter(list[0].Id); } } IConfigurationSession configurationSession = null; if (GetMailboxFolderStatistics.PropertyExists(array[13])) { byte[] array3 = (byte[])array[13]; if (array3 != null) { Guid tagGuid = new Guid(array3); configurationSession = this.CreateConfigurationSession(mailboxSession); List <RetentionPolicyTag> list2 = ELCTaskHelper.FindRetentionPolicyTag(configurationSession, tagGuid); if (list2 == null || list2.Count != 1) { this.WriteWarning(Strings.UnableToRetrieveDeletePolicyTag); } else { mailboxFolderConfiguration.DeletePolicy = new RetentionPolicyTagIdParameter(list2[0].Id); } } } if (GetMailboxFolderStatistics.PropertyExists(array[14])) { byte[] array4 = (byte[])array[14]; if (array4 != null) { Guid tagGuid2 = new Guid(array4); if (configurationSession == null) { configurationSession = this.CreateConfigurationSession(mailboxSession); } List <RetentionPolicyTag> list3 = ELCTaskHelper.FindRetentionPolicyTag(configurationSession, tagGuid2); if (list3 == null || list3.Count != 1) { this.WriteWarning(Strings.UnableToRetrieveArchivePolicyTag); } else { mailboxFolderConfiguration.ArchivePolicy = new RetentionPolicyTagIdParameter(list3[0].Id); } } } } return(mailboxFolderConfiguration); }
internal Band ToBand() { return(new Band(this.BandProfile, ByteQuantifiedSize.FromBytes(this.MinSize), ByteQuantifiedSize.FromBytes(this.MaxSize), this.WeightFactor, this.IncludeOnlyPhysicalMailboxes, PersistedBandDefinition.FromPersistableLogonAge(this.MinLastLogonAgeTicks), PersistedBandDefinition.FromPersistableLogonAge(this.MaxLastLogonAgeTicks))); }
public DirectorySize(string dirName, ulong size) { this.Name = dirName; this.Size = ByteQuantifiedSize.FromBytes(size); }
private static string RunComponentCommand(string componentName, DiagnosableParameters componentParameters) { XDocument xdocument = new XDocument(); XElement xelement = new XElement("Diagnostics"); xdocument.Add(xelement); if (string.Equals(componentName, "ProcessLocator", StringComparison.OrdinalIgnoreCase)) { XElement xelement2 = new XElement("ProcessLocator"); xelement.Add(xelement2); List <KeyValuePair <Guid, string> > registeredProcessGuids = ProcessAccessRpcServer.GetRegisteredProcessGuids(); int num = 0; if (string.Equals(componentParameters.Argument, "debug", StringComparison.OrdinalIgnoreCase)) { using (List <KeyValuePair <Guid, string> > .Enumerator enumerator = registeredProcessGuids.GetEnumerator()) { while (enumerator.MoveNext()) { KeyValuePair <Guid, string> pair = enumerator.Current; ProcessAccessManager.AddAsXmlElement(xelement2, pair); num++; } goto IL_117; } } HashSet <string> hashSet = new HashSet <string>(registeredProcessGuids.Count); foreach (KeyValuePair <Guid, string> pair2 in registeredProcessGuids) { if (pair2.Key != ProcessAccessRpcServer.ProcessLocatorGuid && !hashSet.Contains(pair2.Value)) { ProcessAccessManager.AddAsXmlElement(xelement2, pair2); num++; hashSet.Add(pair2.Value); } } IL_117: xelement2.AddFirst(new XElement("count", num)); } else { using (Process currentProcess = Process.GetCurrentProcess()) { DateTime dateTime = currentProcess.StartTime.ToUniversalTime(); DateTime utcNow = DateTime.UtcNow; XElement content = new XElement("ProcessInfo", new object[] { new XElement("id", currentProcess.Id), new XElement("serverName", Environment.MachineName), new XElement("startTime", dateTime), new XElement("currentTime", utcNow), new XElement("lifetime", (utcNow - dateTime).ToString()), new XElement("threadCount", currentProcess.Threads.Count), new XElement("handleCount", currentProcess.HandleCount), new XElement("workingSet", ByteQuantifiedSize.FromBytes((ulong)currentProcess.WorkingSet64)) }); xelement.Add(content); } bool flag = string.IsNullOrEmpty(componentName); bool flag2 = componentName == "?"; if (!flag2 && !flag && !ProcessAccessManager.diagnosableComponents.ContainsKey(componentName)) { XElement content2 = new XElement(componentName, new XElement("message", string.Format("Component \"{0}\" is not supported by this process.", componentName))); xelement.Add(content2); flag2 = true; } XElement xelement3 = new XElement("Components"); xelement.Add(xelement3); lock (ProcessAccessManager.RpcServerLockObject) { if (flag) { using (IEnumerator <KeyValuePair <string, IDiagnosable> > enumerator3 = ProcessAccessManager.diagnosableComponents.GetEnumerator()) { while (enumerator3.MoveNext()) { KeyValuePair <string, IDiagnosable> keyValuePair = enumerator3.Current; xelement3.Add(keyValuePair.Value.GetDiagnosticInfo(componentParameters)); } goto IL_3C2; } } if (flag2) { using (IEnumerator <KeyValuePair <string, IDiagnosable> > enumerator4 = ProcessAccessManager.diagnosableComponents.GetEnumerator()) { while (enumerator4.MoveNext()) { KeyValuePair <string, IDiagnosable> keyValuePair2 = enumerator4.Current; xelement3.Add(new XElement("Component", keyValuePair2.Key)); } goto IL_3C2; } } IDiagnosable diagnosable = ProcessAccessManager.diagnosableComponents[componentName]; XElement diagnosticInfo = diagnosable.GetDiagnosticInfo(componentParameters); xelement3.Add(diagnosticInfo); IL_3C2 :; } } string result; try { using (StringWriter stringWriter = new StringWriter()) { using (XmlTextWriter xmlTextWriter = new XmlTextWriter(stringWriter)) { xmlTextWriter.Formatting = Formatting.None; xdocument.Save(xmlTextWriter); } result = stringWriter.ToString(); } } catch (XmlException ex) { foreach (XElement xelement4 in xdocument.Descendants()) { ex.Data[xelement4.Name] = xelement4.Value; } throw; } return(result); }
protected virtual ByteQuantifiedSize CreateByteQuantifiedSizeFromValue(ulong value) { return(ByteQuantifiedSize.FromBytes(value)); }
internal static void GetEntryFromStatus(RpcDatabaseCopyStatus2 copyStatus, DatabaseCopyStatusEntry entry) { CopyStatusEnum copyStatus2 = copyStatus.CopyStatus; CopyStatus copyStatus3 = GetMailboxDatabaseCopyStatus.TranslateRpcStatusToTaskStatus(copyStatus2); entry.Status = copyStatus3; entry.m_statusRetrievedTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.StatusRetrievedTime); entry.m_lastStatusTransitionTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastStatusTransitionTime); entry.InstanceStartTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.InstanceStartTime); entry.m_errorMessage = copyStatus.ErrorMessage; entry.m_errorEventId = ((copyStatus.ErrorEventId != 0U) ? new uint?(copyStatus.ErrorEventId) : null); entry.m_extendedErrorInfo = copyStatus.ExtendedErrorInfo; if (copyStatus3 == CopyStatus.Suspended || copyStatus3 == CopyStatus.FailedAndSuspended || copyStatus3 == CopyStatus.Seeding) { entry.m_suspendMessage = copyStatus.SuspendComment; } entry.m_singlePageRestore = copyStatus.SinglePageRestoreNumber; entry.m_mailboxServer = copyStatus.MailboxServer; entry.m_activeDatabaseCopy = copyStatus.ActiveDatabaseCopy; entry.m_actionInitiator = copyStatus.ActionInitiator; entry.ActiveCopy = copyStatus.IsActiveCopy(); if (copyStatus.ActivationPreference > 0) { entry.ActivationPreference = new int?(copyStatus.ActivationPreference); } entry.IsLastCopyAvailabilityChecksPassed = new bool?(copyStatus.IsLastCopyAvailabilityChecksPassed); entry.IsLastCopyRedundancyChecksPassed = new bool?(copyStatus.IsLastCopyRedundancyChecksPassed); entry.LastCopyAvailabilityChecksPassedTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastCopyAvailabilityChecksPassedTime); entry.LastCopyRedundancyChecksPassedTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastCopyRedundancyChecksPassedTime); entry.DiskFreeSpacePercent = copyStatus.DiskFreeSpacePercent; entry.DiskFreeSpace = ByteQuantifiedSize.FromBytes(copyStatus.DiskFreeSpaceBytes); entry.DiskTotalSpace = ByteQuantifiedSize.FromBytes(copyStatus.DiskTotalSpaceBytes); entry.ExchangeVolumeMountPoint = copyStatus.ExchangeVolumeMountPoint; entry.DatabaseVolumeMountPoint = copyStatus.DatabaseVolumeMountPoint; entry.DatabaseVolumeName = copyStatus.DatabaseVolumeName; entry.DatabasePathIsOnMountedFolder = new bool?(copyStatus.DatabasePathIsOnMountedFolder); entry.LogVolumeMountPoint = copyStatus.LogVolumeMountPoint; entry.LogVolumeName = copyStatus.LogVolumeName; entry.LogPathIsOnMountedFolder = new bool?(copyStatus.LogPathIsOnMountedFolder); entry.LastDatabaseVolumeName = copyStatus.LastDatabaseVolumeName; entry.LastDatabaseVolumeNameTransitionTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastDatabaseVolumeNameTransitionTime); entry.VolumeInfoError = copyStatus.VolumeInfoLastError; entry.m_activationSuspended = copyStatus.ActivationSuspended; if (copyStatus.ActivationSuspended) { entry.m_suspendMessage = copyStatus.SuspendComment; } entry.m_latestAvailableLogTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LatestAvailableLogTime); entry.m_latestCopyNotificationTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastCopyNotifiedLogTime); entry.m_latestCopyTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastCopiedLogTime); entry.m_latestInspectorTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastInspectedLogTime); entry.m_latestReplayTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastReplayedLogTime); entry.m_latestLogGenerationNumber = copyStatus.LastLogGenerated; entry.m_copyNotificationGenerationNumber = copyStatus.LastLogCopyNotified; entry.m_copyGenerationNumber = copyStatus.LastLogCopied; entry.m_inspectorGenerationNumber = copyStatus.LastLogInspected; entry.m_replayGenerationNumber = copyStatus.LastLogReplayed; entry.m_contentIndexState = copyStatus.ContentIndexStatus; entry.m_contentIndexErrorMessage = copyStatus.ContentIndexErrorMessage; entry.m_contentIndexErrorCode = copyStatus.ContentIndexErrorCode; entry.m_contentIndexVersion = copyStatus.ContentIndexVersion; entry.m_contentIndexBacklog = copyStatus.ContentIndexBacklog; entry.m_contentIndexRetryQueueSize = copyStatus.ContentIndexRetryQueueSize; entry.m_contentIndexMailboxesToCrawl = copyStatus.ContentIndexMailboxesToCrawl; entry.m_contentIndexSeedingPercent = copyStatus.ContentIndexSeedingPercent; entry.m_contentIndexSeedingSource = copyStatus.ContentIndexSeedingSource; entry.m_logCopyQueueIncreasing = new bool?(copyStatus.CopyQueueNotKeepingUp); entry.m_logReplayQueueIncreasing = new bool?(copyStatus.ReplayQueueNotKeepingUp); entry.m_replaySuspended = new bool?(copyStatus.ReplaySuspended); entry.ResumeBlocked = new bool?(copyStatus.ResumeBlocked); entry.ReseedBlocked = new bool?(copyStatus.ReseedBlocked); if (copyStatus.WorkerProcessId != 0) { entry.m_workerProcessId = new int?(copyStatus.WorkerProcessId); } entry.LastLogInfoIsStale = copyStatus.LastLogInfoIsStale; entry.LastLogInfoFromCopierTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastLogInfoFromCopierTime); entry.LastLogInfoFromClusterTime = DumpsterStatisticsEntry.ToNullableLocalDateTime(copyStatus.LastLogInfoFromClusterTime); entry.LastLogInfoFromClusterGen = copyStatus.LastLogInfoFromClusterGen; entry.LowestLogPresent = copyStatus.LowestLogPresent; entry.m_logsReplayedSinceInstanceStart = new long?(copyStatus.LogsReplayedSinceInstanceStart); entry.m_logsCopiedSinceInstanceStart = new long?(copyStatus.LogsCopiedSinceInstanceStart); entry.ReplicationIsInBlockMode = copyStatus.ReplicationIsInBlockMode; entry.ActivationDisabledAndMoveNow = copyStatus.ActivationDisabledAndMoveNow; entry.AutoActivationPolicy = (DatabaseCopyAutoActivationPolicyType)copyStatus.AutoActivationPolicy; int num = copyStatus.MinimumSupportedDatabaseSchemaVersion; if (num > 0) { entry.MinimumSupportedDatabaseSchemaVersion = string.Format("{0}.{1}", num >> 16, num & 65535); } num = copyStatus.MaximumSupportedDatabaseSchemaVersion; if (num > 0) { entry.MaximumSupportedDatabaseSchemaVersion = string.Format("{0}.{1}", num >> 16, num & 65535); } num = copyStatus.RequestedDatabaseSchemaVersion; if (num > 0) { entry.RequestedDatabaseSchemaVersion = string.Format("{0}.{1}", num >> 16, num & 65535); } GetMailboxDatabaseCopyStatus.UpdateReplayLagStatus(entry, copyStatus); GetMailboxDatabaseCopyStatus.UpdateDatabaseSeedStatus(entry, copyStatus); GetMailboxDatabaseCopyStatus.UpdateBackupInfo(entry, copyStatus); GetMailboxDatabaseCopyStatus.UpdateDumpsterRequests(entry, copyStatus); if (copyStatus.OutgoingConnections != null) { entry.m_outgoingConnections = (ConnectionStatus[])Serialization.BytesToObject(copyStatus.OutgoingConnections); } if (copyStatus.IncomingLogCopyingNetwork != null) { entry.m_incomingLogCopyingNetwork = (ConnectionStatus)Serialization.BytesToObject(copyStatus.IncomingLogCopyingNetwork); } if (copyStatus.SeedingNetwork != null) { entry.m_seedingNetwork = (ConnectionStatus)Serialization.BytesToObject(copyStatus.SeedingNetwork); } entry.MaxLogToReplay = copyStatus.MaxLogToReplay; }