private void DoNothing( ItemMetadata item, ItemChange change, SaveChangeContext context, bool deleted = false, MegaNodeHelper existingNode = null) { // creating if (item == null) { if (existingNode == null) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(new Exception())); } item = _metadataStore.Metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); item.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(item, existingNode.Node.Id, existingNode.Path); return; } if (deleted) { item.MarkAsDeleted(change.ChangeVersion); } item.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(item); }
private void ProcessConstraint( ItemChange change, SaveChangeContext context, MegaStoreConstraintException e, ItemMetadata item, MegaNodeHelper conflictingNode) { switch (e.ConstraintType) { case MegaStoreConstraintType.TargetExists: ResolveConflict(item, change, context, conflictingNode); break; case MegaStoreConstraintType.NoParent: OnDemandedResync(); context.RecordConstraintConflictForItem(ConstraintConflictReason.NoParent); break; // todo add no-free-space handling case MegaStoreConstraintType.ZeroSize: context.RecordConstraintConflictForItem(ConstraintConflictReason.Other); break; case MegaStoreConstraintType.NotEmpty: OnDemandedResync(); context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); break; } }
// the node is suddenly out, remove it from database // (it was a concurrency delete attempt - we should restore the existing version) private void ForgetItem(SaveChangeContext context, ItemMetadata item, Exception e) { _metadataStore.Metadata.RemoveItemMetadata(new List <SyncId> { item.GlobalId }); OnDemandedResync(); context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); }
//Save the item, taking the appropriate action for the 'change' and the data from the item (in 'context') public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { ulong timeStamp = 0; ItemMetadata item = null; switch (saveChangeAction) { case SaveChangeAction.Create: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); if (item != null) { // doubtful solution _metadataStore.Metadata.RemoveItemMetadata(new List<SyncId> { item.GlobalId }); item = null; } CreateItem(change, context); break; case SaveChangeAction.UpdateVersionAndData: case SaveChangeAction.UpdateVersionOnly: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); if (item == null) { CreateItem(change, context); break; } if (saveChangeAction == SaveChangeAction.UpdateVersionOnly) { item.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(item); } else { UpdateItem(item, change, context); } break; case SaveChangeAction.DeleteAndStoreTombstone: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); // didn't know about this item if (item == null) { item = _metadataStore.Metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); item.MarkAsDeleted(change.ChangeVersion); item.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(item); } else { DeleteItem(item, change, context); } break; case SaveChangeAction.UpdateVersionAndMergeData: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); ResolveConflict(item, change, context, null); break; case SaveChangeAction.DeleteAndRemoveTombstone: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); if (item != null) { DeleteItem(item, change, context, true); } break; } }
/// <summary> /// UPDATE /// </summary> /// private void UpdateItem(ItemMetadata item, ItemChange change, SaveChangeContext context) { var data = (IFileDataRetriever)context.ChangeData; var attr = _metadataStore.GetItemInfo(item); var stream = data.FileData.IsDirectory ? null : data.FileStream; try { SyncedNodeAttributes updatedNode = null; //if pathes are different then consider renaming with unchanged content if (attr.Path != data.FileData.RelativePath) { updatedNode = _nodeStore.MoveFile(attr.Path, data.FileData.RelativePath, attr.Id); OnAppliedChange(ChangeType.Rename, data.FileData.RelativePath, attr.Path); } else { updatedNode = _nodeStore.UpdateFile(attr.Path, data.FileData, stream, attr.Id); OnAppliedChange(ChangeType.Update, data.FileData.RelativePath); } item.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(item, updatedNode.Id, updatedNode.Path); } catch (MegaStoreConstraintException e) { ProcessConstraint(change, context, e, item, e.Node); } catch (MegaStoreException e) { ForgetItem(context, item, e); } catch (MegaApiException e) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); OnDemandedResync(); } catch (DirectoryNotFoundException e) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); OnDemandedResync(); } catch (COMException e) { OnDemandedResync(); context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); } finally { CloseStream(stream); } }
private void BackupFile(ItemMetadata item, string path, ItemChange change, SaveChangeContext context) { var t = _nodeStore.BackupFile(path); var newItem = _metadataStore.CreateItemMetadata(); _metadataStore.SaveItemMetadata(newItem, t.Node.Id, t.Path); if (item == null) { CreateItem(change, context); } else { UpdateItem(item, change, context); } }
/// <summary> /// DELETE /// </summary> private void DeleteItem(ItemMetadata item, ItemChange change, SaveChangeContext context, bool removeTombstone = false) { try { var attr = _metadataStore.GetItemInfo(item); _nodeStore.DeleteFile(attr.Path, attr.Id); OnAppliedChange(ChangeType.Delete, null, attr.Path); if (removeTombstone) { _metadataStore.Metadata.RemoveItemMetadata(new List <SyncId> { item.GlobalId }); } else { item.MarkAsDeleted(change.ChangeVersion); _metadataStore.SaveItemMetadata(item); } } catch (MegaStoreConstraintException e) { ProcessConstraint(change, context, e, item, null); } // never mind, the item isn't found anyway catch (MegaStoreException) { if (removeTombstone) { _metadataStore.Metadata.RemoveItemMetadata(new List <SyncId> { item.GlobalId }); } else { item.MarkAsDeleted(change.ChangeVersion); _metadataStore.SaveItemMetadata(item); } } catch (MegaApiException e) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); OnDemandedResync(); } }
/// <summary> /// CREATE /// </summary> private void CreateItem(ItemChange change, SaveChangeContext context, ItemMetadata itemToSaveChanges = null) { var data = (IFileDataRetriever)context.ChangeData; Stream stream = null; try { stream = data.FileData.IsDirectory ? null : data.FileStream; var createdNode = _nodeStore.InsertNode(data.FileData, data.FileData.RelativePath, stream); if (itemToSaveChanges == null) { itemToSaveChanges = _metadataStore.CreateItemMetadata(change.ItemId, change.CreationVersion); } itemToSaveChanges.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(itemToSaveChanges, createdNode.Id, createdNode.Path); OnAppliedChange(ChangeType.Create, data.FileData.RelativePath); } catch (MegaStoreConstraintException e) { ProcessConstraint(change, context, e, null, e.Node); } catch (MegaApiException e) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); } catch (DirectoryNotFoundException e) { OnDemandedResync(); context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); } catch (COMException e) { OnDemandedResync(); context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); } finally { CloseStream(stream); } }
public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { // anyone know how to implement ??? throw new NotImplementedException(); }
public void GetUpdatedKnowledge(SaveChangeContext context) { context.GetUpdatedDestinationKnowledge(out myKnowledge, out myForgottenKnowledge); }
public override void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { // Extract the data from the change TransferMechanism data = context.ChangeData as TransferMechanism; // Now apply the change if (!(saveChangeAction == SaveChangeAction.UpdateVersionOnly) && ((change.ChangeKind & ChangeKind.Deleted) == 0)) { ItemMetadata item = new ItemMetadata(); item.ItemId = change.ItemId; item.ChangeVersion = change.ChangeVersion; item.CreationVersion = change.CreationVersion; item.Uri = data.Uri; RemoteFileInfo fileInfo = new RemoteFileInfo(); fileInfo.FolderPath = Path; fileInfo.Length = data.DataStream.Length; fileInfo.Metadata = item; fileInfo.FileByteStream = data.DataStream; Proxy.UploadFile(fileInfo); // Close input stream data.DataStream.Close(); } else { Proxy.DeleteFile(Path, change.ItemId, _filters); } // If we made it here, the change was successfully applied locally // (or it is a version only change), so we can update our knowledge with the // learned knowledge from the change context.GetUpdatedDestinationKnowledge(out _syncKnowledge, out _forgottenKnowledge); }
//Save the item, taking the appropriate action for the 'change' and the data from the item (in 'context') public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { Thread.Sleep(1000); ulong timeStamp = 0; ItemMetadata item = null; ItemData data = null; change.WorkEstimate = 1; switch (saveChangeAction) { case SaveChangeAction.Create: //Do duplicate detection here item = _metadata.FindItemMetadataById(change.ItemId); if (null != item) { throw new Exception("SaveItemChange must not have Create action for existing items."); } item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); item.ChangeVersion = change.ChangeVersion; data = new ItemData( (ItemData)context.ChangeData); //We are using the same id for both the local and global item id. _store.CreateItem( data, change.ItemId.GetGuidId()); SaveItemMetadata(item, _store.Get(change.ItemId.GetGuidId()).TimeStamp); break; case SaveChangeAction.UpdateVersionAndData: case SaveChangeAction.UpdateVersionOnly: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { throw new Exception("Item Not Found in Store!?"); } item.ChangeVersion = change.ChangeVersion; if (saveChangeAction == SaveChangeAction.UpdateVersionOnly) { SaveItemMetadata(item); } else //Also update the data and the timestamp. { data = new ItemData((ItemData)context.ChangeData); timeStamp = _store.UpdateItem(item.GlobalId.GetGuidId(), data); SaveItemMetadata(item, timeStamp); } break; case SaveChangeAction.DeleteAndStoreTombstone: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); } if (change.ChangeKind == ChangeKind.Deleted) { item.MarkAsDeleted(change.ChangeVersion); } else { // This should never happen in Sync Framework V1.0 throw new Exception("Invalid ChangeType"); } item.ChangeVersion = change.ChangeVersion; SaveItemMetadata(item, 0); // set timestamp to 0 for tombstones _store.DeleteItem(item.GlobalId.GetGuidId()); break; //Merge the changes! (Take the data from the local item + the remote item),noting to update the tick count to propagate the resolution! case SaveChangeAction.UpdateVersionAndMergeData: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { throw new Exception("Item Not Found in Store!?"); } if (item.IsDeleted != true) { //Note - you must update the change version to propagate the resolution! item.ChangeVersion = new SyncVersion(0, _metadata.GetNextTickCount()); //Combine the conflicting data... ItemData mergedData = (_store.Get(item.GlobalId.GetGuidId())).Merge( (ItemData)context.ChangeData); timeStamp = _store.UpdateItem(item.GlobalId.GetGuidId(), mergedData); SaveItemMetadata(item, timeStamp); } break; case SaveChangeAction.DeleteAndRemoveTombstone: item = _metadata.FindItemMetadataById(change.ItemId); if (item != null) { List<SyncId> ids = new List<SyncId>(); ids.Add(item.GlobalId); _metadata.RemoveItemMetadata(ids); } _store.DeleteItem(change.ItemId.GetGuidId()); break; } }
private void UploadBack(ItemMetadata item, ItemChange change, SaveChangeContext context) { //TODO this still re-downloads the file just uploaded item.ResurrectDeletedItem(); CreateItem(change, context, item); }
/// <summary> /// CONFLICT /// </summary> private void ResolveConflict(ItemMetadata item, ItemChange change, SaveChangeContext context, MegaNodeHelper conflictingNode) { var data = (IFileDataRetriever)context.ChangeData; // item does not exist in metadata (can happen when create+create) if (item == null) { if (conflictingNode == null) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(new Exception())); } if (FilesAreEqual(data, conflictingNode)) { DoNothing(item, change, context, false, conflictingNode); } else { BackupFile(item, conflictingNode.Path, change, context); } return; } var attr = _metadataStore.GetItemInfo(item); try { if (change.ChangeKind == ChangeKind.Deleted) { // local delete + remote delete if (item.IsDeleted) { DoNothing(item, change, context, true); } // local delete + remote update else { DownloadBack(item, change); } } else { // local update + remote delete if (item.IsDeleted) { UploadBack(item, change, context); } // update + update else { if (FilesAreEqual(data, _nodeStore.FindNodeById(attr.Id))) { DoNothing(item, change, context); } else { BackupFile(item, attr.Path, change, context); } } } } catch (MegaApiException e) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); } }
/// <summary> /// DELETE /// </summary> private void DeleteItem(ItemMetadata item, ItemChange change, SaveChangeContext context, bool removeTombstone = false) { try { var attr = _metadataStore.GetItemInfo(item); _nodeStore.DeleteFile(attr.Path, attr.Id); OnAppliedChange(ChangeType.Delete, null, attr.Path); if (removeTombstone) { _metadataStore.Metadata.RemoveItemMetadata(new List<SyncId> { item.GlobalId }); } else { item.MarkAsDeleted(change.ChangeVersion); _metadataStore.SaveItemMetadata(item); } } catch (MegaStoreConstraintException e) { ProcessConstraint(change, context, e, item, null); } // never mind, the item isn't found anyway catch (MegaStoreException) { if (removeTombstone) { _metadataStore.Metadata.RemoveItemMetadata(new List<SyncId> { item.GlobalId }); } else { item.MarkAsDeleted(change.ChangeVersion); _metadataStore.SaveItemMetadata(item); } } catch (MegaApiException e) { context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); OnDemandedResync(); } }
//Save the item, taking the appropriate action for the 'change' and the data from the item (in 'context') public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { ulong timeStamp = 0; ItemMetadata item = null; switch (saveChangeAction) { case SaveChangeAction.Create: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); if (item != null) { // doubtful solution _metadataStore.Metadata.RemoveItemMetadata(new List <SyncId> { item.GlobalId }); item = null; } CreateItem(change, context); break; case SaveChangeAction.UpdateVersionAndData: case SaveChangeAction.UpdateVersionOnly: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); if (item == null) { CreateItem(change, context); break; } if (saveChangeAction == SaveChangeAction.UpdateVersionOnly) { item.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(item); } else { UpdateItem(item, change, context); } break; case SaveChangeAction.DeleteAndStoreTombstone: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); // didn't know about this item if (item == null) { item = _metadataStore.Metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); item.MarkAsDeleted(change.ChangeVersion); item.ChangeVersion = change.ChangeVersion; _metadataStore.SaveItemMetadata(item); } else { DeleteItem(item, change, context); } break; case SaveChangeAction.UpdateVersionAndMergeData: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); ResolveConflict(item, change, context, null); break; case SaveChangeAction.DeleteAndRemoveTombstone: item = _metadataStore.Metadata.FindItemMetadataById(change.ItemId); if (item != null) { DeleteItem(item, change, context, true); } break; } }
public override void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { // Extract the data from the change TransferMechanism data = context.ChangeData as TransferMechanism; // Item metadata ItemMetadata item = _sync.GetItemMetaData(saveChangeAction, change, data); // Now apply the change if (!(saveChangeAction == SaveChangeAction.UpdateVersionOnly) && ((change.ChangeKind & ChangeKind.Deleted) == 0)) { // Only copy if destination file name is known // (May have been lost if loser of name collision) if (item.Uri != String.Empty) { FileInfo fi = new FileInfo(System.IO.Path.Combine(Path, item.Uri)); if (!fi.Directory.Exists) { fi.Directory.Create(); } // Change should have stream data, so copy the file data to the local store using (FileStream outputStream = new FileStream(System.IO.Path.Combine(Path, item.Uri), FileMode.OpenOrCreate)) { const int copyBlockSize = 4096; byte[] buffer = new byte[copyBlockSize]; int bytesRead; // Simple block-by-block copy while ((bytesRead = data.DataStream.Read(buffer, 0, copyBlockSize)) > 0) { outputStream.Write(buffer, 0, bytesRead); } // Truncate if needed outputStream.SetLength(outputStream.Position); } // Update the last write time from the updated file to the metadata entry item.LastWriteTimeUtc = fi.LastWriteTimeUtc; } // Close input stream data.DataStream.Close(); } else { // Not an update/create, so must be a delete or version only change // Is it a delete?... if (item.IsTombstone && item.Uri != String.Empty) { // Change is a delete File.Delete(System.IO.Path.Combine(Path, item.Uri)); } } // If we made it here, the change was successfully applied locally // (or it is a version only change), so we can update our knowledge with the // learned knowledge from the change _sync.GetUpdatedKnowledge(context); }
/// <summary> /// Download Mechanism /// </summary> /// <param name="saveChangeAction"></param> /// <param name="change"></param> /// <param name="context"></param> public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { DataTransfer data = context.ChangeData as DataTransfer; ItemMetadata item = sync.GetItemMetaData(saveChangeAction, change, data); switch (saveChangeAction) { case SaveChangeAction.Create: { System.Diagnostics.Debug.WriteLine("Create File: " + item.Uri); UpdateOrCreateFile(data, item); break; } case SaveChangeAction.UpdateVersionAndData: { System.Diagnostics.Debug.WriteLine("UpdateVersion And Data File: " + item.Uri); UpdateOrCreateFile(data, item); break; } case SaveChangeAction.DeleteAndStoreTombstone: { System.Diagnostics.Debug.WriteLine(" Delete File: " + item.Uri); File.Delete(Path.Combine(folderPath, item.Uri)); break; } default: { throw new NotImplementedException(saveChangeAction + " ChangeAction is not implemented!"); } } sync.GetUpdatedKnowledge(context); }
// the node is suddenly out, remove it from database // (it was a concurrency delete attempt - we should restore the existing version) private void ForgetItem(SaveChangeContext context, ItemMetadata item, Exception e) { _metadataStore.Metadata.RemoveItemMetadata(new List<SyncId> { item.GlobalId }); OnDemandedResync(); context.RecordRecoverableErrorForItem(new RecoverableErrorData(e)); }
public void GetUpdatedKnowledge(SaveChangeContext context) { context.GetUpdatedDestinationKnowledge(out _syncKnowledge, out _forgottenKnowledge); }
public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { ItemMetadata item = null; T data = default(T); try { switch (saveChangeAction) { case SaveChangeAction.Create: try { //Do duplicate detection here item = _metaData.FindItemMetadataById(change.ItemId); if (item != null) { throw new SyncProviderException("SaveItemChange must not have Create action for existing items."); } item = _metaData.CreateItemMetadata(change.ItemId, change.CreationVersion); item.ChangeVersion = change.ChangeVersion; data = ConvertFromTransferData(context.ChangeData); CreateDataItem(change, item, data); SaveItemMetadata(item); } catch (Exception e) { throw new SyncProviderException(e, SaveChangeAction.Create); } break; case SaveChangeAction.UpdateVersionAndData: case SaveChangeAction.UpdateVersionOnly: try { item = _metaData.FindItemMetadataById(change.ItemId); if (null == item) { throw new SyncProviderException("Item Not Found in Store!?"); } item.ChangeVersion = change.ChangeVersion; if (saveChangeAction == SaveChangeAction.UpdateVersionOnly) { SaveItemMetadata(item); } else //Also update the data. { data = ConvertFromTransferData(context.ChangeData); UpdateDataItem(change, item, data); SaveItemMetadata(item); } } catch (Exception e) { throw new SyncProviderException(e, SaveChangeAction.UpdateVersionAndData); } break; case SaveChangeAction.DeleteAndStoreTombstone: try { item = _metaData.FindItemMetadataById(change.ItemId); if (null == item) { item = _metaData.CreateItemMetadata(change.ItemId, change.CreationVersion); } if (change.ChangeKind == ChangeKind.Deleted) { item.MarkAsDeleted(change.ChangeVersion); } else { // This should never happen in Sync Framework V1.0 throw new SyncProviderException("Invalid ChangeType"); } item.ChangeVersion = change.ChangeVersion; SaveItemMetadata(item); DeleteDataItem(change, item, data); //item.GlobalId.GetGuidId()); } catch (Exception e) { throw new SyncProviderException(e, SaveChangeAction.DeleteAndStoreTombstone); } break; //Merge the changes! (Take the data from the local item + the remote item),noting to update the tick count to propagate the resolution! case SaveChangeAction.UpdateVersionAndMergeData: try { item = _metaData.FindItemMetadataById(change.ItemId); if (null == item) { throw new SyncProviderException("Item Not Found in Store!?"); } if (item.IsDeleted != true) { //Note - you must update the change version to propagate the resolution! item.ChangeVersion = new SyncVersion(0, _metaData.GetNextTickCount()); //Combine the conflicting data... T dataItem = GetDataItem(item); if (dataItem == null) { throw new SyncProviderException("data item not found for merge"); } data = ConvertFromTransferData(context.ChangeData); data = MergeDataItem(dataItem, data); UpdateDataItem(change, item, data); SaveItemMetadata(item); } } catch (Exception e) { throw new SyncProviderException(e, SaveChangeAction.UpdateVersionAndMergeData); } break; case SaveChangeAction.DeleteAndRemoveTombstone: try { item = _metaData.FindItemMetadataById(change.ItemId); if (item != null) { _metaData.RemoveItemMetadata(new SyncId[] { item.GlobalId }); } data = ConvertFromTransferData(context.ChangeData); DeleteDataItem(change, item, data); } catch (Exception e) { throw new SyncProviderException(e, SaveChangeAction.DeleteAndRemoveTombstone); } break; } } catch (SyncProviderException e) { Exception exception = e.InnerException != null ? e.InnerException : e; string itemDescr = e.SaveChangeAction.ToString(); string errDescr = e.Message + "[" + e.InnerException != null?e.InnerException.ToString() : string.Empty + "]"; RecoverableErrorData recoverableError = new RecoverableErrorData(exception, itemDescr, errDescr); context.RecordRecoverableErrorForItem(recoverableError); } }
public abstract void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context);
public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { DataTransfer data = context.ChangeData as DataTransfer; switch (saveChangeAction) { case SaveChangeAction.Create: { ItemMetadata item = new ItemMetadata(); item.ItemId = change.ItemId; item.ChangeVersion = change.ChangeVersion; item.CreationVersion = change.CreationVersion; item.Uri = data.Uri; data.DataStream.Position = 0; System.Diagnostics.Debug.WriteLine("Uploading File:" + item.Uri); service.UploadFile(data.DataStream.Length, item, data.DataStream); data.DataStream.Close(); sync.UpdateItemItem(item); break; } case SaveChangeAction.DeleteAndStoreTombstone: { ItemMetadata item = sync.GetItemMetaData(saveChangeAction, change, data); sync.DeleteItem(change.ItemId); service.DeleteFile(change.ItemId, item.Uri); break; } default: { throw new NotImplementedException(saveChangeAction + " ChangeAction is not implemented!"); } } context.GetUpdatedDestinationKnowledge(out myKnowledge, out myForgottenKnowledge); }
//Save the item, taking the appropriate action for the 'change' and the data from the item (in 'context') public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { Thread.Sleep(1000); ulong timeStamp = 0; ItemMetadata item = null; ItemData data = null; change.WorkEstimate = 1; switch (saveChangeAction) { case SaveChangeAction.Create: //Do duplicate detection here item = _metadata.FindItemMetadataById(change.ItemId); if (null != item) { throw new Exception("SaveItemChange must not have Create action for existing items."); } item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); item.ChangeVersion = change.ChangeVersion; data = new ItemData((ItemData)context.ChangeData); //We are using the same id for both the local and global item id. _store.CreateItem(data, change.ItemId.GetGuidId()); SaveItemMetadata(item, _store.Get(change.ItemId.GetGuidId()).TimeStamp); break; case SaveChangeAction.UpdateVersionAndData: case SaveChangeAction.UpdateVersionOnly: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { throw new Exception("Item Not Found in Store!?"); } item.ChangeVersion = change.ChangeVersion; if (saveChangeAction == SaveChangeAction.UpdateVersionOnly) { SaveItemMetadata(item); } else //Also update the data and the timestamp. { data = new ItemData((ItemData)context.ChangeData); timeStamp = _store.UpdateItem(item.GlobalId.GetGuidId(), data); SaveItemMetadata(item, timeStamp); } break; case SaveChangeAction.DeleteAndStoreTombstone: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); } if (change.ChangeKind == ChangeKind.Deleted) { item.MarkAsDeleted(change.ChangeVersion); } else { // This should never happen in Sync Framework V1.0 throw new Exception("Invalid ChangeType"); } item.ChangeVersion = change.ChangeVersion; SaveItemMetadata(item, 0); // set timestamp to 0 for tombstones _store.DeleteItem(item.GlobalId.GetGuidId()); break; //Merge the changes! (Take the data from the local item + the remote item),noting to update the tick count to propagate the resolution! case SaveChangeAction.UpdateVersionAndMergeData: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { throw new Exception("Item Not Found in Store!?"); } if (item.IsDeleted != true) { //Note - you must update the change version to propagate the resolution! item.ChangeVersion = new SyncVersion(0, _metadata.GetNextTickCount()); //Combine the conflicting data... ItemData mergedData = (_store.Get(item.GlobalId.GetGuidId())).Merge((ItemData)context.ChangeData); timeStamp = _store.UpdateItem(item.GlobalId.GetGuidId(), mergedData); SaveItemMetadata(item, timeStamp); } break; case SaveChangeAction.DeleteAndRemoveTombstone: item = _metadata.FindItemMetadataById(change.ItemId); if (item != null) { List <SyncId> ids = new List <SyncId>(); ids.Add(item.GlobalId); _metadata.RemoveItemMetadata(ids); } _store.DeleteItem(change.ItemId.GetGuidId()); break; } }
protected override void AfterSaveChanges(SaveChangeContext context) { this.GetService <IEFCacheServiceProvider>() .InvalidateCacheDependencies(context.ChangedEntityNames.ToArray()); }
public void SaveItemChange(SaveChangeAction saveChangeAction, ItemChange change, SaveChangeContext context) { try { UInt64 timeStamp = 0; ItemMetadata item = null; ISyncDataObject data = null; switch (saveChangeAction) { case SaveChangeAction.Create: //Do duplicate detection here item = _metadata.FindItemMetadataById(change.ItemId); if (null != item) { throw new SyncException("SaveItemChange must not have Create action for existing items."); } item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); item.ChangeVersion = change.ChangeVersion; data = (ISyncDataObject)context.ChangeData; //We are using the same id for both the local and global item id. var version = _syncContext.CreateItem(data, change.ItemId.GetGuidId(), CompanyId, StoreId); if (version != null) { timeStamp = BitConverter.ToUInt64(version, 0); SaveItemMetadata(item, timeStamp); } break; case SaveChangeAction.UpdateVersionAndData: case SaveChangeAction.UpdateVersionOnly: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { throw new SyncException("Item Not Found in Store!?"); } item.ChangeVersion = change.ChangeVersion; if (saveChangeAction == SaveChangeAction.UpdateVersionOnly) { SaveItemMetadata(item); } else //Also update the data and the timestamp. { data = (ISyncDataObject)context.ChangeData; timeStamp = BitConverter.ToUInt64(_syncContext.UpdateItem(item.GlobalId.GetGuidId(), data, CompanyId, StoreId), 0); SaveItemMetadata(item, timeStamp); } break; case SaveChangeAction.DeleteAndStoreTombstone: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { // item = _metadata.CreateItemMetadata(change.ItemId, change.CreationVersion); return; } if (change.ChangeKind == ChangeKind.Deleted) { item.MarkAsDeleted(change.ChangeVersion); } else { // This should never happen in Sync Framework V1.0 throw new SyncException("Invalid ChangeType"); } item.ChangeVersion = change.ChangeVersion; SaveItemMetadata(item, timeStamp); // set timestamp to 0 for tombstones _syncContext.DeleteItem(item.GlobalId.GetGuidId(), CompanyId, StoreId); break; //Merge the changes! (Take the data from the local item + the remote item),noting to update the tick count to propagate the resolution! case SaveChangeAction.UpdateVersionAndMergeData: item = _metadata.FindItemMetadataById(change.ItemId); if (null == item) { throw new SyncException("Item Not Found in Store!?"); } if (item.IsDeleted != true) { //Note - you must update the change version to propagate the resolution! item.ChangeVersion = new SyncVersion(0, _metadata.GetNextTickCount()); //Combine the conflicting data... ISyncDataObject mergedData = _syncContext.Merge(_syncContext.GetItem(item.GlobalId.GetGuidId(), CompanyId, StoreId), (ISyncDataObject)context.ChangeData, CompanyId, StoreId); timeStamp = BitConverter.ToUInt64(_syncContext.UpdateItem(item.GlobalId.GetGuidId(), mergedData, CompanyId, StoreId), 0); SaveItemMetadata(item, timeStamp); } break; case SaveChangeAction.DeleteAndRemoveTombstone: item = _metadata.FindItemMetadataById(change.ItemId); if (item != null) { List <SyncId> ids = new List <SyncId>(); ids.Add(item.GlobalId); _metadata.RemoveItemMetadata(ids); } _syncContext.DeleteItem(change.ItemId.GetGuidId(), CompanyId, StoreId); break; } } catch (SyncException ex) { ILog logger = LogManager.GetLogger(Assembly.GetExecutingAssembly().GetName().Name); logger.Error(ex.Message, ex); //do Log } catch (DbEntityValidationException ex) { ILog logger = LogManager.GetLogger(Assembly.GetExecutingAssembly().GetName().Name); logger.Error(ex.Message, ex); //do Log } catch (Exception ex) { ILog logger = LogManager.GetLogger(Assembly.GetExecutingAssembly().GetName().Name); logger.Error(ex.Message, ex); //do Log } }