protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker) { if (base.IsFieldSet("RemoteSourceMailboxServerLegacyDN")) { changedValuesTracker.AppendLine(string.Format("RemoteMailboxServerLegacyDN: {0} -> {1}", requestJob.RemoteMailboxServerLegacyDN, this.RemoteSourceMailboxServerLegacyDN)); requestJob.RemoteMailboxServerLegacyDN = this.RemoteSourceMailboxServerLegacyDN; } if (base.IsFieldSet("OutlookAnywhereHostName")) { changedValuesTracker.AppendLine(string.Format("OutlookAnywhereHostName: {0} -> {1}", requestJob.OutlookAnywhereHostName, this.OutlookAnywhereHostName)); requestJob.OutlookAnywhereHostName = this.OutlookAnywhereHostName; } if (base.IsFieldSet("RemoteCredential")) { changedValuesTracker.AppendLine("RemoteCredential: <secure> -> <secure>"); requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, requestJob.AuthenticationMethod); } if (base.IsFieldSet("IsAdministrativeCredential")) { changedValuesTracker.AppendLine(string.Format("IsAdministrativeCredential: {0} -> {1}", requestJob.IsAdministrativeCredential, this.IsAdministrativeCredential)); requestJob.IsAdministrativeCredential = new bool?(this.IsAdministrativeCredential); } if (base.IsFieldSet("StartAfter") && !RequestTaskHelper.CompareUtcTimeWithLocalTime(requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter), this.StartAfter)) { RequestTaskHelper.SetStartAfter(this.StartAfter, requestJob, changedValuesTracker); } if (base.IsFieldSet("IncrementalSyncInterval")) { changedValuesTracker.AppendLine(string.Format("IncrementalSyncInterval: {0} -> {1}", requestJob.IncrementalSyncInterval, this.IncrementalSyncInterval)); requestJob.IncrementalSyncInterval = this.IncrementalSyncInterval; } }
protected override void ValidateRequest(TransactionalRequestJob requestJob) { DateTime?timestamp = requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter); bool flag = RequestTaskHelper.CompareUtcTimeWithLocalTime(timestamp, this.StartAfter); bool flag2 = base.IsFieldSet("StartAfter") && !flag; if (flag2) { this.CheckJobStatusInQueuedForStartAfterSet(requestJob); } DateTime utcNow = DateTime.UtcNow; if (flag2 && this.StartAfter != null) { RequestTaskHelper.ValidateStartAfterTime(this.StartAfter.Value.ToUniversalTime(), new Task.TaskErrorLoggingDelegate(base.WriteError), utcNow); } if (base.IsFieldSet("IncrementalSyncInterval")) { if (requestJob.IncrementalSyncInterval == TimeSpan.Zero || requestJob.JobType < MRSJobType.RequestJobE15_AutoResume) { base.WriteError(new IncrementalSyncIntervalCannotBeSetOnNonIncrementalRequestsException(), ErrorCategory.InvalidArgument, this.Identity); } RequestTaskHelper.ValidateIncrementalSyncInterval(this.IncrementalSyncInterval, new Task.TaskErrorLoggingDelegate(base.WriteError)); } if (base.IsFieldSet("StartAfter") && flag) { this.WriteWarning(Strings.WarningScheduledTimeIsUnchanged("StartAfter")); } base.ValidateRequest(requestJob); }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); this.targetUser = RequestTaskHelper.ResolveADUser(base.RecipSession, base.GCSession, base.ServerSettings, this.Mailbox, base.OptionalIdentityData, base.DomainController, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), false); TaskLogger.LogExit(); }
internal void ValidateRequestProtectionStatus(RequestJobBase requestJob) { if (requestJob.Protect && RequestTaskHelper.CheckUserOrgIdIsTenant(base.ExecutingUserOrganizationId)) { base.WriteError(new RequestIsProtectedPermanentException(requestJob.Name), ErrorCategory.InvalidArgument, this.Identity); } }
private MailboxDatabase ChooseTargetMailboxDatabase(ADObjectId sourceMailboxDatabase) { return(RequestTaskHelper.ChooseTargetMDB(new ADObjectId[] { sourceMailboxDatabase }, false, this.mailbox, base.DomainController, base.ScopeSet, new Action <LocalizedString>(base.WriteVerbose), new Action <LocalizedException, ExchangeErrorCategory, object>(base.WriteError), new Action <Exception, ErrorCategory, object>(base.WriteError), this.Mailbox)); }
protected override void WriteResult(IConfigurable dataObject) { TaskLogger.LogEnter(new object[] { dataObject }); TDataObject tdataObject = (TDataObject)((object)dataObject); try { RequestTaskHelper.GetUpdatedMRSRequestInfo(tdataObject, this.Diagnostic, this.DiagnosticArgument); if (tdataObject.Status == RequestStatus.Queued) { tdataObject.PositionInQueue = this.rjProvider.ComputePositionInQueue(tdataObject.RequestGuid); } base.WriteResult(tdataObject); if (tdataObject.ValidationResult != RequestJobBase.ValidationResultEnum.Valid) { this.WriteWarning(Strings.ErrorInvalidRequest(tdataObject.Identity.ToString(), tdataObject.ValidationMessage)); } if (tdataObject.PoisonCount > 5) { this.WriteWarning(Strings.WarningJobIsPoisoned(tdataObject.Identity.ToString(), tdataObject.PoisonCount)); } if (base.ParameterSetName.Equals("MigrationRequestQueue")) { base.WriteVerbose(Strings.RawRequestJobDump(CommonUtils.ConfigurableObjectToString(tdataObject))); } } finally { TaskLogger.LogExit(); } }
protected override void ModifyRequest(TransactionalRequestJob requestJob) { base.ModifyRequest(requestJob); if (base.IsFieldSet("SourceDatabase")) { PublicFolderDatabase publicFolderDatabase = (PublicFolderDatabase)base.GetDataObject <PublicFolderDatabase>(this.SourceDatabase, base.ConfigSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(this.SourceDatabase.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(this.SourceDatabase.ToString()))); DatabaseInformation databaseInformation = MapiUtils.FindServerForMdb(publicFolderDatabase.Id.ObjectGuid, null, null, FindServerFlags.None); if (!this.IsSupportedDatabaseVersion(databaseInformation.ServerVersion)) { base.WriteError(new DatabaseVersionUnsupportedPermanentException(publicFolderDatabase.Identity.ToString(), databaseInformation.ServerFqdn, new ServerVersion(databaseInformation.ServerVersion).ToString()), ErrorCategory.InvalidArgument, null); } requestJob.SourceDatabase = publicFolderDatabase.Id; } if (base.IsFieldSet("RemoteMailboxLegacyDN")) { requestJob.RemoteMailboxLegacyDN = this.RemoteMailboxLegacyDN; } if (base.IsFieldSet("RemoteMailboxServerLegacyDN")) { requestJob.RemoteMailboxServerLegacyDN = this.RemoteMailboxServerLegacyDN; } if (base.IsFieldSet("OutlookAnywhereHostName")) { requestJob.OutlookAnywhereHostName = this.OutlookAnywhereHostName; } if (base.IsFieldSet("AuthenticationMethod")) { requestJob.AuthenticationMethod = new AuthenticationMethod?(this.AuthenticationMethod); } if (base.IsFieldSet("RemoteCredential")) { requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, requestJob.AuthenticationMethod); } }
protected override void ValidateRequest(TransactionalRequestJob requestJob) { base.ValidateRequest(requestJob); base.ValidateRequestIsActive(requestJob); base.ValidateRequestProtectionStatus(requestJob); base.ValidateRequestIsRunnable(requestJob); base.ValidateRequestIsNotCancelled(requestJob); if (!requestJob.Suspend) { base.WriteVerbose(Strings.RequestNotSuspended(requestJob.Name)); } if (RequestJobStateNode.RequestStateIs(requestJob.StatusDetail, RequestState.Completion) && !RequestJobStateNode.RequestStateIs(requestJob.StatusDetail, RequestState.IncrementalSync)) { base.WriteError(new SuspendWhenReadyToCompleteCannotBeUsedDuringCompletionException(requestJob.Name), ErrorCategory.InvalidArgument, requestJob.Identity); } using (MailboxReplicationServiceClient mailboxReplicationServiceClient = requestJob.CreateMRSClient(base.ConfigSession, requestJob.WorkItemQueueMdb.ObjectGuid, base.UnreachableMrsServers)) { LocalizedString message = requestJob.Message; requestJob.Message = LocalizedString.Empty; try { List <ReportEntry> entries = null; using (mailboxReplicationServiceClient.ValidateAndPopulateRequestJob(requestJob, out entries)) { RequestTaskHelper.WriteReportEntries(requestJob.Name, entries, requestJob.Identity, new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.TaskWarningLoggingDelegate(this.WriteWarning), new Task.TaskErrorLoggingDelegate(base.WriteError)); } } finally { requestJob.Message = message; } } }
protected override void SetRequestProperties(TransactionalRequestJob dataObject) { base.SetRequestProperties(dataObject); dataObject.JobType = MRSJobType.RequestJobE15_CreatePublicFoldersUnderParentInSecondary; dataObject.RequestType = MRSRequestType.PublicFolderMailboxMigration; dataObject.WorkloadType = base.WorkloadType; if (base.ParameterSetName.Equals("MailboxMigrationOutlookAnywherePublicFolder")) { dataObject.AuthenticationMethod = new AuthenticationMethod?(this.AuthenticationMethod); dataObject.OutlookAnywhereHostName = this.OutlookAnywhereHostName; dataObject.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, new AuthenticationMethod?(this.AuthenticationMethod)); dataObject.RemoteMailboxLegacyDN = this.RemoteMailboxLegacyDN; dataObject.RemoteMailboxServerLegacyDN = this.RemoteMailboxServerLegacyDN; } else { dataObject.SourceDatabase = this.sourceDatabase; dataObject.SourceExchangeGuid = this.sourceDatabase.ObjectGuid; } dataObject.PreserveMailboxSignature = false; dataObject.PreventCompletion = true; dataObject.SuspendWhenReadyToComplete = true; dataObject.AllowedToFinishMove = false; dataObject.SourceDatabase = this.sourceDatabase; dataObject.TargetDatabase = base.MdbId; dataObject.TargetUserId = this.TargetMailboxUser.Id; dataObject.ExchangeGuid = this.TargetMailboxUser.ExchangeGuid; dataObject.TargetExchangeGuid = this.TargetMailboxUser.ExchangeGuid; dataObject.FolderToMailboxMap = this.folderToMailboxMapping; dataObject.AllowLargeItems = false; dataObject.SkipFolderPromotedProperties = true; dataObject.SkipFolderViews = true; dataObject.SkipFolderRestrictions = true; dataObject.SkipContentVerification = true; }
protected override void PostSaveAction() { if (!base.ParameterSetName.Equals("MigrationRequestQueue") && this.requestCondition == RemoveRequest <TIdentity> .RequestCondition.None && this.DataObject != null) { RequestTaskHelper.TickleMRS(this.DataObject, MoveRequestNotification.Canceled, this.mdbGuid, base.ConfigSession, base.UnreachableMrsServers); } }
protected override void InternalValidate() { TaskLogger.LogEnter(); try { base.ValidateRootFolders(this.SourceRootFolder, this.TargetRootFolder); if (!this.FilePath.IsUnc) { base.WriteError(new NonUNCFilePathPermanentException(this.FilePath.PathName), ErrorCategory.InvalidArgument, this.FilePath); } bool flag = !OrganizationId.ForestWideOrgId.Equals(base.ExecutingUserOrganizationId); bool flag2 = this.RemoteHostName != null; if (flag && !flag2) { base.WriteError(new RemoteMailboxImportNeedRemoteProxyException(), ErrorCategory.InvalidArgument, this); } this.user = RequestTaskHelper.ResolveADUser(base.RecipSession, base.GCSession, base.ServerSettings, this.Mailbox, base.OptionalIdentityData, base.DomainController, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), true); bool wildcardedSearch = false; if (!string.IsNullOrEmpty(base.Name)) { base.ValidateName(); base.RequestName = base.Name; } else { wildcardedSearch = true; base.RequestName = "MailboxImport"; } if (base.ParameterSetName.Equals("MailboxImportRequest")) { this.DisallowImportForPublicFolderMailbox(); if (this.user.RecipientType != RecipientType.UserMailbox) { base.WriteError(new InvalidRecipientTypePermanentException(this.user.ToString(), this.user.RecipientType.ToString()), ErrorCategory.InvalidArgument, this.Mailbox); } if (this.IsArchive && (this.user.ArchiveGuid == Guid.Empty || this.user.ArchiveDatabase == null)) { base.WriteError(new MailboxLacksArchivePermanentException(this.user.ToString()), ErrorCategory.InvalidArgument, this.IsArchive); } if (!this.IsArchive && this.user.Database == null) { base.WriteError(new MailboxLacksDatabasePermanentException(this.user.ToString()), ErrorCategory.InvalidArgument, this.Mailbox); } base.RescopeToOrgId(this.user.OrganizationId); ADObjectId mdbId = null; ADObjectId mdbServerSite = null; this.LocateAndChooseMdb(null, this.IsArchive ? this.user.ArchiveDatabase : this.user.Database, null, this.Mailbox, this.Mailbox, out mdbId, out mdbServerSite); base.MdbId = mdbId; base.MdbServerSite = mdbServerSite; base.Flags = (RequestFlags.IntraOrg | RequestFlags.Pull); } base.RequestName = this.CheckRequestNameAvailability(base.RequestName, this.user.Id, true, MRSRequestType.MailboxImport, this.Mailbox, wildcardedSearch); base.InternalValidate(); } finally { TaskLogger.LogExit(); } }
protected override void ValidateRequest(TransactionalRequestJob requestJob) { if (base.IsFieldSet("IncrementalSyncInterval")) { RequestTaskHelper.ValidateIncrementalSyncInterval(this.IncrementalSyncInterval, new Task.TaskErrorLoggingDelegate(base.WriteError)); } base.ValidateRequest(requestJob); }
private void RetrieveSourceMailboxInformation() { this.mailbox = RequestTaskHelper.ResolveADUser(base.RecipSession, base.GCSession, base.ServerSettings, this.Mailbox, base.OptionalIdentityData, base.DomainController, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), true); if (this.mailbox.Database == null) { base.WriteError(new MailboxLacksDatabasePermanentException(this.mailbox.ToString()), ErrorCategory.InvalidArgument, this.Mailbox); } this.sourceDatabaseInformation = new DatabaseInformation?(MapiUtils.FindServerForMdb(this.mailbox.Database.ObjectGuid, null, null, FindServerFlags.None)); }
protected override void InternalBeginProcessing() { base.InternalBeginProcessing(); RequestTaskHelper.ValidateItemLimits(this.BadItemLimit, this.LargeItemLimit, this.AcceptLargeDataLoss, new Task.TaskErrorLoggingDelegate(base.WriteError), new Task.TaskWarningLoggingDelegate(this.WriteWarning), base.ExecutingUserIdentity); if (this.BatchName != null && this.BatchName.Length > 255) { base.WriteError(new ParameterLengthExceededPermanentException("BatchName", 255), ErrorCategory.InvalidArgument, this.BatchName); } }
protected override void InternalValidate() { TaskLogger.LogEnter(); try { if (!string.IsNullOrEmpty(base.Name)) { base.ValidateName(); base.RequestName = base.Name; } else { base.RequestName = base.ParameterSetName; } this.RetrieveSourceMailboxInformation(); base.RescopeToOrgId(this.mailbox.OrganizationId); string parameterSetName; if ((parameterSetName = base.ParameterSetName) != null) { ADObjectId mdbId; ADObjectId mdbServerSite; RequestFlags requestFlags; if (!(parameterSetName == "MailboxRelocationJoin")) { if (!(parameterSetName == "MailboxRelocationSplit")) { goto IL_135; } if (this.mailbox.UnifiedMailbox == null || !ADRecipient.TryGetFromCrossTenantObjectId(this.mailbox.UnifiedMailbox, out this.sourceContainer).Succeeded) { base.WriteError(new MailboxRelocationSplitSourceNotInContainerException(this.mailbox.ToString()), ErrorCategory.InvalidArgument, this.Mailbox); } this.RetrieveTargetMailboxInformation(); requestFlags = this.LocateAndChooseMdb(this.mailbox.Database, this.targetMailboxDatabase.Id, this.Mailbox, this.TargetDatabase, this.TargetDatabase, out mdbId, out mdbServerSite); } else { this.RetrieveTargetContainerAndMailboxInformation(); requestFlags = this.LocateAndChooseMdb(this.mailbox.Database, this.targetContainer.Database, this.Mailbox, this.TargetContainer, this.TargetContainer, out mdbId, out mdbServerSite); } this.moveFlags |= requestFlags; base.MdbId = mdbId; base.MdbServerSite = mdbServerSite; base.Flags = this.moveFlags; RequestTaskHelper.ValidateNotImplicitSplit(this.moveFlags, this.mailbox, new Task.TaskErrorLoggingDelegate(base.WriteError), this.Mailbox); this.ValidateNoOtherActiveRequests(); base.InternalValidate(); return; } IL_135: throw new NotImplementedException(); } finally { TaskLogger.LogExit(); } }
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker) { base.ModifyRequestInternal(requestJob, changedValuesTracker); if (base.IsFieldSet("SkipMoving")) { RequestJobInternalFlags requestJobInternalFlags = requestJob.RequestJobInternalFlags; RequestTaskHelper.SetSkipMoving(this.SkipMoving, requestJob, new Task.TaskErrorLoggingDelegate(base.WriteError), true); changedValuesTracker.AppendLine(string.Format("InternalFlags: {0} -> {1}", requestJobInternalFlags, requestJob.RequestJobInternalFlags)); } }
protected override void InternalBeginProcessing() { base.InternalBeginProcessing(); if (this.Organization != null) { IConfigurationSession session = RequestTaskHelper.CreateOrganizationFindingSession(base.CurrentOrganizationId, base.ExecutingUserOrganizationId); ADOrganizationalUnit adorganizationalUnit = (ADOrganizationalUnit)base.GetDataObject <ADOrganizationalUnit>(this.Organization, session, null, new LocalizedString?(Strings.ErrorOrganizationNotFound(this.Organization.ToString())), new LocalizedString?(Strings.ErrorOrganizationNotUnique(this.Organization.ToString()))); base.CurrentOrganizationId = adorganizationalUnit.OrganizationId; } }
protected override void SetRequestProperties(TransactionalRequestJob dataObject) { base.SetRequestProperties(dataObject); dataObject.RequestType = MRSRequestType.MailboxImport; if (dataObject.WorkloadType == RequestWorkloadType.None) { if (string.IsNullOrEmpty(this.RemoteHostName)) { dataObject.WorkloadType = RequestWorkloadType.Local; } else { dataObject.WorkloadType = RequestWorkloadType.RemotePstIngestion; } } dataObject.ContentCodePage = this.ContentCodePage; dataObject.FilePath = this.FilePath.PathName; if (this.user != null) { dataObject.TargetUserId = this.user.Id; dataObject.TargetUser = this.user; } if (base.ParameterSetName.Equals("MailboxImportRequest")) { if (!string.IsNullOrEmpty(this.SourceRootFolder)) { dataObject.SourceRootFolder = this.SourceRootFolder; } if (!string.IsNullOrEmpty(this.TargetRootFolder)) { dataObject.TargetRootFolder = this.TargetRootFolder; } if (this.IsArchive) { dataObject.TargetIsArchive = true; dataObject.TargetExchangeGuid = this.user.ArchiveGuid; dataObject.TargetDatabase = ADObjectIdResolutionHelper.ResolveDN(this.user.ArchiveDatabase); } else { dataObject.TargetIsArchive = false; dataObject.TargetExchangeGuid = this.user.ExchangeGuid; dataObject.TargetDatabase = ADObjectIdResolutionHelper.ResolveDN(this.user.Database); } dataObject.TargetAlias = this.user.Alias; if (this.RemoteCredential != null) { dataObject.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, null); } if (!string.IsNullOrEmpty(this.RemoteHostName)) { dataObject.RemoteHostName = this.RemoteHostName; } } }
private void SetSkipMergingAndInternalFlags(TransactionalRequestJob dataObject) { RequestTaskHelper.SetSkipMerging(this.SkipMerging, dataObject, new Task.TaskErrorLoggingDelegate(base.WriteError)); RequestTaskHelper.SetInternalFlags(this.InternalFlags, dataObject, new Task.TaskErrorLoggingDelegate(base.WriteError)); if (this.SkipMerging == null) { using (SettingsContextBase.ActivateContext(dataObject)) { dataObject.SkipKnownCorruptions = ConfigBase <MRSConfigSchema> .GetConfig <bool>("SkipKnownCorruptionsDefault"); } } }
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker) { if (base.IsFieldSet("RemoteServerName")) { changedValuesTracker.AppendLine(string.Format("RemoteServerName: {0} -> {1}", requestJob.RemoteHostName, this.RemoteServerName)); requestJob.RemoteHostName = this.RemoteServerName; } if (base.IsFieldSet("RemoteServerPort")) { changedValuesTracker.AppendLine(string.Format("RemoteServerPort: {0} -> {1}", requestJob.RemoteHostPort, this.RemoteServerPort)); requestJob.RemoteHostPort = this.RemoteServerPort; } if (base.IsFieldSet("SmtpServerName")) { changedValuesTracker.AppendLine(string.Format("SmtpServerName: {0} -> {1}", requestJob.SmtpServerName, this.SmtpServerName)); requestJob.SmtpServerName = this.SmtpServerName; } if (base.IsFieldSet("SmtpServerPort")) { changedValuesTracker.AppendLine(string.Format("SmtpServerPort: {0} -> {1}", requestJob.SmtpServerPort, this.SmtpServerPort)); requestJob.SmtpServerPort = this.SmtpServerPort; } if (base.IsFieldSet("Authentication")) { changedValuesTracker.AppendLine(string.Format("Authentication: {0} -> {1}", requestJob.AuthenticationMethod, this.Authentication)); requestJob.AuthenticationMethod = new AuthenticationMethod?(this.Authentication); } if (base.IsFieldSet("Security")) { changedValuesTracker.AppendLine(string.Format("Security: {0} -> {1}", requestJob.SecurityMechanism, this.Security)); requestJob.SecurityMechanism = this.Security; } if (base.IsFieldSet("Password")) { changedValuesTracker.AppendLine("Password: <secure> -> <secure>"); PSCredential psCred = new PSCredential(requestJob.RemoteCredential.UserName, this.Password); requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(psCred, requestJob.AuthenticationMethod); } if (base.IsFieldSet("IncrementalSyncInterval")) { changedValuesTracker.AppendLine(string.Format("IncrementalSyncInterval: {0} -> {1}", requestJob.IncrementalSyncInterval, this.IncrementalSyncInterval)); requestJob.IncrementalSyncInterval = this.IncrementalSyncInterval; } if (base.IsFieldSet("StartAfter") && !RequestTaskHelper.CompareUtcTimeWithLocalTime(requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.StartAfter), this.StartAfter)) { RequestTaskHelper.SetStartAfter(this.StartAfter, requestJob, changedValuesTracker); } if (base.IsFieldSet("CompleteAfter") && !RequestTaskHelper.CompareUtcTimeWithLocalTime(requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.CompleteAfter), this.CompleteAfter)) { RequestTaskHelper.SetCompleteAfter(this.CompleteAfter, requestJob, changedValuesTracker); } }
protected override void SetRequestProperties(TransactionalRequestJob dataObject) { base.SetRequestProperties(dataObject); dataObject.RequestType = MRSRequestType.MailboxRestore; if (dataObject.WorkloadType == RequestWorkloadType.None) { dataObject.WorkloadType = RequestWorkloadType.Local; } if (this.targetUser != null) { dataObject.TargetUserId = this.targetUser.Id; dataObject.TargetUser = this.targetUser; } if (!string.IsNullOrEmpty(this.SourceRootFolder)) { dataObject.SourceRootFolder = this.SourceRootFolder; } dataObject.SourceIsArchive = false; dataObject.SourceExchangeGuid = this.sourceMailboxGuid; dataObject.SourceDatabase = this.sourceDatabase; dataObject.MailboxRestoreFlags = new MailboxRestoreType?(this.restoreFlags); if (!string.IsNullOrEmpty(this.TargetRootFolder)) { dataObject.TargetRootFolder = this.TargetRootFolder; } if (this.TargetIsArchive) { dataObject.TargetIsArchive = true; dataObject.TargetExchangeGuid = this.targetUser.ArchiveGuid; dataObject.TargetDatabase = ADObjectIdResolutionHelper.ResolveDN(this.targetUser.ArchiveDatabase); } else { dataObject.TargetIsArchive = false; dataObject.TargetExchangeGuid = this.targetUser.ExchangeGuid; dataObject.TargetDatabase = ADObjectIdResolutionHelper.ResolveDN(this.targetUser.Database); } dataObject.TargetAlias = this.targetUser.Alias; dataObject.AllowedToFinishMove = true; if (this.IsPublicFolderMailboxRestore) { dataObject.SkipFolderRules = true; } if (base.ParameterSetName.Equals("RemoteMailboxRestore")) { dataObject.RemoteDatabaseGuid = new Guid?(this.RemoteDatabaseGuid); dataObject.RemoteHostName = this.RemoteHostName; dataObject.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, new AuthenticationMethod?(AuthenticationMethod.WindowsIntegrated)); } }
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker) { if (base.IsFieldSet("RemoteCredential")) { changedValuesTracker.AppendLine("RemoteCredential: <secure> -> <secure>"); requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, null); } if (base.IsFieldSet("RemoteHostName")) { changedValuesTracker.AppendLine(string.Format("RemoteHostName: {0} -> {1}", requestJob.RemoteHostName, this.RemoteHostName)); requestJob.RemoteHostName = this.RemoteHostName; } base.ModifyRequestInternal(requestJob, changedValuesTracker); }
protected override void TranslateException(ref Exception e, out ErrorCategory category) { LocalizedException ex = RequestTaskHelper.TranslateExceptionHandler(e); if (ex == null) { ErrorCategory errorCategory; base.TranslateException(ref e, out errorCategory); category = errorCategory; return; } e = ex; category = ErrorCategory.ResourceUnavailable; }
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker) { if (base.IsFieldSet("SuspendWhenReadyToComplete")) { changedValuesTracker.AppendLine(string.Format("SWRTC: {0} -> {1}", requestJob.SuspendWhenReadyToComplete, this.SuspendWhenReadyToComplete)); requestJob.SuspendWhenReadyToComplete = this.SuspendWhenReadyToComplete; } if (base.IsFieldSet("CompleteAfter") && !RequestTaskHelper.CompareUtcTimeWithLocalTime(requestJob.TimeTracker.GetTimestamp(RequestJobTimestamp.CompleteAfter), this.CompleteAfter)) { RequestTaskHelper.SetCompleteAfter(this.CompleteAfter, requestJob, changedValuesTracker); } if (base.IsFieldSet("IncrementalSyncInterval")) { requestJob.IncrementalSyncInterval = this.IncrementalSyncInterval; } }
protected override void ModifyRequestInternal(TransactionalRequestJob requestJob, StringBuilder changedValuesTracker) { if (base.IsFieldSet("RemoteCredential")) { string arg = (requestJob.RemoteCredential == null) ? null : requestJob.RemoteCredential.UserName; string arg2 = (this.RemoteCredential == null) ? null : this.RemoteCredential.UserName; changedValuesTracker.AppendLine(string.Format("UserName of RemoteCredential: {0} -> {1}", arg, arg2)); requestJob.RemoteCredential = RequestTaskHelper.GetNetworkCredential(this.RemoteCredential, null); } if (base.IsFieldSet("RemoteHostName")) { changedValuesTracker.AppendLine(string.Format("RemoteHostName: {0} -> {1}", requestJob.RemoteHostName, this.RemoteHostName)); requestJob.RemoteHostName = this.RemoteHostName; } base.ModifyRequestInternal(requestJob, changedValuesTracker); }
protected override void WriteResult(IConfigurable dataObject) { TaskLogger.LogEnter(new object[] { dataObject }); MoveRequestStatistics moveRequestStatistics = (MoveRequestStatistics)dataObject; try { RequestTaskHelper.GetUpdatedMRSRequestInfo(moveRequestStatistics, this.Diagnostic, this.DiagnosticArgument); if (moveRequestStatistics.Status == RequestStatus.Queued) { moveRequestStatistics.PositionInQueue = this.mrProvider.ComputePositionInQueue(moveRequestStatistics.ExchangeGuid); } base.WriteResult(moveRequestStatistics); string identity; if (moveRequestStatistics.UserId != null) { identity = moveRequestStatistics.UserId.ToString(); } else if (moveRequestStatistics.Identity != null) { identity = moveRequestStatistics.Identity.ToString(); } else { identity = moveRequestStatistics.ExchangeGuid.ToString(); } if (moveRequestStatistics.ValidationResult != RequestJobBase.ValidationResultEnum.Valid) { this.WriteWarning(Strings.ErrorInvalidMoveRequest(identity, moveRequestStatistics.ValidationMessage)); } if (moveRequestStatistics.PoisonCount > 5) { this.WriteWarning(Strings.WarningJobIsPoisoned(identity, moveRequestStatistics.PoisonCount)); } if (base.ParameterSetName.Equals("MigrationMoveRequestQueue")) { base.WriteVerbose(Strings.RawRequestJobDump(CommonUtils.ConfigurableObjectToString(moveRequestStatistics))); } } finally { TaskLogger.LogExit(); } }
protected override void InternalBeginProcessing() { base.InternalBeginProcessing(); if (base.IsFieldSet("CompleteAfter") && base.IsFieldSet("SuspendWhenReadyToComplete")) { DateTime?completeAfter = base.IsFieldSet("CompleteAfter") ? new DateTime?(this.CompleteAfter) : null; RequestTaskHelper.ValidateStartAfterCompleteAfterWithSuspendWhenReadyToComplete(null, completeAfter, this.SuspendWhenReadyToComplete.ToBool(), new Task.TaskErrorLoggingDelegate(base.WriteError)); } if (base.IsFieldSet("IncrementalSyncInterval") && base.IsFieldSet("SuspendWhenReadyToComplete") && this.SuspendWhenReadyToComplete.ToBool()) { base.WriteError(new SuspendWhenReadyToCompleteCannotBeSetWithIncrementalSyncIntervalException(), ErrorCategory.InvalidArgument, this.SuspendWhenReadyToComplete); } if (base.IsFieldSet("IncrementalSyncInterval")) { RequestTaskHelper.ValidateIncrementalSyncInterval(this.IncrementalSyncInterval, new Task.TaskErrorLoggingDelegate(base.WriteError)); } }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); if (this.TargetMailbox != null) { ADUser aduser = RequestTaskHelper.ResolveADUser(base.RecipSession, base.GCSession, base.ServerSettings, this.TargetMailbox, base.OptionalIdentityData, base.DomainController, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), false); this.targetUserId = aduser.Id; } if (this.SourceDatabase != null) { this.SourceDatabase.AllowLegacy = true; MailboxDatabase mailboxDatabase = (MailboxDatabase)base.GetDataObject <MailboxDatabase>(this.SourceDatabase, base.ConfigSession, null, new LocalizedString?(Strings.ErrorDatabaseNotFound(this.SourceDatabase.ToString())), new LocalizedString?(Strings.ErrorDatabaseNotUnique(this.SourceDatabase.ToString()))); this.sourceDatabaseId = mailboxDatabase.Id; } TaskLogger.LogExit(); }
private void RetrieveTargetContainerAndMailboxInformation() { this.targetContainer = RequestTaskHelper.ResolveADUser(base.RecipSession, base.GCSession, base.ServerSettings, this.TargetContainer, base.OptionalIdentityData, base.DomainController, new DataAccessHelper.CategorizedGetDataObjectDelegate(base.GetDataObject <ADUser>), new Task.TaskVerboseLoggingDelegate(base.WriteVerbose), new Task.ErrorLoggerDelegate(base.WriteError), true); if (this.targetContainer.UnifiedMailbox != null) { base.WriteError(new MailboxRelocationJoinTargetNotContainerOwnerException(this.targetContainer.ToString()), ErrorCategory.InvalidArgument, this.TargetContainer); } if (this.targetContainer.MailboxContainerGuid == null) { base.WriteError(new MailboxRelocationJoinTargetNotContainerException(this.targetContainer.ToString()), ErrorCategory.InvalidArgument, this.TargetContainer); } if (this.targetContainer.Database == null) { base.WriteError(new MailboxLacksDatabasePermanentException(this.targetContainer.ToString()), ErrorCategory.InvalidArgument, this.TargetContainer); } this.targetDatabaseInformation = new DatabaseInformation?(MapiUtils.FindServerForMdb(this.targetContainer.Database.ObjectGuid, null, null, FindServerFlags.None)); }
protected override void InternalBeginProcessing() { base.InternalBeginProcessing(); RequestTaskHelper.ValidateItemLimits(this.BadItemLimit, this.LargeItemLimit, this.AcceptLargeDataLoss, new Task.TaskErrorLoggingDelegate(base.WriteError), new Task.TaskWarningLoggingDelegate(this.WriteWarning), base.ExecutingUserIdentity); if (this.BatchName != null && this.BatchName.Length > 255) { base.WriteError(new ParameterLengthExceededPermanentException("BatchName", 255), ErrorCategory.InvalidArgument, this.BatchName); } if (this.TargetDatabase != null) { this.specifiedTargetMDB = this.LocateAndVerifyMdb(this.TargetDatabase, out this.newTargetServerVersion); } if (this.ArchiveTargetDatabase != null) { this.specifiedArchiveTargetMDB = this.LocateAndVerifyMdb(this.ArchiveTargetDatabase, out this.newArchiveTargetServerVersion); } }