protected void SafeCloseLoggingStream()
{
if (this.syncCycleLogStream != null)
{
try
{
this.syncCycleLogStream.SetLength(this.syncCycleLogStream.Position);
this.syncCycleLogStream.Close();
this.syncCycleLogStream = null;
this.SyncInfoEntry.Logger.Save();
}
catch (IOException exception)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SafeCloseLoggingStream: Failed with IOException", exception);
}
catch (StorageTransientException exception2)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SafeCloseLoggingStream: Failed with StorageTransientException", exception2);
}
catch (StoragePermanentException exception3)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SafeCloseLoggingStream: Failed with StoragePermanentException", exception3);
}
}
}
protected void SafeInitializeLoggingStream()
{
try
{
if (this.SyncInfoEntry.Logger != null)
{
this.syncCycleLogStream = this.SyncInfoEntry.Logger.GetStream();
}
else
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SafeInitializeLoggingStream: Logger is null and possibly caused by corruption of log stream configuration", new ArgumentException());
}
}
catch (IOException exception)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SafeInitializeLoggingStream: Failed with IOException", exception);
}
catch (StorageTransientException exception2)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SafeInitializeLoggingStream: Failed with StorageTransientException", exception2);
}
catch (StoragePermanentException exception3)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SafeInitializeLoggingStream: Failed with StoragePermanentException", exception3);
}
}
protected bool HandleShutDown()
{
if (this.Job != null && this.Job.IsShuttingdown)
{
this.resourceMonitor.ResetBudget();
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, "HandleShutDown: Shutdown the job by invoke callback");
this.executionAsyncResult.InvokeCallback(null);
return(true);
}
return(false);
}
public static string GetExceptionLogString(Exception e)
{
if (e == null)
{
throw new ArgumentNullException("e is null");
}
string empty = string.Empty;
List <string> list = null;
List <string> list2 = null;
ProtocolLog.GetExceptionTypeAndDetails(e, out list, out list2, out empty, true);
return(empty);
}
private void UpdateSyncMetadataOnSyncFailure()
{
try
{
ExDateTime? exDateTime = this.GetSyncMetadataValue("LastSuccessfulSyncTime") as ExDateTime?;
ExDateTime? exDateTime2 = this.GetSyncMetadataValue("FirstAttemptedSyncTime") as ExDateTime?;
ExDateTime? exDateTime3 = this.GetSyncMetadataValue("LastFailedSyncEmailTime") as ExDateTime?;
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine(ProtocolLog.GetExceptionLogString(this.LastError));
if (this.LastError is SharePointException)
{
stringBuilder.AppendLine("SharePointException Diagnostic Info:");
stringBuilder.AppendLine(((SharePointException)this.LastError).DiagnosticInfo);
}
this.SetSyncMetadataValue("LastSyncFailure", stringBuilder.ToString());
this.SetSyncMetadataValue("LastFailedSyncTime", ExDateTime.UtcNow);
ExDateTime?exDateTime4 = exDateTime ?? exDateTime2;
if ((exDateTime3 == null || ExDateTime.UtcNow - exDateTime3 > TimeSpan.FromHours(24.0)) && exDateTime4 != null && ExDateTime.UtcNow - exDateTime4 > TimeSpan.FromHours(12.0))
{
StoreObjectId destFolderId = Utils.EnsureSyncIssueFolder(this.mailboxSession);
using (MessageItem messageItem = MessageItem.Create(this.mailboxSession, destFolderId))
{
LocalizedString empty = LocalizedString.Empty;
messageItem.From = new Participant(this.Job.SyncInfoEntry.MailboxPrincipal);
messageItem.Subject = this.GetSyncIssueEmailErrorString(this.LastError.Message, out empty);
using (TextWriter textWriter = messageItem.Body.OpenTextWriter(BodyFormat.TextHtml))
{
messageItem.Body.Reset();
using (HtmlWriter htmlWriter = new HtmlWriter(textWriter))
{
htmlWriter.WriteStartTag(HtmlTagId.P);
htmlWriter.WriteText(empty);
htmlWriter.WriteEndTag(HtmlTagId.P);
}
}
messageItem.IsDraft = false;
messageItem.MarkAsUnread(true);
messageItem.Save(SaveMode.NoConflictResolutionForceSave);
this.SetSyncMetadataValue("LastFailedSyncEmailTime", ExDateTime.UtcNow);
}
}
}
catch (StorageTransientException exception)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "UpdateSyncMetadataOnSyncFailure: Failed with StorageTransientException", exception);
}
catch (StoragePermanentException exception2)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "UpdateSyncMetadataOnSyncFailure: Failed with StoragePermanentException", exception2);
}
}
private static void LogEvent(ProtocolLog.Component component, ProtocolLog.EventType eventType, LoggingContext loggingContext, string data, Exception exception)
{
if (string.IsNullOrEmpty(data))
{
throw new ArgumentNullException("data");
}
ProtocolLog.InitializeIfNeeded();
LogRowFormatter logRowFormatter = new LogRowFormatter(ProtocolLog.LogSchema);
logRowFormatter[1] = component;
logRowFormatter[2] = eventType;
if (loggingContext != null)
{
logRowFormatter[5] = loggingContext.MailboxGuid.ToString();
logRowFormatter[3] = loggingContext.TransactionId.ToString();
logRowFormatter[4] = loggingContext.User;
logRowFormatter[6] = loggingContext.Context;
}
logRowFormatter[7] = data;
if (exception != null)
{
List <string> list = null;
List <string> list2 = null;
string value = null;
ProtocolLog.GetExceptionTypeAndDetails(exception, out list, out list2, out value, false);
logRowFormatter[8] = list[0];
logRowFormatter[9] = list2[0];
if (list.Count > 1)
{
logRowFormatter[10] = list[list.Count - 1];
logRowFormatter[11] = list2[list2.Count - 1];
}
logRowFormatter[12] = value;
}
ProtocolLog.instance.logInstance.Append(logRowFormatter, 0);
if (loggingContext != null && loggingContext.LoggingStream != null)
{
try
{
logRowFormatter.Write(loggingContext.LoggingStream);
}
catch (StorageTransientException)
{
}
catch (StoragePermanentException)
{
}
}
}
private void ProtectedExecution(AsyncCallback callback, IAsyncResult asyncResult)
{
try
{
GrayException.MapAndReportGrayExceptions(delegate()
{
callback(asyncResult);
});
}
catch (GrayException ex)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "WrapCallbackWithUnhandledExceptionAndSendReport: Failed with unexpected exception", ex);
this.executionAsyncResult.InvokeCallback(ex);
}
}
protected override void End()
{
try
{
if (base.LastError != null)
{
ProtocolLog.LogCycleFailure(this.loggingComponent, this.loggingContext, "The sync cycle completed with error", base.LastError);
}
else
{
ProtocolLog.LogCycleSuccess(this.loggingComponent, this.loggingContext, "The sync cycle completed successfully");
}
this.SafeCloseLoggingStream();
}
finally
{
base.End();
}
}
public bool UpdateNextBatch()
{
for (int i = 0; i < this.membershipSynchronizer.workLoadSize; i++)
{
if (!this.usersEnumerator.MoveNext())
{
return(false);
}
MembershipSynchronizer.UsersToUpdateShowInMyClient.UserToUpdate userToUpdate = this.usersEnumerator.Current;
bool flag;
Exception ex;
this.membershipSynchronizer.membershipHelper.SetShowInMyClient(userToUpdate.Id, userToUpdate.IsAdd, out flag, out ex);
if (ex != null)
{
ProtocolLog.LogError(this.membershipSynchronizer.loggingComponent, this.membershipSynchronizer.loggingContext, string.Format("MembershipSynchronizer.SetShowInMyClient: failed to SetShowInMyClient for user {0}", userToUpdate.Id), ex);
}
}
return(true);
}
public override IAsyncResult BeginExecute(AsyncCallback executeCallback, object state)
{
this.executeStopwatch = Stopwatch.StartNew();
this.executionAsyncResult = new LazyAsyncResult(null, state, executeCallback);
try
{
this.InitializeSyncMetadata();
base.UpdateSyncMetadataOnBeginSync();
}
catch (StorageTransientException ex)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SiteSynchronizer.BeginExecute:failed with StorageTransientException", ex);
this.executionAsyncResult.InvokeCallback(ex);
return(this.executionAsyncResult);
}
catch (StoragePermanentException ex2)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "SiteSynchronizer.BeginExecute:failed with StoragePermanentException", ex2);
this.executionAsyncResult.InvokeCallback(ex2);
return(this.executionAsyncResult);
}
this.OnGetDocumentLibraryListsComplete(this.executionAsyncResult);
return(this.executionAsyncResult);
}
protected virtual void OnGetDocumentLibraryListsComplete(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw new InvalidOperationException("OnGetDocumentLibraryListsComplete: asyncResult cannot be null here.");
}
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, string.Format("SiteSynchronizer.BeginExecute", new object[0]));
bool flag = (base.SyncOption & SyncOption.CurrentDocumentLibsOnly) == SyncOption.CurrentDocumentLibsOnly;
Dictionary <Guid, List> dictionary = new Dictionary <Guid, List>();
if (!flag)
{
try
{
this.InitializeDocumentLibraryList(dictionary);
if (base.HandleShutDown())
{
return;
}
}
catch (WebException e)
{
SharePointException value = new SharePointException(this.siteUri.AbsoluteUri, e, false);
this.executionAsyncResult.InvokeCallback(value);
return;
}
catch (IOException value2)
{
this.executionAsyncResult.InvokeCallback(value2);
return;
}
catch (ClientRequestException value3)
{
this.executionAsyncResult.InvokeCallback(value3);
return;
}
catch (ServerException value4)
{
this.executionAsyncResult.InvokeCallback(value4);
return;
}
}
List <StoreObjectId> list = new List <StoreObjectId>();
List <List> list2 = new List <List>();
Dictionary <StoreObjectId, List> dictionary2 = new Dictionary <StoreObjectId, List>();
try
{
using (Folder folder = Folder.Bind(this.mailboxSession, DefaultFolderType.Root))
{
using (QueryResult queryResult = folder.FolderQuery(FolderQueryFlags.None, new ExistsFilter(FolderSchema.LinkedId), null, new PropertyDefinition[]
{
FolderSchema.LinkedId,
FolderSchema.Id,
FolderSchema.DisplayName,
FolderSchema.LinkedUrl,
FolderSchema.LinkedSiteAuthorityUrl
}))
{
object[][] rows;
do
{
rows = queryResult.GetRows(10000);
for (int i = 0; i < rows.Length; i++)
{
Guid guid = (Guid)rows[i][0];
StoreObjectId objectId = ((VersionedId)rows[i][1]).ObjectId;
string a = rows[i][2] as string;
string text = rows[i][3] as string;
string text2 = rows[i][4] as string;
Uri uri = null;
if (!string.IsNullOrEmpty(text2))
{
uri = new Uri(text2);
}
if (string.IsNullOrEmpty(text))
{
this.executionAsyncResult.InvokeCallback(new ArgumentNullException("LinkedUrl is null for folder " + objectId.ToString()));
}
if (!flag)
{
List list3 = null;
if (dictionary.TryGetValue(guid, out list3))
{
if (!string.Equals(a, list3.Title, StringComparison.Ordinal) || (uri != null && !UriComparer.IsEqual(uri, this.siteUri)) || (this.Job.SyncOption & SyncOption.FullSync) == SyncOption.FullSync)
{
dictionary2[objectId] = dictionary[guid];
}
this.documentLibraryInfos.Enqueue(new DocumentLibraryInfo(objectId, list3.Id, list3.RootFolder.ServerRelativeUrl));
dictionary.Remove(guid);
}
else
{
list.Add(objectId);
}
}
else
{
this.documentLibraryInfos.Enqueue(new DocumentLibraryInfo(objectId, guid, new Uri(text).AbsolutePath));
}
}
}while (rows.Length != 0);
list2.AddRange(dictionary.Values);
}
if (list.Count > 0)
{
folder.DeleteObjects(DeleteItemFlags.HardDelete, list.ToArray());
}
foreach (KeyValuePair <StoreObjectId, List> keyValuePair in dictionary2)
{
if (base.HandleShutDown())
{
return;
}
using (Folder folder2 = Folder.Bind(this.mailboxSession, keyValuePair.Key))
{
Uri uri2 = new Uri(new Uri(this.siteUri.GetLeftPart(UriPartial.Authority)), keyValuePair.Value.RootFolder.ServerRelativeUrl);
bool flag2 = Utils.HasFolderUriChanged(folder2, uri2);
if (flag2)
{
folder2[FolderSchema.SharePointChangeToken] = string.Empty;
folder2[FolderSchema.LinkedUrl] = uri2.AbsoluteUri;
folder2[FolderSchema.LinkedSiteUrl] = this.siteUri.AbsoluteUri;
string valueOrDefault = folder2.PropertyBag.GetValueOrDefault <string>(FolderSchema.LinkedUrl, string.Empty);
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, string.Format("SiteSynchronizer: Document Library URL has changed from {0} to {1}", valueOrDefault, uri2.AbsoluteUri));
}
folder2.DisplayName = keyValuePair.Value.Title;
folder2[FolderSchema.LinkedSiteAuthorityUrl] = this.siteUri.AbsoluteUri;
folder2.Save();
}
}
foreach (List list4 in list2)
{
if (base.HandleShutDown())
{
return;
}
using (Folder folder3 = Folder.Create(this.mailboxSession, folder.Id.ObjectId, StoreObjectType.ShortcutFolder, list4.Title, CreateMode.OpenIfExists))
{
folder3[FolderSchema.LinkedId] = list4.Id;
Uri uri3 = new Uri(new Uri(this.siteUri.GetLeftPart(UriPartial.Authority)), list4.RootFolder.ServerRelativeUrl);
folder3[FolderSchema.LinkedUrl] = uri3.AbsoluteUri;
folder3[FolderSchema.LinkedSiteUrl] = this.siteUri.AbsoluteUri;
folder3[FolderSchema.LinkedListId] = list4.Id;
folder3[FolderSchema.IsDocumentLibraryFolder] = true;
folder3[FolderSchema.LinkedSiteAuthorityUrl] = this.siteUri.AbsoluteUri;
folder3.Save();
folder3.Load();
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, string.Format("SiteSynchronizer: Create or update top level document library Name:{0}, LinkedUrl: {1}, LinkedId {2}, ListId {3}", new object[]
{
folder3.DisplayName,
folder3[FolderSchema.LinkedUrl],
folder3[FolderSchema.LinkedId],
folder3[FolderSchema.LinkedListId]
}));
this.documentLibraryInfos.Enqueue(new DocumentLibraryInfo(folder3.Id.ObjectId, list4.Id, list4.RootFolder.ServerRelativeUrl));
}
}
}
base.SyncResult = this.documentLibraryInfos;
this.executionAsyncResult.InvokeCallback(null);
}
catch (StorageTransientException value5)
{
this.executionAsyncResult.InvokeCallback(value5);
}
catch (StoragePermanentException value6)
{
this.executionAsyncResult.InvokeCallback(value6);
}
}
public override IAsyncResult BeginExecute(AsyncCallback executeCallback, object state)
{
this.executionAsyncResult = new LazyAsyncResult(null, state, executeCallback);
this.performanceCounter.Start(OperationType.EndToEnd);
try
{
this.InitializeSyncMetadata();
base.UpdateSyncMetadataOnBeginSync();
}
catch (StorageTransientException ex)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "MaintenanceSynchronizer.BeginExecute: failed with StorageTransientException", ex);
this.executionAsyncResult.InvokeCallback(ex);
return(this.executionAsyncResult);
}
catch (StoragePermanentException ex2)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, "MaintenanceSynchronizer.BeginExecute: failed with StoragePermanentException", ex2);
this.executionAsyncResult.InvokeCallback(ex2);
return(this.executionAsyncResult);
}
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, "MaintenanceSynchronizer.BeginExecute");
Exception value = null;
Uri uri;
string b;
if (this.recordedSiteUrl != null && this.webCollectionUrl != null && this.TryGetSharePointSiteUrlAndTitle(this.webCollectionUrl, this.webId, out uri, out b, out value))
{
if (UriComparer.IsEqual(this.recordedSiteUrl, uri))
{
if (string.Equals(this.displayName, b))
{
goto IL_286;
}
}
try
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, null, CultureInfo.InvariantCulture.LCID, false, ConsistencyMode.IgnoreInvalid, null, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.orgId), 189, "BeginExecute", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\LinkedFolder\\MaintenanceSynchronizer.cs");
ADUser aduser = tenantOrRootOrgRecipientSession.FindByExchangeGuid(this.TeamMailboxGuid) as ADUser;
if (aduser == null)
{
value = new ObjectNotFoundException(new LocalizedString("Cannot find the team mailbox by mailbox guid " + this.TeamMailboxGuid));
}
else
{
aduser.SharePointUrl = uri;
aduser.DisplayName = b;
tenantOrRootOrgRecipientSession.Save(aduser);
ProtocolLog.LogInformation(this.loggingComponent, this.loggingContext, "MaintenanceSynchronizer.BeginExecute: updated new SharePoint site URL: " + uri);
if (!UriComparer.IsEqual(this.recordedSiteUrl, uri))
{
RpcClientWrapper.EnqueueTeamMailboxSyncRequest(this.mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn, this.mailboxSession.MailboxOwner.MailboxInfo.MailboxGuid, QueueType.TeamMailboxDocumentSync, this.mailboxSession.MailboxOwner.MailboxInfo.OrganizationId, "Maintenance Synchronizer", tenantOrRootOrgRecipientSession.LastUsedDc, SyncOption.Default);
RpcClientWrapper.EnqueueTeamMailboxSyncRequest(this.mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn, this.mailboxSession.MailboxOwner.MailboxInfo.MailboxGuid, QueueType.TeamMailboxMembershipSync, this.mailboxSession.MailboxOwner.MailboxInfo.OrganizationId, "Maintenance Synchronizer", tenantOrRootOrgRecipientSession.LastUsedDc, SyncOption.Default);
}
}
}
catch (DataSourceOperationException ex3)
{
value = ex3;
}
catch (DataValidationException ex4)
{
value = ex4;
}
catch (TransientException ex5)
{
value = ex5;
}
}
IL_286:
this.executionAsyncResult.InvokeCallback(value);
return(this.executionAsyncResult);
}
private bool UpdateAccessTokenIfNeeded(Uri sharepointUrl, ExchangePrincipal siteMailbox, ICredentials accessingUserCredential, ClientSecurityContext accessingUserSecurityContext, int sessionHashCode, out Exception exception, bool isTest = false)
{
exception = null;
if (siteMailbox == null)
{
throw new ArgumentNullException("siteMailbox");
}
if (accessingUserSecurityContext == null)
{
throw new ArgumentNullException("accessingUserSecurityContext");
}
if (sharepointUrl == null)
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug <string>((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Skip site mailbox {0} because its Sharepoint URL is null", siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString());
return(false);
}
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug <ClientSecurityContext, string, string>((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Entered with user {0}, site mailbox {1}, URL {2}", accessingUserSecurityContext, siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl.AbsoluteUri);
LoggingContext loggingContext = new LoggingContext(siteMailbox.MailboxInfo.MailboxGuid, sharepointUrl.AbsoluteUri, accessingUserSecurityContext.ToString(), null);
AccessState accessState = AccessState.Denied;
bool flag = false;
SharepointAccessManager.Key key = this.GetKey(accessingUserSecurityContext.UserSid, siteMailbox.MailboxInfo.MailboxGuid);
if (!SharepointAccessManager.Instance.TryGetValue(key, out accessState))
{
flag = true;
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Cache miss, query Sharepoint");
SharepointAccessManager.PermissionCheckerClient permissionCheckerClient = new SharepointAccessManager.PermissionCheckerClient(sessionHashCode, siteMailbox.MailboxInfo.MailboxGuid, sharepointUrl.AbsoluteUri, accessingUserSecurityContext.UserSid, key, accessingUserCredential, this.requestTimeout, this.requestThroughLocalProxy, isTest);
LazyAsyncResult lazyAsyncResult = (LazyAsyncResult)permissionCheckerClient.BeginExecute(new AsyncCallback(SharepointAccessManager.OnCheckComplete), permissionCheckerClient);
int num = (int)this.synchronousWaitTimeout.TotalSeconds * 2;
int num2 = 0;
while (!lazyAsyncResult.IsCompleted || lazyAsyncResult.Result == null)
{
Thread.Sleep(500);
num2++;
if (num2 > num)
{
break;
}
}
object result = lazyAsyncResult.Result;
if (!(result is AccessState))
{
exception = ((lazyAsyncResult.Result is Exception) ? (lazyAsyncResult.Result as Exception) : new TimeoutException("Timed out"));
WebException ex = exception as WebException;
if (ex != null)
{
SharePointException exception2 = new SharePointException(sharepointUrl.AbsoluteUri, ex, false);
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceError <WebExceptionStatus, string, Exception>((long)permissionCheckerClient.SessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Query failed with WebException. Status: {0}, Message: {1}, InnerException: {2}", ex.Status, ex.Message, ex.InnerException);
ProtocolLog.LogError(ProtocolLog.Component.SharepointAccessManager, loggingContext, "Query failed with SharePointException", exception2);
}
else
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceError <Type, string, Exception>((long)permissionCheckerClient.SessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Query failed with {0}, Message: {1}, InnerException: {2}", exception.GetType(), exception.Message, exception.InnerException);
ProtocolLog.LogError(ProtocolLog.Component.SharepointAccessManager, loggingContext, string.Format("Query failed with {0}", exception.GetType()), exception);
}
return(false);
}
accessState = (AccessState)result;
}
else if (accessState == AccessState.Pending)
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Skip because there is an pending request");
return(true);
}
if (accessState == AccessState.Allowed)
{
if (!accessingUserSecurityContext.AddGroupSids(new SidBinaryAndAttributes[]
{
new SidBinaryAndAttributes(WellKnownSids.SiteMailboxGrantedAccessMembers, 4U)
}))
{
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceError((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Failed to add SiteMailboxGrantedAccessMembers group sid to access token");
return(false);
}
ExTraceGlobals.SiteMailboxPermissionCheckTracer.TraceDebug <ClientSecurityContext, string, string>((long)sessionHashCode, "SharepointAccessManager.UpdateAccessTokenIfNeeded: Access is allowed for user {0}, site mailbox {1}, URL {2}", accessingUserSecurityContext, siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl.AbsoluteUri);
if (flag)
{
ProtocolLog.LogInformation(ProtocolLog.Component.SharepointAccessManager, loggingContext, string.Format("Allow access for site mailbox {0}, URL {1}", siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl));
}
}
else if (flag)
{
ProtocolLog.LogInformation(ProtocolLog.Component.SharepointAccessManager, loggingContext, string.Format("Deny access for site mailbox {0}, URL {1}", siteMailbox.MailboxInfo.PrimarySmtpAddress.ToString(), sharepointUrl));
}
return(true);
}
private void Initialize()
{
ProtocolLog.instance.logInstance = new Log(ProtocolLog.GetLogFileName(), new LogHeaderFormatter(ProtocolLog.LogSchema), "TeamMailboxSyncLog");
ProtocolLog.instance.logInstance.Configure(Path.Combine(ExchangeSetupContext.InstallPath, "Logging\\TeamMailbox\\"), ProtocolLog.LogMaxAge, 262144000L, 10485760L);
}
public static void LogError(ProtocolLog.Component component, LoggingContext loggingContext, string data, Exception exception)
{
ProtocolLog.LogEvent(component, ProtocolLog.EventType.Error, loggingContext, data, exception);
}
protected virtual Exception ProcessNewOwnersAndMembers(Guid mailboxGuid, List <ADObjectId> newOwners, List <ADObjectId> newMembers)
{
Exception ex = null;
try
{
this.mailbox = (this.recipientSession.FindByExchangeGuid(mailboxGuid) as ADUser);
if (this.mailbox == null)
{
throw new ObjectNotFoundException(new LocalizedString("Cannot find the team mailbox by mailbox guid " + mailboxGuid));
}
this.tm = TeamMailbox.FromDataObject(this.mailbox);
}
catch (ADTransientException ex2)
{
ex = ex2;
}
catch (ADExternalException ex3)
{
ex = ex3;
}
catch (ADOperationException ex4)
{
ex = ex4;
}
catch (DataValidationException ex5)
{
ex = ex5;
}
catch (ObjectNotFoundException ex6)
{
ex = ex6;
}
if (ex != null)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: Failed to find team mailbox {0}", (this.mailbox == null) ? mailboxGuid.ToString() : this.mailbox.PrimarySmtpAddress.ToString()), ex);
return(ex);
}
this.membershipHelper = new TeamMailboxMembershipHelper(this.tm, this.recipientSession);
TeamMailboxNotificationHelper teamMailboxNotificationHelper = null;
if (this.isFirstSync)
{
teamMailboxNotificationHelper = new TeamMailboxNotificationHelper(this.tm, this.recipientSession);
ADObjectId adobjectId = (this.tm.OwnersAndMembers.Count > 0) ? this.tm.OwnersAndMembers[0] : null;
try
{
if (adobjectId != null)
{
List <ADObjectId> list = MembershipSynchronizer.ListForSingleId(adobjectId);
ProtocolLog.LogStatistics(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: the following users have been added to team mailbox {0}: {1}", this.mailbox.PrimarySmtpAddress, MembershipSynchronizer.GetUsersString(list)));
int count = this.tm.Owners.Count;
teamMailboxNotificationHelper.SendNotification(list, TeamMailboxNotificationType.MemberInvitation);
}
}
catch (StorageTransientException ex7)
{
ex = ex7;
}
catch (StoragePermanentException ex8)
{
ex = ex8;
}
if (ex != null)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: failed sending notifications for team mailbox {0}", this.mailbox.PrimarySmtpAddress), ex);
}
}
new List <ADObjectId>();
IList <ADObjectId> newUserList = TeamMailbox.MergeUsers(newOwners, newMembers);
IList <ADObjectId> userList;
IList <ADObjectId> list2;
bool flag = this.membershipHelper.UpdateTeamMailboxUserList(this.tm.Owners, newOwners, out userList, out list2);
IList <ADObjectId> list3;
IList <ADObjectId> list4;
bool flag2 = this.membershipHelper.UpdateTeamMailboxUserList(this.tm.OwnersAndMembers, newUserList, out list3, out list4);
if (flag || flag2)
{
TeamMailbox.DiffUsers(list3, userList);
try
{
this.membershipHelper.SetTeamMailboxUserPermissions(list3, list4, null, true);
}
catch (OverflowException ex9)
{
ex = ex9;
}
catch (COMException ex10)
{
ex = ex10;
}
catch (UnauthorizedAccessException ex11)
{
ex = ex11;
}
catch (TransientException ex12)
{
ex = ex12;
}
catch (DataSourceOperationException ex13)
{
ex = ex13;
}
if (ex != null)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: failed setting AD permissions for team mailbox {0}", this.mailbox.PrimarySmtpAddress), ex);
return(ex);
}
ProtocolLog.LogStatistics(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: the following users have been added to team mailbox {0}: {1}", this.mailbox.PrimarySmtpAddress, MembershipSynchronizer.GetUsersString(list3)));
ProtocolLog.LogStatistics(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: the following users have been removed from team mailbox {0}: {1}", this.mailbox.PrimarySmtpAddress, MembershipSynchronizer.GetUsersString(list4)));
try
{
this.teamMailboxSecurityRefresher.Refresh(this.mailbox, this.recipientSession);
}
catch (DatabaseNotFoundException ex14)
{
ex = ex14;
}
catch (ObjectNotFoundException ex15)
{
ex = ex15;
}
if (ex != null)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: failed setting team mailbox {0} store permissions for userToAdd {1} and usersToRemove {2}", this.mailbox.PrimarySmtpAddress, MembershipSynchronizer.GetUsersString(list3), MembershipSynchronizer.GetUsersString(list4)), ex);
}
if (teamMailboxNotificationHelper == null)
{
teamMailboxNotificationHelper = new TeamMailboxNotificationHelper(this.tm, this.recipientSession);
}
try
{
teamMailboxNotificationHelper.SendNotification(list3, TeamMailboxNotificationType.MemberInvitation);
}
catch (StorageTransientException ex16)
{
ex = ex16;
}
catch (StoragePermanentException ex17)
{
ex = ex17;
}
if (ex != null)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.ProcessNewOwnersAndMembers: failed sending member invitation for team mailbox {0}", this.mailbox.PrimarySmtpAddress), ex);
}
this.usersToUpdateShowInMyClient = new MembershipSynchronizer.UsersToUpdateShowInMyClient(list3, list4, this);
while (this.usersToUpdateShowInMyClient.UpdateNextBatch())
{
TimeSpan timeSpan;
this.IsThrottleDelayNeeded(out timeSpan);
}
}
return(ex);
}
protected virtual void OnGetUsersComplete(IAsyncResult asyncResult)
{
if (asyncResult == null)
{
throw new InvalidOperationException("OnGetUsersComplete: asyncResult or the AsynState cannot be null here.");
}
if (base.HandleShutDown())
{
return;
}
Exception ex = null;
XmlReader xmlReader = this.EndGetUsers((ICancelableAsyncResult)asyncResult, out ex);
if (ex != null)
{
this.executionAsyncResult.InvokeCallback(ex);
return;
}
List <ADObjectId> list = new List <ADObjectId>();
bool flag = false;
Guid mailboxGuid = this.Job.SyncInfoEntry.MailboxGuid;
List <string> list2 = new List <string>();
List <string> list3 = new List <string>();
try
{
using (xmlReader)
{
MembershipSynchronizer.ParseUsers(xmlReader, MembershipSynchronizer.isMultiTenant, out list2, out list3);
}
}
catch (XmlException value)
{
this.executionAsyncResult.InvokeCallback(value);
return;
}
foreach (string text in list2)
{
try
{
Exception ex2;
ADRawEntry adrawEntry = TeamMailboxNameIdResolver.Resolve(this.recipientSession, text, out ex2);
if (ex2 != null)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.OnGetUsersComplete: Skip the update for user {0} because we failed to resolve it", text), ex2);
}
else if (adrawEntry != null)
{
if (TeamMailboxMembershipHelper.IsUserQualifiedType(adrawEntry))
{
if (this.newOwners.Count + list.Count >= 1800)
{
flag = true;
break;
}
list.Add(adrawEntry.Id);
}
else
{
ProtocolLog.LogStatistics(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.OnGetUsersComplete: Drop unqualified owner {0} for team mailbox {1}", adrawEntry.Id, mailboxGuid));
}
}
}
catch (NonUniqueRecipientException exception)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.OnGetUsersComplete: Skip the update for user {0} because of NonUniqueRecipientException", text), exception);
}
}
if (!this.doneDownloadingOwners)
{
this.newOwners = list;
this.doneDownloadingOwners = true;
this.BeginDownloadUsers(new AsyncCallback(this.OnGetUsersComplete), false);
return;
}
this.newMembers = list;
if (flag)
{
ProtocolLog.LogError(this.loggingComponent, this.loggingContext, string.Format("MembershipSynchronizer.OnGetUsersComplete: the total user count is more than TotalOwnersAndMembersLimit ({0}), updated {1} users only for team mailbox {2}.", 1800, 1800, mailboxGuid), new NotSupportedException());
}
Exception value2 = this.ProcessNewOwnersAndMembers(mailboxGuid, this.newOwners, this.newMembers);
this.executionAsyncResult.InvokeCallback(value2);
}
public static void LogInformation(ProtocolLog.Component component, LoggingContext loggingContext, string data)
{
ProtocolLog.LogEvent(component, ProtocolLog.EventType.Information, loggingContext, data, null);
}
public static void LogCycleSuccess(ProtocolLog.Component component, LoggingContext loggingContext, string data)
{
ProtocolLog.LogEvent(component, ProtocolLog.EventType.CycleSuccess, loggingContext, data, null);
}
public static void LogStatistics(ProtocolLog.Component component, LoggingContext loggingContext, string data)
{
ProtocolLog.LogEvent(component, ProtocolLog.EventType.Statistics, loggingContext, data, null);
}
public static void LogCycleFailure(ProtocolLog.Component component, LoggingContext loggingContext, string data, Exception exception)
{
ProtocolLog.LogEvent(component, ProtocolLog.EventType.CycleFailure, loggingContext, data, exception);
}