Client File Synchronization Recovery Using Persistent Identifiers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing content management systems face challenges in accurately synchronizing local copies of content items on client machines with the CMS repository, particularly when file paths are altered or files are moved outside monitored folders, leading to loss of history information and metadata.
Innovation Solution
The use of first and second unique identifiers, stored in a local database, to associate local files with corresponding content items in the CMS repository, allowing the local client synchronization application to track and restore synchronization without relying on file path information.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If file path information is used to track local files, then synchronization can be monitored, but synchronization breaks when files are moved or paths are altered
Solution Approach 1:
The patent introduces unique identifiers as an intermediary between the local file system and the CMS repository. Instead of directly tracking file paths, the system uses immutable unique identifiers that remain constant regardless of file location changes. This intermediary layer decouples the synchronization mechanism from file path dependencies, allowing files to be moved or renamed without breaking synchronization.
Solution Approach 2:
The patent creates a copy of the file's unique identifier information and stores it in the local database. This copied identifier information serves as a persistent reference that survives file system changes. By copying and storing the unique identifier separately from the file path, the system maintains a reliable link between the local file and CMS content item even when the file is moved or renamed.
2Loss of information
If file path tracking is used, then synchronization status can be monitored, but history information and metadata are lost when synchronization breaks
Solution Approach 1:
The patent performs preliminary actions by storing the unique identifier and synchronization status in a local database before any file operations occur. This pre-stored information serves as a safety net that preserves history and metadata even if subsequent file operations cause synchronization to break. The local database is updated in advance with all necessary tracking information.
Solution Approach 2:
The unique identifier acts as an intermediary that preserves the relationship between local files and CMS content items throughout the file's lifecycle. This intermediary reference allows the system to restore synchronization and recover history information even after files are moved, renamed, or temporarily disconnected from the CMS.
3Productivity
If the system waits for synchronization breaks to detect them, then simple tracking is possible, but productivity is reduced due to manual intervention
Solution Approach 1:
The patent implements a feedback mechanism where the local client synchronization application continuously monitors the local database for synchronization status changes. When a break is detected, the system automatically initiates recovery procedures by querying the CMS repository using the stored unique identifier. This closed-loop feedback system eliminates the need for manual intervention while maintaining simple tracking logic.
Solution Approach 2:
The synchronization system performs self-service by automatically detecting breaks and initiating recovery without user involvement. The local client application uses the pre-stored unique identifier to autonomously restore synchronization with the CMS repository, making the system self-correcting and reducing productivity losses associated with manual intervention.
Data Source
AI summary
Using a first unique identifier of a local file on a client machine associated with a second unique identifier of a content item maintained at a content management system repository, synchronization of the local file and the content item can be restored after a synchronization break.