internal static PublicFolderMailboxDiagnosticsInfo Load(OrganizationId organizationId, Guid contentMailboxGuid, DiagnosticsLoadFlags loadFlags, Action <LocalizedString, LocalizedString, int> writeProgress)
{
PublicFolderMailboxDiagnosticsInfo result;
using (PublicFolderSession publicFolderSession = PublicFolderSession.OpenAsAdmin(organizationId, null, contentMailboxGuid, null, CultureInfo.CurrentCulture, "Client=Management;Action=Get-PublicFolderMailboxDiagnostics", null))
{
result = PublicFolderMailboxDiagnosticsInfo.Load(publicFolderSession, loadFlags, writeProgress);
}
return(result);
}
internal static StoreSession OpenSession(ExchangePrincipal principal, GenericIdentity actualExecutingIdentity, bool publicFolderSession = false)
{
if (actualExecutingIdentity == null)
{
throw new ArgumentNullException("actualExecutingIdentity");
}
if (!publicFolderSession)
{
return(MailboxSession.OpenAsAdmin(principal, CultureInfo.InvariantCulture, "Client=EDiscoverySearch;Action=Search;Interactive=False", actualExecutingIdentity, true));
}
return(PublicFolderSession.OpenAsAdmin(principal.MailboxInfo.OrganizationId, null, principal.MailboxInfo.MailboxGuid, null, CultureInfo.InvariantCulture, "Client=EDiscoverySearch;Action=Search;Interactive=False", null));
}
private void EnsureMailboxExistsOnDatabase(Guid mailboxGuid)
{
TenantPublicFolderConfiguration value = TenantPublicFolderConfigurationCache.Instance.GetValue(this.DataObject.OrganizationId);
if (value.GetLocalMailboxRecipient(mailboxGuid) == null)
{
TenantPublicFolderConfigurationCache.Instance.RemoveValue(this.DataObject.OrganizationId);
}
using (PublicFolderSession.OpenAsAdmin(this.DataObject.OrganizationId, null, mailboxGuid, null, CultureInfo.CurrentCulture, "Client=Management;Action=UpdatePublicFolderMailbox", null))
{
}
}
// Token: 0x0600191D RID: 6429 RVA: 0x000922A4 File Offset: 0x000904A4
private Folder GetFolderFromPath(string path, bool isPublicFolder)
{
string[] array = path.Split(new char[]
{
'/',
'\\'
}, StringSplitOptions.RemoveEmptyEntries);
CultureInfo userCulture = Culture.GetUserCulture();
StoreObjectId storeObjectId = null;
StoreSession storeSession = null;
OwaStoreObjectIdType objectIdType = OwaStoreObjectIdType.MailBoxObject;
try
{
if (isPublicFolder)
{
storeSession = PublicFolderSession.OpenAsAdmin(this.userContext.ExchangePrincipal.MailboxInfo.OrganizationId, this.userContext.ExchangePrincipal, Guid.Empty, null, userCulture, "Client=OWA;Action=WebPart + Admin + GetFolderFromPath", null);
storeObjectId = this.userContext.PublicFolderRootId;
objectIdType = OwaStoreObjectIdType.PublicStoreFolder;
}
else
{
storeSession = MailboxSession.OpenAsAdmin(this.owaContext.ExchangePrincipal, userCulture, "Client=OWA;Action=WebPart + Admin + GetFolderFromPath");
GccUtils.SetStoreSessionClientIPEndpointsFromHttpRequest(storeSession, this.owaContext.HttpContext.Request);
storeObjectId = this.userContext.GetRootFolderId(this.userContext.MailboxSession);
}
for (int i = 0; i < array.Length; i++)
{
object[][] folderIdByDisplayName = this.GetFolderIdByDisplayName(array[i], storeObjectId, storeSession);
if (folderIdByDisplayName == null || folderIdByDisplayName.Length == 0)
{
return(null);
}
storeObjectId = ((VersionedId)folderIdByDisplayName[0][0]).ObjectId;
}
}
finally
{
if (storeSession != null)
{
storeSession.Dispose();
storeSession = null;
}
}
if (storeObjectId == null)
{
return(null);
}
return(this.GetFolderFromId(OwaStoreObjectId.CreateFromFolderId(storeObjectId, objectIdType)));
}
public PublicFolderSession GetPublicFolderSession(Guid publicFolderMailboxGuid)
{
PublicFolderSession result;
using (this.CheckDisposed("GetPublicFolderSession"))
{
ExTraceGlobals.SessionTracer.TraceDebug((long)this.GetHashCode(), "PublicFolderSessionCache.GetPublicFolderContentSession called");
if (publicFolderMailboxGuid == PublicFolderSession.HierarchyMailboxGuidAlias)
{
publicFolderMailboxGuid = this.GetHierarchyMailboxGuidForUser();
}
PublicFolderSession publicFolderSession;
if (this.openedSessions.TryGetValue(publicFolderMailboxGuid, out publicFolderSession))
{
result = publicFolderSession;
}
else
{
lock (this.lockObject)
{
if (this.openedSessions.TryGetValue(publicFolderMailboxGuid, out publicFolderSession))
{
return(publicFolderSession);
}
if (this.openSessionAsAdmin)
{
publicFolderSession = PublicFolderSession.OpenAsAdmin(this.organizationId, this.connectAsPrincipal, publicFolderMailboxGuid, (this.clientSecurityContext == null) ? null : new WindowsPrincipal(this.clientSecurityContext.Identity), this.cultureInfo, this.clientInfoString, this.budget);
}
else
{
publicFolderSession = PublicFolderSession.Open(this.connectAsPrincipal, publicFolderMailboxGuid, this.clientSecurityContext, this.cultureInfo, this.clientInfoString);
publicFolderSession.AccountingObject = this.budget;
}
if (this.timeZone != null)
{
publicFolderSession.ExTimeZone = this.timeZone;
}
if (this.firstPublicFolderSession == null)
{
this.firstPublicFolderSession = publicFolderSession;
}
this.openedSessions.Add(publicFolderSession.MailboxGuid, publicFolderSession);
}
result = publicFolderSession;
}
}
return(result);
}
private StoreSession OpenPublicFolderMailboxSession(Guid mdbGuid, ADUser adUser)
{
try
{
return(PublicFolderSession.OpenAsAdmin(adUser.OrganizationId, null, adUser.ExchangeGuid, null, CultureInfo.InvariantCulture, "Client=Management;Action=GetFailedDocuments", null));
}
catch (StoragePermanentException exception)
{
base.WriteError(exception, ErrorCategory.ReadError, null);
}
catch (StorageTransientException exception2)
{
base.WriteError(exception2, ErrorCategory.ReadError, null);
}
return(null);
}
// Token: 0x06000F1B RID: 3867 RVA: 0x0005A338 File Offset: 0x00058538
public static bool IsSyncRequired(Guid mailboxGuid, OrganizationId organizationId, out bool isLongRunningOp, IXSOFactory xsoFactory, IPublicFolderMailboxLoggerBase logger)
{
isLongRunningOp = false;
bool flag = true;
using (PublicFolderSession publicFolderSession = PublicFolderSession.OpenAsAdmin(organizationId, null, mailboxGuid, null, CultureInfo.CurrentCulture, string.Format("{0};Action={1}", "Client=TBA", "PublicFolderSplitHelper"), null))
{
using (Folder folder = xsoFactory.BindToFolder(publicFolderSession, publicFolderSession.GetTombstonesRootFolderId()) as Folder)
{
using (UserConfiguration configuration = UserConfiguration.GetConfiguration(folder, new UserConfigurationName("PublicFolderSyncInfo", ConfigurationNameKind.Name), UserConfigurationTypes.Dictionary))
{
IDictionary dictionary = configuration.GetDictionary();
int? num = dictionary.Contains("NumberOfFoldersToBeSynced") ? ((int?)dictionary["NumberOfFoldersToBeSynced"]) : null;
int? num2 = dictionary.Contains("NumberOfFoldersSynced") ? ((int?)dictionary["NumberOfFoldersSynced"]) : null;
int? num3 = (num == null) ? null : (num - (num2 ?? 0));
flag = (num3 == null || num3 > 0);
isLongRunningOp = (flag && (num3 == null || num3 > PublicFolderSplitConfig.Instance.LongRunningSyncChangeCount));
logger.LogEvent(LogEventType.Statistics, string.Format("PublicFolderSplitHelper::IsSyncRequired - FTBS={0},FS={1},FTBSN={2}", num, num2, num3));
}
}
}
return(flag);
}
private static void ProcessAttachment(WacRequest wacRequest, PropertyOpenMode openMode, WacUtilities.AttachmentProcessor attachmentProcessor)
{
ADSessionSettings adSessionSettings;
ExchangePrincipal exchangePrincipal = WacUtilities.GetExchangePrincipal(wacRequest, out adSessionSettings, wacRequest.WacFileRep.IsArchive);
WacRequestHandler.ProcessUsingBudget(wacRequest.WacFileRep.LogonSid, delegate
{
string ewsAttachmentId = wacRequest.EwsAttachmentId;
CultureInfo cultureInfo = CultureInfo.GetCultureInfo(wacRequest.CultureName);
string clientInfoString = "Client=OWA;Action=WAC";
if (exchangePrincipal.RecipientTypeDetails.HasFlag(RecipientTypeDetails.PublicFolder) || exchangePrincipal.RecipientTypeDetails.HasFlag(RecipientTypeDetails.PublicFolderMailbox))
{
using (PublicFolderSession publicFolderSession = PublicFolderSession.OpenAsAdmin(null, exchangePrincipal, null, cultureInfo, clientInfoString, null))
{
WacUtilities.ProcessAttachment(publicFolderSession, ewsAttachmentId, exchangePrincipal, openMode, attachmentProcessor);
return;
}
}
using (MailboxSession mailboxSession = MailboxSession.OpenAsSystemService(exchangePrincipal, cultureInfo, clientInfoString))
{
WacUtilities.ProcessAttachment(mailboxSession, ewsAttachmentId, exchangePrincipal, openMode, attachmentProcessor);
}
}, adSessionSettings);
}
private PublicFolderSession GetPublicFolderSession(Server server)
{
return(FreeBusyFolder.RetryOnStorageTransientException <PublicFolderSession>(() => PublicFolderSession.OpenAsAdmin(OrganizationId.ForestWideOrgId, null, Guid.Empty, null, CultureInfo.CurrentCulture, "Client=management;Action=Install-FreeBusyFolder", null)));
}
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();
}
}
private StoreSession OpenMailboxSession(StoreMailboxData mailbox)
{
Guid activityId = (ActivityContext.ActivityId != null) ? ActivityContext.ActivityId.Value : Guid.Empty;
AssistantBase assistant = this.Assistant as AssistantBase;
string nonLocalizedName = this.Assistant.NonLocalizedName;
Guid mailboxGuid = mailbox.MailboxGuid;
StoreSession result;
try
{
ExchangePrincipal exchangePrincipal;
if (mailbox.TenantPartitionHint != null)
{
ADSessionSettings adSettings = ADSessionSettings.FromTenantPartitionHint(mailbox.TenantPartitionHint);
exchangePrincipal = ExchangePrincipal.FromLocalServerMailboxGuid(adSettings, this.DatabaseInfo.Guid, mailbox.Guid);
}
else
{
exchangePrincipal = ExchangePrincipal.FromMailboxData(mailbox.Guid, this.DatabaseInfo.Guid, mailbox.OrganizationId ?? OrganizationId.ForestWideOrgId, Array <CultureInfo> .Empty);
}
if (mailbox.IsPublicFolderMailbox)
{
StoreSession storeSession = PublicFolderSession.OpenAsAdmin(null, exchangePrincipal, null, CultureInfo.InstalledUICulture, string.Format("{0};Action={1}", "Client=TBA", this.Assistant.GetType().Name), null);
AssistantsLog.LogMailboxSucceedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, mailboxGuid, mailbox.DisplayName, this);
result = storeSession;
}
else
{
bool flag = false;
MailboxSession mailbox2 = this.DatabaseInfo.GetMailbox(exchangePrincipal, ClientType.TimeBased, this.Assistant.GetType().Name);
try
{
mailbox2.ReconstructExchangePrincipal();
mailbox2.ExTimeZone = ExTimeZone.CurrentTimeZone;
flag = true;
AssistantsLog.LogMailboxSucceedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, mailboxGuid, mailbox.DisplayName, this);
result = mailbox2;
}
finally
{
if (!flag)
{
mailbox2.Dispose();
}
}
}
}
catch (ObjectNotFoundException ex)
{
string text = "MailboxNotFound";
string message = string.Format("{0}: {1}", this, text);
string value = string.Format("{0}:{1}", text, mailbox.MailboxGuid);
ExTraceGlobals.TimeBasedDatabaseJobTracer.TraceError((long)this.GetHashCode(), message);
AssistantsLog.LogMailboxFailedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, ex, mailboxGuid, mailbox.DisplayName, this);
throw new SkipException(new LocalizedString(value), ex);
}
catch (StorageTransientException ex2)
{
string message2 = string.Format("{0}: Could not open mailbox store session due to storage transient error: {1}", this, ex2.Message);
ExTraceGlobals.TimeBasedDatabaseJobTracer.TraceError((long)this.GetHashCode(), message2);
AssistantsLog.LogMailboxFailedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, ex2, mailboxGuid, mailbox.DisplayName, this);
Interlocked.Increment(ref this.mailboxesFailedToOpenStoreSessionCount);
throw;
}
catch (Exception ex3)
{
string message3 = string.Format("{0}: Could not open mailbox store session due to error: {1}", this, ex3.Message);
ExTraceGlobals.TimeBasedDatabaseJobTracer.TraceError((long)this.GetHashCode(), message3);
AssistantsLog.LogMailboxFailedToOpenStoreSessionEvent(activityId, nonLocalizedName, assistant, ex3, mailboxGuid, mailbox.DisplayName, this);
Interlocked.Increment(ref this.mailboxesFailedToOpenStoreSessionCount);
throw;
}
return(result);
}
