private AbstractFolderEvent CreateLocalEventBasedOnStorage(IFileSystemInfo fsObject, IMappedObject storedParent, IMappedObject storedMappedChild)
{
AbstractFolderEvent createdEvent = null;
if (storedMappedChild.ParentId == storedParent.RemoteObjectId)
{
// Renamed, Updated or Equal
#if __COCOA__
if (fsObject.Name.Normalize(NormalizationForm.FormD) == storedMappedChild.Name.Normalize(NormalizationForm.FormD) && fsObject.LastWriteTimeUtc == storedMappedChild.LastLocalWriteTimeUtc)
{
#else
if (fsObject.Name == storedMappedChild.Name && fsObject.LastWriteTimeUtc == storedMappedChild.LastLocalWriteTimeUtc)
{
#endif
// Equal
createdEvent = null;
}
else
{
// Updated or Renamed
createdEvent = FileOrFolderEventFactory.CreateEvent(null, fsObject, localChange: MetaDataChangeType.CHANGED, src: this);
}
}
else
{
// Moved
IFileSystemInfo oldLocalPath = fsObject is IFileInfo ? (IFileSystemInfo)this.fsFactory.CreateFileInfo(this.storage.GetLocalPath(storedMappedChild)) : (IFileSystemInfo)this.fsFactory.CreateDirectoryInfo(this.storage.GetLocalPath(storedMappedChild));
createdEvent = FileOrFolderEventFactory.CreateEvent(null, fsObject, localChange: MetaDataChangeType.MOVED, oldLocalObject: oldLocalPath, src: this);
}
return(createdEvent);
}
/// <summary>
/// Creates the local events and returns the creationEvents, the other Events are stored in the eventMap, handled objects are removed from storedObjects.
/// </summary>
/// <returns>
/// The remote events.
/// </returns>
/// <param name='storedObjects'>
/// Stored objects.
/// </param>
/// <param name='remoteTree'>
/// Remote tree.
/// </param>
/// <param name='eventMap'>
/// Event map.
/// </param>
public List <AbstractFolderEvent> CreateEvents(
List <IMappedObject> storedObjects,
IObjectTree <IFileableCmisObject> remoteTree,
Dictionary <string, Tuple <AbstractFolderEvent, AbstractFolderEvent> > eventMap,
ISet <IMappedObject> handledStoredObjects)
{
List <AbstractFolderEvent> createdEvents = new List <AbstractFolderEvent>();
var storedParent = storedObjects.Find(o => o.RemoteObjectId == remoteTree.Item.Id);
foreach (var child in remoteTree.Children)
{
var storedMappedChild = storedObjects.Find(o => o.RemoteObjectId == child.Item.Id);
if (storedMappedChild != null)
{
AbstractFolderEvent newEvent = this.CreateRemoteEventBasedOnStorage(child.Item, storedParent, storedMappedChild);
eventMap[child.Item.Id] = new Tuple <AbstractFolderEvent, AbstractFolderEvent>(null, newEvent);
}
else
{
// Added
AbstractFolderEvent addEvent = FileOrFolderEventFactory.CreateEvent(child.Item, null, MetaDataChangeType.CREATED, src: this);
createdEvents.Add(addEvent);
}
createdEvents.AddRange(this.CreateEvents(storedObjects, child, eventMap, handledStoredObjects));
if (storedMappedChild != null)
{
handledStoredObjects.Add(storedMappedChild);
}
}
return(createdEvents);
}
/// <summary>
/// Creates the local events and returns the creationEvents, the other Events are stored in the eventMap, handled objects are removed from storedObjects
/// </summary>
/// <returns>
/// The local events.
/// </returns>
/// <param name='storedObjects'>
/// Stored objects.
/// </param>
/// <param name='localTree'>
/// Local tree.
/// </param>
/// <param name='eventMap'>
/// Event map.
/// </param>
public List <AbstractFolderEvent> CreateEvents(
List <IMappedObject> storedObjects,
IObjectTree <IFileSystemInfo> localTree,
Dictionary <string, Tuple <AbstractFolderEvent, AbstractFolderEvent> > eventMap)
{
List <AbstractFolderEvent> creationEvents = new List <AbstractFolderEvent>();
var parent = localTree.Item;
IMappedObject storedParent = null;
Guid? guid = parent.Uuid;
if (guid != null)
{
storedParent = storedObjects.Find(o => o.Guid.Equals((Guid)guid));
}
foreach (var child in localTree.Children)
{
bool removeStoredMappedChild = false;
IMappedObject storedMappedChild = this.FindStoredObjectByFileSystemInfo(storedObjects, child.Item);
if (storedMappedChild != null)
{
var localPath = this.storage.GetLocalPath(storedMappedChild);
#if __COCOA__
if ((!localPath.Normalize(NormalizationForm.FormD).Equals(child.Item.FullName.Normalize(NormalizationForm.FormD))) && this.fsFactory.IsDirectory(localPath) != null)
{
#else
if ((!localPath.Equals(child.Item.FullName)) && this.fsFactory.IsDirectory(localPath) != null)
{
#endif
// Copied
creationEvents.Add(this.GenerateCreatedEvent(child.Item));
}
else
{
// Moved, Renamed, Updated or Equal
AbstractFolderEvent correspondingRemoteEvent = GetCorrespondingRemoteEvent(eventMap, storedMappedChild);
AbstractFolderEvent createdEvent = this.CreateLocalEventBasedOnStorage(child.Item, storedParent, storedMappedChild);
eventMap[storedMappedChild.RemoteObjectId] = new Tuple <AbstractFolderEvent, AbstractFolderEvent>(createdEvent, correspondingRemoteEvent);
removeStoredMappedChild = true;
}
}
else
{
// Added
creationEvents.Add(this.GenerateCreatedEvent(child.Item));
}
creationEvents.AddRange(this.CreateEvents(storedObjects, child, eventMap));
if (removeStoredMappedChild)
{
storedObjects.Remove(storedMappedChild);
}
}
return(creationEvents);
}
private void InformAboutRemoteObjectsDeleted(IEnumerable <IFileSystemInfo> objects)
{
foreach (var deleted in objects)
{
AbstractFolderEvent deletedEvent = FileOrFolderEventFactory.CreateEvent(null, deleted, MetaDataChangeType.DELETED, src: this);
this.Queue.AddEvent(deletedEvent);
}
}
private bool DelayEventIfRetryCountPositive(AbstractFolderEvent fileOrFolderEvent)
{
if (fileOrFolderEvent.RetryCount > 0)
{
this.retryEvents.Add(fileOrFolderEvent);
return(true);
}
return(false);
}
private static AbstractFolderEvent GetCorrespondingRemoteEvent(Dictionary <string, Tuple <AbstractFolderEvent, AbstractFolderEvent> > eventMap, IMappedObject storedMappedChild)
{
AbstractFolderEvent correspondingRemoteEvent = null;
Tuple <AbstractFolderEvent, AbstractFolderEvent> tuple;
if (eventMap.TryGetValue(storedMappedChild.RemoteObjectId, out tuple))
{
correspondingRemoteEvent = tuple.Item2;
}
return(correspondingRemoteEvent);
}
private IMappedObject GetStoredObject(AbstractFolderEvent e)
{
if (e is FolderEvent)
{
return(this.storage.GetObjectByRemoteId((e as FolderEvent).RemoteFolder.Id));
}
else if (e is FileEvent)
{
return(this.storage.GetObjectByRemoteId((e as FileEvent).RemoteFile.Id));
}
return(null);
}
private void Solve(ISolver s, AbstractFolderEvent e)
{
using (var activity = new ActivityListenerResource(this.activityListener)) {
if (e is FolderEvent)
{
s.Solve((e as FolderEvent).LocalFolder, (e as FolderEvent).RemoteFolder, ContentChangeType.NONE, ContentChangeType.NONE);
}
else if (e is FileEvent)
{
s.Solve((e as FileEvent).LocalFile, (e as FileEvent).RemoteFile, (e as FileEvent).LocalContent, (e as FileEvent).RemoteContent);
}
}
}
private void AccumulateEvent(AbstractFolderEvent abstractFolderEvent, IMappedObject storedObject)
{
Logger.Debug("Accumulating: " + this.storage.GetLocalPath(storedObject));
if (abstractFolderEvent is FolderEvent)
{
(abstractFolderEvent as FolderEvent).LocalFolder = this.fsFactory.CreateDirectoryInfo(this.storage.GetLocalPath(storedObject));
}
if (abstractFolderEvent is FileEvent)
{
(abstractFolderEvent as FileEvent).LocalFile = this.fsFactory.CreateFileInfo(this.storage.GetLocalPath(storedObject));
}
}
public void HandleFSFolderRemovedEvents()
{
this.queue.Setup(q => q.AddEvent(It.IsAny <AbstractFolderEvent>()))
.Callback((ISyncEvent f) => this.returnedFolderEvent = f as AbstractFolderEvent);
var watcher = new WatcherConsumer(this.queue.Object);
var folderRemovedFSEvent = new FSEvent(WatcherChangeTypes.Deleted, this.localFolder.FullName, true);
Assert.True(watcher.Handle(folderRemovedFSEvent));
Assert.AreEqual(MetaDataChangeType.DELETED, this.returnedFolderEvent.Local);
Assert.AreEqual(this.localFolder.FullName, (this.returnedFolderEvent as FolderEvent).LocalFolder.FullName);
Assert.IsNull((this.returnedFolderEvent as FolderEvent).RemoteFolder);
Assert.AreEqual(MetaDataChangeType.NONE, (this.returnedFolderEvent as FolderEvent).Remote);
}
private string GetRemoteObjectName(AbstractFolderEvent e)
{
if (e is FolderEvent)
{
return((e as FolderEvent).RemoteFolder.Name);
}
else if (e is FileEvent)
{
return((e as FileEvent).RemoteFile.Name);
}
else
{
throw new ArgumentException();
}
}
private string GetParentId(AbstractFolderEvent e)
{
if (e is FolderEvent)
{
return((e as FolderEvent).RemoteFolder.ParentId);
}
else if (e is FileEvent)
{
return((e as FileEvent).RemoteFile.Parents[0].Id);
}
else
{
throw new ArgumentException();
}
}
public void HandleFSFileAddedEvents()
{
this.queue.Setup(q => q.AddEvent(It.IsAny <AbstractFolderEvent>()))
.Callback((ISyncEvent f) => this.returnedFileEvent = f as AbstractFolderEvent);
var watcher = new WatcherConsumer(this.queue.Object);
var fileCreatedFSEvent = new FSEvent(WatcherChangeTypes.Created, this.localFile.FullName, false);
Assert.True(watcher.Handle(fileCreatedFSEvent));
Assert.AreEqual(MetaDataChangeType.CREATED, this.returnedFileEvent.Local);
Assert.AreEqual(ContentChangeType.CREATED, (this.returnedFileEvent as FileEvent).LocalContent);
Assert.AreEqual(this.localFile.FullName, (this.returnedFileEvent as FileEvent).LocalFile.FullName);
Assert.IsNull((this.returnedFileEvent as FileEvent).RemoteFile);
Assert.AreEqual(MetaDataChangeType.NONE, (this.returnedFileEvent as FileEvent).Remote);
Assert.AreEqual(ContentChangeType.NONE, (this.returnedFileEvent as FileEvent).RemoteContent);
}
public void SetUp()
{
this.localPath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
this.localFolder = new DirectoryInfo(this.localPath);
this.localFolder.Create();
this.localSubFolder = new DirectoryInfo(Path.Combine(this.localFolder.FullName, Path.GetRandomFileName()));
this.localSubFolder.Create();
this.localFile = new FileInfo(Path.Combine(this.localFolder.FullName, Path.GetRandomFileName()));
using (this.localFile.Create())
{
}
this.queue = new Mock <ISyncEventQueue>();
this.returnedFileEvent = null;
this.returnedFolderEvent = null;
}
private void DoHandle(AbstractFolderEvent actualEvent)
{
SituationType localSituation = this.LocalSituation.Analyse(this.storage, actualEvent);
SituationType remoteSituation = this.RemoteSituation.Analyse(this.storage, actualEvent);
ISolver solver = this.Solver[(int)localSituation, (int)remoteSituation];
if (solver == null)
{
throw new NotImplementedException(string.Format("Solver for LocalSituation: {0}, and RemoteSituation {1} not implemented", localSituation, remoteSituation));
}
Stopwatch watch = Stopwatch.StartNew();
this.Solve(solver, actualEvent);
watch.Stop();
Logger.Debug(string.Format("Solver {0} took {1} ms", solver.GetType(), watch.ElapsedMilliseconds));
}
public void HandleFSFolderRenamedEvents()
{
string oldpath = Path.Combine(this.localFolder.FullName, Path.GetRandomFileName());
this.queue.Setup(q => q.AddEvent(It.IsAny <AbstractFolderEvent>()))
.Callback((ISyncEvent f) => this.returnedFolderEvent = f as AbstractFolderEvent);
var watcher = new WatcherConsumer(this.queue.Object);
var folderRenamedFSEvent = new FSMovedEvent(oldpath, this.localFolder.FullName, true);
Assert.True(watcher.Handle(folderRenamedFSEvent));
Assert.AreEqual(MetaDataChangeType.MOVED, this.returnedFolderEvent.Local);
Assert.AreEqual(this.localFolder.FullName, (this.returnedFolderEvent as FolderEvent).LocalFolder.FullName);
Assert.AreEqual(oldpath, (this.returnedFolderEvent as FolderMovedEvent).OldLocalFolder.FullName);
Assert.IsNull((this.returnedFolderEvent as FolderMovedEvent).RemoteFolder);
Assert.IsNull((this.returnedFolderEvent as FolderMovedEvent).OldRemoteFolderPath);
Assert.AreEqual(MetaDataChangeType.NONE, (this.returnedFolderEvent as FolderEvent).Remote);
}
private void FindReportAndRemoveMutualDeletedObjects(IDictionary <string, IFileSystemInfo> removedRemoteObjects, IDictionary <string, IFileSystemInfo> removedLocalObjects)
{
IEnumerable <string> intersect = removedRemoteObjects.Keys.Intersect(removedLocalObjects.Keys);
IList <string> mutualIds = new List <string>();
foreach (var id in intersect)
{
AbstractFolderEvent deletedEvent = FileOrFolderEventFactory.CreateEvent(null, removedLocalObjects[id], MetaDataChangeType.DELETED, MetaDataChangeType.DELETED, src: this);
mutualIds.Add(id);
this.Queue.AddEvent(deletedEvent);
}
foreach (var id in mutualIds)
{
removedLocalObjects.Remove(id);
removedRemoteObjects.Remove(id);
}
}
private AbstractFolderEvent CreateLocalEventBasedOnStorage(IFileSystemInfo fsObject, IMappedObject storedParent, IMappedObject storedMappedChild)
{
AbstractFolderEvent createdEvent = null;
if (storedParent == null)
{
throw new ArgumentNullException("storedParent", "stored parent is null. Stored child: " + storedMappedChild.ToString() + Environment.NewLine + "local object is: " + fsObject.FullName);
}
if (storedMappedChild.ParentId == storedParent.RemoteObjectId)
{
// Renamed, Updated or Equal
#if __COCOA__
if (fsObject.Name.Normalize(NormalizationForm.FormD) == storedMappedChild.Name.Normalize(NormalizationForm.FormD) && fsObject.LastWriteTimeUtc == storedMappedChild.LastLocalWriteTimeUtc)
{
#else
if (fsObject.Name == storedMappedChild.Name &&
fsObject.LastWriteTimeUtc == storedMappedChild.LastLocalWriteTimeUtc &&
fsObject.ReadOnly == storedMappedChild.IsReadOnly)
{
#endif
// Equal
createdEvent = null;
}
else
{
// Updated or Renamed
createdEvent = FileOrFolderEventFactory.CreateEvent(null, fsObject, localChange: MetaDataChangeType.CHANGED, src: this);
}
}
else
{
// Moved
IFileSystemInfo oldLocalPath = fsObject is IFileInfo ? (IFileSystemInfo)this.fsFactory.CreateFileInfo(this.storage.GetLocalPath(storedMappedChild)) : (IFileSystemInfo)this.fsFactory.CreateDirectoryInfo(this.storage.GetLocalPath(storedMappedChild));
createdEvent = FileOrFolderEventFactory.CreateEvent(null, fsObject, localChange: MetaDataChangeType.MOVED, oldLocalObject: oldLocalPath, src: this);
}
return(createdEvent);
}
private AbstractFolderEvent CreateRemoteEventBasedOnStorage(IFileableCmisObject cmisObject, IMappedObject storedParent, IMappedObject storedMappedChild)
{
AbstractFolderEvent newEvent = null;
if (storedParent != null && storedMappedChild.ParentId == storedParent.RemoteObjectId)
{
// Renamed or Equal
if (storedMappedChild.Name == cmisObject.Name)
{
// Equal or property update
if (storedMappedChild.LastChangeToken != cmisObject.ChangeToken)
{
// Update
newEvent = FileOrFolderEventFactory.CreateEvent(cmisObject, null, MetaDataChangeType.CHANGED, src: this);
AddRemoteContentChangeTypeToFileEvent(newEvent as FileEvent, storedMappedChild, cmisObject as IDocument);
}
else
{
// Equal
newEvent = null;
}
}
else
{
// Renamed
newEvent = FileOrFolderEventFactory.CreateEvent(cmisObject, null, MetaDataChangeType.CHANGED, src: this);
AddRemoteContentChangeTypeToFileEvent(newEvent as FileEvent, storedMappedChild, cmisObject as IDocument);
}
}
else
{
// Moved
newEvent = FileOrFolderEventFactory.CreateEvent(cmisObject, null, MetaDataChangeType.MOVED, oldRemotePath: this.storage.GetRemotePath(storedMappedChild), src: this);
AddRemoteContentChangeTypeToFileEvent(newEvent as FileEvent, storedMappedChild, cmisObject as IDocument);
}
return(newEvent);
}
private bool CouldLocalObjectBeAccumulated(AbstractFolderEvent e)
{
if (e == null)
{
return(false);
}
else if (e.Remote == MetaDataChangeType.DELETED)
{
return(false);
}
else if (e is FileEvent)
{
return((e as FileEvent).LocalFile == null);
}
else if (e is FolderEvent)
{
return((e as FolderEvent).LocalFolder == null);
}
else
{
return(false);
}
}
