KR101045540B1 - Method and system for data synchronization - Google Patents

Abstract

PURPOSE: A method and system for synchronizing data are provided to divide data into a block unit and synchronize only data of a data block which is damaged, deformed, and established, thereby simplifying synchronization of data of a large amount. CONSTITUTION: A data divider(210) disunites data into the same size of a block unit. A data converter(220) uses a hash algorithm to convert content of data which is divided into the block data into a encoded unique key. A terminal includes a data division part, a data conversion unit, and a table generating unit.

Description

Data Synchronization System and Method {METHOD AND SYSTEM FOR DATA SYNCHRONIZATION}

The present invention relates to a data synchronization system and method, and to an ultra-fast file synchronization system and method using an encryption algorithm in a network environment.

In general, data synchronization refers to a technique for matching the contents of specific data distributed over two or more logical devices (ie, computers) present on a network.

Conventional synchronization techniques use relatively simple logic. Compare the date of change of data or the size of data, and if this information is wrong, synchronize the whole data.

However, in the prior art, when the data is large in size (for example, voice, video data, or database file, etc.), the time burden is large because the entire data must be transmitted or copied. In addition, the second problem is that if some of the data is damaged (for example, by changing the contents of the data without changing the size or modified date of the data due to an intelligent virus, etc.), there is a fatal problem that synchronization is not possible. have.

Accordingly, an object of the present invention is to simplify synchronization of a large amount of data to reduce synchronization time, and when a part of data is damaged, only the damaged part of data can be synchronized effectively, and data integrity services can be provided. The present invention provides a data synchronization system and method for simplifying maintenance.

In order to achieve the above object, the present invention provides a data partitioning unit for dividing data into block units, a data conversion unit for converting the actual content of the blocked data into an encrypted unique key, and a unique key of the converted data. A server including a storage unit storing a unique key generation file used for generating a unique key and storing the data in a server index table structure, and generating and storing the data, and receiving a unique key generation file from the server It includes a terminal for generating a terminal index table, and provides a data synchronization system characterized in that to perform data synchronization through comparison between the server index table and the terminal index table.

The terminal comprises a terminal data partition unit for separating the generated and stored data in block units, a data converter for converting the actual content of the blocked data into an encrypted unique key using a unique key generation file provided from the server; And a table generator for converting the converted data in the form of the unique key into the terminal index table structure.

The data dividing unit divides the data provided from the terminal into blocks of the same size, and the data converting unit generates a unique key using the blocked data using a hash algorithm.

The comparison between the server index table and the terminal index table may be performed in the terminal or the server or in a separate comparison terminal or comparison server.

In order to achieve the above object, a terminal data partitioning unit for generating and storing data according to the present invention, separating the data into blocks, and a terminal data converting unit for converting the actual contents of the blocked data into an encrypted unique key; Storing a unique key of the converted data in a terminal index table structure, comparing a storage unit storing a unique key generation file used for generating the unique key with the terminal index table and a server index table. At least one terminal including a comparator for synchronizing the generated data block, and a server for generating a unique key through information provided from the terminal data partitioning unit or the terminal data converting unit or storing the unique key as the server index table. A data synchronization system is provided.

When the server receives data in block units from the terminal data partitioning unit, the server converts the server data into an encrypted unique key and stores the server storing the unique key of the converted data as a server index table file. And a server, when the server receives an index table in the form of a unique key from the terminal data converter, the server stores the index table as a server index table file.

Receiving data from the terminal for generating data according to the present invention to achieve the above object; Blocking the received data, generating a unique key from a data block through a unique key generation file, and storing the received data in the form of a server index table; Transmitting the unique key generation file to the terminal to block data stored in the terminal, and generating a unique key to form a terminal index table; Comparing the server index table with the terminal index table; And determining that the data in the corresponding block is identical when the indexes are the same, and determining that the data in the corresponding block is not the same when the indexes are not identical.

Generating the unique key and storing the data in the form of a server index table may include separating the provided data into a plurality of blocks, and blocking the data blocks divided into blocks using the unique key generation file. And generating the actual content of the data as a unique key, and storing the unique key in the form of a server index table.

And before transmitting the unique key generation file to the terminal, receiving a data synchronization request from the terminal.

