JP2020017282A - Storage constrained synchronization engine - Google Patents

Abstract

To provide a method, computer program and system for synchronizing content items across client computing systems connected by a network.SOLUTION: The method comprises synchronizing client devices 100A and 100B using a content management system 110. The content management system 110 comprises: a data store 218 in which content items are stored; a pending block table 220 that maintains a list of pending blocks expected to be received; and a namespace table 222 that stores data associating individual content items with namespaces.SELECTED DRAWING: Figure 2

Description

Cross-reference to related applications

    [0001] This application is related to US Provisional Patent Application No. 62 / 327,379, filed April 29, 2016, US Patent Application No. 15 / 396,254, filed December 30, 2016, and 2017. All of U.S. Patent Application No. 15,420,014, filed January 30, 2014, are hereby incorporated by reference in their entirety.

  [0002] Embodiments of the present disclosure generally relate to improving the performance of computer systems that provide synchronization of content items, and in particular, client devices that have limited storage allocation for synchronized content items. Improving the synchronization of content items between a content item and a content management system.

  [0003] Content management systems allow users to share content items from one client to another. The client is a computing device that provides content items to a content management system for storage and synchronization with other clients. Other clients may be operated by other users and may be devices registered or managed by the same user. The user specifies which content items, or directories containing the content items, are available to be shared with other users, i.e., synchronized with such user's client device. Typically, a content management system synchronizes predetermined content with all client devices designed to share the content item. As a result, each of those client devices will store a very large amount of shared content items. In some cases, the amount of storage occupied by the shared content item on the client device is substantially the amount of storage available on the client device for other items such as asynchronous content items and applications. The capacity will be reduced.

, [0004] FIGS. 1A and 1B are conceptual diagrams illustrating one embodiment of constrained synchronization. [0005] FIG. 2 is a diagram illustrating a system environment for a content management system that synchronizes content items between client devices. [0006] FIG. 3 is a diagram illustrating a software architecture of a client device. [0007] FIG. 4 is a constrained synchronization interaction diagram for accessing existing content items in a local content directory. [0008] FIG. 5 is a constrained synchronization interaction diagram for creating a new content item stored in a local content directory. [0009] FIG. 6 is a diagram illustrating a host system environment based on constrained synchronization. [0010] FIG. 7 illustrates an interaction diagram for constrained synchronization managed by a host device. FIG. 8 is a diagram illustrating a user interface for a local content directory having icons representing remote and local content items. [0012] FIG. 9 is a conceptual diagram illustrating constrained synchronization using predicted content item importance. FIG. 10 is a diagram illustrating a system environment of a content management system that uses predicted content item importance for constrained synchronization. [0014] FIG. 11 is a diagram illustrating a software configuration of a client device that uses content management triggered in an idle state. [0015] FIG. 12 is a diagram illustrating a system environment for a content management system that uses idle-triggered content management. [0016] FIG. 13 is a flowchart illustrating a process used in idle-triggered content management. FIG. 14 is a block diagram illustrating the structure of a file journal according to one embodiment. [0018] FIG. 15 is a flowchart illustrating a detailed process of committing a content item, according to one embodiment. FIG. 16 is a flowchart illustrating a detailed process for replacing a content item with a placeholder item, according to one embodiment. [0020] FIG. 17 is a flowchart illustrating a detailed process for replacing a content item with a placeholder item according to one embodiment. FIG. 18 is a flowchart illustrating a detailed process of converting a placeholder item to a content item according to one embodiment. FIG. 19 is a flowchart illustrating an example of an algorithm of an update function executed by the content synchronization module upon receiving an update entry of the update file journal. FIG. 20 is a flowchart illustrating an algorithm for reconstructing items in a shared file path, according to one embodiment. FIG. 21 is a flowchart illustrating an algorithm for reconstructing items in a shared block list, according to one embodiment. FIG. 22 is a flowchart illustrating an algorithm for configuring an updated item as a new item, according to one embodiment. FIG. 23 is a flowchart illustrating an algorithm for reconstructing an item with a shared journal ID, according to one embodiment. [0027] These figures illustrate various embodiments of the invention for purposes of illustration only. Those skilled in the art will readily appreciate from the following description that other alternative embodiments of the arrangements and methods set forth below may be used without departing from the principles of the invention described below.

<Functional overview of restricted synchronization>
[0028] A general functional overview and processing of a constrained synchronization system is described below. As a preliminary condition, a user stores a content item on a client device and the content item is synchronized with an instance of the content item on another client device or with a host system, generally a content management system. The client device stores content items in a local content directory. Content items stored in the local content directory are synchronized with the content management system to keep a copy of the content item and synchronize the content item with other client devices. Each client device runs a client application and allows a user to access a content management system. The client application further allows the user to set a maximum storage allocation or local content directory size.

  [0029] In one aspect, the client devices are maintained locally available on the client device and selectively determine synchronized content items whose entirety is stored only on the content management system. Is composed of In one embodiment, the client device receives a request to access a content item, for example, from an application that needs to access the content item. The client device determines whether the requested content item is a placeholder item or a content item stored locally on the client device. A placeholder item is an item that represents or executes a content item, but does not include application data for the content item. Generally, placeholder items without storing actual application content such as image data, video data, audio data, database tables, spreadsheet data, graphic data, source or object code, or other types of content data. Replicates the metadata attributes of the content item, such as the name of the content item, and various attributes, such as the type, path information, access rights, change information, and size of the content item. Because placeholder items only store metadata for content items, they require a small amount of storage, eg, typically only about 4 kilobytes, compared to content items that can be hundreds of megabytes or gigabytes in size. I need. Thus, using placeholder items that represent content items operates to save a great deal of storage space, thereby improving the functionality of the client device.

  [0030] If the client device determines that the requested content item is a placeholder item, this means that the requested content item is not currently stored on the client device, but is stored on the content management system. Is shown. Accordingly, the client device downloads a content item corresponding to the requested placeholder item from the content management system. The client device further determines whether storing the content item in the local content directory exceeds a maximum storage size defined for the directory. In this case, the client device determines whether the content item or item in the local content directory can be deleted from the local content directory or replaced with a placeholder item representing the content item. Generally, the client device updates the latest content on the client device to select a content item from a local content directory that has been determined to be abandoned by the user of the client device or a user accessing the content item through the content management system. Access time (e.g., the action of the user of the client device or an application running thereon), the latest access time on other client devices with which the content item is shared (e.g., the action of the user of those client devices) Use one or more attributes of the shared content item, including the size of the content item and the frequency of access. A combination of these factors may also be used to determine neglected content items. The client device deletes the content items so that the downloaded content items create sufficient storage space in the local content directory to be stored within the maximum storage size without exceeding them. Select the number of content items from the directory. In one embodiment, the client device determines that the total amount of storage used by those content items in the shared content directory is at least equal to or greater than the amount of storage required to store the downloaded content items. Choose the number of

  [0031] The client device deletes the selected content items and creates a corresponding placeholder item for each of the deleted content items. The client device stores the placeholder item in a directory location corresponding to the deleted content item. Storing the placeholder item in the corresponding location allows for subsequent retrieval of the deleted content item in a manner that is visible to the requesting application.

  [0032] This embodiment can maintain access to all content items shared in the content management system, while each client device has more space for other content items and applications, Provided is a restricted shared storage system that improves the storage efficiency of each client device and the storage efficiency of a content management system as a whole. More specifically, this embodiment allows the client device to operate effectively as if it had a larger storage capacity than it actually is. For example, as if a client device having a storage allocation of only 10 GB for a local content directory has a storage allocation for that directory of over 4,000 GB (4 TB), a 400-fold increase in available storage. Can work. In the past, such a solution for limited local storage capacity was not possible due to network connectivity and bandwidth limitations, but such problems have been resolved as a result of recent developments in the Internet infrastructure, It allows for extensive connectivity and fast upload and download speeds.

  [0033] Despite recent developments in the Internet infrastructure, the computation, upload and download times required for deleting content items, replacing them with placeholder items, and restoring them based on user requirements, are May still affect device performance. Accordingly, alternative embodiments are also described that reduce the storage load on the client device in the conventional shared content synchronization method, while reducing the impact on device performance as seen by the user. In one embodiment, calculations, uploads, and downloads are completed based on predicted user access to shared content items represented as placeholder items. To predict user access to content items, the client application or content management system maintains a retention score for each content item. Here, the storage score is a measure of the degree of importance predicted for the user of each content item. Each client device is configured to have a storage score threshold, and any content item having a very high predicted importance (represented by a storage score above the storage score threshold) will be sent to the corresponding client device. Downloaded. The storage score is calculated based on various attributes including the latest access time, location, type, size, access frequency, sharing status, number of accounts having access, number of devices having access, or number of devices storing content items. Can be done.

  [0034] Alternatively, other embodiments monitor the activity of the client device (whether by the content management system or by the client application) while sharing content items on the client device that exceed the client device's storage quota. Allow storage space to be occupied. Once the client device is determined to be idle, the client application deletes the content item, as described above, to reduce the available storage space occupied by the content item stored on the client device. , Replace them with placeholder items. In those embodiments, the storage allocation is not always kept, ie, the occupied storage may be reduced according to the attributes of other content items. Instead of maintaining the storage allocation, for example, whenever the client device is idle, all content items with the latest access that are older than a certain period of time (eg, two weeks) are deleted and placeholder items are deleted. It may be replaced. The process will not maintain the occupied storage space under the storage allocation, but will be desired by the user because the client device is idle, i.e., running while not actively being used by the user. Using a constrained synchronization system by providing an improved user experience over the embodiments described above, while providing a similar increase in effective storage capacity. The client device configured as described above can be improved.

  1A and 1B are schematic diagrams illustrating embodiments of constrained synchronization. FIG. 1A illustrates a process for storing a content item in a storage folder with a synchronization constraint. FIG. 1B illustrates the process of opening a placeholder item on a client device with storage constraints.

  [0036] In FIGS. 1A and 1B, client device 100A is one of a plurality of user control devices that can be connected to and synchronized with content management system 110. Content management system 110 is an instantiated server that synchronizes content from multiple client devices using a network. The shared content storage directory 120 is a directory located on the client device 100 that contains content synchronized with the content management system 110. The storage allocation 130 is a parameter value that specifies the amount of storage space allowed for all content items in the shared content storage directory 120. The storage allocation 130 can be set by a user of the client device 100A, an operating system of the client device 100, a client application of the content management system 110, a system administrator, or a policy that has established the content management system 110. An exemplary value for storage allocation 130 is 10 GB, which means that a user can store up to 10 GB of content items in the shared content storage directory 120 as a whole (attributes and data of all content items). I do. The content items 140 are stored in the shared content storage directory 120, and after synchronization between the client device 100 and the content management system 110, the version of each content item 140 in the shared content storage directory 120 is also maintained by the content management system 110. Is done.

  [0037] As used herein, the term "content item" refers to any file, group of files, or collection of files. Any content item consisting solely of a single file may alternatively be referred to as a file. Additionally, terms such as "file table" may be used to refer to an individual file or an amount of a content item.

  [0038] In FIG. 1, the shared content storage directory 120 is illustrated as a box containing the content items 140. The storage allocation 130 is represented by a specific length of the box representing the content storage directory 120.

  [0039] A first illustration of the client device 100A and the content management system 110 represents a typical state of two entities. The client device has content items 140A, 140B, and 140C in its shared content storage directory 120 (only a smaller number of content items 140 are shown for illustrative purposes, but in practice, the number of content items 140 is , Thousands, tens of thousands, or more). The content management system 110 is represented to be synchronized with the client device 100A, where it retains the same version of each of the content items stored on the client device 100A despite having no storage allocation 130. I do. Further, the content management system 110 supports another client device 100B where the content item 140A is shared. The presence of the content item 140D associated with the identifier of the client device 100B indicates that the client device 100B is also synchronizing the content item 140D with the content management system 110. Accordingly, each client device 100 can synchronize the content item 140 with only the content management system 110, or with the content management system 110 and other client devices 100.

  [0040] Stage 1.1 illustrates the operation of a request from client device A to store content item 140E in shared content storage directory 120. However, as shown, the addition of the content item 140E to the shared content storage directory 120 requires the The total storage space occupied by item 140 exceeds storage allocation 130.

  [0041] Stage 1.2 illustrates the operation of selecting an abandoned content item 140C to be deleted from the client device 100 so as to ensure sufficient available storage to store the content item 140E. According to one embodiment, either the client device 100 or the content management system 110 determines which content items 140 to select as neglected. Various methods described below can be used to determine which content items are selected as neglected. In this example, while only a single content item 140C is selected, in practice, any number of content items 140 may be selected according to the storage capacity that needs to be available.

  [0042] Stage 1.3 illustrates an operation of deleting the selected content item 140C from the client device 100A. In place of each deleted content item, the client device 100A creates a placeholder item 160C representing the deleted content item 140C and places the deleted content item 140C and the placeholder in the same location in the shared content storage directory 120. Stores an item. Alternatively, content management system 110 may create placeholder item 160 and then download placeholder file 160C to content storage directory 120. The placeholder item includes attributes indicating the deleted content item 140C, such as the content name, path information, content attribute, and content size, but does not include the actual data of the content item 140C. By not including the actual data of their corresponding content items, placeholder items require very little storage. For example, placeholder items typically require a minimum file size allocation provided by the operating system, such as 4 KB. This small size is virtually shown in FIG. 1 using a vertical line, and indicates that the size of the placeholder item is very small compared to the content item 140C itself. For example, while a deleted content item 140C may be several megabytes or several gigabytes (common for audio and video files), the storage required for a placeholder item representing such a content item is only about 4 KB. is there. As a result, the client device 100 can reduce the amount of local storage used for shared content items to less than the storage quota 130, thereby reducing the newly created (or new content item size). Sufficient space is available to store the content item 140E (updated to the correct version). Information identifying the selected (and deleted) content items is maintained on the client device 100A, allowing those items to be selectively retrieved later. The information is stored in a list 150 of stored content items that are stored remotely in a remote content item table 366 (not shown in FIG. 1A, but will be described in detail later) of the content management system 110. Is stored in

  [0043] Stage 1.4 illustrates the operation of saving the content item 140E to the client device 100A as soon as sufficient space is made available in the shared content storage directory 120. As soon as the client device 100A successfully stores the content item 140E in the shared content storage directory 120, synchronization with the content management system 110 is started and the content item 140E is uploaded to the content management system 110. The content management system 110 always keeps a full copy of all content items (including placeholder items) on the client device 100A.

  [0044] Referring to FIG. 1B, client device 100A and content management system 110 are shown after content item 140E has been synchronized from client device 100A to content management system 110.

  [0045] Stage 1.5 illustrates the operation of the client device 100A requesting access to the content item 140C (eg, opening the content item 140C using a word processor or viewing the content item with a file browser). . Here, the client device 100 determines that the requested content item is represented by the placeholder item. If the content item is stored locally, it is provided to the requesting application on client device 100A. In this case, the requested content item is deleted from the client device 100A and is only stored remotely on the content management system 110, where the client device 100 downloads the requested content item to the content management system 110. Request to do so. If there is sufficient space in the shared content storage directory 120, the content management system 110 downloads the requested content item to the client device 100A, and the client then places a placeholder item 160C representing the content item 140C into the content item 140C itself. To allow any requesting application to transparently access the content item. However, in this case, the addition of the content item 140C to the shared content storage directory 120 would exceed the storage quota 130, as shown by the content item 140C extending outside the boundaries of the shared content storage directory 120. Become.

  [0046] Stage 1.6 illustrates an operation of selecting a left-over content item to delete from client device 100A. In this case, the selected neglected content item is the content item 140A.

  [0047] Stage 1.7 illustrates the operation of deleting content item 140A and replacing it with its placeholder item 160A. This deletion creates enough space in the shared content storage directory 120 for content items 140C to be downloaded from the content management system 110 and added to the placeholder item representation without exceeding the storage quota 130. I do. The deleted content item 140A is included in the remotely stored content item list 150 and is restored to the shared content storage directory 120, so the content item 140C is deleted from the list 150.

  [0048] Stage 1.8 indicates that the content item 140C can be opened by the requesting application as soon as it resides on the client device 100A. As soon as the process shown in FIGS. 1A and 1B is completed on the client device, normal synchronization occurs between the client device 100A and the content management system 110, and to the content item 140 on the client device 100A. All changes are mirrored on the content management system 110. All content items 140 (even if represented by placeholder items) are kept on the content management system 110 until they are deleted from the shared content storage directory 120.

