public void LogElementCompleted(ISyncElement element) { NewLogEntry( new string[] { GetTimeStamp() + "Elemento completato: " + element.Name }); }
public void LogElementStarting(ISyncElement element) { NewLogEntry( new string[] { GetTimeStamp() + "Avvio elemento: " + element.Name }); }
/// <summary> /// Checks wheter the resource exists in the index and RemoteProperties /// </summary> /// <param name="path"></param> /// <returns></returns> private (bool existInIndex, bool existsRemote) CheckForElementExistance(ISyncElement element, IEnumerable <IRemoteProperty> remoteProperties, SyncIndexManager manager) { bool exstIndex = GetIndexElement(manager, element) != null; bool exstRemote = GetProperty(remoteProperties, element) != null; return(exstIndex, exstRemote); }
/// <summary> /// Creates a SyncIndex Element fromt the given local and remote Elements /// </summary> /// <param name="localElement"></param> /// <param name="remoteElement"></param> /// <returns></returns> private SyncIndexElementDTO CreateIndexElement(ISyncElement localElement, IRemoteProperty remoteElement) { return(new SyncIndexElementDTO() { ReleativeFilePath = localElement.RelativePath, RemoteRevision = remoteElement == null ? "" : remoteElement.RemoteRevision, LocalRevision = localElement.Revision, ElementType = localElement.Type }); }
/// <summary> /// Uploads the given ISync Element using the ISyncClient /// If success the Element will be added or an existing element will be updated with /// the new values /// </summary> /// <param name="element"></param> /// <param name="client"></param> /// <param name="indexManager"></param> private void Upload(CancellationToken cancleToken, ISyncElement element, ISyncClient client, SyncIndexManager indexManager) { IRemoteProperty uploaded = element.Upload(cancleToken, client); if (uploaded != null) { //Upload was successfull, add as tracked element to index indexManager.AddOrUpdate(CreateIndexElement(element, uploaded)); } }
/// <summary> /// Returns the IndexElement matching the given ISyncElement /// </summary> /// <param name="manager"></param> /// <param name="element"></param> /// <returns></returns> private SyncIndexElementDTO GetIndexElement(SyncIndexManager manager, ISyncElement element) { IEnumerable <SyncIndexElementDTO> elements = manager.GetOrCreateIndexFile(); if (elements != null) { return(elements.Where(x => x.ElementType == element.Type && x.ReleativeFilePath == element.RelativePath ).FirstOrDefault()); } return(null); }
/// <summary> /// Handles the synchronisation of the given ISyncElement /// </summary> /// <param name="element"></param> /// <param name="client"></param> /// <param name="properties"></param> /// <param name="indexManager"></param> private void HandleISyncElement(CancellationToken cancleToken, ISyncElement element, ISyncClient client, IEnumerable <IRemoteProperty> properties, SyncIndexManager indexManager, ILogger logger, Configuration config) { if (cancleToken.IsCancellationRequested) { return; } //The general rules defining when to synchronize what are the same //for all ISyncClients and they follow the following design: // //1. Iterate all local folder and their files, check for updates on server: // Both: // 1. when it does not exist in index and server -> upload // 2. when it exists only in index -> delete (has been deleted remotely) // 3. when exists on server but not index -> update index // Files: // 1. When is exists in server and index -> check for updates //2. Add all files that are not in index to local copy //3. Remove all files that exist in index and server but not local from server -> deleted local (bool existInIndex, bool existsRemote)existance = CheckForElementExistance(element, properties, indexManager); if (!existance.existInIndex && !existance.existsRemote) { //Not in index and not in remote -> upload logger.Debug(element.Type + " " + element.RelativePath + " does not exist in local Index and remote, " + "File will be added to both"); Upload(cancleToken, element, client, indexManager); //Set the Method to ignore Updates -> Just handle children in case of Directory //Because directly checking for updates may cause exceptions because the server is //slow and does not return the correct properties on request yet HandleISyncElementChildrenOrUpdates(cancleToken, element, client, properties, indexManager, logger, config, true); } else if (existance.existInIndex && !existance.existsRemote) { //In index but not remote -> delete (has been deleted remotely) logger.Debug(element.Type + " " + element.RelativePath + " exists in index but has been removed remote. Deleting " + element.Type); DeleteLocalElement(element, indexManager); } else if (!existance.existInIndex && existance.existsRemote) { //Remote but not in index -> Add to index logger.Debug(element.Type + " " + element.RelativePath + " was missing in the index -> will be added."); //As it cannot be said if there was changes remote, no remote revision is added indexManager.AddOrUpdate(CreateIndexElement(element, null)); HandleISyncElementChildrenOrUpdates(cancleToken, element, client, properties, indexManager, logger, config, false); } else if (existance.existInIndex && existance.existsRemote) { HandleISyncElementChildrenOrUpdates(cancleToken, element, client, properties, indexManager, logger, config, false); } }
/// <summary> /// Deletes the given ISyncElement and removes it from index if successfull /// </summary> /// <param name="element"></param> /// <param name="indexManager"></param> private void DeleteLocalElement(ISyncElement element, SyncIndexManager indexManager) { if (element.Delete()) { SyncIndexElementDTO dto = GetIndexElement(indexManager, element); if (element.Type == SyncElementType.Directory) { //If a Directory was removed, remove all sub Element that //have been contained in that directory indexManager.RemoveAll(x => x.ReleativeFilePath.Length >= dto.ReleativeFilePath.Length && x.ReleativeFilePath.Substring(0, dto.ReleativeFilePath.Length) == dto.ReleativeFilePath); } else { indexManager.Remove(dto); } } }
public SyncElementViewModel(ISyncElement syncElement) { SyncElement = syncElement; }
public virtual void SetParent(ISyncElement syncElement) { ParentElement = syncElement; }
/// <summary> /// Returns the Remote Property that matching the given ISyncElement /// </summary> /// <param name="remoteProperties"></param> /// <param name="element"></param> /// <returns>Matching remote property or null if not found</returns> private IRemoteProperty GetProperty(IEnumerable <IRemoteProperty> remoteProperties, ISyncElement element) { //Remote properties seem to have a slash more at the beginning return(remoteProperties.Where(x => x.DecodedRelativeRemotePath.PathsEqual(element.RelativePath) && x.ElementType == element.Type).FirstOrDefault()); }
/// <summary> /// Checks for the given elements children or remote updates, has the option to only check the children and ignore updates in case /// Can be usefull to give the server enough time to index new files /// </summary> /// <param name="cancleToken"></param> /// <param name="element"></param> /// <param name="client"></param> /// <param name="properties"></param> /// <param name="indexManager"></param> /// <param name="logger"></param> /// <param name="config"></param> /// <param name="ignoreUpdates"></param> private void HandleISyncElementChildrenOrUpdates(CancellationToken cancleToken, ISyncElement element, ISyncClient client, IEnumerable <IRemoteProperty> properties, SyncIndexManager indexManager, ILogger logger, Configuration config, bool ignoreUpdates) { //File: check for updates //Directoy: process with going one hierarchy deeper if (element.Type.Equals(SyncElementType.File)) { if (!ignoreUpdates) { CheckForFileUpdates(cancleToken, (FileSyncElement)element, client, properties, indexManager); } } else if (element.Type.Equals(SyncElementType.Directory)) { GetDataAndHandleSync(cancleToken, element.AbsolutePath, client, logger, config, indexManager); } else { throw new NotImplementedException(); } }
public SubJob(ISyncElement targetElement) { Status = JobStatus.OnQueue; TargetElement = targetElement; Dependencies = new List <ISubJob>(); }