In the data synchronization method between the server and the terminal, the terminal and the terminal or the server and the server according to the present invention in order to achieve the above object, the first data is blocked, and the block data is indexed using an encryption technique to the first Forming an index table; Receiving second data information; Comparing the stored first data with total information of the second data; Blocking the second data information and indexing using an encryption technique to form a second index table; Comparing the first and third index tables; And if there is no difference, the synchronization is recognized by the same data, and if there is a difference, it is determined whether it is a part, whole or new, and in case of a part, only the data packet of the corresponding part is synchronized, If the entire data is synchronized, and if the new data synchronization method, characterized in that it comprises the step of synchronizing the new portion or the whole.

As described above, the present invention divides data into units of blocks, makes the actual contents of the data of units of blocks into unique keys, stores them as index tables, and compares index tables between servers and terminals or between terminals and terminals. By identifying damaged, modified, or newly created data blocks, only the data in those blocks can be synchronized, simplifying large data synchronization and reducing synchronization time. In addition, when a part of the data is damaged, it is possible to effectively synchronize only the data of the damaged part, to provide a data integrity service, and to simplify the maintenance of the data.

Hereinafter, with reference to the accompanying drawings will be described an embodiment of the present invention in more detail. However, the present invention is not limited to the embodiments disclosed below, but may be implemented in various forms, and only the embodiments of the present invention make the disclosure of the present invention complete and the scope of the invention to those skilled in the art. It is provided to inform you completely. Like numbers refer to like elements in the figures.

Recently, due to the rapid increase in the amount of data, it is difficult to synchronize the entire data (for example, backup). In this embodiment, the data is divided into a plurality of blocks, a unique key is produced from the actual contents of the divided data block, and a system for quickly and effectively synchronizing data is provided by comparing the unique keys. .

1 is a block diagram of a data synchronization system according to an embodiment of the present invention. 2 is a conceptual diagram illustrating an operation of a server according to an embodiment of the present invention. 3 is a diagram illustrating a data and index management structure stored in a server according to an embodiment of the present invention.

Referring to FIG. 1, the data synchronization system according to the present embodiment includes a terminal 100 generating data and a server 200 dividing the data of the terminal 100 into a plurality of blocks and storing them as encrypted block data. ).

In the present embodiment, the actual content of the file is blocked to a certain size by using an encryption technique. In addition, it has a structure that is converted into unique encrypted data that can represent this block and stored in the index table. The data can be synchronized by comparing these index tables.

The server 200 includes a data partitioning unit 210 for separating data provided from a terminal in block units, a data converter 220 for converting the actual content of the blocked data into an encrypted unique key, and the unique key form. The storage unit 230 stores the converted data in an index table structure and stores a unique key generation file used for generating the unique key.

In this case, when the server 200 receives the blocked data from the terminal 100, the server 200 automatically blocks the data even though the encrypted unique key is not received. Automatically generate it with an encrypted unique key. This means that the terminal 100 is provided with the data dividing unit and the data converting unit, and also stores the unique key generation file. That is, through this, the terminal 100 may transmit not only the corresponding data but also the index table including the data in which the data is blocked and the encrypted unique key to the server 200.

Since the structure of the index table storage unit 230 storing the encrypted unique key generated by the server 200 has only the encrypted unique key and location information of the block of the corresponding data, the terminal 100 has minimal information. ) Can quickly compare the integrity of the data for each block requested by.

As shown in FIG. 2, the data dividing unit 210 separates the data Data1 provided from the terminal 100 into blocks having the same size (size). That is, as shown in the figure, if the size of the initial data Data1 is 100, and these are divided into four blocks, the size of one block is 25. Here, the size and number of blocks may vary in accordance with the size of the provided data Data1. Here, the block size can be 500 kilobytes to 500 megabytes. In this case, when the size is smaller than the size, the data throughput is increased. When the size is larger than the range, the data comparison time is long. In FIG. 3, data of 1 gigabyte in size is blocked in units of 1 megabyte.

The data converter 220 generates a unique key using the data blocked using a hash algorithm. At this time, the data conversion unit 220 makes the actual content of the data blocked through a separate unique key generation file as a unique key. That is, the data converter 220 converts the blocked data into unique encrypted data that can represent the blocked data using the blocked data, and stores the data in an index table. In this case, the blocked data may be compressed. That is, as shown in FIG. 3, a fixed-size index file is generated according to the value of the data file and stored in a table form. For example, the data file of the first block is "0100110101100111". When the data file is changed using a hash algorithm, the data file is "BA220CBD4426" having the above information.