<Overview of system architecture>
[0049] FIG. 2 is a diagram illustrating the system architecture of a constrained synchronization system. Details of each component are described below, but some elements are introduced here to provide a constrained synchronization description. Further, as will be apparent to those skilled in the art, the operations and methods used for constrained synchronization necessarily require a computer and are not performed in any embodiment by mental steps of human action. Further, while such operations may utilize the ease of a computer to store and retrieve information, send and receive information, or process information, those skilled in the art will recognize that such operations may be performed using the algorithms described herein. Because it is performed in a particular way with respect to specially defined data, and thus requires the computer to be configured in a manner different from the way that such a computer is natively provided solely by the operating system and standard applications, only the general Understand that it is not a computer operation. In addition, the required configuration enhances the storage capacity of the computer beyond the steps of a general operating computer configured with conventional operating systems and file management systems through the steps described below.

  [0050] Client device 100 may be any suitable communication means for providing internetworking between client devices 100 located remotely from content management system 110, such as through a network (not shown), such as a LAN, WAN, or WAN. , And communicates with the content management system 110. Generally, a client device 100A having an installed client application 200A provides a content item to a content management system 110. The client application 200A includes programs and protocols required by the client device 100A to perform functions related to storage-constrained synchronization. Therefore, the client device 100A frequently performs the actions required by the client application 200A. However, since the client device 100A and the client application 200A operate together, for the sake of simplicity, some of those operations are referred to using the "client device 100A" as the operating element. The user of the client device 100A specifies a predetermined content item to be shared with the client device 100B, which may be, for example, another computer managed by the same user or a computer operated by a different user. The content management system 110 notifies the client device 100B and synchronizes the designated content item received from the client device 100A as local content stored in the client device 100B.

  [0051] Content management system 110 associates each content item with a namespace corresponding to the collection of content items. The namespace specifies a directory (or “folder”) in the directory structure where a predetermined content item is stored. The association of a content item to a particular namespace is stored in a namespace table 222. Content management system 110 associates each client with a namespace that has access, along with an identification of the specific right to access, modify, and delete content items in each namespace. When a client 100 is synchronized to a namespace, the client stores a local copy of the content item associated with the namespace and organizes the content item according to the location of the content, if available. A user is associated with an individual client device 100 or multiple clients 100, for example, the user can synchronize a home computer, a work computer, a portable computer, a smartphone, and a tablet computer all together. To share a content item, a user specifies a namespace to share with other users and / or clients. Content management system 110 then synchronizes the content items in the shared namespace across clients associated with the shared namespace. The content items stored in content management system 110 may include any type of content item, including documents, data, movies, applications, codes, images, music, and the like. A content item may also be a folder or other mechanism that groups content items along with collections, playlists, albums, file archives, and the like.

  [0052] Each user is associated with an account on the content management system 110 that includes information identifying the amount of storage to be used for storing content items on the content management system 110. The client device also has a specified capacity of local storage, which is the size of the shared content storage directory 120, for storing the content items to be synchronized, the specified capacity being determined by the storage allocation parameters 130 described above. It is. For example, a user account may specify that a user has 50 GB of storage available on the content management system 110, but has a storage allocation on the client device 100 of only 10GB. In such a situation, if the user modifies a locally stored shared content item, the content item may increase in size, thereby exceeding the storage quota on the client device 100. Similarly, a user can create and store new content items in the shared content storage directory 120 that are to be shared and synchronized with the content management system 110, thereby exceeding the storage allocation on the client device 100. Is also good. In these cases, the client device 100 is storage limited and can no longer maintain a local copy of all content items synchronized by the content management system 110, and the amount of shared content items is reduced by the storage for the client device 100. Exceed quota.

  [0053] While either the client device 100 or the content management system 110 is configured to select one or more content items for deletion from local storage, they are still remotely on the content management system 110. Retained, they can then be retrieved and restored to the client device 100. Generally, the selected content item will be accessed last, either across the specific client device 100 that has requested access to the content item, or across all client devices 100 with which the content item is shared. Since the longest time has passed since then, other methods of selection will be described later. In a client-based embodiment, the client application 200 maintains information identifying the most recent access to each shared content item stored on the client device 100. If the storage is limited, the client application 200 selects one or more content items that have been accessed last and that have passed the longest time (hereinafter abbreviated as “LRA”). In a host-based embodiment, the content management system 110 keeps access data for all content items, and the system 110 may access the content item on any client device 100 where the content item is shared. Update this information at any time. The selection of the LRA is only one of many possible methods of selecting a neglected content item (referred to herein as "UCSM"), each of which can be implemented as a host-based or client-based system. . Any UCSM may examine the vnode reference for each content item to determine if it is eligible for deletion. The vnode for each content item includes information about the number of accesses to the content item and status indicators for other content items, including whether the content item is currently in use or open.

  [0054] For ease of explanation, whenever a content item is selected to be removed from resident on the client device 100 in response to storage restrictions, the action is that most UCSMs are accessed by the user. In order to operate to identify the least probable content item, it is referred to herein as "selecting a neglected content item." A neglected content item refers to a content item selected by any UCSM outlined in the following description.

  [0055] Basic LRA Selection: To perform a basic LRA selection, the client application 200 accesses a queue of content items ordered by the last locally accessed date, and accesses the head of the queue. Holds a queue of content items that have passed the longest time. The last access date and time of each content item is stored in the content access history table. Accessing a content item includes creating, opening, previewing, or modifying the content item. Any number of those actions are considered accesses, e.g., in this embodiment, either opening, modifying, or saving a content item is considered an access, while previewing a content item is considered an access. It is not necessary. The cumulative total of storage sizes (e.g., to date) is calculated starting from the last accessed content item identified in the queue and the longest time elapsed (i.e., the top content item in the queue). Is calculated for each content item listed in the queue up to the content item located last. If storage is limited, the client application 200 determines the amount of storage space required to store the content item, and thus determines the index of the content item whose cumulative storage size exceeds the storage space requirement. Advance the queue. The specified index is used to select all content items including the index of the queue to be deleted from the shared content storage directory 120 on the client device 100 described above.

  [0056] These processes are further described in Table 1. In this example, 75 MB of storage is needed to store the content item. Since the total of content items A and B is only 70 MB, deletion of those two content items cannot provide a sufficient amount of storage for that item. Therefore, content items A, B, and C with a total cumulative size of 150 MB are selected at the corresponding indexes 00, 01, and 02 (as indicated by the designation in the rightmost column).

  [0057] Remote LRA selection: The LRA selection also provides access to the content item directly through the content management system 110 or on the client device 100 that is sharing a version of the content item. May be based on remote access by other users. To accomplish this, in one embodiment, each client device 100 synchronizes its own content access history table with the content management system 110, for example, during normal content item synchronization operations or at other times. This embodiment allows each client device 100 to maintain current access information for all content items shared with any other client device. Alternatively, in a host-based embodiment, the content management system 110 may maintain a content access history table that includes an access history for each content item across all client devices designated to synchronize and share. , Thereby having an updated list for use in LRA selection. Thus, remote LRA selection involves the content management system 110 selecting the content item that has been accessed the longest time since the accumulated storage size exceeds the required storage space. In this embodiment, the queue is ordered by the latest access time from all client devices that are synchronized for the content item.

  [0058] Table 2 is an example of how a remote LRA can be implemented. In this example, content items B and C were last remotely accessed on different client devices at 2014/5/24 and 2014/4/5, respectively, but both (as described in Table 1). Both were locally accessed last on March 24, 2014. Changing the date of the last access for items B and C due to their remote access moves them further in the queue as compared to when the basic LRA selection is used. As a result, in this example, items A and D are selected instead of A, B, and C.

  [0059] Content item size selection: Another factor that can be used to select content items to delete is their size. In one embodiment, the size is used to minimize the number of content items that are deleted and stored remotely from the client device 100. This can be achieved by ordering the queues by size (minimum to maximum) instead of the date accessed. The value of the required storage space can then be compared to the individual sizes until a content item with a size that exceeds the required storage space is identified. The client application 200 will then select the content item to delete. If no single content item is larger than the required storage space, the largest content item is selected, its size is subtracted from the required storage space value, and the process repeats from the beginning of the queue.

  [0060] Table 3 is an example of the selection method. In this example, 40 MB of storage is needed to store the content item. Item B is selected to be deleted from client 100 because it is the first content item with a queue index that exceeds the required storage value of 40 MB.

