private void ProcessSyncStateFolders(Folder deviceFolder, ISyncLogger syncLogger)
{
using (QueryResult queryResult = deviceFolder.FolderQuery(FolderQueryFlags.None, null, null, DeviceSyncStateMetadata.NullSyncPropertiesFolders))
{
for (;;)
{
IStorePropertyBag[] propertyBags = queryResult.GetPropertyBags(100);
if (propertyBags == null || propertyBags.Length == 0)
{
break;
}
foreach (IStorePropertyBag propertyBag in propertyBags)
{
SyncStateMetadata metadataFromPropertyBag = this.GetMetadataFromPropertyBag(deviceFolder.Session as MailboxSession, propertyBag, syncLogger);
if (metadataFromPropertyBag != null)
{
syncLogger.TraceDebug <SyncStateMetadata>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[DeviceSyncStateMetadata.ProcessSyncStateFolders] Found SyncState: {0}", metadataFromPropertyBag);
this.syncStateMap.TryAdd(metadataFromPropertyBag.Name, metadataFromPropertyBag);
}
else
{
syncLogger.TraceDebug <DeviceIdentity>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[DeviceSyncStateMetadata.ProcessSyncStateFolders] Discovered unusable sync state for device {0}", this.Id);
}
}
}
}
}
public UserSyncStateMetadata Get(MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
UserSyncStateMetadata userSyncStateMetadata = null;
if (!this.cache.TryGetValue(mailboxSession.MailboxGuid, out userSyncStateMetadata))
{
syncLogger.TraceDebug <Guid>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[UserSyncStateMetadataCache.Get] Cache miss for mailbox {0}", mailboxSession.MailboxGuid);
userSyncStateMetadata = new UserSyncStateMetadata(mailboxSession);
lock (this.instanceLock)
{
UserSyncStateMetadata result = null;
if (this.cache.TryGetValue(mailboxSession.MailboxGuid, out result))
{
syncLogger.TraceDebug(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[UserSyncStateMetadataCache.Get] Second TryGet returned cached value. Discarding new one.");
return(result);
}
this.cache.TryAddSliding(mailboxSession.MailboxGuid, userSyncStateMetadata, UserSyncStateMetadataCache.CacheEntrySlidingLiveTimeEntry.Value);
}
return(userSyncStateMetadata);
}
syncLogger.TraceDebug <SmtpAddress>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[UserSyncStateMetadataCache.Get] Cache hit for user: {0}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress);
if (userSyncStateMetadata.MailboxGuid != mailboxSession.MailboxGuid)
{
throw new InvalidOperationException(string.Format("[UserSyncStateMetadataCache.Get] cached userState for mailbox {0} was keyed off incorrect mailbox {1}", userSyncStateMetadata.MailboxGuid, mailboxSession.MailboxGuid));
}
return(userSyncStateMetadata);
}
private void ProcessSyncStateItems(Folder deviceFolder, ISyncLogger syncLogger)
{
using (QueryResult queryResult = deviceFolder.ItemQuery(ItemQueryType.None, null, null, DeviceSyncStateMetadata.NullSyncPropertiesItems))
{
for (;;)
{
IStorePropertyBag[] propertyBags = queryResult.GetPropertyBags(100);
if (propertyBags == null || propertyBags.Length == 0)
{
break;
}
foreach (IStorePropertyBag storePropertyBag in propertyBags)
{
string displayName = (string)storePropertyBag.TryGetProperty(ItemSchema.Subject);
SyncStateMetadata metadataFromPropertyBag = this.GetMetadataFromPropertyBag(storePropertyBag, displayName, syncLogger);
if (metadataFromPropertyBag != null)
{
StoreObjectId objectId = ((VersionedId)storePropertyBag.TryGetProperty(ItemSchema.Id)).ObjectId;
metadataFromPropertyBag.FolderSyncStateId = null;
metadataFromPropertyBag.ItemSyncStateId = objectId;
syncLogger.TraceDebug <SyncStateMetadata>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[DeviceSyncStateMetadata.ProcessSyncStateItems] Found Item SyncState: {0}", metadataFromPropertyBag);
this.syncStateMap.TryAdd(metadataFromPropertyBag.Name, metadataFromPropertyBag);
}
else
{
syncLogger.TraceDebug <DeviceIdentity>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[DeviceSyncStateMetadata.ProcessSyncStateItems] Discovered unusable sync state for device {0}", this.Id);
}
}
}
}
}
public DiffProcessor(IWorkerConfiguration workerConfig, ISynchronization sync, ISvc source, ISvc target, IBlackMirrorHttpClient httpClient, ISyncLogger syncLogger, IUser defaultPushUser)
{
//this.mirror = mirror;
this.sync = sync;
this.source = source;
this.target = target;
this.httpClient = httpClient;
this.syncLogger = syncLogger;
this.defaultPushUser = defaultPushUser;
this.ignoredFiles = sync.Mirror.IgnoredFiles?.ToList() ?? new List <string>();
this.ignoredFiles.AddRange(new[]
{
@"^\.svn\\?.*$",
@"(^\.git\\.*$)|(^\.git$)",
@"^.*\\node_modules\\.*$",
@"^.*\\bower_components\\.*$",
@"^packages\\?.*$",
@"^.*\.dll$",
@"^.*\.pdb",
@"^.*\.nupkg",
@"^.*\.tar",
@"^.*\.tgz",
@"^.*\.jar",
@"^.*\.exe",
});
this.retriever = new UserRetriever(workerConfig);
this.timeoutMaxRetryCount = workerConfig.TimeoutMaxRetryCount;
}
public override ISyncProvider CreateSyncProvider(Folder folder, ISyncLogger syncLogger = null)
{
if (this.UseNewProvider)
{
return(new FirstTimeSyncProvider(folder, this.trackReadFlagChanges, this.trackAssociatedMessageChanges, this.trackConversations, this.allowTableRestrict, false));
}
return(new MailboxSyncProvider(folder, this.trackReadFlagChanges, this.trackAssociatedMessageChanges, false, this.trackConversations, this.allowTableRestrict, false, AirSyncDiagnostics.GetSyncLogger()));
}
public SyncStateStorageEnumerator(MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
this.syncLogger = (syncLogger ?? TracingLogger.Singleton);
UserSyncStateMetadata userSyncStateMetadata = UserSyncStateMetadataCache.Singleton.Get(mailboxSession, this.syncLogger);
this.devices = userSyncStateMetadata.GetAllDevices(mailboxSession, true, this.syncLogger);
this.index = -1;
this.mailboxSession = mailboxSession;
}
public Svn(ISynchronization sync, ISvcRepository repository, string repoPath, string ownerName, string ownerPassword, ISyncLogger syncLogger)
{
this.sync = sync;
this.repository = repository;
this.repoPath = repoPath;
this.username = ownerName;
this.ownerPassword = ownerPassword;
this.syncLogger = syncLogger;
}
public SqliteSyncProvider(SqliteSyncConfiguration configuration, ProviderMode providerMode = ProviderMode.Bidirectional, ISyncLogger logger = null)
{
Configuration = configuration;
ProviderMode = providerMode;
_logger = logger;
if (configuration.Tables.Any(_ => _.SyncDirection != SyncDirection.UploadAndDownload) &&
providerMode == ProviderMode.Bidirectional)
{
throw new InvalidOperationException("One or more table with sync direction different from Bidirectional: please must specify the provider mode to Local or Remote");
}
}
public DeviceSyncStateMetadata TryRemove(DeviceIdentity deviceIdentity, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
DeviceSyncStateMetadata result;
bool arg = this.devices.TryRemove(deviceIdentity, out result);
syncLogger.TraceDebug <DeviceIdentity, bool>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[UserSyncStateMetadata.TryRemove] Tried to remove '{0}'. Success? {1}", deviceIdentity, arg);
return(result);
}
internal static Folder GetSyncFolderRoot(MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
StoreObjectId storeObjectId = mailboxSession.GetDefaultFolderId(DefaultFolderType.SyncRoot);
if (storeObjectId == null)
{
syncLogger.TraceDebug <Guid>(ExTraceGlobals.SyncTracer, 0L, "[SyncStateStorage.GetSyncFolderRoot] ExchangeSyncData folder missing for mailbox {0}. Creating it now.", mailboxSession.MailboxGuid);
storeObjectId = mailboxSession.CreateDefaultFolder(DefaultFolderType.SyncRoot);
}
return(Folder.Bind(mailboxSession, storeObjectId, SyncStateStorage.loggingEnabledAsArray));
}
public virtual ISyncProvider CreateSyncProvider(ISyncLogger syncLogger = null)
{
Folder folder;
if (this.folder != null)
{
folder = this.folder;
this.folder = null;
}
else
{
folder = Folder.Bind(this.storeSession, this.folderId);
}
return(this.CreateSyncProvider(folder, this.trackReadFlagChanges, this.trackAssociatedMessageChanges, this.returnNewestChangesFirst, this.trackConversations, this.allowTableRestrict, true, syncLogger));
}
public Git(ISynchronization sync, ISvcRepository repository, string repoPath, string userName, string password, string refspec, ISyncLogger syncLogger)
{
this.credentials = new UsernamePasswordCredentials {
Username = userName, Password = password
};
this.sync = sync;
this.repository = repository;
this.repoPath = repoPath;
this.userName = userName;
this.refspec = refspec;
this.syncLogger = syncLogger;
if (Repository.IsValid(repoPath))
{
this.repo = new Repository(repoPath);
}
}
public SyncStateMetadata TryRemove(string name, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
SyncStateMetadata syncStateMetadata;
bool arg = this.syncStateMap.TryRemove(name, out syncStateMetadata);
syncLogger.TraceDebug <string, bool>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[DeviceSyncStateMetadata.TryRemove] Removing '{0}'. Success? {1}", name, arg);
FolderSyncStateMetadata folderSyncStateMetadata = syncStateMetadata as FolderSyncStateMetadata;
if (folderSyncStateMetadata != null && folderSyncStateMetadata.IPMFolderId != null)
{
this.ipmToFolderSyncStateMap.TryRemove(folderSyncStateMetadata.IPMFolderId, out folderSyncStateMetadata);
}
return(syncStateMetadata);
}
public override ISyncProvider CreateSyncProvider(ISyncLogger syncLogger = null)
{
Folder folder;
if (this.folder != null)
{
folder = this.folder;
this.folder = null;
}
else
{
folder = Folder.Bind(this.storeSession, this.folderId);
}
if (this.UseNewProvider)
{
return(new FirstTimeSyncProvider(folder, this.trackReadFlagChanges, this.trackAssociatedMessageChanges, this.trackConversations, this.allowTableRestrict));
}
return(new MailboxSyncProvider(folder, this.trackReadFlagChanges, this.trackAssociatedMessageChanges, false, this.trackConversations, this.allowTableRestrict, AirSyncDiagnostics.GetSyncLogger()));
}
private Folder GetSyncRootFolder(MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
Folder result = null;
try
{
result = Folder.Bind(mailboxSession, DefaultFolderType.SyncRoot);
}
catch (ObjectNotFoundException)
{
syncLogger.TraceDebug <SmtpAddress>(ExTraceGlobals.SyncTracer, (long)this.GetHashCode(), "[UserSyncStateMetadata.GetDevice] Missing SyncRoot folder for mailbox {0}. Recreating.", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress);
mailboxSession.CreateDefaultFolder(DefaultFolderType.SyncRoot);
result = Folder.Bind(mailboxSession, DefaultFolderType.SyncRoot);
}
return(result);
}
public static bool GetMailboxLoggingEnabled(MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
if (mailboxSession.IsConnected)
{
StoreObjectId defaultFolderId = mailboxSession.GetDefaultFolderId(DefaultFolderType.SyncRoot);
if (defaultFolderId == null)
{
return(false);
}
using (Folder folder = Folder.Bind(mailboxSession, defaultFolderId, SyncStateStorage.loggingEnabledAsArray))
{
return(SyncStateStorage.IsMailboxLoggingEnabled(folder));
}
}
syncLogger.TraceDebug(ExTraceGlobals.SyncProcessTracer, 0L, "[SyncStateStorage.GetMailboxLoggingEnabled] MailboxSession was not connected - defaulting to false since we can't write to the mailbox.");
return(false);
}
public SyncStateMetadata TryAdd(SyncStateMetadata syncStateMetadata, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
SyncStateMetadata syncStateMetadata2 = this.syncStateMap.GetOrAdd(syncStateMetadata.Name, syncStateMetadata);
if (syncStateMetadata.GetType().IsSubclassOf(syncStateMetadata2.GetType()))
{
syncLogger.TraceDebug <string, string>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[DeviceSyncStateMetadata.TryAdd] New sync state metadata instance ({0}) is subclass of cached one ({1}). Replacing.", syncStateMetadata.GetType().Name, syncStateMetadata2.GetType().Name);
this.syncStateMap[syncStateMetadata.Name] = syncStateMetadata;
syncStateMetadata2 = syncStateMetadata;
}
FolderSyncStateMetadata folderSyncStateMetadata = syncStateMetadata2 as FolderSyncStateMetadata;
if (folderSyncStateMetadata != null && folderSyncStateMetadata.IPMFolderId != null)
{
syncLogger.TraceDebug <string>(ExTraceGlobals.SyncProcessTracer, (long)this.GetHashCode(), "[DeviceSyncStateMetadata.TryAdd] Encountered FolderSyncStateMetadata instance for '{0}'. Adding source key to reverse mapping.", syncStateMetadata.Name);
this.ipmToFolderSyncStateMap[folderSyncStateMetadata.IPMFolderId] = folderSyncStateMetadata;
}
return(syncStateMetadata2);
}
public static FolderHierarchyChangeDetector.MailboxChangesManifest RunICSManifestSync(bool catchup, FolderHierarchyChangeDetector.SyncHierarchyManifestState hierState, MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
syncLogger.TraceDebug <SmtpAddress, bool>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Checking for folder hierarhcy changes for Mailbox: {0}. Catchup? {1}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, catchup);
MapiStore _ContainedMapiStore = mailboxSession.__ContainedMapiStore;
FolderHierarchyChangeDetector.MailboxChangesManifest mailboxChangesManifest = new FolderHierarchyChangeDetector.MailboxChangesManifest();
FolderHierarchyChangeDetector.ManifestHierarchyCallback iMapiManifestCallback = new FolderHierarchyChangeDetector.ManifestHierarchyCallback(catchup, mailboxChangesManifest);
try
{
using (MapiFolder ipmSubtreeFolder = _ContainedMapiStore.GetIpmSubtreeFolder())
{
SyncConfigFlags syncConfigFlags = SyncConfigFlags.ManifestHierReturnDeletedEntryIds;
int serverVersion = mailboxSession.MailboxOwner.MailboxInfo.Location.ServerVersion;
if ((serverVersion >= Server.E14MinVersion && serverVersion < Server.E15MinVersion) || (long)serverVersion >= FolderHierarchyChangeDetector.E15MinVersionSupportsOnlySpecifiedPropsForHierarchy)
{
syncConfigFlags |= SyncConfigFlags.OnlySpecifiedProps;
}
using (MapiHierarchyManifestEx mapiHierarchyManifestEx = ipmSubtreeFolder.CreateExportHierarchyManifestEx(syncConfigFlags, hierState.IdsetGiven, hierState.CnsetSeen, iMapiManifestCallback, FolderHierarchyChangeDetector.PropsToFetch, null))
{
while (mapiHierarchyManifestEx.Synchronize() != ManifestStatus.Done)
{
}
byte[] idSetGiven;
byte[] cnetSeen;
mapiHierarchyManifestEx.GetState(out idSetGiven, out cnetSeen);
syncLogger.TraceDebug <SmtpAddress, int, int>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Updating ICS state for mailbox: '{0}'. Change Count: {1}, Delete Count: {2}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, mailboxChangesManifest.ChangedFolders.Count, mailboxChangesManifest.DeletedFolders.Count);
hierState.Update(idSetGiven, cnetSeen);
}
}
}
catch (MapiPermanentException arg)
{
syncLogger.TraceDebug <SmtpAddress, MapiPermanentException>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Caught MapiPermanentException when determining folder ICS changes for mailbox: {0}. Exception: {1}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, arg);
return(null);
}
catch (MapiRetryableException arg2)
{
syncLogger.TraceDebug <SmtpAddress, MapiRetryableException>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderHierarchyChangeDetector.RunICSManifestSync] Caught MapiRetryableException when determining folder ICS changes for mailbox: {0}. Exception: {1}", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, arg2);
return(null);
}
return(mailboxChangesManifest);
}
// Token: 0x0600170D RID: 5901 RVA: 0x0008A30F File Offset: 0x0008850F
public ISyncProvider CreateSyncProvider(ISyncLogger syncLogger = null)
{
return(new RecipientInfoCacheSyncProvider(this.mailboxSession, this.maxEntries));
}
protected FolderHierarchySyncState(SyncStateStorage syncStateStorage, StoreObject storeObject, SyncStateMetadata syncStateMetadata, SyncStateInfo syncStateInfo, bool newSyncState, ISyncLogger syncLogger = null) : base(syncStateStorage, storeObject, syncStateMetadata, syncStateInfo, newSyncState, syncLogger)
{
}
public static SyncStateRootStorage GetOrCreateSyncStateRootStorage(MailboxSession mailboxSession, string protocol, ISyncLogger syncLogger = null)
{
if (mailboxSession == null)
{
throw new ArgumentNullException("mailboxSession");
}
if (protocol == null)
{
throw new ArgumentNullException("protocol");
}
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
string protocol2 = protocol + "Root";
DeviceIdentity deviceIdentity = new DeviceIdentity("RootDeviceId", "RootDeviceType", protocol2);
SyncStateStorage syncStateStorage = SyncStateStorage.Bind(mailboxSession, deviceIdentity, syncLogger);
if (syncStateStorage == null)
{
syncStateStorage = SyncStateStorage.Create(mailboxSession, deviceIdentity, StateStorageFeatures.ContentState, syncLogger);
}
return(new SyncStateRootStorage(syncStateStorage));
}
internal static FolderHierarchySyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, ISyncLogger syncLogger = null)
{
return(FolderHierarchySyncState.GetSyncState(syncStateStorage, syncStateParentFolder, null, syncLogger));
}
internal static FolderHierarchySyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, StoreObjectId storeObjectId, ISyncLogger syncLogger = null)
{
SyncStateInfo syncStateInfo = new FolderHierarchySyncStateInfo();
StoreObject syncStateStoreObject = SyncState.GetSyncStateStoreObject(syncStateStorage, syncStateParentFolder, syncStateInfo, syncLogger, new PropertyDefinition[0]);
if (syncStateStoreObject == null)
{
return(null);
}
SyncStateMetadata syncState = syncStateStorage.DeviceMetadata.GetSyncState(syncStateParentFolder.Session as MailboxSession, syncStateInfo.UniqueName, syncLogger);
return(new FolderHierarchySyncState(syncStateStorage, syncStateStoreObject, syncState, syncStateInfo, false, syncLogger));
}
public static bool DeleteSyncStateStorage(MailboxSession mailboxSession, StoreObjectId deviceFolderId, DeviceIdentity deviceIdentity, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
ArgumentValidator.ThrowIfNull("mailboxSession", mailboxSession);
ArgumentValidator.ThrowIfNull("folderId", deviceFolderId);
bool result = false;
SyncStateTypeFactory.GetInstance().RegisterInternalBuilders();
UserSyncStateMetadata userSyncStateMetadata = UserSyncStateMetadataCache.Singleton.Get(mailboxSession, syncLogger);
AggregateOperationResult aggregateOperationResult = mailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreId[]
{
deviceFolderId
});
syncLogger.Information <string>(ExTraceGlobals.SyncTracer, 0L, "SyncStateStorage::DeleteSyncStateStorage. Result = {0}", aggregateOperationResult.OperationResult.ToString());
userSyncStateMetadata.TryRemove(deviceIdentity, syncLogger);
List <DeviceSyncStateMetadata> allDevices = userSyncStateMetadata.GetAllDevices(mailboxSession, false, syncLogger);
if (allDevices != null)
{
foreach (DeviceSyncStateMetadata deviceSyncStateMetadata in allDevices)
{
syncLogger.Information <DeviceIdentity, DeviceIdentity>(ExTraceGlobals.SyncTracer, 0L, "SyncStateStorage::DeleteSyncStateStorage. Found device folder '{0}', Looking for folder '{1}'", deviceSyncStateMetadata.Id, deviceIdentity);
if (deviceSyncStateMetadata.Id.Equals(deviceIdentity))
{
try
{
aggregateOperationResult = mailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreId[]
{
deviceSyncStateMetadata.DeviceFolderId
});
syncLogger.Information <DeviceIdentity, DeviceIdentity, string>(ExTraceGlobals.SyncTracer, 0L, "SyncStateStorage::DeleteSyncStateStorage. try Deleting SyncState folder again.folderName:{0}, originalFolder:{1}, result:{2}", deviceSyncStateMetadata.Id, deviceIdentity, aggregateOperationResult.OperationResult.ToString());
continue;
}
catch
{
syncLogger.Information(ExTraceGlobals.SyncTracer, 0L, "SyncStateStorage::DeleteSyncStateStorage. Error deleting the sync state folder.");
continue;
}
}
if (deviceSyncStateMetadata.Id.IsProtocol("AirSync"))
{
result = true;
break;
}
}
}
return(result);
}
internal static FolderHierarchySyncState CreateSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
SyncStateInfo syncStateInfo = new FolderHierarchySyncStateInfo();
StoreObject storeObject = SyncState.CreateSyncStateStoreObject(syncStateStorage, syncStateInfo, syncStateParentFolder, null, null, syncLogger);
if (syncStateStorage.DeviceMetadata.TryRemove(syncStateInfo.UniqueName, syncLogger) != null)
{
syncLogger.TraceDebug <DeviceIdentity, string>(ExTraceGlobals.SyncTracer, 0L, "[FolderHierarchySyncState.CreateSyncState] Removed stale cached sync state metadata for device {0}, sync state {1}", syncStateStorage.DeviceMetadata.Id, syncStateInfo.UniqueName);
}
SyncStateMetadata syncStateMetadata = (storeObject is Item) ? new SyncStateMetadata(syncStateStorage.DeviceMetadata, syncStateInfo.UniqueName, syncStateStorage.SaveOnDirectItems ? null : storeObject.ParentId, storeObject.Id.ObjectId) : new SyncStateMetadata(syncStateStorage.DeviceMetadata, syncStateInfo.UniqueName, storeObject.Id.ObjectId, null);
return(new FolderHierarchySyncState(syncStateStorage, storeObject, syncStateMetadata, syncStateInfo, true, syncLogger));
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="syncLogger">The logger to use when a batch has finished.</param>
/// <remarks>The <paramref name="syncLogger"/> is stored in a static variable, so you can't
/// have two batch loggers running at the same time and expect them to log to different loggers</remarks>
public BatchLogger(ISyncLogger syncLogger)
{
_syncLogger = syncLogger;
}
public static SyncStateStorage.SyncStateStorageEnumerator GetEnumerator(MailboxSession mailboxSession, ISyncLogger syncLogger = null)
{
return(new SyncStateStorage.SyncStateStorageEnumerator(mailboxSession, syncLogger));
}
private static SyncStateStorage GetSyncStateStorage(MailboxSession session, DeviceSyncStateMetadata deviceMetadata, ISyncLogger syncLogger = null)
{
if (deviceMetadata == null)
{
return(null);
}
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
Folder folder = null;
SyncStateStorage syncStateStorage = null;
bool flag = false;
SyncStateStorage result;
try
{
try
{
folder = Folder.Bind(session, deviceMetadata.DeviceFolderId, SyncStateStorage.loggingEnabledAndCreateTimeAsArray);
syncStateStorage = new SyncStateStorage(folder, deviceMetadata, syncLogger);
}
catch (ObjectNotFoundException)
{
syncLogger.TraceDebug <DeviceSyncStateMetadata>(ExTraceGlobals.SyncTracer, 0L, "[SyncStateStorage.Create] Did not find SyncStateStorage for device {0}. Removing from cache.", deviceMetadata);
UserSyncStateMetadata userSyncStateMetadata = UserSyncStateMetadataCache.Singleton.Get(session, syncLogger);
userSyncStateMetadata.TryRemove(deviceMetadata.Id, syncLogger);
deviceMetadata = userSyncStateMetadata.GetDevice(session, deviceMetadata.Id, syncLogger);
if (deviceMetadata != null)
{
folder = Folder.Bind(session, deviceMetadata.DeviceFolderId, SyncStateStorage.loggingEnabledAndCreateTimeAsArray);
syncStateStorage = new SyncStateStorage(folder, deviceMetadata, syncLogger);
}
}
flag = true;
result = syncStateStorage;
}
finally
{
if (!flag)
{
if (syncStateStorage != null)
{
syncStateStorage.Dispose();
syncStateStorage = null;
}
if (folder != null)
{
folder.Dispose();
folder = null;
}
}
}
return(result);
}
public static void UpdateMailboxLoggingEnabled(MailboxSession mailboxSession, bool mailboxLoggingEnabled, ISyncLogger syncLogger = null)
{
using (Folder syncFolderRoot = SyncStateStorage.GetSyncFolderRoot(mailboxSession, syncLogger))
{
if (mailboxLoggingEnabled)
{
syncFolderRoot[SyncStateStorage.airsyncMailboxLoggingEnabledProp] = ExDateTime.UtcNow;
}
else
{
syncFolderRoot.Delete(SyncStateStorage.airsyncMailboxLoggingEnabledProp);
}
syncFolderRoot.Save();
syncFolderRoot.Load();
Folder folder = null;
try
{
folder = SyncStateStorage.CreateAndSaveFolder(mailboxSession, syncFolderRoot.Id.ObjectId, CreateMode.OpenIfExists, SyncStateStorage.MailboxLoggingTriggerFolder, null, null, syncLogger);
if (folder != null)
{
syncFolderRoot.DeleteObjects(DeleteItemFlags.SoftDelete, new StoreId[]
{
folder.Id.ObjectId
});
}
}
finally
{
if (folder != null)
{
folder.Dispose();
}
}
}
}
private static Folder CreateAndSaveFolder(MailboxSession mailboxSession, StoreObjectId containerId, CreateMode createMode, string displayName, string containerClass, Folder folderIn, ISyncLogger syncLogger = null)
{
if (syncLogger == null)
{
syncLogger = TracingLogger.Singleton;
}
Folder folder = null;
bool flag = false;
Folder result;
try
{
if (folderIn == null)
{
folder = Folder.Create(mailboxSession, containerId, StoreObjectType.Folder, displayName, createMode);
folder[SyncStateStorage.airsyncLockProp] = "0";
}
else
{
folder = folderIn;
}
if (containerClass != null)
{
folder[InternalSchema.ContainerClass] = containerClass;
}
StoreObjectId storeObjectId = null;
if (!folder.IsNew)
{
storeObjectId = folder.Id.ObjectId;
}
FolderSaveResult folderSaveResult = folder.Save();
if (folderSaveResult.OperationResult != OperationResult.Succeeded)
{
syncLogger.TraceDebug <string, FolderSaveResult>(ExTraceGlobals.SyncTracer, 0L, "SyncStateStorage::CreateAndSaveFolder. Failed to create folder {0}, due to {1}.", displayName, folderSaveResult);
if (storeObjectId == null)
{
folder.Load(null);
storeObjectId = folder.StoreObjectId;
}
mailboxSession.Delete(DeleteItemFlags.SoftDelete, new StoreId[]
{
storeObjectId
});
throw folderSaveResult.ToException(ServerStrings.ExCannotCreateFolder(folderSaveResult));
}
folder.Load(SyncStateStorage.loggingEnabledAndCreateTimeAsArray);
flag = true;
result = folder;
}
finally
{
if (!flag && folder != null)
{
folder.Dispose();
folder = null;
}
}
return(result);
}