The index table of the present embodiment is a file (i.e., an index file) that stores the actual contents of all data recorded by the server 200 in a fixed size, generates it as a unique key, and stores it. simple. The file (that is, the index file) contains only the unique block-specific keys sequentially described. In addition, since the present invention has to periodically compare the current time stamp of the file in order to detect a file that has been modulated after the file-change detection due to a problem (data update, addition, etc.) that is difficult to completely process the data block. A structure was needed. However, in the present embodiment, only the order of configuring the unique encryption key and encryption key can distinguish the other parts of the data stored in the terminal and the server by transmitting only this index table when the integrity of the data and the terminal 100 request.

Such a simple structure improves the speed of block comparison of data internally, and even when a plurality of terminals 100 simultaneously request index table data from the server 200, the terminal does not directly compare the data inside the server 200. Since it is possible to compare stars, there is an advantage that the load of the server 100 can be minimized.

The storage unit 230 stores a unique key generation file for generating a unique key. Here, the unique key generation file may be stored as a unique file for each data provided from the terminal 100. Of course, the present invention is not limited thereto, and the data provided from the single terminal 100 may share the same file. In addition, multiple data may share a single file. Here, a unique key generation file may be provided in the terminal 100.

The storage unit 230 stores the aforementioned index table. At this time, each index value (that is, the unique key) of the index table blocks the actual data, makes the actual content of the blocked data into a unique key, and stores it in the form of an index table. Therefore, it can be seen that each index value of the index table is equal to the actual data value.

Here, it is effective that the uniqueness generation file used to generate the index table and its unique key are linked to each other. When the terminal 100 requests one data, the terminal 100 also provides the terminal with an index table corresponding to the data and a unique key generation file for generating the index table.

Through this, the terminal 100 also blocks the corresponding data, generates the unique key as a unique key generation file, and stores the blocked data in the form of an index table.

To this end, the terminal 100 converts the data generated by the terminal data partitioner to separate the generated and stored data into blocks, and converts the actual contents of the blocked data into an encrypted unique key using a unique key generation file provided from the server. And a table generator for converting the converted data in the form of the unique key into the terminal index table structure. As described above, the terminal 100 may also store a file for generating a unique key.

The server index table provided by the server 200 and the terminal index table newly generated by the terminal 100 are compared. As a result of the comparison, the change of the data can be confirmed only by the difference between the index values between the two index tables, and only the block in which the difference value is generated can be synchronized with the server to restore the damaged or changed data to its original state. Here, the comparison between the two tables is preferably performed in the server 200. Of course, the present invention is not limited thereto and may be performed by the terminal 100. In addition, a separate comparison terminal or comparison server may be installed, and the operation may be performed in the comparison terminal and the comparison server.

Hereinafter, a data synchronization method according to the present embodiment will be described with reference to the drawings.

4 is a flowchart illustrating a data synchronization method according to an embodiment. 5 is a flowchart illustrating an operation of a server according to an exemplary embodiment. 6 and 7 are conceptual views illustrating a data synchronization method according to an embodiment.

4 to 7, first, predetermined data is generated by the terminal 100. At this time, the data vary in size. Subsequently, the terminal 100 transmits the generated data to the server 200 (S110).

Subsequently, the server 200 stores and stores the data values in the form of a separate indexing table (S120).

This will be described in more detail with reference to FIG. 4 as follows. First, the server 200 separates the provided data into a plurality of block units (S121). As mentioned above, in recent years, the size of data has become very large. In particular, in the case of video and audio data, the size is increased from bytes to gigabytes. As the size of data increases, a problem arises in that a comparison time for precise data synchronization between the server 200 and the terminal 100 is long, as described in the related art. However, by dividing the data into a plurality of block units and comparing only the block units as described above, the comparison time for data synchronization can be reduced. In addition, as described above, the terminal 100 blocks data and transmits the data to the server 100.

Subsequently, the data blocks divided in block units are generated using a unique key generation file to generate the actual content of the blocked data as a unique key (S123). Then, it is stored in the form of a server index table (S125). The unique key is stored as an index value of an index table. In addition, the index values are effectively arranged in sequence according to the order of the data blocks. Here, as shown in (a) of FIG. 7, data blocks are separated in units of 1 megabyte, and fixed size index files are generated for them. In addition, as described above, the terminal 100 may provide the index table file to the server 200. At this time, the server 200 may store this file.

As described above with reference to FIG. 3, one file is divided into blocks of 1 megabyte unit, and data for each block is made a unique key value and stored as an index file. That is, the index file and the unique key generation file do not exist separately, and the components of the index file are a set of unique keys. Blocked data is also loaded internally to generate unique key values for computation. This simplifies the index file, reducing the amount of data needed for synchronization and speeding up the comparison of data consistency.