[0061] Selection Based on Content Item Size and Access Time: The size selection method described above may select frequently accessed content items for deletion. By taking into account both size and access time, the content management system can avoid deleting content items from the client device 100 that may be requested by the user in the near future. In one embodiment, the two-variable selection method includes calculating a weighted score for each content item based on the amount of storage of each content item that contributes to reaching the required storage allocation and its latest access date and time. Achieved by For example,
Score = w ₁ S + w ₂ A
Here, S is a metric that represents the size of the content item, A is a metric that represents the time since the last access to the content item, w ₁ and w ₂ are weighting. The weighting of A and S can be based on their relative importance, as determined by the user, or based on historical content items that indicate access patterns to content items on a particular client device 100 be able to. Thereafter, the queue is ordered by score, and the first content item in the queue is selected for deletion.

[0062] An example of the method of this embodiment is shown in Table 4 below. For ease of illustration, the access time metric A is the difference between the current time and the latest access time for a particular content item, the current time and the time of the last accessed item (here, the last used item). What was done is the ratio with the difference of 2014/9/3). In this example, the size metric has the following relationship.
For s> = r: S = r / s
For s <r: S = s ² / r ²
Here, s is the item size of the content, r is the required storage space, and S is the size metric. This piecewise function has a maximum of one when s = r.

  [0063] In the example displayed in Table 4, the required storage space is 40 MB and the weights w1 and w2 are both 1. A size metric and an access time metric are calculated and then used to calculate a total score for each content item. In this example, item B has the highest score and is selected for deletion from client device 100. If the selected content item is smaller than the required storage space, the new required storage space is calculated as the difference between the old storage space and the size of the first selected content item, and the score is recalculated. , A new queue is generated for all content items using the newly calculated required storage space, and the selection process is repeated.

  [0064] To better select the access frequency and the most recently selected content item, other factors, such as frequency, may be considered in addition to the access time. High-frequency, low-licensed content items are those that have been frequently selected in the past (more than 6 months ago), but have not been selected recently, and low-frequency, low-licensed content items are frequently accessed. Content item that has never been done. The frequency of access may be measured in relation to the average frequency, type, namespace, source domain, or other content item attributes for a particular client device or any set of client devices. For example, if a content item has not been accessed on the client device in the last 4 months but has been accessed 25 times before that time, the user may have accessed it only once in the past and have a similar recency than the content item May be relevant.

[0065] In one embodiment, in addition to the most recent access to each content item, the number of accesses to each content item is maintained (either at the client device 100 or the content management system 110). A score is determined for each content item as a combination of metric weightings representing the respective variables. For example, the weighting score for each content item is based on the access frequency of the content item and its latest access date. For example,
Score = w ₁ F + w ₂ A
Here, F is a metric representing the access frequency, and A is a metric representing the time since the last access to the content item. w ₁ and w ₂ are weights. The weights of A and F may be based on their relative importance, as determined by a user, by a system administrator, or based on a historical content item access pattern of content items on a particular client device 100. it can. The cues are then ordered by score. The running sum is calculated at each index and compared to the required storage space. When the required storage space is exceeded by the cumulative sum, the index in the queue and all content items at the index are selected for deletion from the client device 100.

[0066] Table 5 is an example of the present selection method. In this example, the required storage space is 40 MB and the weights w ₁ and w ₂ are both 1. The queues are ordered by total score and compared to the storage space for which the cumulative sum is needed. This results in items C and E being selected for deletion from client device 100.

  [0067] Any of the above USCMs may consider the entire folder in a single queue index instead of a single individual file. For example, if LRA UCSM is used and a folder contains multiple files, the most recently accessed files in that folder will have an earlier access date and time than all other content items in the shared content directory It may be more effective to select entire folders that have been left out, especially if you need significant storage space. Alternatively, the combined metric for a folder may be an average, median, or other statistic that allows the content items in the folder to be generalized and placed in a queue.

  [0068] As described below, any of the foregoing methods may be used to select a neglected content item to delete from client device 100. The process of selecting a neglected content item allows for increased storage capacity on the client device as provided by the constrained content management system 100.

<Overview of Content Management System>
[0069] A synchronization method using the content management system 110 between the client devices 100A and 100B may be described with reference to the architecture illustrated by FIG. One of many possible synchronization methods that can be used for storage-constrained synchronization is described below.

  [0070] Content management system 110 stores content items in data store 218. Content items are stored in fixed-size parts called blocks. The size of the block varies according to the implementation, and in one embodiment, the block is 4 megabytes in size. Thus, content items of small size are stored in a single block, while content items of large size are divided into tens, hundreds, or more blocks of storage of the content management system 110. Can be stored. The metadata includes a plurality of blocks of the content item and a block list that defines the order of the blocks in the content item.

  [0071] The pending block table 220 holds a list of pending blocks that are expected to be received at the content management system. The reserved block table 220 stores an association between a plurality of blocks (identified by block identifiers) and a namespace to which the transmitted block indicated by the client 100 belongs.

  [0072] The namespace table 222 stores data that associates individual content items with namespaces and holds data that associates each namespace with a client.

  [0073] The metadata server 212 is responsible for managing requests from clients to add new content items to the content management system ("commit"). Metadata server 212 also receives a request from client device 100 to synchronize the content item. The metadata server 212 holds a record of the latest time when the client device 100 is synchronized with the content management system 110. Upon receiving a request to synchronize from the client device 100, the metadata server 212 determines any content items that have been committed to the namespace synchronized to the client device 100 since the last synchronization time stamp. Further, the metadata server 212 determines any pending blocks received after the latest synchronization time stamp.

  [0074] The notification server 216 communicates with the client 100 and, in particular, notifies the client that new data is available. Notification server 216 maintains a list of clients 110 associated with each namespace in namespace table 222. When the notification server 216 receives an alert from the block server 214 or the metadata server 212 that a new block is available for a given namespace, the notification server 216 is associated with the namespace from the namespace table 212. Identify the client. The notification server 216 notifies the client 100 associated with the namespace to activate the client 100, indicating that a new block is available for the identified namespace.

  [0075] Normal synchronization between two clients 100, client 100A and client 100B, occurs as follows. First, the client device 100A adds an additional content item to the shared data. The additional content item is then sent to the content management system 110. Content management system 110 notifies client device 100B that the additional content item is in the shared data, and client device 100B retrieves the additional content item from content management system 110 as client device 100B. The content management system 110 maintains a list of content items and pending blocks that are expected to be received by the content management system 110 using the pending block table 220 and is received by the client device 100B by the content management system 110. To download the block corresponding to the content item as the block to be downloaded. Pending blocks are those blocks that correspond to content items that are expected to be received by the content management system 110 and that are to be received by the client device 100B before the content items are committed to the content management system 110. Used to identify blocks that can be provided.

  [0076] To manage content items that are being transferred, the content management system 110 maintains a list of pending blocks along with a namespace associated with the pending blocks. When a pending block is received, the client associated with the namespace can be notified and a transfer for the received block can begin. Accordingly, the uploading client (providing a new content item) and the downloading client (receiving a new content item) transfer blocks to the content management system 110 asynchronously.

