// Token: 0x06000EEE RID: 3822 RVA: 0x000588A4 File Offset: 0x00056AA4
public override void Invoke()
{
this.tracer.TraceDebug <string>((long)this.GetHashCode(), "PublicFolderHierarchySyncProcessor::Invoke::{0} - Begin processing", this.publicFolderSession.DisplayAddress);
try
{
if (!this.publicFolderSession.IsPrimaryHierarchySession)
{
this.tracer.TraceDebug <string>((long)this.GetHashCode(), "PublicFolderHierarchySyncProcessor::Invoke::{0} - Processing for public folder content-only mailbox", this.publicFolderSession.DisplayAddress);
PublicFolderSyncJobState publicFolderSyncJobState = PublicFolderSyncJobRpc.StartSyncHierarchy(this.publicFolderSession.MailboxPrincipal, true);
string text = null;
ExTraceGlobals.FaultInjectionTracer.TraceTest <string>(2235968829U, ref text);
if (text != null)
{
while (publicFolderSyncJobState.JobStatus == PublicFolderSyncJobState.Status.Queued)
{
Thread.Sleep(1000);
publicFolderSyncJobState = PublicFolderSyncJobRpc.QueryStatusSyncHierarchy(this.publicFolderSession.MailboxPrincipal);
}
}
}
}
catch (StoragePermanentException arg)
{
this.tracer.TraceError <string, StoragePermanentException>((long)this.GetHashCode(), "PublicFolderHierarchySyncProcessor::Invoke::{0} - Unable to process {1}", this.publicFolderSession.DisplayAddress, arg);
}
catch (StorageTransientException arg2)
{
this.tracer.TraceError <string, StorageTransientException>((long)this.GetHashCode(), "PublicFolderHierarchySyncProcessor::Invoke::{0} - Unable to process {1}", this.publicFolderSession.DisplayAddress, arg2);
}
}
// Token: 0x06000F19 RID: 3865 RVA: 0x0005A248 File Offset: 0x00058448
public static void SyncAndWaitForCompletion(Guid mailboxGuid, OrganizationId organizationId, IXSOFactory xsoFactory, IPublicFolderMailboxLoggerBase logger, ISplitOperationState splitOperationState)
{
ExchangePrincipal contentMailboxPrincipal;
if (!PublicFolderSession.TryGetPublicFolderMailboxPrincipal(organizationId, mailboxGuid, false, out contentMailboxPrincipal))
{
throw new ObjectNotFoundException(ServerStrings.PublicFolderMailboxNotFound);
}
PublicFolderSyncJobState publicFolderSyncJobState = PublicFolderSyncJobRpc.StartSyncHierarchy(contentMailboxPrincipal, true);
int num = 0;
while (publicFolderSyncJobState.JobStatus != PublicFolderSyncJobState.Status.Completed && publicFolderSyncJobState.LastError == null && (double)num++ < PublicFolderSplitConfig.Instance.TimeoutForSynchronousOperation.TotalMilliseconds / PublicFolderSplitConfig.Instance.QuerySyncStatusInterval.TotalMilliseconds)
{
Thread.Sleep(PublicFolderSplitConfig.Instance.QuerySyncStatusInterval.Milliseconds);
publicFolderSyncJobState = PublicFolderSyncJobRpc.QueryStatusSyncHierarchy(contentMailboxPrincipal);
}
bool flag;
if (publicFolderSyncJobState.JobStatus != PublicFolderSyncJobState.Status.Completed || PublicFolderSplitHelper.IsSyncRequired(mailboxGuid, organizationId, out flag, xsoFactory, logger))
{
splitOperationState.Error = new SyncInProgressException(organizationId.OrganizationalUnit.Name, mailboxGuid.ToString());
return;
}
if (PublicFolderSplitHelper.HasSyncFailure(publicFolderSyncJobState))
{
splitOperationState.Error = publicFolderSyncJobState.LastError;
}
}
internal static void SyncPublicFolder(IConfigurationSession configurationSession, StoreObjectId folderId)
{
using (PublicFolderDataProvider publicFolderDataProvider = new PublicFolderDataProvider(configurationSession, "*-PublicFolderClientPermission", Guid.Empty))
{
PublicFolderSession publicFolderSession = publicFolderDataProvider.PublicFolderSession;
using (CoreFolder coreFolder = CoreFolder.Bind(publicFolderSession, folderId, new PropertyDefinition[]
{
CoreFolderSchema.AclTableAndSecurityDescriptor
}))
{
PublicFolderContentMailboxInfo contentMailboxInfo = coreFolder.GetContentMailboxInfo();
Guid guid = contentMailboxInfo.IsValid ? contentMailboxInfo.MailboxGuid : Guid.Empty;
ExchangePrincipal contentMailboxPrincipal;
if (guid != Guid.Empty && guid != publicFolderSession.MailboxGuid && PublicFolderSession.TryGetPublicFolderMailboxPrincipal(publicFolderSession.OrganizationId, guid, true, out contentMailboxPrincipal))
{
PublicFolderSyncJobRpc.SyncFolder(contentMailboxPrincipal, folderId.ProviderLevelItemId);
}
}
}
}
// Token: 0x06000F5F RID: 3935 RVA: 0x0005B8C8 File Offset: 0x00059AC8
private void SyncAndReturn(Guid mailboxGuid)
{
this.splitOperationState.PartialStep = true;
ExchangePrincipal contentMailboxPrincipal;
if (!PublicFolderSession.TryGetPublicFolderMailboxPrincipal(base.CurrentPublicFolderSession.OrganizationId, mailboxGuid, false, out contentMailboxPrincipal))
{
throw new ObjectNotFoundException(ServerStrings.PublicFolderMailboxNotFound);
}
PublicFolderSyncJobState publicFolderSyncJobState = PublicFolderSyncJobRpc.StartSyncHierarchy(contentMailboxPrincipal, false);
if (PublicFolderSplitHelper.HasSyncFailure(publicFolderSyncJobState))
{
this.splitOperationState.Error = publicFolderSyncJobState.LastError;
return;
}
if ((int)this.splitOperationState.PartialStepCount > PrepareTargetMailboxOperation.PartialStepIterationLimit)
{
this.splitOperationState.Error = new PartialStepsOverLimitException("Long running sync operation", PrepareTargetMailboxOperation.PartialStepIterationLimit);
}
}
protected override void OnMoveCompleted(MailboxCopierBase mbxCtx)
{
CommonUtils.CatchKnownExceptions(delegate
{
Guid hierarchyMailboxGuid = this.publicFolderConfiguration.GetHierarchyMailboxInformation().HierarchyMailboxGuid;
if (mbxCtx.TargetMailboxGuid != hierarchyMailboxGuid)
{
MrsTracer.Service.Debug("Attempting to start hierarchy sync to content mailbox {0}.", new object[]
{
mbxCtx.TargetTracingID
});
PublicFolderSyncJobRpc.StartSyncHierarchy(this.publicFolderConfiguration.OrganizationId, mbxCtx.TargetMailboxGuid, mbxCtx.TargetServerInfo.MailboxServerName, true);
}
}, delegate(Exception e)
{
MrsTracer.Service.Error("Failed to start hierarchy sync to content mailbox {0} - {1}", new object[]
{
mbxCtx.TargetTracingID,
e
});
});
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
try
{
ADUser aduser = this.DataObject as ADUser;
if (aduser == null || aduser.RecipientTypeDetails != RecipientTypeDetails.PublicFolderMailbox)
{
base.WriteError(new ObjectNotFoundException(Strings.PublicFolderMailboxNotFound), ExchangeErrorCategory.Client, aduser);
}
ExchangePrincipal exchangePrincipal = ExchangePrincipal.FromADUser(base.SessionSettings, aduser);
string serverFqdn = exchangePrincipal.MailboxInfo.Location.ServerFqdn;
if (this.InvokeSynchronizer)
{
TenantPublicFolderConfiguration value = TenantPublicFolderConfigurationCache.Instance.GetValue(aduser.OrganizationId);
Organization orgContainer = this.ConfigurationSession.GetOrgContainer();
if (orgContainer.DefaultPublicFolderMailbox.HierarchyMailboxGuid != value.GetHierarchyMailboxInformation().HierarchyMailboxGuid || value.GetLocalMailboxRecipient(aduser.ExchangeGuid) == null)
{
TenantPublicFolderConfigurationCache.Instance.RemoveValue(aduser.OrganizationId);
}
if (aduser.ExchangeGuid == value.GetHierarchyMailboxInformation().HierarchyMailboxGuid)
{
base.WriteError(new TaskArgumentException(Strings.ErrorSecondaryMailboxIdRequired), ExchangeErrorCategory.Client, exchangePrincipal);
}
if (this.FullSync)
{
using (PublicFolderSession publicFolderSession = PublicFolderSession.OpenAsAdmin(this.DataObject.OrganizationId, null, aduser.ExchangeGuid, null, CultureInfo.CurrentCulture, "Client=Management;Action=UpdatePublicFolderMailbox", null))
{
using (Folder folder = Folder.Bind(publicFolderSession, publicFolderSession.GetTombstonesRootFolderId()))
{
using (UserConfiguration configuration = UserConfiguration.GetConfiguration(folder, new UserConfigurationName("PublicFolderSyncInfo", ConfigurationNameKind.Name), UserConfigurationTypes.Dictionary))
{
IDictionary dictionary = configuration.GetDictionary();
dictionary["SyncState"] = null;
configuration.Save();
}
}
}
}
PublicFolderSyncJobState publicFolderSyncJobState = PublicFolderSyncJobRpc.StartSyncHierarchy(exchangePrincipal, this.ReconcileFolders);
if (!this.SuppressStatus)
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageStartUpdatePublicFolderMailbox(this.Identity.ToString())));
int num = 0;
while (publicFolderSyncJobState.JobStatus != PublicFolderSyncJobState.Status.Completed && publicFolderSyncJobState.LastError == null && num++ < UpdatePublicFolderMailbox.timeToWaitInMilliseconds / UpdatePublicFolderMailbox.QueryIntervalInMilliseconds)
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageUpdatePublicFolderMailboxUnderProgress(publicFolderSyncJobState.JobStatus.ToString())));
Thread.Sleep(UpdatePublicFolderMailbox.QueryIntervalInMilliseconds);
publicFolderSyncJobState = PublicFolderSyncJobRpc.QueryStatusSyncHierarchy(exchangePrincipal);
}
if (publicFolderSyncJobState.LastError != null)
{
base.WriteError(publicFolderSyncJobState.LastError, ExchangeErrorCategory.ServerOperation, publicFolderSyncJobState);
}
if (publicFolderSyncJobState.JobStatus == PublicFolderSyncJobState.Status.Completed)
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageUpdatePublicFolderMailboxCompleted));
}
else
{
base.WriteObject(new UpdatePublicFolderMailboxResult(Strings.StatusMessageSynchronizerRunningInBackground));
}
}
}
else if (aduser.ExchangeGuid != Guid.Empty)
{
MailboxDatabase mailboxDatabase = base.GlobalConfigSession.Read <MailboxDatabase>(aduser.Database);
if (mailboxDatabase == null)
{
base.WriteError(new TaskArgumentException(Strings.ElcMdbNotFound(this.Identity.ToString())), ExchangeErrorCategory.Client, null);
}
this.EnsureMailboxExistsOnDatabase(aduser.ExchangeGuid);
AssistantsRpcClient assistantsRpcClient = new AssistantsRpcClient(serverFqdn);
try
{
assistantsRpcClient.Start("PublicFolderAssistant", aduser.ExchangeGuid, mailboxDatabase.Guid);
}
catch (RpcException ex)
{
base.WriteError(new TaskException(RpcUtility.MapRpcErrorCodeToMessage(ex.ErrorCode, serverFqdn)), ExchangeErrorCategory.Client, null);
}
}
}
finally
{
TaskLogger.LogExit();
}
}