Thereafter, when a data synchronization request is received from the terminal 100, the server 200 provides the terminal 100 with a server indexing table file corresponding to the requested data (S130). Here, the server 200 may provide the terminal 100 with unique key generation information for generating the indexing table.

Subsequently, the terminal 100 converts the data stored in the terminal 100 into a terminal indexing table by performing the aforementioned index table generation method of the server (S140).

That is, it blocks the data stored by itself and generates a unique key using the unique key generation file received from the server 200. The generated unique key is stored as a terminal index table. As shown in (b) of FIG. 7, the data of the terminal 100 is also blocked in units of 1 megabyte, and a fixed size index file is generated using the data.

Subsequently, the terminal index table generated in the terminal 100 and the index values of the server index table generated in the server 100 are sequentially compared (S150).

As a result of the comparison, when the values of the two index tables are the same, it is determined that the data in the data block corresponding to the corresponding index table match (S160). However, if the values are not the same, it is determined that the data in the data block corresponding to the corresponding index table does not match (inconsistent). Through this, the location of the data block whose data value is changed / changed can be known, and the entire data can be synchronized by synchronizing only this area with the server 200 (S170).

As shown in FIG. 6, a server index table having an index value of Index 0 to Index n is located in the server. As described above, the terminal receives the unique key generation file from the server and indexes its data. At this time, as shown in FIG. 5, a terminal indexing table having index values from Index 0 to Index n and index n + 1 to Index n + 3 is generated.

Subsequently, the server indexing table and the terminal indexing table are compared. As shown in FIG. 5, it can be seen that Index 7.1 and Index n + 1, Index n + 2, and Index n + 3 are changed and added.

In addition, as shown in FIG. 7, two fixed-size index files of the server and the terminal are compared, and data of a portion where values thereof do not match is recognized as changed data.

In this case, synchronization may be performed to change data of the server based on data of the terminal corresponding to the change and the added value according to the user's setting. Of course, the data of the terminal may be synchronized based on the data of the server corresponding to the change and the added value.

The changed index of each data block can know the location of the changed file contents simply by comparing the indexes without the actual data comparison between the two sides in the synchronization process. Therefore, the conventional technical limitation may be overcome by changing only a part of the changed file that needs to be synchronized.

In particular, the present technology has a great technical improvement in that the conventional technology can completely overcome the inconsistency of the data during synchronization, which is caused by simply comparing the modified date or the size of the file and making it a reference for synchronization. Can be.

For example, a terminal infected with a new virus (ie, a PC) could not be treated with a vaccine. However, by using the synchronization of the present technology, it is possible to find a virus code concealed inside a normal file and process it as a normal code at high speed.

In this embodiment, not only the technology for synchronizing the data of the terminal 100 with the data of the server 200, but also all the data stored in the server 200 can be synchronized in the same operation in the other terminal 100. This can be used in a large data service (multimedia data, database data, online game software and patch data, etc.) using the same because it can transmit only the wrong part of the data of the different terminals 100 in one index file.

When this technology is commercialized, it can be utilized in various industrial environments to maximize the effect.

In other words, if you use a terminal such as a PC, the program may suddenly break. In this case, the most common solution is to uninstall and reinstall the program. However, with this technology, customers can connect to the developer of the software and test the integrity to automatically find and repair the damaged parts of the program installed on their hard disk.

In addition, PC rooms (PC rooms) in which a large number of terminals are arranged have been established in Korea for a long time and have been settled as a cultural industry all over the world. However, such a PC room is a chronic problem, and if the installed online game breaks, it takes a long time to receive maintenance and costs each time. However, even in this case, the technology can network other broken PCs with a normal PC and conduct an integrity test. At this time, the terminal (that is, PC) that is normally operating becomes a server, and the failed terminal becomes a terminal. This allows for more efficient treatment than conventional maintenance without incurring additional costs.

In addition, a number of data files are generated and managed in real time in the terminal (PC) or server we work with. If you back up such data to another space, it will be difficult due to the large amount of data. However, if the technology is applied, only the changed parts can be accurately determined and replaced, which can drastically reduce time and cost.

In addition, the present embodiment may compare data in units of blocks separately after first comparing all data in addition to the above-described method.

8 is a flowchart illustrating a data synchronization method according to a modification of an embodiment of the present invention.