<Overview of Client Device>
[0077] Each client device 100 holds a local copy of shared data that is synchronized with a desktop, laptop, tablet, mobile device, or other client using the content management system 110 and the installed client application 200. Computing device such as a system. The shared data may be synchronized only with the client associated with a single user, or may be synchronized with the client associated with multiple users. Client device 100 includes modules and applications for handling and adding shared data, as described further with respect to FIG.

  FIG. 3 shows modules of the client application 200. Client application 200 includes various modules and a data store for synchronizing data with content management system 110. The client application 200 includes a content synchronization module 310, a hashing module 320, a download module 330, an upload module 340, and a storage management module 350. Further, the client application 200 holds a data store including a file journal 360, a resident file table 362, shared data 364, a remote file table 366, a configuration file 368, and a block cache 370. In addition to the client application 200, FIG. 3 also shows the storage kernel extension 384 residing on the client device operating system. The client application 200 and its associated kernel extension, which uses the module instance client application 200 as a particular computer, can perform the functions described herein and describe the storage capacity and functional performance of the client device. To make improvements.

  [0079] Shared data 364 is data that has been synchronized by content management system 110 and includes content items received from content management system 110. As the user adds, modifies, or deletes content items in the shared data 364, those changes are synchronized with the content management system 110. The hashing module 320 and block cache 370 operate to identify blocks containing content items that are uploaded to the content management system 110. The hashing module assigns a block identifier by executing any suitable hashing algorithm, such as MD5 or SHA-1. Content synchronization module 310 then uses those identifiers to compare resident blocks located in block cache 370 with blocks maintained by content management system 110. Although those modules are present in the embodiments herein, the implementation of this block is not necessary for the storage constrained synchronization invention.

  [0080] In the client application 200, when the data of the shared data 364 on the client device 100 is modified or added to the shared data 364, the modification to the shared data 364 is transmitted to the content management system 110. Is done. Client device 100 is also configured to receive notifications from content management system 110. When the client device 100 receives the notification, the client device 100 queries the content management system 110 for a modification to the shared data 364. When the shared data is modified, the client device 100 requests a modification from the content management system 110 to store the shared data on the client device 100. In some cases, the modified data may be associated with a content item represented by a placeholder item. In this case, the client device 100 may suspend the request for modification data from the content management system 110 until access to the content item represented by the placeholder item is requested by an application on the client device 100. Alternatively, once the shared content item is modified by another client device 100, the content management system 110 may request that the constrained client device 100 restore the content item represented by the placeholder item, As a result, the modifications can be synchronized at the expense of other content items residing on the restricted client.

  [0081] Within the client application 200, the file journal 360 stores a table listing metadata of all content items accessible to the account using the client application 200. The metadata includes a revision date and time, a namespace, and a block list corresponding to each content item. Content items that are not resident or out of sync are still included in the file journal 360.

  [0082] The resident file table 362 stores a list of files resident on the client device 100 regardless of storage restrictions.

  [0083] Remote file table 366 stores a list of files that have been selected to be deleted from the client device and replaced with placeholder items. These files are merely retained by the content management system 110 so that other users can access the files.

  [0084] Configuration file 368 is a file maintained by client application 200 and includes storage allocation 120 at the client device. In some embodiments, storage allocation 120 may be created by a user or by a computer system having control via client application 200. For example, the operating system may change the storage allocation 120 to maintain sufficient storage capacity used by other applications.

  [0085] The storage kernel extension 384 is configured to monitor a request from an application to the operating system 380 to access the content item and determine whether the requested content item is a placeholder item. Is a means for executing the function. The storage kernel extension 384 enacts a direct modification to the structure and functionality of the operating system to allow for increased effective storage capacity on the client device.

  [0086] Kernel extension 384 monitors requests to open content items managed by client application 200. Kernel extension 384 monitors file system 382 on operating system 380 to determine when a request to open a content item managed by client application 200 is made. When a request for a content item is made in the file system 382, the kernel extension 384 changes the path name of the content item to determine whether it is in a content item stored in the shared content storage directory 120. Find out.

  [0087] Kernel extension 384 determines whether the requested content item is a placeholder item by determining whether its size is below a threshold size, or , Based on extended file attributes for content items managed by the client application 200. A file attribute indicating the placeholder item may be assigned to the placeholder item so that the kernel extension can identify the placeholder item without checking the size of the requested content item. If the kernel extension 384 determines that the file is a placeholder item, the kernel extension notifies the client application 200 of the identification information.

  [0088] FIG. 4 illustrates one embodiment of a process for accessing a content item that is not resident on the client device 100, but is included in the file system as if it were resident on the client device 100. It is an interaction diagram. File system 382 receives a request to open a content item in a synchronized folder on client device 100 (400). The request may be from any application, such as a file explorer, word processor, document reader, image editing, and the like. The storage kernel extension 384 intercepts such a file system request and obtains the path name of the requested content item (402). The storage kernel extension 384 uses the pathname to determine (404) whether the content item is a placeholder item. The storage kernel extension 384 checks the size of the requested content item to determine if it is below a predetermined threshold or otherwise matches the size of the shadow item (4 KB). It may be determined whether the item is a placeholder item. Alternatively, the storage kernel extension unit 384 can read file attribute extension information that stores a value indicating whether the content item is a placeholder item or a normal content item. If the content item is not a placeholder item, then storage kernel extension 384 allows the request to continue as usual and provides a file handle to the file system, thereby opening the content item.

  When determining that the content item is a placeholder item, the storage kernel extension unit 384 transmits a request identifier number (information about the request including the request type) and a file path to the storage management module 350. (406) The file name is passed. The storage management system 350 deletes the file name from the remote file table 366 (408). The storage management system 350 then activates (412) a download thread that checks for content items that require synchronization from the content item. As soon as the requested content item is deleted from the remote file table 408, the download thread can request content information from the content management system 110, including the size of the requested content item in preparation for the download. (414). The storage management module 350 receives the size information from the content management system 110 (416) and determines whether storing the content item on the client device 100 exceeds a predetermined storage limit (418). If the storage limit is exceeded by adding the requested content item, the storage management module 350 selects one or more content items stored on the client device 100 for deletion (422). However, if the storage limit is not exceeded, the storage management module 350 proceeds to download the content item (430).

  [0090] If the storage allocation 130 is exceeded by adding the requested content item to the shared content storage directory 120, the storage management module 350 uses the requested content item before requesting the download (430). One or more content items to be moved may be selected to ensure sufficient storage space possible, thereby preventing the shared content storage directory 120 from being occupied more than its allocated space. The storage management module 350 selects a content item to be deleted (422) by first determining a neglected content item using any of the above-described UCSMs (420). If the access history of a particular content item or other information related to each selection method is stored in the host system, a request is made to the host system to update the client application 300 version of that information (FIG. 4). Not shown). As soon as the current version of the access history or any other necessary information is obtained for each content item of the content management system 110, the storage management module 350 can determine the neglected content item (420). ).

  [0091] The storage management module then selects the neglected content item to delete from the client device (422). In this embodiment, to select a content item to delete (422), the storage management module 350 generates by the USCM in use to create a storage space at least equal to the size of the requested content item to download. Consider the queues that will be created in detail. Selection of a neglected content item for deletion can be performed using any of the methods described above.

  [0092] The storage management module 350 then adds the name of the selected content item to the remote file table 366. Upon completion of the addition (424) (426), the storage management module 350 deletes the selected content item from the shared content storage directory 120 (428), and then deletes the deleted content item for each deleted content item. Create a corresponding placeholder item that has the same metadata and location as the item, but does not include content information about the content item. The placeholder items may be represented on the client user interface as if they were still resident on the client device 100. FIG. 8 is a diagram showing how a placeholder item is represented in the user interface of the client device 100.

  [0093] When the selected content item is deleted, sufficient storage space is created on the client device 100 so that the requested content item can be stored in the content management system 110 without exceeding the storage limit of the shared content storage directory 120. Can be downloaded from Therefore, the storage management module 350 sends the download request 430 to the download module 330. The download module 330 then initiates a download (432) with the content management system 110. When the content item is downloaded to the download module 330 (434), the content item is passed to the storage management module 350 (436), and the requested content item is stored in the previously specified location (438) and downloaded to the storage kernel extension 384. Is notified (440). In one embodiment, the storage management module 350 attaches the content of the downloaded content item to the placeholder item's metadata and updates the content item's attributes to indicate that the content item is no longer a placeholder item. This allows the requesting application to transparently access the requested content item using the same file handle and identity used to initially request access to the content item. The storage kernel extension 384 then allows the requesting application to open (444) the content item through a file handle (442) to the file system 382.

  [0094] FIG. 5 is an interaction diagram illustrating one embodiment of a process for storing a content item in a shared content storage directory 120 to approximate a storage allocation 130. The content item may be a newly created content item in the shared content storage directory 120, a content item relocated to the shared content storage directory 120, or a content item that is already in the shared content storage directory 120 and increases in size. It may be a content item that has been modified in a manner. The process begins with the application making a request to the operating system file system 382 to save the content item in the sync folder (500). The storage kernel extension 384 monitors this request and receives the request ID, file path, and size from the file system (502). Thereafter, the storage kernel extension unit 384 transmits the information to the storage management module 350 (504). The storage management module determines whether adding a new content item exceeds the storage limit of the sync folder (506). If the storage limit is not exceeded, the file system 382 allows the content item to be stored normally. If the storage limit is exceeded, the storage management module 350 determines the neglected content item (508) and selects it as the content item to be deleted from the client device. When an abandoned content item is selected, their name is added to the remote file table 366 (512), which causes the content to be out of sync by the content management system 110. The storage management module then deletes the selected content item from the client device 100 and replaces it with a placeholder item that has the same metadata and location but no content as the deleted content item (514). Upon completion of the process, there is sufficient storage space in the restricted folder in the storage management module to allow the original content item to be stored (516). The storage management module then activates an upload thread (518) and accesses the metadata (520) to upload the content of the stored content item to the content management system 110 (522).

  [0095] In addition to automatically deleting content items and creating placeholder items, some embodiments also provide the user with certain content that is stored only remotely in the content management system 110. Allows you to select items. This may be implemented by simply allowing the user to select from a context menu (eg, "right click") on a particular synchronized content item. The client application 200 then presents the user with the option to remote the selected content item. When the user selects that option, the content item is deleted from client device 100, the name of the content item is added to remote file table 366, and a placeholder item having the same metadata and location as the original content item is deleted. Created to represent an item. If the user subsequently desires access to the content item, the same process as shown in FIG. 5 may be used to retrieve the content item from the content management system 110.

  [0096] In some embodiments, upon reaching the storage quota 130, regardless of whether the UCSM actually selects the content item to be deleted from the client device 100, the particular user remains resident on the client device. The client device is configured to enable selecting a content item. This embodiment provides an operational improvement that allows a user to maintain quick access to certain important content items. In this embodiment, the client application 200 allows the user to access a context menu and subsequently select an option to enforce content items that remain resident on the client device 100. When selected, the name of the content item is added to the resident file table 362. The resident file table 362 is later accessed in the UCSM used by the storage management module 350, as shown at 422, and all content items in the table are excluded from the selection process. For example, if a given content item is selected for deletion, the resident file table 362 is consulted to determine if the selected content item is listed there, and if so, the selected Content items are ignored and other content items are actually selected by UCSM.

  [0097] Content related to placeholder items on client device 100 is not synchronized, which complicates content management. For example, if a user on a client device moves a content item represented as a placeholder item on a second client device, then if the second client device does not receive synchronization data for the placeholder item, The location will change on the first client device but will not change on other client devices. For example, a content item may be completely deleted from the content management system 110 by one client device 100 while being represented by a placeholder item on a different client device 100. If this situation occurs, the user of the second client device 100 may attempt to access the content item represented by the placeholder item only to find out that it is no longer present. To avoid such confusing situations, in some embodiments, the content management system 110 is configured to synchronize placeholder items only for metadata, that is, if any attributes of the placeholder items are When changed, the content management system 110 modifies all client devices 100 that have access to the content item, regardless of whether the content item is represented as a placeholder item on any of those client devices. Synchronized attributes. Therefore, when a content item is deleted from one client device, the placeholder item representing the content item is also deleted on any other client device 100. Alternatively, in some embodiments, the content item content item is stored on another client device such that its size is changed to fit within the remaining storage in the shared content storage directory 120 on the client device 100. May be downloaded to the client device 100 even if access to the content item is not required.

  [0098] Some of the embodiments described above ensure that the client application 200 does not exceed the predetermined storage quota 130 and operate to request data from the content management system 110. Represents the synchronization system with. A host-based embodiment is shown in FIG. 6, where the content management system 110 manages a constrained synchronization process, including maintaining information identifying information on remote and resident content items at each client device 100. . The host-based embodiment provides the same benefits of increasing the effective storage capacity on the client device 100, while reducing the computation required from the client device, thereby reducing the amount of computation required from other embodiments. To improve the performance of the client device 100. The constrained content management system 600 includes the elements of the content management system 110 shown in FIG. 2 and further utilizes the storage management module 350 with the necessary data files necessary for the storage management module 350 to function properly. Will be corrected as follows. Within the constrained content management system, the metadata server 212, block server 214, notification server 216, data store 218, pending block table 220, and namespace table 222 are implemented in a manner similar to that implemented in the content management system 110. Function. Further, the storage management module 350 functions in a similar manner as when resident on the client device, and operates to determine when storage space limits are exceeded and to create placeholder items appropriately. Storage management module 350 also operates to receive information from client device 100 about requests made by operating system 380. When a request is made to open one or more content items, information about the request is sent by the storage management module 350 to the remotely-monitoring content management system 110, thereby providing the placeholder item on the client device 100 with a placeholder item. The necessary downloads to provide access are made. Storage management module 350 uses client configuration file 610 to provide information about the storage configuration on each client device associated with the constrained content management system. The synchronization table 620 is a record of all content items on the client device requesting synchronization with the constrained content management system 600, some of the content items being placeholder items and metadata synchronization. Only the content items included in this table are a subset of the content items located in the data store 218 because only those items are needed. Further, in this embodiment, the synchronization table 620 includes both a resident file table 362 and a remote file table 366 configured to indicate the client device 100 where each content item is to be held or resident remotely. May be replaced by using For embodiments using the latter configuration, implementing metadata synchronization for placeholder items is easier if the placeholder items are identified directly in the remote file table 366 of each client device 100. . The user data 630 is stored on the constrained content management system 600, which allows the storage management module 350 to determine a neglected content item.

  [0099] FIG. 7 is an interaction diagram illustrating one embodiment of a process for storage synchronization with host management constraints. The application on the client device 100 requests the content item to be stored in a folder that is synchronized on the client device (700). The storage kernel extension records the request ID, the file path, and the size of the content item (702), and transfers the information to the client application 200 (704). The client application 200 transfers the size information of the content item to the storage management module 350 on the constrained content management system 600 (706). The storage management module 350 requests storage restrictions for the particular client that received the content item size from the client configuration file 610 (708). Storage management module 350 determines whether the storage limit is exceeded by comparing the size added to other content items residing on client device 100 with the storage allocation received from client configuration file 610 (712). ). The storage management module 350 requests content data on the client from the synchronization table 620 (714), so that content items to be deleted from the client can be selected from the synchronized content items on the client. The synchronization table responds with synchronized content data for the particular client (716). The storage management module 350 requests user access data from the user data 630 stored on the host device used to determine the LRA content item (718). The data is immediately received from the user data table 630 (820). Storage management module 350 determines LRA content items (722) and selects them to be removed from the client (724) to provide the required storage space. The storage management module 350 sends a request to the client application 200 to delete the content item and create a placeholder item (728). Authorization is provided to the client application 200 to complete the original request 700 to save the content item (730). Finally, the storage management module updates the user data to reflect access to the first content item to the saved content item (732), after which a new content item is available for upload. Therefore, the metadata server 212 requests synchronization of the client device 100 (734).

  [00100] FIG. 8 illustrates an example of a user interface of a client device 100 that operates in conjunction with a content management system that provides constrained synchronization. The synchronization file folder 800 operates like the shared content storage directory 120. Folder 800 contains corresponding icons 810A (.m4a music file), 810B (.xlsx spreadsheet), 810C (.docx word processing file), 810D (.mat Matlab file), and 810E (jpg image file). Contains a number of content items, which are represented. Each icon 810 is superimposed with a status icon 820 indicating the storage status of the content item.

  [00101] Status icon 820A ("check icon") indicates that the content item is currently resident on client device 100 and is synchronized with the current version of the content item maintained by content management system 110. .

  [00102] Status icon 820B indicates that the content item is resident on client device 100 upon completion of synchronization with the content management system.

  [00103] Status icon 820C indicates that the content item is a placeholder item and is not currently resident on the client device, but is still retained on content management system 110.

  [00104] Status icon 820D indicates that the content item is resident on the client device and synchronized with its version maintained by content management system 110. Additionally, a green circle with a pin icon 840 indicates that the content item has been selected to remain resident on the storage-restricted client device 800.

  [0100] FIG. 9 illustrates an alternative embodiment of constrained synchronization that predicts user access to a particular content item remotely at a client device and downloads the predicted content item prior to the access. It is a conceptual diagram. This approach provides a further improvement in the operation of the client device by almost always eliminating the user's latency in retrieving content items from the content management system 110 over the network. The storage score 900 is calculated for each content item 140 in the shared content storage directory 120. The score is a measure of the expected importance of the content item, as described below, and is calculated as a function of the time of the last access or a number of other factors that determine that the user's request is expected. Can be done. Further, each content storage directory 120 is configured with a storage score threshold specified by the user or set by a predetermined value. The predicted importance of the content item exceeds the retention score threshold 910 of the particular shared content storage directory 120 on the client device 100 having access to the content item, as measured by the retention score 900 of the same content item. Each time, the content item is downloaded to the shared content storage directory if it is remote to the client device and held in the shared content directory if it is resident on the client device.

  [0101] Step 9.1 illustrates a typical state of a content management system that predicts user access to content items. In this example, the content management system 110 manages two client devices 100A and 100B. Shared content storage directories 120A and 120B are located within each client device. Shared content storage directory 120A stores content items 140A, 140B and 140C, while shared content storage directory 120B stores content item 140D and shadow item representation 160A of content item 140A. Synchronized versions of all content items 140 are stored in content management system 110.

  [0102] Further, each content item 140 has a corresponding retention score 900, where 900A is the retention score of content item 140A and 900B is the retention score of content item 140B. Each shared content storage directory is also configured with a storage score threshold 910, where 910A is a storage score threshold for the shared content storage directory 120A and 910B is a storage score threshold for the shared content storage directory 120B.

  [0103] In step 9.1, the content item 140A is not retained in the shared content storage directory 120B. In this case, there is no content item present in the shared content storage directory 120 that has a storage score 900 lower than the storage score threshold 910, but this scenario is similar to that of the other embodiments described above or below. Could be used in addition to For example, if the storage allocation is sufficiently large, it may not be necessary to remotely maintain the file even if the storage score 900 is lower than the storage score threshold 910 because the storage allocation is still affecting.

  [0104] At step 9.2, the user of the client device 100A performs a user action 920 on the content item 140A that is considered access to the content item 140A. In this example, the storage score 900A of the content item 140A is increased from 20 to 60 because the storage score 900 is calculated as a function of the latest access time (the magnitude of this change is arbitrary for the purpose of this example). The details of calculating the storage score will be described later, but there is a possibility that the score will not be changed to the same score.)

  [0105] At step 9.3, the content management system 110 or, in some embodiments, the client application of the client 100B, may determine that the storage score 900A of the content item 140A is a shared content storage directory 120B where the content item 140A is remote. Is determined to be not less than the storage score threshold value 910B. Since the storage score 900A exceeds the storage score threshold 910B, the content item 140A is downloaded to the client device 100B and stored in the shared content storage directory 120B.

  [0106] Similar to the UCSM above, there are many conservation score calculation methods. Typically, the storage score can be normalized to the user's behavioral attributes, resulting in a different storage score for the same content item on each client device, or globalization such that the score is the same on each client device. . The advantage of the normalized preservation score lies in averaging differences in user behavior. For example, if the retention score is a function of the content item's latest access time, such that it increases as the time difference between the current time and the latest access time decreases, then compared to a content item that is shared with less active users, A more active user will boost the retention score of content items shared with that user. For a third user that is shared with both active and inactive users, recent access by the active user is higher than recent access by the inactive user if the retention score is not normalized. The saved scores will lose their prediction quality because only items from active users will have the highest saved scores, despite the low predictions of. When the storage score is normalized, it may be normalized to the attributes of a particular user or a particular content item.

  [0107] The following method is an example of a method for determining a storage score or a score that predicts user access to a content item. In addition, the preservation score may use the combination of multiple methods described below to create the most predictive measure of predicted importance. Typically, the retention score increases as the predicted importance of the content item increases, however, the opposite is also true if it is convenient for this embodiment. In this case, the corresponding storage score threshold becomes the minimum value, and when the storage score of the content item is equal to or less than the storage score threshold, the content item is downloaded to the corresponding shared content storage directory. For the purposes of this disclosure, the following presupposes an increasing conservation score as the default case.

