internal static FolderSyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, ISyncProviderFactory syncProviderFactory, string syncStateName, Func <SyncStateStorage, StoreObject, FolderSyncStateMetadata, SyncStateInfo, ISyncProviderFactory, bool, ISyncLogger, FolderSyncState> creator, ISyncLogger syncLogger = null) { ArgumentValidator.ThrowIfNullOrEmpty("syncStateName", syncStateName); SyncStateInfo syncStateInfo = new FolderSyncStateInfo(syncStateName); StoreObject syncStateStoreObject = SyncState.GetSyncStateStoreObject(syncStateStorage, syncStateParentFolder, syncStateInfo, syncLogger, new PropertyDefinition[] { InternalSchema.SyncFolderSourceKey }); if (syncStateStoreObject == null) { return(null); } byte[] valueOrDefault = syncStateStoreObject.GetValueOrDefault <byte[]>(InternalSchema.SyncFolderSourceKey); if (syncProviderFactory != null) { try { syncProviderFactory.SetCollectionIdFromBytes(valueOrDefault); } catch (ArgumentException innerException) { syncStateStorage.DeleteFolderSyncState(syncStateName); syncStateStorage.DeviceMetadata.TryRemove(syncStateName, null); throw new CorruptSyncStateException(ServerStrings.ExSyncStateCorrupted(syncStateName), innerException); } } FolderSyncStateMetadata folderSyncStateMetadata = FolderSyncState.GetFolderSyncStateMetadata(syncStateStorage, syncStateStoreObject.Session as MailboxSession, syncStateName, syncLogger); if (creator == null) { return(new FolderSyncState(syncStateStorage, syncStateStoreObject, folderSyncStateMetadata, syncStateInfo, syncProviderFactory, false, syncLogger)); } return(creator(syncStateStorage, syncStateStoreObject, folderSyncStateMetadata, syncStateInfo, syncProviderFactory, false, syncLogger)); }
private static FolderSyncStateMetadata GetFolderSyncStateMetadata(SyncStateStorage syncStateStorage, MailboxSession mailboxSession, string name, ISyncLogger syncLogger = null) { if (syncLogger == null) { syncLogger = TracingLogger.Singleton; } SyncStateMetadata syncState = syncStateStorage.DeviceMetadata.GetSyncState(mailboxSession, name, syncLogger); FolderSyncStateMetadata folderSyncStateMetadata = syncState as FolderSyncStateMetadata; if (folderSyncStateMetadata == null) { syncLogger.TraceDebug <SmtpAddress, string>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderSyncState.GetFolderSyncStateMetadata] SyncStateMetadata in place of FolderSyncStateMetadata for Mailbox: {0}, State: {1}. Trying re-read...", mailboxSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress, name); syncStateStorage.DeviceMetadata.TryRemove(name, syncLogger); syncState = syncStateStorage.DeviceMetadata.GetSyncState(mailboxSession, name, syncLogger); folderSyncStateMetadata = (syncState as FolderSyncStateMetadata); if (folderSyncStateMetadata == null) { syncStateStorage.DeleteFolderSyncState(name); syncStateStorage.DeviceMetadata.TryRemove(name, null); throw new CorruptSyncStateException(ServerStrings.ExSyncStateCorrupted(name), new InvalidOperationException("SyncStateMetadata in place of FolderSyncStateMetadata")); } syncLogger.TraceDebug <string>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderSyncState.GetFolderSyncStateMetadata] Re-read of sync state {0} was successful.", name); } return(folderSyncStateMetadata); }
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 SyncStateRootStorage(SyncStateStorage syncStateStorage) { if (syncStateStorage == null) { throw new ArgumentNullException("syncStateStorage"); } this.syncStateStorage = syncStateStorage; }
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 SyncStateStorage Create(MailboxSession mailboxSession, DeviceIdentity deviceIdentity, StateStorageFeatures features, bool onlySetPropsIfAlreadyExists, ISyncLogger syncLogger = null) { if (syncLogger == null) { syncLogger = TracingLogger.Singleton; } EnumValidator.ThrowIfInvalid <StateStorageFeatures>(features, "features"); SyncStateTypeFactory.GetInstance().RegisterInternalBuilders(); UserSyncStateMetadata userSyncStateMetadata = UserSyncStateMetadataCache.Singleton.Get(mailboxSession, syncLogger); DeviceSyncStateMetadata deviceSyncStateMetadata = userSyncStateMetadata.GetDevice(mailboxSession, deviceIdentity, syncLogger); SyncStateStorage syncStateStorage = (deviceSyncStateMetadata == null) ? null : SyncStateStorage.GetSyncStateStorage(mailboxSession, deviceSyncStateMetadata, syncLogger); if (syncStateStorage == null || onlySetPropsIfAlreadyExists) { Folder folder = null; SyncStateStorage syncStateStorage2 = null; bool flag = false; try { folder = SyncStateStorage.CreateAndSaveFolder(mailboxSession, mailboxSession.GetDefaultFolderId(DefaultFolderType.SyncRoot), CreateMode.OpenIfExists, deviceIdentity.CompositeKey, null, (syncStateStorage == null) ? null : syncStateStorage.folder, syncLogger); if (deviceSyncStateMetadata != null && deviceSyncStateMetadata.DeviceFolderId != folder.Id.ObjectId) { userSyncStateMetadata.TryRemove(deviceSyncStateMetadata.Id, syncLogger); deviceSyncStateMetadata = null; } if (deviceSyncStateMetadata == null) { deviceSyncStateMetadata = new DeviceSyncStateMetadata(mailboxSession, folder.Id.ObjectId, syncLogger); deviceSyncStateMetadata = userSyncStateMetadata.GetOrAdd(deviceSyncStateMetadata); } syncStateStorage2 = new SyncStateStorage(folder, deviceSyncStateMetadata, syncLogger); flag = true; return(syncStateStorage2); } finally { if (!flag) { if (syncStateStorage2 != null) { syncStateStorage2.Dispose(); syncStateStorage2 = null; } if (folder != null) { folder.Dispose(); folder = null; } } } return(syncStateStorage); } return(syncStateStorage); }
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)); }
internal static CustomSyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, SyncStateInfo syncStateInfo, ISyncLogger syncLogger, params PropertyDefinition[] propertiesToFetch) { if (syncLogger == null) { syncLogger = TracingLogger.Singleton; } SyncStateMetadata syncStateMetadata = null; StoreObject syncStateStoreObject = SyncState.GetSyncStateStoreObject(syncStateStorage, syncStateParentFolder, syncStateInfo, syncLogger, out syncStateMetadata, propertiesToFetch); if (syncStateStoreObject == null) { return(null); } return(new CustomSyncState(syncStateStorage, syncStateStoreObject, syncStateMetadata, syncStateInfo, false)); }
internal static CustomSyncState CreateSyncState(SyncStateStorage syncStateStorage, SyncStateInfo syncStateInfo, Folder syncStateParentFolder, ISyncLogger syncLogger = null) { if (syncLogger == null) { syncLogger = TracingLogger.Singleton; } 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, "[CustomSyncState.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 CustomSyncState(syncStateStorage, storeObject, syncStateMetadata, syncStateInfo, true)); }
public static GetSyncStateResult GetData(MailboxSession session, ParsedCallData callData) { GetSyncStateResult getSyncStateResult = new GetSyncStateResult(); getSyncStateResult.LoggingEnabled = SyncStateStorage.GetMailboxLoggingEnabled(session, null); using (SyncStateStorage.GetSyncFolderRoot(session, null)) { UserSyncStateMetadata userSyncStateMetadata = UserSyncStateMetadataCache.Singleton.Get(session, null); List <DeviceSyncStateMetadata> allDevices = userSyncStateMetadata.GetAllDevices(session, true, null); getSyncStateResult.Devices = new List <DeviceData>(allDevices.Count); foreach (DeviceSyncStateMetadata deviceSyncStateMetadata in allDevices) { if (SyncStateDiagnostics.ShouldAddDevice(callData, deviceSyncStateMetadata.Id)) { DeviceData deviceData = new DeviceData { Name = deviceSyncStateMetadata.Id.CompositeKey, SyncFolders = new List <SyncStateFolderData>(), FolderId = deviceSyncStateMetadata.DeviceFolderId }; getSyncStateResult.Devices.Add(deviceData); foreach (KeyValuePair <string, SyncStateMetadata> keyValuePair in deviceSyncStateMetadata.SyncStates) { bool flag = string.Equals(keyValuePair.Key, callData.SyncStateName, StringComparison.OrdinalIgnoreCase); if (callData.SyncStateName == null || flag) { SyncStateFolderData syncStateFolderData = new SyncStateFolderData { Name = keyValuePair.Key, StorageType = keyValuePair.Value.StorageType.ToString() }; if (flag) { SyncStateDiagnostics.GetSyncStateBlob(session, keyValuePair.Value, syncStateFolderData); } else { syncStateFolderData.SyncStateSize = -1; } deviceData.SyncFolders.Add(syncStateFolderData); } } } } } return(getSyncStateResult); }
public static SyncStateStorage Bind(MailboxSession mailboxSession, DeviceIdentity deviceIdentity, ISyncLogger syncLogger = null) { if (syncLogger == null) { syncLogger = TracingLogger.Singleton; } ArgumentValidator.ThrowIfNull("mailboxSession", mailboxSession); SyncStateTypeFactory.GetInstance().RegisterInternalBuilders(); UserSyncStateMetadata userSyncStateMetadata = UserSyncStateMetadataCache.Singleton.Get(mailboxSession, syncLogger); DeviceSyncStateMetadata device = userSyncStateMetadata.GetDevice(mailboxSession, deviceIdentity, syncLogger); if (device != null) { return(SyncStateStorage.GetSyncStateStorage(mailboxSession, device, syncLogger)); } return(null); }
public bool MoveNext() { this.CheckDisposed("MoveNext"); if (this.current != null) { this.current.Dispose(); this.current = null; } if (this.devices == null || this.index >= this.devices.Count) { return(false); } this.index++; if (this.index >= this.devices.Count) { return(false); } this.current = SyncStateStorage.GetSyncStateStorage(this.mailboxSession, this.devices[this.index], this.syncLogger); return(this.current != null || this.MoveNext()); }
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); }
internal static FolderSyncState CreateSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, ISyncProviderFactory syncProviderFactory, string syncFolderId, ISyncLogger syncLogger = null) { if (syncLogger == null) { syncLogger = TracingLogger.Singleton; } SyncStateInfo syncStateInfo = new FolderSyncStateInfo(syncFolderId); StoreObject storeObject = SyncState.CreateSyncStateStoreObject(syncStateStorage, syncStateInfo, syncStateParentFolder, new PropertyDefinition[] { InternalSchema.SyncFolderSourceKey }, new object[] { syncProviderFactory.GetCollectionIdBytes() }, syncLogger); if (syncStateStorage.DeviceMetadata.TryRemove(syncStateInfo.UniqueName, syncLogger) != null) { syncLogger.TraceDebug <DeviceIdentity, string>(ExTraceGlobals.SyncTracer, 0L, "[FolderSyncState.CreateSyncState] Removed stale cached sync state metadata for device {0}, sync state {1}", syncStateStorage.DeviceMetadata.Id, syncStateInfo.UniqueName); } FolderSyncStateMetadata syncStateMetadata = (storeObject is Item) ? new FolderSyncStateMetadata(syncStateStorage.DeviceMetadata, syncStateInfo.UniqueName, syncStateStorage.SaveOnDirectItems ? null : storeObject.ParentId, storeObject.Id.ObjectId, StoreObjectId.Deserialize(syncProviderFactory.GetCollectionIdBytes())) : new FolderSyncStateMetadata(syncStateStorage.DeviceMetadata, syncStateInfo.UniqueName, storeObject.Id.ObjectId, null, StoreObjectId.Deserialize(syncProviderFactory.GetCollectionIdBytes())); return(new FolderSyncState(syncStateStorage, storeObject, syncStateMetadata, syncStateInfo, syncProviderFactory, true, 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)); }
protected static StoreObject GetSyncStateStoreObject(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, SyncStateInfo syncStateInfo, byte[] identBytes, ISyncLogger syncLogger, params PropertyDefinition[] propsToReturn) { FolderSyncStateMetadata folderSyncStateMetadata = FolderSyncState.GetFolderSyncStateMetadata(syncStateStorage, syncStateParentFolder.Session as MailboxSession, syncStateInfo.UniqueName, syncLogger); if (folderSyncStateMetadata == null) { return(null); } StoreObject storeObject = null; if (folderSyncStateMetadata.StorageType != StorageType.Folder) { if (folderSyncStateMetadata.StorageType != StorageType.Item) { if (folderSyncStateMetadata.StorageType != StorageType.DirectItem) { goto IL_85; } } try { storeObject = Microsoft.Exchange.Data.Storage.Item.Bind(syncStateParentFolder.Session, folderSyncStateMetadata.ItemSyncStateId, SyncState.AppendAdditionalProperties(propsToReturn)); ((Item)storeObject).OpenAsReadWrite(); return(storeObject); } catch { storeObject.Dispose(); throw; } IL_85: throw new InvalidOperationException("Unsupported storage type for sync state"); } storeObject = Folder.Bind(syncStateParentFolder.Session, folderSyncStateMetadata.FolderSyncStateId, SyncState.AppendAdditionalProperties(propsToReturn)); return(storeObject); }
public static SyncStateStorage Create(MailboxSession mailboxSession, DeviceIdentity deviceIdentity, StateStorageFeatures features, ISyncLogger syncLogger = null) { return(SyncStateStorage.Create(mailboxSession, deviceIdentity, features, false, syncLogger)); }
protected CustomSyncState(SyncStateStorage syncStateStorage, StoreObject storeObject, SyncStateMetadata syncStateMetadata, SyncStateInfo syncStateInfo, bool syncStateIsNew) : base(syncStateStorage, storeObject, syncStateMetadata, syncStateInfo, syncStateIsNew, null) { }
protected FolderHierarchySyncState(SyncStateStorage syncStateStorage, StoreObject storeObject, SyncStateMetadata syncStateMetadata, SyncStateInfo syncStateInfo, bool newSyncState, ISyncLogger syncLogger = null) : base(syncStateStorage, storeObject, syncStateMetadata, syncStateInfo, newSyncState, syncLogger) { }
protected FolderSyncState(SyncStateStorage syncStateStorage, StoreObject storeObject, FolderSyncStateMetadata syncStateMetadata, SyncStateInfo syncStateInfo, ISyncProviderFactory syncProviderFactory, bool newSyncState, ISyncLogger syncLogger = null) : base(syncStateStorage, storeObject, syncStateMetadata, syncStateInfo, newSyncState, syncLogger) { this.syncProviderFactory = syncProviderFactory; }
internal static FolderHierarchySyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, ISyncLogger syncLogger = null) { return(FolderHierarchySyncState.GetSyncState(syncStateStorage, syncStateParentFolder, null, syncLogger)); }
internal static bool IsMailboxLoggingEnabled(Folder rootFolder) { ExDateTime?loggingEnabledTime = SyncStateStorage.GetLoggingEnabledTime(rootFolder); return(loggingEnabledTime != null && ExDateTime.UtcNow < loggingEnabledTime.Value.IncrementDays(SyncStateStorage.loggingExpirationInDays)); }
internal static FolderSyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, string syncFolderId, ISyncLogger syncLogger = null) { return(FolderSyncState.GetSyncState(syncStateStorage, syncStateParentFolder, null, syncFolderId, syncLogger)); }
internal static FolderSyncState GetSyncState(SyncStateStorage syncStateStorage, Folder deviceFolder, ISyncProviderFactory syncProviderFactory, Func <SyncStateStorage, StoreObject, FolderSyncStateMetadata, SyncStateInfo, ISyncProviderFactory, bool, ISyncLogger, FolderSyncState> creator, ISyncLogger syncLogger = null) { if (syncLogger == null) { syncLogger = TracingLogger.Singleton; } ArgumentValidator.ThrowIfNull("syncStateStorage", syncStateStorage); ArgumentValidator.ThrowIfNull("deviceFolder", deviceFolder); ArgumentValidator.ThrowIfNull("syncProviderFactory", syncProviderFactory); byte[] collectionIdBytes = syncProviderFactory.GetCollectionIdBytes(); if (collectionIdBytes == null || collectionIdBytes.Length == 0) { throw new ArgumentException("SyncProviderFactory CollectionId bytes cannot be null or empty."); } StoreObjectId storeObjectId = null; try { storeObjectId = StoreObjectId.Deserialize(collectionIdBytes); } catch (ArgumentException innerException) { syncLogger.TraceError <string>(ExTraceGlobals.SyncTracer, 0L, "[FolderSyncState.GetSyncState(syncProviderFactory)] The IPMFolderBytes that the provider gave us are invalid for folder {0}", deviceFolder.DisplayName); throw new CorruptSyncStateException(ServerStrings.ExSyncStateCorrupted(deviceFolder.DisplayName), innerException); } FolderSyncStateMetadata folderSyncStateMetadata = null; if (!syncStateStorage.DeviceMetadata.SyncStatesByIPMFolderId.TryGetValue(storeObjectId, out folderSyncStateMetadata)) { syncLogger.TraceDebug <DeviceIdentity, string>(ExTraceGlobals.SyncTracer, 0L, "[FolderSyncState.GetSyncState(syncProviderFactory)] Cache miss for device {0}, IPM folder Id {1}", syncStateStorage.DeviceMetadata.Id, storeObjectId.ToBase64String()); return(null); } SyncStateMetadata syncStateMetadata = folderSyncStateMetadata; StoreObject storeObject = SyncState.GetSyncStateStoreObject(deviceFolder, ref syncStateMetadata, syncLogger, new PropertyDefinition[] { InternalSchema.SyncFolderSourceKey }); if (!object.ReferenceEquals(folderSyncStateMetadata, syncStateMetadata)) { FolderSyncStateMetadata folderSyncStateMetadata2 = syncStateMetadata as FolderSyncStateMetadata; if (folderSyncStateMetadata2 == null) { syncLogger.TraceDebug <string, string>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderSyncState.GetSyncState] Device {0} has non-folder sync state for {1}. Returning null.", deviceFolder.DisplayName, folderSyncStateMetadata.Name); if (storeObject != null) { storeObject.Dispose(); storeObject = null; } } else { syncLogger.TraceDebug <string, string>(ExTraceGlobals.SyncProcessTracer, 0L, "[FolderSyncState.GetSyncState] Device {0} had state folder sync state metadata for {1}. Replacing.", deviceFolder.DisplayName, folderSyncStateMetadata.Name); folderSyncStateMetadata = folderSyncStateMetadata2; } } if (storeObject == null) { return(null); } SyncStateInfo syncStateInfo = new FolderSyncStateInfo(folderSyncStateMetadata.Name); if (creator == null) { return(new FolderSyncState(syncStateStorage, storeObject, folderSyncStateMetadata, syncStateInfo, syncProviderFactory, false, syncLogger)); } return(creator(syncStateStorage, storeObject, folderSyncStateMetadata, syncStateInfo, syncProviderFactory, false, syncLogger)); }
internal static FolderSyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, ISyncProviderFactory syncProviderFactory, string syncStateName, ISyncLogger syncLogger = null) { return(FolderSyncState.GetSyncState(syncStateStorage, syncStateParentFolder, syncProviderFactory, syncStateName, null, syncLogger)); }
internal static CustomSyncState GetSyncState(SyncStateStorage syncStateStorage, Folder syncStateParentFolder, SyncStateInfo syncStateInfo, ISyncLogger syncLogger = null) { return(CustomSyncState.GetSyncState(syncStateStorage, syncStateParentFolder, syncStateInfo, syncLogger, null)); }