First, as shown in FIG. 8, the server or the terminal for which synchronization is started requests the entire data information (S210). Subsequently, the data owned by the server or the terminal is compared with the received total data information (S220). Here, the data comparison may be performed at the server or the terminal. Therefore, if data comparison is performed in the server, the terminal requests data and compares its own data with the provided data. Of course, when the data is compared in the terminal it works in reverse.

In this case, the entire data information may effectively include information such as data size, name, modification and creation date. As such information, it is desirable to use information that does not include the actual content of the data.

Subsequently, individual data are compared (S230). In this case, the individual data comparison is divided into the aforementioned data blocks, and they are performed by comparing the indexed tables.

If there is no difference as a result of the comparison, the same data is recognized and the synchronization is completed (S240).

If there is a difference as a result of the comparison, it is first determined whether the difference is a part (that is, the front part, the middle part, the back part), the whole, or whether new data is added (S250).

At this time, if the difference occurs in part, the data packet of the wrong part is requested (S260). Thereafter, only the wrong part is exchanged for data and synchronization is terminated (S270).

However, if the wrong part is all or addition of new data, the entire file is requested (S280). The synchronization is terminated by replacing the existing file with the entire file (S290).

On the other hand, the present invention is not limited to the above-described specific embodiments, anyone who has ordinary knowledge in the field belonging to the present invention without departing from the gist of the invention claimed in the claims the order of the processing procedure Various modifications may be made, such as changing the type of hardware, or changing the type of hardware where the component is to be located.

1 is a block diagram of a data synchronization system in accordance with an embodiment of the present invention.

2 is a conceptual diagram illustrating the operation of a server according to an embodiment of the present invention.

3 is a flowchart illustrating a data synchronization method according to an embodiment of the present invention.

4 is a flowchart illustrating an operation of a server according to an embodiment of the present invention.

5 is a conceptual diagram illustrating a data synchronization method according to an embodiment of the present invention.

<Explanation of symbols for main parts of the drawings>

100: terminal 200: server

210: data partitioner 220: data converter

230: storage unit

Claims (10)

A data divider for dividing the provided data into block units of the same size; A data converter for converting the contents of the data separated in block units into a unique key encrypted using a hash algorithm; A server including a storage unit storing a unique key of the converted data and position information of a corresponding data block in a server index table structure and storing a unique key generation file used for generating the unique key; And A terminal data partitioning unit that generates and stores data and separates the generated and stored data into block units having the same size, and the contents of the data separated in block units using a unique key generation file provided from the server as an encrypted unique key. And a terminal including a data converting unit for converting and a table generating unit for converting the unique key of the converted data and position information of the corresponding data block into a terminal index table structure. And data synchronization is performed through comparison between the server index table and the terminal index table. delete delete The method of claim 1, The comparison between the server index table and the terminal index table is performed in the terminal or the server, or in a separate comparison terminal or comparison server. A terminal data divider for generating and storing data and separating the data into blocks of the same size; A terminal data converting unit converting contents of the data separated in block units into an encrypted unique key; A storage unit for storing the unique key of the converted data and the location information of the corresponding data block in a terminal index table structure, and storing a unique key generation file used for generating the unique key; At least one terminal including a comparison unit configured to compare the terminal index table and a server index table to synchronize a data block having a difference; And A server data conversion unit for converting the data in the block unit into an encrypted unique key, a server storage unit for storing the unique key of the converted data and location information of the corresponding data block in the server index table; And a server for storing the unique index type index table from the terminal data converter as a server index table file. delete In the method of synchronizing a large amount of data between the server and the terminal, Receiving data by the server from a terminal generating data; Blocking the received data in units of blocks of the same size, generating a unique key from a data block through a unique key generation file, and storing the received data in the form of a server index table; The server transmitting the unique key generation file to the terminal, the terminal blocking the data stored in the terminal, and generating a unique key to form a terminal index table; Comparing the server index table and the terminal index table at the server or the terminal; And And determining, by the server or the terminal, that the data in the corresponding block matches when the indexes are the same, and determining that the data in the corresponding block does not match when the indices are not identical. The method of claim 7, wherein generating the unique key and storing the unique key in the form of a server index table, Separating the provided data into a plurality of blocks of the same size; Using the unique key generation file to divide the data blocks divided into block units, generating the contents of the blocked data as the unique key; And storing the unique key in the form of a server index table. The method of claim 7, wherein before transmitting the unique key generation file to the terminal, The server further comprises the step of receiving a data synchronization request from the terminal. delete

Images