[0108] Latest Access Scoring: In latest access scoring, the storage score of a content item is a function of the latest access time of the content item. The save score may simply be the reciprocal of the difference in seconds between the current time and the last access time:
RS = 1 / (t _C -t _A )
Here, RS is a conservation score, t _C is the current time, t _A is the latest access time.

  [0109] If normalization is required in a particular embodiment, the user's or client device's defined as the number of accesses to any shared content item by a particular user or a particular client device within a predetermined time period. Various user attributes, such as access frequency, may be used. Alternatively, the average last access time of multiple content items shared by a particular user or client device may be used.

  [0110] Access Frequency Scoring: In access frequency scoring, the storage score of a content item increases as the number of accesses to the same content item within a predetermined time period increases. To normalize access frequency scoring, the access frequency for a given content item is divided by the average access frequency for all content items on the client device or shared with the user, or vice versa. It may be enlarged.

  [0111] Location-related access scoring In location-related access scoring, the storage score of a first content item is determined by the content item's own latest access time, access frequency, or any other characteristic: A weighted combination with similar properties of additional content items stored in the same folder as the first content item. This means that access to a content item in a folder is a prediction of access to another content item in the same folder.

  [0112] Similar access scoring In similar access scoring, the storage score of the first content item is the content item's own latest access time, access frequency, and additional content having attributes similar to the first content item. A weighted combination with similar characteristics of the item. The attributes include the type, size, and location of the content item, and a user who has access to the content item. This means that an access to a similar content item is a prediction of another access to the content item.

  [0113] Criteria-based retention scoring: In criteria-based retention scoring, the retention score of a content item is based on the number of previously identified prediction criteria satisfied by the content item. For example, access to content items by other users within 24 hours, access frequency greater than 5 accesses last week, and access to sufficiently similar content items within the last 3 days are all within the next 6 hours. It may be a predetermined criterion that is predictive of attempting to access a remote content item. Accordingly, the storage score of the content item may be increased by a predetermined magnitude for each of the criteria satisfied by the content item. The increasing magnitude for satisfying a particular criterion may be proportional to the expected strength of the particular criterion.

  [0114] FIG. 10 is a diagram illustrating a system environment of a content management system that uses predicted content item importance for constrained synchronization. Most of the modules of the constrained content management system shown in FIG. 10 perform their similar or identical functions described with reference to FIG. 6, except as described above. Therefore, the functions of all the modules in the content management system 1000 will not be described in detail here.

  [0115] The content management system 1000 includes a metadata server 212, a block server 214, a notification server 216, a data store 218, a pending block table 220, a namespace table 222, a storage management module 350, a client configuration file 610, a synchronization table 620, It includes user data 630, stored score table 1010, and stored score module 1020. The client configuration file 610 and user data 630 have significant changes from the previous version shown in FIG. The client configuration file 610 is modified to include a retention score threshold for each shared content storage directory of each client device, while the user data is modified to include user data related to the retention scoring method used. Is done. Stored score module 1020 captures user data 630 and data from data store 218 to generate stored score table 1010. The storage score table is a table listing the storage scores of each content item managed by the content management system 1000. A separate stored score table may be closed for each client device if normalization is used to calculate the stored score. When the storage score of the content item is updated, the storage score module 1020 may determine whether the content item corresponding to the recently changed storage score is remote on any client devices and the storage of those client devices. The client configuration file 610 and the synchronization table 620 are consulted to determine if any of the score thresholds are exceeded. If the storage score threshold is exceeded, the storage score module causes the storage management module 350 to perform the necessary downloads and replace the displayed shadow items.

  [0116] FIG. 11 shows the software architecture of the client application 1100 for constrained synchronization according to another embodiment. In the present embodiment, while the client device is determined to be idle by the client application, all of downloading the remote content item, deleting the neglected content item, and creating the shadow file are performed. Such a change in the timing of the constrained synchronization process provides a similar increase in effective storage capacity while improving the client device by providing improvements in the embodiments described above. In order to perform these functions, the idle state that triggers this embodiment changes the system architecture shown in FIG. In this embodiment, the client application 1100 includes a synchronization module 310, a storage status module 1110, a file journal 360, a resident file table 362, shared data 364, a remote file table 366, a configuration file 368, and a block cache 370. You. The content synchronization module 310 further includes a hashing module 320, a download module 330, an upload module 340, and a storage management module 350. The storage state module 1110 further includes a calculation module 1120, a state comparison module 1130, an action module 1140, and a system state module 1150. Unless otherwise specified, all of the foregoing modules and data tables have the same functions as described above, with minor modifications as those skilled in the art will recognize in order to accommodate the new module. Optional key changes are described below.

  [0117] The system state module 1150 uses the storage kernel extension 382 to measure system activity of the operating system 380. System activity may be, but is not limited to, the number of cycles of a non-idle processor (regardless of coordination of multiple processor cores), the number of threads of the client device 100, or the number of processes as a percentage of processor frequency or other CPU utilization metrics. And can be measured using process activities. The network activity metric may also be used as a percentage of the maximum rate for a particular port or connection, including network utilization defined in bits per second or packets per second. Further, memory usage metrics, including available or free random access memory (RAM) capacity, may be used to measure system activity. The system state module 1150 may use the activity metrics described above or any other suitable activity metrics, individually or in combination, to measure activity of the entire system.

  [0118] If the measure of system activity is below a predetermined activity threshold, the system state module 1150 reports to the saved score module 1110 that the client device is currently idle. The activity threshold may be defined as a percentage of the total computing resources of the client device, as defined by the activity metric, or the activity threshold may be defined as a specific value of the activity metric. For example, an activity threshold may be defined as the state of the client device 100 using less than 25% of available processing resources. Alternatively, the activity threshold may be defined as a state where other processes of the client device 100 use less than 2 GB of total memory, or such that there is at least 4 GB of available total memory on the client device. .

  [0119] When the client device 100 is determined to be idle by the system status module 1150, the status calculation module 1120 determines the storage status of the shared content storage directory 120. Typically, the saved state comprises content items resident on the client device and a set of attributes corresponding to those content items. These attributes may include the content item's size, last access time, access frequency, directory location, or any other suitable attribute that indicates the importance of the content item for storage on the client device. Further, the storage state may be represented by a set of statistics calculated using at least one of the attributes described above.

  [0120] The comparison module 1130 receives the storage state from the state calculation module 1120, and then determines the current storage state of the shared content storage directory 120, which may be specified by the user, as defined in the configuration file 368, Is compared with the threshold storage state. The threshold storage state may be a set of criteria associated with the attribute, or may be a calculated statistic of a client device included in the storage state. The comparison module 1130 determines whether the current storage state satisfies a threshold storage state criterion. If these criteria are violated (e.g., not satisfied), the comparison module 1130 sends to the action module 1140 the content items corresponding to the attributes that violate the threshold preservation state criteria, or statistics calculated based on those attributes. Report.

  [0121] The action module 1140 receives the report from the comparison module 1130. Thereafter, an action for returning the holding state to the threshold storage state reference is determined. These actions may include removing the content items from the shared content storage directory 120 and replacing them with shadow items or replacing the shadow items representing remote content items with the content items themselves. Once those actions have been determined, the action module 1140 requests that the content synchronization module 310 complete the required actions.

  [0122] Alternatively, the idle state triggered constrained synchronization, which reduces the computational load on the client device and increases the availability of the device to other users, may be performed by the content management system itself. Good. FIG. 12 shows a system environment for completing this task. The content management system 1200 with restrictions includes a metadata server 212, a block server 214, a notification server 216, a data store 218, a pending block table 220, a namespace table 222, a storage management module 350, a client configuration file 610, a synchronization table 620, It includes user data 630, a storage state table 1210, and a storage state module 1220. Unless otherwise specified, all of the foregoing modules and data tables have the same functions as described above, with minor modifications as those skilled in the art will recognize in order to accommodate the new module. Optional key changes are described below.

  [0123] In this embodiment, the client application 200 on the client device connected to the content management system 1200 reports the status of the client device to the content management system 1200. If the client device is idle, the content management system 1200 uses the storage status module 1220 to determine the storage status of the shared content storage directory 120 on the idle client device. The storage status module then updates the storage status table 1210, which includes the current storage status of all client devices connected to the content management system 1200. Stored state module 1220 then performs the same steps as stored state module 1110, using potentially similar sub-modules, as described in the description of FIG.

  [0124] The storage state of the shared content storage directory may be determined using various methods. Typically, the saved state is criteria-based and is maintained if the client application periodically determines that the client device is idle. However, it is also possible to implement the save state and the threshold save state numerically, such that each state is represented by statistics calculated using attributes of the content item residing on the client device. If the storage state is criteria based, the threshold storage state is a set of criteria that content items in the shared content storage directory should satisfy. Further, in the case of criteria-based retention, the user may be provided with an option to select retention criteria, which allows for customization of categories of content items residing on the client device.

  [0125] The time period used to check each client device may be a predetermined value of the content management system set by the user, or determined based on usage patterns of a particular client device. Is also good. For example, if users access content items on their client devices on average every 24 hours, the time period may be set to ensure that the shared content storage directory is maintained until 24 hours have elapsed. Good.

  [0126] Instead of periodically checking the shared content directory, maintain the shared content directory only if the shared content directory satisfies a second set of criteria indicating urgency, eg, close to hardware storage limits. It may be.

  [0127] Storage space criteria: One possible set of criteria is to have criteria for storage allocation. For example, the storage quota can be set to 20 GB, but instead of operating in the same manner as in the above embodiment, the content management system will allow the content item stored in the shared content storage directory until the device is idle. It is allowed to exceed a reference value (20 GB in this example). Thereafter, a similar process of determining a neglected content item is used to delete the appropriate content item and satisfy the storage space criteria of the shared content storage directory.

  [0128] Access Time Reference The second reference may be an access time reference. For example, the criterion may be that a content item with a latest access time earlier than a predetermined time interval cannot reside in the shared content storage directory. Those content items will be allowed to remain resident in the shared content storage directory until the client device is idle. At this point, the stored state module will simply request that all content items with the latest access time prior to the predetermined time interval be deleted.

  [0129] Another set of content item size criteria is content item size criteria. In this method, a threshold is set for the size of each content item. Thus, if the device is idle, any content item above or below the threshold is excluded from resident on the client device.

  [0130] Access frequency criterion: Finally, the access frequency criterion is used to set the minimum number of accesses within a predetermined time interval required to remain resident on the client device. If a particular content item is not accessed frequently enough, it will be removed from the client device when idle.

  [0131] Note that the list of preservation criteria is not completely exhaustive. Further, these criteria may be used in combination with others to provide more complex rules.

  [0132] FIG. 13 is a flowchart illustrating a function of constrained content management triggered by an idle state. First, the system checks to determine whether a particular client device is idle (1300). This step is performed either periodically or in response to the content storage directory reaching a predetermined threshold. If the device is idle, the system determines the storage state of the client device (1310). Thereafter, the system compares the current storage state of the shared content storage directory with the storage state criteria for the shared content storage directory. If the criteria are satisfied by the current storage state of the shared content storage directory, the system performs a check (1300) again to determine if the client device is idle. If not, the system identifies (1330) the actions to be performed on the shared content storage directory that are required for the shared content storage directory to meet the saved status criteria. The system then performs those actions on the shared content storage directory to match the predetermined storage state criteria (1340).

<Synchronization of placeholder items in parallel with content items>
[0133] FIG. 14 is a block diagram illustrating a structure of the file journal 360 according to one embodiment. File journal 360 includes an entry for each content item or placeholder in the client device's shared content storage directory. The file journal includes two sections, a local file journal 1400 and an updated file journal 1410. Each journal contains metadata about a list of file items (the listed items may include the same or different items). The local file journal 1400 contains metadata for items currently resident on the client device. The metadata may include a local namespace ID, a local journal ID, a local file path, a local block list, a local extended attribute, a local size, a local change time, and a local synchronization type. Each version of an item is uniquely identified by a pair of namespace ID and journal ID. Each field of the local file journal is described below.

  [0134] Local namespace ID: A metadata value indicating the namespace associated with the item.

  [0135] Local Journal ID: A metadata value indicating a specific journal entry corresponding to the item version.

  [0136] Local file path: A metadata value indicating the location of the item in the shared content storage directory.

  [0137] Local block list: A metadata value indicating the block containing the item.

  [0138] Local Extended Attributes: Metadata values that include additional attributes for the item. These may include the last access time, creation time, or any other attributes of the item.

  [0139] Local size: A metadata value indicating the size of the item. If the item is classified as a placeholder item, the local size of the item is the size of the content represented by the placeholder item.

  [0140] Local change time: A metadata value indicating the time when the latest change to the item occurred.

  [0141] Local synchronization type: A metadata value indicating whether the item is a content item or a placeholder item.

  [0142] The update file journal 1410 is added with update metadata for items received from the content management system 110 or created by a function of the client application 200 and residing on the client device. Without an update for a particular item, there would be no update file journal entry for that item 1400. The update metadata may include an update namespace ID, an update journal ID, an update file path, an update block list, an update extended attribute, an update size, an update change time, an update synchronization type, and a force reconstruct value. Good.

  [0143] Except for forced reconfiguration values, the fields of the updated file journal entry correspond to the local file journal entry. A difference between the entry in the local file journal entry and the updated file journal entry indicates that the content item associated with the entry has been changed in some way. For example, if the update file path is different from the local file path, it indicates that the item associated with the entry (by the journal ID of the entry) has moved from the local file path to the update file path.

<Committing (adding) content items from the client device to the content management system>
[0144] FIG. 15 is a flowchart illustrating one embodiment of an algorithm for committing a content item. The content synchronization module 310 detects, at 1500, a new or changed content item in the shared content storage directory 120. The changed content item indicates that one of the attributes of the content item has been changed, including at least one of a file path (or file name), a block list, an extended attribute, a size, and a latest change time. When the content synchronization module 310 detects a change to an existing content item, as opposed to creating a new content item, at 1510, the local journal ID is a value representing the pending status of the content item for conflict resolution purposes. (Eg, zero).

  [0145] As soon as a new or changed content item is detected, the hash module 320 may, at 1520, hash the hash value of any new or changed data as a new block to recreate the block list. Calculate and determine any new or changed attributes for the content item. The block list and attributes of the new or changed content item are then committed to the content management system 110 at 1530. The client device may then at 1540 create a new entry in the local file journal 1400 that includes the new journal ID in the namespace for the new or modified version of the detected content item in the local metadata. The set is received from the content management system 110. At 1550, the client device 100 creates a new local file journal entry based on the received metadata. Based on the association in the namespace table 222, the content management system 110 communicates the update entry to the update file journal 1410 of another client device 100 associated with the new or changed content item namespace. An algorithm for managing entries in the update file journal 1410 will be described below with reference to FIG.

<Committing (adding) placeholder items from the client device to the content management system>
[0146] FIG. 16 is a flowchart illustrating one embodiment of an algorithm for committing placeholder items. The content synchronization module 310 detects 1600 a new or changed placeholder item in the shared content storage directory. The placeholder item may be a JSON dictionary or some other expression having at least two fields including a namespace ID and a journal ID. The namespace and journal ID stored in the placeholder item correspond to the local namespace ID and local journal ID of the local file journal 1400. When a placeholder item is changed or created, the corresponding local journal ID is set at 1610 to a value (eg, 0) indicating a pending state in the placeholder item for conflict resolution purposes.

  [0147] The new or changed attributes of the placeholder are determined by the content synchronization module 310 at 1620. Possible changes to the placeholder item include a change in the name of the placeholder item and a change in the file path of the placeholder item. Actions that may result in the creation of a new placeholder item may include copying the placeholder item or moving a content item from one namespace to another.

  [0148] Once the new or changed attributes are determined by the content synchronization module 310, the journal ID and namespace ID of the placeholder item are 1630 to commit the placeholder item attribute to the content management system 110. used. The client device then creates, at 1640, local metadata for creating a new entry in the local file journal 1400, including the new journal ID, on the namespace for the new or changed version of the detected placeholder item. Are received from the content management system 110. At 1650, the client device 100 creates a new local file journal entry based on the received metadata. The placeholder item itself is also updated to reflect the new journal ID. The update entry corresponding to the commit event is then communicated to other client devices 100 associated with the new or changed placeholder item namespace based on the namespace table 222 association. An algorithm for managing entries in the update file journal 1410 will be described below with reference to FIG.

<Replace content item with placeholder item on client device>
[0149] Content items that reside on the client device 100 may be marked with placeholder items. This may occur by direct user action or by the determination of the client application 200 or the content management system 110 according to one of the methods described above for determining unintended content items. FIG. 17 is a flowchart illustrating one embodiment of an algorithm for replacing a content item with a placeholder item. Once the content item has been identified by replacement with a proxy placeholder item, the content synchronization module 310 sends 1700 from the local file journal 1400 to the updated file journal 1410, except for the update sync type field, the Copy the entry. The content synchronization module 310 sets 1710 the entry's update synchronization type field to indicate the placeholder item. Subsequently, the content synchronization module indicates in the forced reconfiguration field of the update file journal entry that the content item needs to be reconfigured despite the fact that the updated version of the content item has the same attributes as the original content item. “True” shown at 310 is set.

<Replacement of placeholder items with content items on client devices>
[0150] The process for replacing a placeholder item with a content item is basically the reverse of the process for replacing a content item with a proxy placeholder item. Placeholder items representing content items on client device 100 may be marked to be restored to content items. This may occur from direct user actions or by the determination of the client application 200 or the content management system 110 according to one of the methods described above for determining unintended content items. FIG. 18 is a flowchart illustrating one embodiment of an algorithm for replacing placeholder items with content items. Once a placeholder item has been identified for restoration to a content item, the content synchronization module 310 sends 1800 the local file journal 1400 to the update file journal 1410, excluding the update synchronization type field, for the placeholder item Copy the entry. Content synchronization module 310 sets 1810 an update synchronization type field of the entry to indicate the content item. Subsequently, the forced reconfiguration field of the update file journal entry indicates that the placeholder item needs to be reconfigured despite the fact that the update entry for the placeholder item has the same attributes as the local journal entry. “True” shown in the synchronization module 310 is set.

<Update function>
[00105] FIG. 19 is a flowchart illustrating an example of an algorithm of the update function 1900 executed by the content synchronization module 310 upon receiving an update entry of the update file journal 1410. The update function 1900 is to determine what changes need to be made to resolve an updated file journal entry received from the content management system 110 or generated by the content synchronization module 310 itself. , A series of steps performed by the content synchronization module 310. An update journal is not limited to a content item that resides on a client device (directly if a new journal ID is created on that namespace based on a commit from a different client device associated with the namespace). And placeholder items that represent content items on the client device (either directly by a user action or by a decision by the client application 200 or the content management system 110). To be replaced by the content item that it represents (either by an appropriate user action or by a client application or content management system decision). It may be created in a number of situations including when it is click.

  [0151] The content management system 110 creates a new journal ID when a new content item or version of a content item is added to the namespace. When this occurs, the content management system 110 pushes metadata associated with the new content item or content item version from the metadata server 212 to the client device 100 associated with the namespace. When the transmitted metadata is received by the client device 100, the content synchronization module 310 saves the metadata as an entry in the update file journal 1410. As a result, the update synchronization type of the entry may not be included in the transmitted metadata and may instead be determined by the client application 200 according to one embodiment.

  [0152] Upon storing the metadata as an entry in the update file journal 1410, the update function 1900 compares the entry in the update file journal 1410 (representing a change or new version of the item) with the entry contained in the local file journal 1400. Perform the following steps to resolve the differences between: The update function first determines 1910 whether the update file path of the update file journal entry is equal to the local file path of any local journal entry stored on the client device 100. If there is a local journal entry with the same file path, the update function then determines at 1920 the update journal entry by determining whether the update journal ID of the update entry matches the local journal ID of the local entry. It is determined whether the item to be updated is a new version of the item placed on the client device 100. If the updated journal ID does not match the local journal ID, the content synchronization module 310 determines that a new version of the item represented by the local journal entry exists and reconstructs the item in the shared file path. Start the process. This processing will be described later in detail with reference to FIG.

  [0153] On the other hand, if the content synchronization module 310 determines in 1920 that the update journal ID is equal to the local journal ID, the content synchronization module 310 determines 1940 whether the forced reconfiguration value is true for the update entry. I do. If the forced reconfiguration value is true, the content synchronization module 310 starts a process for reconfiguring the item with the shared journal ID. This processing will be described later in detail with reference to FIG.

  [0154] If the content synchronization module 310 determines at 1940 that the forced reconfiguration value is false, then the update journal entry will be considered as a duplicate update at 1990, and further action by the client application 200 will be performed. Without, deleted.

  [0155] Returning to step 1910, the update function 1900 also determines at 1910 that the update file path is not the same as any of the local file paths of the entries stored in the local file journal 1400. In this case, the content synchronization module 310 determines at 1930 whether the update block list of the update entry matches any of the local block lists in the local file journal 1400. If the update block list is unique, then the update function 1900 determines that the update entry indicates a new item and configures the update item as a new item according to the process described in detail below with reference to FIG. judge.

  [0156] If the content synchronization module 310 determines at 1930 that the updated block list matches the local block list of the local file journal 1400, then the content synchronization module has, at 1950, the updated journal ID has a matching block list. It is determined whether it matches the local journal ID of the local entry. If the journal IDs do not match, then the content synchronization module 310 reconstructs the item using the shared block list. This processing will be described later in detail with reference to FIG.

  [0157] On the other hand, if the content synchronization system determines in 1950 that the update journal ID matches the local journal ID from the local journal entry having the matching block list, as a result, the update function 1900 returns to step 1940 and Proceed as you did.

<Reconfiguration of items in shared file path>
[0158] FIG. 20 is a flowchart illustrating one embodiment of an algorithm for reconstructing items in a shared file path. The algorithm described by FIG. 20 occurs as a result of the negative determination of step 1920 of the update function 1900. Reconstructing an item in a shared file path may result in the content item being converted to a placeholder item when a new version of the content item is uploaded to the content management system 110 or when the content item remains on the same file path. Occurs if it is done or vice versa. The first step of the algorithm is to determine, at 2000, whether the local journal ID of the local file journal entry with the shared file path is pending, indicating that the content item corresponding to the local entry is currently being edited. judge. If the corresponding local journal ID is pending, the system receives the new local journal ID from the content management system 110 until the further modification to the content item is completed at 2005, if any. Wait until. Upon receiving the new journal ID, at 2010, the updated change time of the update entry is compared to the new local change time of the local entry to determine which changes have been made more recently. At 2015, the conflict is resolved based on the comparison of the modification times and the specific edits made to the item. During conflict resolution, if the same blocks listed in the updated block list are still relevant, they will be downloaded and stored in the shared file path. If the conflict resolution process results in an item that is different from the final product of the local or updated change, the result is that the item is hashed again and a new block list is generated through FIG. . If a local change to the item takes precedence over a remote change (represented by an update entry), then the update entry may be discarded.

  [0159] Returning to step 2000, the content synchronization module 310 determines in 2000 that the local journal ID of the local entry having the shared file path is not pending, so that the item corresponding to the entry is currently edited. Indicates that it has not been done. Based on the determination, the content synchronization module 310 determines, at 2020, whether the updated synchronization type is set to “placeholder item” or “content item”. If the update synchronization type indicates "content item", then the content synchronization module 310 performs a check at 2030 to determine whether the updated block list is equal to the local block list of the local journal entry having the shared file path. . If the two block lists are equal, the content synchronization module 310 does not need to download additional blocks from the content management system 110, but instead simply deletes the local journal entry before deleting the update journal entry from the update file journal 1410. Simply replace the attribute of the update journal entry with the attribute of the update journal entry.

  [0160] If it is determined at 2030 that the two block lists are different, the content synchronization module 310 receives an update block requesting a block of the update block list from the content management system 110 at 2045, and the content synchronization module 310 310, at 2050, creates an updated content item in the shared file path based on the received block. Finally, the local journal entry is replaced at 2055 with the updated journal entry before the updated entry is deleted from the updated file journal 1410.

  [0161] Returning to step 2020, if the content synchronization module 310 determines in 2020 that the item is an update synchronization type indicating that it should be a "placeholder item", then the content synchronization module 310 In the shared file path, the local synchronization type of the item is determined. If the local sync type indicates that the item is already a placeholder item, at 2035 an updated placeholder item is created in the shared file path to replace the original placeholder item. The updated placeholder item includes metadata about the updated namespace ID and journal ID. After creating the updated placeholder item at 2035, the local journal entry is replaced at 2055 with the updated journal entry and the updated journal entry is deleted from the updated file journal 1410.

  [0162] Returning to step 2025, if the content synchronization module 310 determines that the local synchronization type is "content item", i.e., represents a content item, the content synchronization system, at 2040, retrieves the content item in the shared file path Replace with a placeholder item having the updated namespace and journal ID pair. After the content item has been replaced with the placeholder item at 2040, the content synchronization module 310 replaces the local journal entry with the updated journal entry and deletes the updated journal entry from the updated file journal 1410 at 2055.

<Reorganization of items in the shared block list>
[0163] FIG. 21 is a flowchart illustrating one embodiment of an algorithm for reconstructing items in a shared block list. The algorithm of FIG. 21 occurs as a result of a negative determination in step 1950 of the update function 1900. If the item is located at a different file path in the shared block list, but has the same block list as the updated block list, the content synchronization module 310 reconstructs the item with the shared block list. This situation occurs when an item moves from one file path to another.

  [0164] First, the content synchronization module 310 determines at 2100 whether the local journal ID is pending. If the local journal ID is pending, the content synchronization module 310 proceeds to the conflict resolution step described above (see 2105, 2110, 2115 in FIG. 21 and 2005, 2010, 2015 in FIG. 20). As a result of the conflict resolution, the content item corresponding to the local journal entry having the shared block list may be moved to an updated file path, may be moved to a new file path, or the item may be moved to a new file path. The content may be changed at the same time as the content is moved to.

  [0165] If it is determined that the local journal ID is not pending at 2100, then, at 2120, the content synchronization module 310 determines the update synchronization type of the update entry at 2120. If the update sync type indicates that the update item is to be a "content item", then the content item with the shared block list is at 2125 from the local file path to the update file path indicated in the update journal entry. Be moved. The content synchronization module 310 then replaces the local journal entry with the updated journal entry at 2130 and deletes the updated journal entry from the updated file journal 1410.

  [0166] Returning to step 2120, if the content synchronization module 310 determines at 2120 that the update item is an update synchronization type that specifies a "placeholder item", then the content synchronization module 310 Judge as the local synchronization type. If the local sync type is "content item", then the content item corresponding to the local entry and having a shared block list is replaced at 2140 with a placeholder item having an updated namespace ID and a journal ID. . The placeholder item is then moved to the location indicated by the update file path. Upon replacing the content item with the placeholder item, the content synchronization module 310 replaces the local journal entry with the updated journal entry at 2130 and deletes the updated journal entry from the updated file journal 1410.

  [0167] If the local sync type is determined to be a "placeholder item" at 2135, the local placeholder item having the local namespace ID and journal ID pair is updated at 2145 with the updated namespace ID and journal ID. Is replaced with an updated placeholder item having a pair of The content synchronization module then saves the updated placeholder item to the updated file path. After replacing the local placeholder item with the updated placeholder item at 2145 and relocating the placeholder item to a new file path, the content synchronization module 310 replaces the local journal entry with the updated journal entry at 2130 and updates the updated file. The updated journal entry is deleted from the journal 1410.

<Composed update items as new items>
[0168] FIG. 22 is a flowchart illustrating one embodiment of an algorithm for configuring an updated item as a new item. The algorithm of FIG. 22 occurs as a result of a negative determination in step 1930 of the update function 1900. If the entry in the local file journal 1400 does not have a local file path or block list that matches the updated file path or updated block list of the updated entry, the content synchronization module 310 configures the updated item as a new item. .

  [0169] When configuring a new item, the content synchronization module 310 first determines, at 2200, the update synchronization type for the updated item. If the update synchronization type is for a placeholder item, the content synchronization module 310 determines 2220 the update entry to create a placeholder item having an update namespace ID and update journal ID pair in the update file path. Is then copied to the local file journal 1400 at 2215, and the update entry is deleted from the update file journal 1410.

  [0170] If the content synchronization module 310 determines at 2200 that the update item is an update synchronization type indicating that it is a content item, then the content synchronization module 310 updates the content management system 110 from the content management system 110 at 2205. Request the block specified by the block list. Upon receiving the requested block, the content synchronization module 310 creates, at 2210, the updated content item in the updated file path using the requested block. As soon as the content item is created, the update entry is then copied 2215 to the local file journal 1400 and the update entry is deleted from the update file journal 1410.

<Reorganization of item with shared journal ID>
[0171] FIG. 23 is a flowchart illustrating one embodiment of an algorithm for reconstructing an item with a shared journal ID. The algorithm described by FIG. 23 occurs as a result of a positive determination in step 1940 of the update function 1900. When the forced reconfiguration value is identified as “true”, the item is reconfigured with the shared journal ID. This means that the item in the shared content storage directory has been converted from a content item to a placeholder item, or vice versa, when the update journal entry was created by the content synchronization module 310 itself. .

  [0172] First, at 2300, the content synchronization module 310 determines the update synchronization type indicated by the update entry. If the update synchronization type indicates a placeholder item, the content synchronization module 310 converts the content item corresponding to the local journal entry having the shared journal ID into a placeholder item that includes the shared namespace ID and journal ID pair at 2320. replace. After replacing the content item with a placeholder item at 2320, the local entry in the local file journal 1400 is then replaced at 2315 with an update entry, and the update entry is deleted from the update file journal 1410.

  [0173] If the content synchronization module 310 determines at 2300 that the update synchronization type indicates a content item, then at 2305, the content synchronization module 310 requests a block of the updated block list from the content management system 110. Upon receiving the requested block, the content synchronization module 310 replaces 2310 the placeholder item corresponding to the local journal with the shared journal ID with a content item created from the requested block. After replacing the placeholder item with the content item at 2320, the local entry in the local file journal 1400 is then replaced at 2315 with the updated entry, and the updated entry is deleted from the updated file journal 1410.

  [0174] The foregoing description of embodiments of the invention has been presented for purposes of illustration; it is not intended to be exhaustive or to limit the invention to the same forms disclosed herein. Those skilled in the art will appreciate that various modifications and variations are possible in light of the above disclosure.

  [0175] Portions of the description describe embodiments of the present invention relating to the manipulation of algorithms and symbolic representations in information. The descriptions and expressions relating to these algorithms are commonly used by those skilled in the data processing arts to effectively convey the substance to others skilled in the art. While described functionally, computationally, or logically, it is understood that these operations should be implemented by computer programs, equivalent electrical circuits, or microcode, or the like. Furthermore, it has also proven convenient, without loss of generality, to refer to variants of these operations as modules. The described operations and their associated modules may be embodied in software, firmware, hardware, or any combination thereof.

  [0176] Any of the steps, operations, or processes described herein may be performed or implemented in one or more hardware or software modules, alone or in combination with other devices. In one embodiment, the software modules may also be implemented on a computer program product comprising a computer readable medium containing computer program code that can be executed by a computer processor that performs any or all of the described steps, operations, or processes. Good.

  [0177] Embodiments of the present invention also relate to an apparatus for performing the operations herein. The apparatus may be specially configured for the required purpose, and / or may include a general-purpose computing device selectively activated or reconfigured by a computer program stored on the computer. Such computer programs may be stored on non-transitory, tangible computer readable storage media, or any other type of media suitable for storing electronic instructions that can be coupled to a computer system bus. Further, any of the computing systems referred to herein may include a single processor, or may be an architecture that employs multiple processor designs to increase computing performance.

  [0178] Embodiments of the invention may also relate to products produced by the computing processes described herein. Such products may include information resulting from a computational process in which the information is stored on a non-transitory, tangible, computer-readable storage medium, and may include any of the computer program products or other combinations of data described herein. Can be included.

  [0179] Finally, the terms used in the specification have been selected primarily for readability and explanation purposes, and have been selected to outline or limit the subject matter of the present invention. Not something. Therefore, it is intended that the scope of the invention not be limited by this detailed description, but rather by any claims published in this application based on this description. Accordingly, the disclosure of embodiments of the invention is intended to be illustrative, and not limiting, of the scope of the invention, which is set forth in the following claims.

Claims (40)

The method
Storing a local file journal on a client device, wherein the local file journal includes a plurality of local entries, each of the plurality of local entries corresponding to a sync item on the client device; and A local journal ID of the sync item, a local block list of the sync item, and a plurality of local attributes of the sync item, each sync item having a content item or Corresponding to shadow items,
Receiving, by the client device, an update entry from a content management system, the update entry comprising: an update namespace ID of the content item; an update journal ID of the content item; an update block list of the content item; Including a plurality of update attributes of the content item and an update synchronization type of the content item;
Comparing the received update entry with the plurality of local entries in the local file journal to identify a shadow item on the client device representing the content item stored in the content management system, The shadow item does not include the content data of the represented content item, and includes at least the namespace ID of the represented content item and the journal ID of the represented content item;
Updating the identified shadow item by replacing the namespace ID of the shadow item with the updated namespace ID and replacing the journal ID of the shadow item with the updated journal ID;
Replacing the local entry corresponding to the shadow item with the update entry. The method of claim 1, further comprising:
Determining that the shadow item is to be replaced with the represented content item based on a comparison identifying the difference between the updated block list and the block list of the identified shadow item;
Downloading a block indicated by the updated block list of the content item from the content management system;
At the client device, replacing the shadow item with the represented content item including the downloaded block. The method of claim 1, further comprising:
Determining that the shadow item is to be replaced with the represented content item based on a forced reconfiguration value associated with the update entry;
Downloading a block indicated by the updated block list of the content item from the content management system;
At the client device, replacing the shadow item with the represented content item including the downloaded block. The method of claim 1, wherein
The update entry includes an update file path, each of the plurality of local entries includes a local file path,
Comparing the received update entry with the plurality of local entries further comprises comparing the update file path with the local file path of each of the plurality of local entries. And how. The method of claim 4, further comprising:
Determining that the shadow item is to be replaced with a new file path based on the comparison;
Relocating the shadow item on the client device to a location identified by the update file path. The method of claim 1, further comprising:
Determining, based on the comparison, that the shadow item is pending based on a change by a user of the client device;
Performing conflict resolution based on an update change time included in the update entry and a change time included in the shadow item. The method of claim 6, further comprising:
Committing the change by the user of the client device to the content management system in response to determining that the change time of the shadow item is later than the update change time. A non-transitory computer-readable storage medium storing instructions that, when executed by a client device, causes the client device to perform an operation, the operation comprising:
Receiving, by the client device, an update entry from a content management system, the update entry including an update namespace ID, an update journal ID, an update block list, a plurality of update attributes, and an update synchronization type. Including,
Comparing the received update entry with a plurality of local entries, each of the plurality of local entries having a local namespace ID, a local journal ID, a local block list, and a plurality of local attributes; The local entry corresponds to a content item or shadow item on the client device;
Identifying a shadow item on the client device based on the comparison, wherein the shadow item represents a content item stored on the content management system, wherein the shadow item is the represented content item Including at least the namespace ID of the represented content item and the journal ID of the represented content item, without including the content data of
Updating the identified shadow item by replacing the namespace ID of the shadow item with the updated namespace ID and replacing the journal ID of the shadow item with the updated journal ID;
Replacing the local entry corresponding to the shadow item with the update entry. 9. The non-transitory computer readable storage medium of claim 8, further comprising:
Determining, based on the comparison, that the shadow item is to be replaced with the represented content item;
Downloading a block specified by the updated block list from the content management system;
At the client device, replacing the shadow item with the represented content item including the downloaded block. A non-transitory computer-readable storage medium according to claim 9, wherein
The non-transitory computer-readable storage medium, wherein the determination that the shadow item is to be replaced with the represented content item is made based on a forced reconfiguration value associated with the update entry. . A non-transitory computer readable storage medium according to claim 8, wherein:
The update entry includes an update file path and each of the plurality of local entries including a local file path;
Comparing the received update entry with the plurality of local entries further comprises comparing the update file path with the local file path of each of the plurality of local entries. Non-transitory computer-readable storage medium. The non-transitory computer readable storage medium of claim 11, further comprising:
Determining that the shadow item is to be replaced with a new file path based on the comparison;
Relocating the shadow item on the client device to a location identified by the update file path. 9. The non-transitory computer readable storage medium of claim 8, further comprising:
Determining, based on the comparison, that the shadow item is pending based on a change by a user of the client device;
A non-transitory computer-readable storage medium, comprising: performing conflict resolution based on an update change time included in the update entry and a change time included in the shadow item. 14. The non-transitory computer readable storage medium of claim 13, further comprising:
Committing the change by the user of the client device to the content management system in response to determining that the change time of the shadow item is later than the update change time. Computer readable storage medium. The system
A processor,
A non-transitory computer-readable storage medium storing instructions, wherein when executed by the processor, the processor:
Receiving, by a client device, an update entry from a content management system, the update entry including an update namespace ID, an update journal ID, an update block list, a plurality of update attributes, and an update synchronization type. , That,
Comparing the received update entry with a plurality of local entries, each of the plurality of local entries having a local namespace ID, a local journal ID, a local block list, and a plurality of local attributes; The local entry corresponds to a content item or shadow item on the client device;
Identifying a shadow item on the client device based on the comparison, wherein the shadow item represents a content item stored on the content management system, wherein the shadow item is the represented content item Including at least the namespace ID of the represented content item and the journal ID of the represented content item, without including the content data of
Updating the identified shadow item by replacing the namespace ID of the shadow item with the updated namespace ID and replacing the journal ID of the shadow item with the updated journal ID;
Replacing said local entry corresponding to said shadow item with said update entry. The system according to claim 15, further comprising:
Determining, based on the comparison, that the shadow item is to be replaced with the represented content item;
Downloading a block specified by the updated block list from the content management system;
At the client device, replacing the shadow item with the represented content item including the downloaded block. 17. The system according to claim 16, wherein
The system of claim 11, wherein the determination that the shadow item is to be replaced with the represented content item is made based on a forced reconfiguration value associated with the update entry. The system according to claim 15, wherein
The update entry includes an update file path and each of the plurality of local entries including a local file path;
Comparing the received update entry with the plurality of local entries further comprises comparing the update file path with the local file path of each of the plurality of local entries. And the system. 19. The system of claim 18, further comprising:
Determining that the shadow item is to be replaced with a new file path based on the comparison;
Relocating the shadow item on the client device to a location identified by the update file path. The system according to claim 15, further comprising:
Determining, based on the comparison, that the shadow item is pending based on a change by a user of the client device;
Performing conflict resolution based on an update change time included in the update entry and a change time included in the shadow item. The method
Storing, by the client device, a plurality of synchronization items, including placeholder items and content items;
Storing, by the client device, a local file journal including a plurality of local entries, each local entry representing one of a plurality of synchronization items, each local entry being a local journal ID of the synchronization item, Including a local block list for the item, a plurality of local attributes of the synchronization item, and a local synchronization type, wherein the local synchronization type indicates whether the synchronization item is a placeholder item or a content item;
Receiving, by the client device, an update entry from a content management system, wherein the update entry represents a new version of a synchronization item of the plurality of synchronization items, and updating the synchronization item. Including a journal ID, an update block list of the certain synchronization item, a plurality of update attributes of the certain synchronization item, and an update synchronization type;
Comparing the received update entry with the plurality of local entries to identify a corresponding local entry from the plurality of local entries;
Determining that the certain synchronization item represented by the corresponding local entry is a placeholder item based on the local synchronization type of the corresponding local entry;
According to the update synchronization type indicating that the new version of the certain synchronization item is a content item,
Downloading blocks for the new version of the certain synchronization item indicated by the updated block list from the content management system to the client device;
At the client device, replacing the placeholder item with a new content item including the downloaded block;
In the local file journal, replacing the corresponding local entry for the certain synchronization item with the update entry for the synchronization item. 22. The method according to claim 21, wherein
Comparing the received update entry with the plurality of local entries further comprises:
Comparing the local journal ID, the local block list, and the plurality of local attributes from the plurality of local entries with the update journal ID, the updated block list, and the plurality of update attributes of the update entry; Comparing the received update entry with the plurality of local entries. 22. The method according to claim 21, wherein
Determining that the certain synchronization item represented by the corresponding local entry is a placeholder item based on the local synchronization type of the corresponding local entry,
Determining whether the local journal ID of the corresponding local entry indicates a pending state for the certain synchronization item;
Receiving a new local journal ID for the corresponding local entry from the content management system and an associated local change time;
Comparing the local change time with an update change time associated with the update entry;
Resolving a conflict between the new version of the certain synchronization item represented by the update entry and the certain synchronization item represented by the corresponding local entry. 22. The method according to claim 21, wherein
Comparing the received update entry with the plurality of local entries is completed using an update function,
The update function,
Comparing an update file path of the certain synchronization item with a local file path of each of the plurality of local entries;
Comparing the update journal ID of the certain synchronization item with the local journal ID of each of the plurality of local entries;
Comparing an updated block list for the certain synchronization item with the local block list of each of the plurality of local entries;
Determining whether a forced reconfiguration value associated with the update entry indicates that the synchronization item is to be reconfigured. 22. The method of claim 21, further comprising:
Receiving a forced reconfiguration value of the update entry from the content management system;
Determining that the forced reconfiguration value indicates that the certain synchronization item is to be reconfigured;
Determining that the new version of the certain sync item is a content item based on the update sync type;
Downloading a block of the new version of the certain synchronization item indicated by the update block list from the content management system;
Replacing the certain synchronization item with a new content item including the downloaded block;
Replacing the corresponding local entry with the update entry. The method according to claim 25, wherein
The update entry indicates that the update journal ID matches the local journal ID, the update block list matches the local block list, and the plurality of update attributes match the plurality of local attributes. Regardless of the comparison with the corresponding local entry, the forced reconfiguration value indicates that the certain synchronization item is to be reconfigured. The method according to claim 26, wherein
The plurality of update attributes for the certain sync item include an update file path for the certain sync item;
The method of claim 2, wherein the plurality of local attributes include a local file path for the certain synchronization item on the client device. The method
Storing, by the client device, a plurality of synchronization items, including placeholder items and content items;
Storing, by the client device, a local file journal including a plurality of local entries, each local entry representing one of a plurality of synchronization items, each local entry being a local journal ID of the synchronization item, Including a local block list for the item, a plurality of local attributes of the synchronization item, and a local synchronization type, wherein the local synchronization type indicates whether the synchronization item is a placeholder item or a content item;
Receiving, by the client device, an update entry from a content management system, wherein the update entry represents a new version of a synchronization item of the stored synchronization items; Including an update journal ID, an update block list of the certain synchronization item, a plurality of update attributes of the certain synchronization item, and an update synchronization type;
Comparing the received update entry with the plurality of local entries to identify a corresponding local entry from the plurality of local entries;
Determining that the certain sync item represented by the corresponding local entry is a content item based on the local sync type of the corresponding local entry;
According to the update synchronization type indicating that the new version of the certain synchronization item is a placeholder item,
At the client device, replacing the content item with a new placeholder item;
Replacing the corresponding local entry with the update entry in the local file journal. 29. The method according to claim 28, wherein
Comparing the received update entry with the plurality of local entries further comprises:
Comparing the local journal ID, the local block list, and the plurality of local attributes from the plurality of local entries with the update journal ID, the updated block list, and the plurality of update attributes of the update entry; Comparing the received update entry with the plurality of local entries. 29. The method according to claim 28, wherein
Determining that the certain synchronization item represented by the corresponding local entry is a placeholder item based on the local synchronization type of the corresponding local entry,
Determining whether the local journal ID of the corresponding local entry indicates a pending state for the certain synchronization item;
Receiving a new local journal ID for the corresponding local entry from the content management system and an associated local change time;
Comparing the local change time with an update change time associated with the update entry;
Resolving a conflict between the new version of the certain synchronization item represented by the update entry and the certain synchronization item represented by the corresponding local entry. 29. The method according to claim 28, wherein
Comparing the received update entry with the plurality of local entries is completed using an update function. 29. The method of claim 28, further comprising:
Receiving the update entry from the content management system, the update entry including a forced reconfiguration value,
In response to the forced reconfiguration value indicating that the certain synchronization item is to be reconfigured,
Determining that the new version of the certain sync item is a placeholder item based on the update sync type;
Replacing the content item with a new placeholder item;
Replacing the corresponding local entry with the update entry. The method according to claim 32, wherein
The update entry indicates that the update journal ID matches the local journal ID, the update block list matches the local block list, and the plurality of update attributes match the plurality of local attributes. Regardless of the comparison with the corresponding local entry, the forced reconfiguration value indicates that the certain synchronization item is to be reconfigured. 34. The method of claim 33,
The plurality of update attributes for the certain sync item include an update file path for the certain sync item;
The method of claim 2, wherein the plurality of local attributes include a local file path for the certain synchronization item on the client device. The method
Storing, by the client device, a plurality of synchronization items, including placeholder items and content items;
Storing, by the client device, a local file journal including a plurality of local entries, each local entry representing one of a plurality of synchronization items, each local entry being a local journal ID of the synchronization item, Including a local block list for the item, a plurality of local attributes of the synchronization item, and a local synchronization type, wherein the local synchronization type indicates whether the synchronization item is a placeholder item or a content item;
Receiving, by the client device, an update entry from a content management system, wherein the update entry represents a new version of a synchronization item of the stored synchronization items; Including an update journal ID, an update block list of the certain synchronization item, a plurality of update attributes of the certain synchronization item, and an update synchronization type;
Comparing the received update entry with the plurality of local entries to identify a corresponding local entry from the plurality of local entries;
Determining that the certain synchronization item represented by the corresponding local entry is a placeholder item based on the local synchronization type of the corresponding local entry;
According to the update synchronization type indicating that the new version of the certain synchronization item is a placeholder item,
Changing the attribute of the placeholder item represented by the corresponding local entry according to the update entry;
In the local file journal, replacing the corresponding local entry for the certain synchronization item with the update entry for the synchronization item. The method according to claim 35, wherein
The method of claim 2, wherein the plurality of update attributes include an update file path, and the plurality of local attributes include a local file path. 37. The method of claim 36, wherein
Changing the attribute of the placeholder item represented by the corresponding local entry according to the update entry comprises changing a file path of the placeholder item based on the update file path of the update entry. The method further comprising: The method according to claim 35, wherein
Changing the attribute of the placeholder item represented by the corresponding local entry according to the update entry further comprises changing the local journal ID of the corresponding local entry according to the update journal ID. A method characterized by the following. The method according to claim 35, wherein
Modifying the attribute of the placeholder item represented by the corresponding local entry according to the update entry further comprises modifying the local block list of the local entry according to the update block list. And how. The method according to claim 35, wherein
Changing the attribute of the placeholder item represented by the corresponding local entry according to the update entry comprises changing a change time associated with the local entry according to a change time associated with the update entry. The method further comprising: