KR20220073430A - Method and apparatus for transfering file using chunking - Google Patents

Abstract

A method is provided for transferring files between a client and a server. A file transmission method according to an embodiment of the present invention includes the steps of: initiating, by a client device, an operation of dividing a transmission target file into M chunks having a preset size; and sequentially transmitting the M chunks to the server However, the steps of transmitting N chunks in parallel through a plurality of connections to the server; Irrespective of , the method may include initiating transmission of one untransmitted chunk among the M chunks.

Description

File transfer method and device using chunking

Embodiments of the present invention relate to a file transfer method and apparatus using chunk division. More specifically, embodiments of the present invention relate to a method and apparatus for parallelly transmitting a plurality of chunks through a plurality of connections between a client and a server.

BACKGROUND With the improvement of the processing power of the computing device, the expansion of the bandwidth of the network infrastructure, and the development of the digital content industry, large files are frequently transmitted between the client device and the server.

Between the client device and the server, web-based file uploading and downloading methods through a web browser may be provided. In a client-server environment, a file uploaded from a client device to a server system may be stored in the server after post-processing such as encryption by an application server of the server system, and the post-processing file is transferred from the application server of the server system It may be transmitted and stored to a storage server of the server system.

When a client device uploads a file to the server system, the file can be divided into multiple chunks and uploaded in parallel to improve upload speed. However, only when the client device separately makes a merge request to the application server together with information on the transferred chunks, the application server can start the process of merging the chunks into one file again. In this case, since the client device that has transmitted the merging request to the application server must wait until the merging is completed in the application server, inconvenience to the user of the client device may be caused.

Furthermore, the application server of the server system may encrypt the file received from the client, and there are cases in which the encryption can be initiated only when the entire file exists. In other words, the encryption process may not start when only some chunks constituting the file are received. In addition, the application server of the server system divides the encrypted file into chunks and transmits it to the storage server, so that the storage server stores the encrypted file.

As described above, while operations such as merging chunks, encryption of merged files, division of encrypted files, and transmission from the application server to the storage server are performed in the server system, a client requesting file upload to the server system as described above A waiting time may occur in the device, which may cause inconvenience to the user.

Korean Patent No. 10-1424362 (Registered on July 22, 2014)

A technical problem to be achieved through some embodiments of the present invention is to provide a method and an apparatus for transferring a file between computing devices.

Another technical problem to be achieved through some embodiments of the present invention is to provide a method and apparatus for parallelly transmitting a plurality of chunks through a plurality of connections between a client and a server.

Another technical problem to be achieved through some embodiments of the present invention is to provide a method and apparatus for increasing transmission efficiency in parallel transmission of a plurality of chunks between a client and a server.

Another technical problem to be achieved through some embodiments of the present invention is to provide a method and apparatus for reducing the waiting time of a client when transferring a file between a client and a server.

Another technical problem to be achieved through some embodiments of the present invention is to provide a method and apparatus capable of transmitting the fact of transmission completion through an asynchronous channel when transferring a file between a client and a server.

The technical problems of the present invention are not limited to the technical problems mentioned above, and other technical problems not mentioned will be clearly understood by those skilled in the art from the following description.

In a method for transmitting a file between a client and a server, according to an embodiment of the present invention for solving the above technical problem, the client device divides the transmission target file into M chunks having a preset size. initiating, sequentially transmitting the M chunks to the server, but transmitting the N chunks in parallel through a plurality of connections to the server, and any one of the N chunks transmitted in parallel When the transmission of is completed, the method may include initiating transmission of one untransmitted chunk among the M chunks, regardless of whether the transmission of the remaining chunks transmitted in parallel is completed.

In one embodiment, the file transmission method further comprises the step of receiving, by the client device, a message indicating completion of transmission of the file to be transmitted from the server, wherein the message indicating completion of transmission is the transmission of the file to be transmitted may be received through a connection different from the connection established between the client device and the server for this purpose.

In an embodiment, the message indicating the completion of the transmission may be received through a websocket connection established between the client device and the server.

In one embodiment, the server sequentially receiving the chunks from the client device, the server merging the received chunks into one in parallel with the sequential reception of the chunks; The method may further include transmitting a message indicating completion of transmission of the transmission target file to the client device when reception of the M chunks is completed, regardless of whether the M chunks are merged.

In one embodiment, the method further comprising: sequentially receiving, by the server, the chunks from the client device; and merging, by the server, the received chunks into one, in parallel with the sequential reception of the chunks. , the step of merging into one file may include, in response to determining that a merge target chunk among the received chunks is not a continuous chunk from a previously merged file, suspending merging of the merge target chunk. can

In an embodiment, the step of merging into one file includes: identifying a first offset in the transmission target file corresponding to a starting point of a merge target chunk among the received chunks; The method may include identifying a second offset in the transmission target file corresponding to the endpoint.

In one embodiment, the file transmission method further includes inserting the received chunks into a priority-based queue based on a position corresponding to each of the received chunks in the transmission target file. may include

In an embodiment, the step of transmitting the N chunks in parallel includes transmitting each chunk as each HTTP request, and a header part of the HTTP request includes each chunk in the transmission target file. location information of , and the body part of the HTTP request may include the contents of each chunk.

In a method for transmitting a file between a client and a server, according to another embodiment of the present invention for solving the above technical problem, the server sequentially receives M chunks divided from a target file from a client device Step, the server merging the received chunks into one in parallel with the sequential reception of the chunks to generate a merged file; and when the reception of the M chunks is completed, the received chunk The method may include transmitting a message indicating completion of transmission of the target file to the client device irrespective of whether the merging of the files has been completed.

In one embodiment, the file transmission method includes the steps of: when the merging of the M chunks is completed, performing post-processing on the merged file to generate a post-processed file; The method may further include dividing into chunks and storing the N chunks in a storage.

In one embodiment, the file transmission method includes: in response to receiving a provision request for the target file, obtaining, by the server, the N chunks from the storage; The method may further include sequentially transmitting the N chunks to one client device.

In order to solve the above technical problem, a computing device according to another embodiment of the present invention includes a chunk generation unit and a chunk transmission unit, and the chunk generation unit converts a target file into M chunks having a preset size. division, and the chunk transmitter sequentially transmits the M chunks, transmits the N chunks in parallel through a plurality of connections, and when the transmission of any one of the N chunks transmitted in parallel is completed, Transmission of one untransmitted chunk among the M chunks may be started regardless of whether the transmission of the remaining chunks transmitted in parallel has been completed.

In an embodiment, the computing device further comprises a websocket communication unit, the chunk transmission unit transmits the chunks through a first connection established by an HTTP request, and the websocket communication unit includes: When the transmission is completed, a message indicating the completion of transmission of the target file may be received through a second connection different from the first connection.

In an embodiment, the chunk transmitter may record location information of each chunk in the target file in a header part of the HTTP request, and record the contents of each chunk in a body part of the HTTP request.

In order to solve the above technical problem, a computing device according to another embodiment of the present invention includes a chunk receiving unit, a chunk merging unit, and a web socket communication unit, wherein the chunk receiving unit includes M chunks divided from a target file. data received sequentially from the client device, the chunk merging unit operates in parallel with the chunk receiving unit to merge chunks sequentially received by the chunk receiving unit into one, and the WebSocket communication unit is configured by the chunk receiving unit When reception of the M chunks is completed, a message indicating completion of transmission of the target file may be transmitted to the client device regardless of whether the merge by the chunk merging unit is completed.

In an embodiment, the computing device further includes a post-processing unit, wherein the post-processing unit performs post-processing on the merged file when the merging of the M chunks is completed, and converts the post-processed file to N It is divided into chunks, and the N chunks can be stored.

In order to solve the above technical problem, a computer-readable non-transitory storage medium according to another embodiment of the present invention includes instructions, and when the instructions are executed by a processor, the processor causes the processor to have a predetermined size. Initiating an operation of dividing a file to be transmitted into M chunks, sequentially transmitting the M chunks to a server, and transmitting N chunks in parallel through a plurality of connections to the server; , when the transmission of any one of the N chunks transmitted in parallel is completed, irrespective of whether the transmission of the remaining chunks transmitted in parallel is completed, starting transmission of one untransmitted chunk among the M chunks It is possible to perform operations including

In one embodiment, the instructions, when executed by the processor, cause the processor to perform operations including receiving, from the server, a message indicating completion of transmission of the file to be transmitted, indicating completion of transmission The message may be received through a connection different from the connection established between the server and the server for transmission of the transmission target file.

1 is a diagram illustrating an exemplary client-server system to which a file transfer method according to some embodiments of the present invention may be applied.
2 is a flowchart illustrating a method of uploading a file from a client device to a server system according to an embodiment of the present invention.
3 to 8 are reference diagrams illustrating exemplary processes in which a transmission target file is divided into a plurality of chunks and transmitted in parallel from a client device to a server system according to the file transmission method described with reference to FIG. 2 .
9 is a flowchart illustrating a method for downloading a file from a server system to a client device according to an embodiment of the present invention.
10 is a reference diagram illustrating an exemplary process in which a transmission target file stored in a state of being divided into chunks in a storage server is transmitted to a client device without merging according to the file transmission method described with reference to FIG. 9 .
11 is a diagram for explaining the configuration and operation of a client device according to another embodiment of the present invention.
12 is a diagram for explaining the configuration and operation of an application server device of a server system according to another embodiment of the present invention.
13 is a diagram for describing an exemplary computing device in which some embodiments of the present invention may be implemented.

Hereinafter, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings. Advantages and features of the present invention and methods of achieving them will become apparent with reference to the embodiments described below in detail in conjunction with the accompanying drawings. However, the technical spirit of the present invention is not limited to the following embodiments, but may be implemented in various different forms, and only the following embodiments complete the technical spirit of the present invention, and in the technical field to which the present invention belongs It is provided to fully inform those of ordinary skill in the art of the scope of the present invention, and the technical spirit of the present invention is only defined by the scope of the claims.

In adding reference numerals to the components of each drawing, it should be noted that the same components are given the same reference numerals as much as possible even though they are indicated on different drawings. In addition, in describing the present invention, if it is determined that a detailed description of a related known configuration or function may obscure the gist of the present invention, the detailed description thereof will be omitted.

Unless otherwise defined, all terms (including technical and scientific terms) used herein may be used with the meaning commonly understood by those of ordinary skill in the art to which the present invention belongs. In addition, terms defined in a commonly used dictionary are not to be interpreted ideally or excessively unless clearly defined in particular. The terminology used herein is for the purpose of describing the embodiments and is not intended to limit the present invention. In this specification, the singular also includes the plural unless specifically stated otherwise in the phrase.

In addition, in describing the components of the present invention, terms such as first, second, A, B, (a), (b), etc. may be used. These terms are only for distinguishing the elements from other elements, and the essence, order, or order of the elements are not limited by the terms. When it is described that a component is “connected”, “coupled” or “connected” to another component, the component may be directly connected or connected to the other component, but another component is formed between each component. It should be understood that elements may also be “connected,” “coupled,” or “connected.”

As used herein, "comprises" and/or "comprising" refers to the presence of one or more other components, steps, operations and/or elements mentioned. or addition is not excluded.

Unless otherwise noted, in this specification, data update refers to creation, modification, and deletion of data.

Hereinafter, some embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a diagram illustrating an exemplary client-server system to which a file transfer method according to some embodiments of the present invention may be applied.

Referring to FIG. 1 , a file transfer method according to embodiments of the present invention may be used for file transfer between a client device 10 and a server system 20 . The file transfer method according to embodiments of the present invention may use web-based server-client communication. Various application services including a web server may be driven in the server system 20 , and the client device 10 may interact with the server system 20 through an application program such as a web browser. Communication protocols including the HTTP protocol may be used between the client device 10 and the server system 20 .

The server system 20 may include an application server 210 . The application server 210 may establish a synchronous and/or asynchronous connection with the client device 10 and provide an application service to the client device 10 . Also, the application server 210 may transmit a file to the client device 10 or receive a file from the client device 10 .

The application server 210 may post-process the file received from the client device 10 . Post-processing may include various processes that may be applied to the received file prior to storing the file received from the client device 10 in the server system 20 . For example, post-processing is the purpose of application services such as file splitting, encryption, compression, security application for DRM (digital content management), digital fingerprint acquisition such as hash value, video codec conversion, etc. There may be various processes that may be required depending on the .

The server system 20 may further include a storage server 220 in addition to the application server 210 . The storage server 220 stores the file received by the application server 210 from the client device 10 in the storage device, and when there is a download request for the file from the client device 10, the requested file is transferred to the application server ( The requested file may be provided to the application server 210 so that the 210 may be transmitted to the client device 10 .

The application server 210 and the storage server 220 may be implemented as components that are physically executed in one computing system or device, or may be implemented as separate physically separate computing devices. The application server 210 and the storage server 220 may be one or more instances running on one or more computing devices in a cloud environment. If data can be exchanged between the application server 210 and the storage server 220 , the application server 210 and the storage server 220 may be located at separate locations.

2 is a flowchart illustrating a method in which a transmission target file is uploaded from the client device 10 to the server system 20 according to an embodiment of the present invention, and FIGS. 3 to 8 show the transmission target file in a plurality of chunks. It is a reference diagram showing an exemplary process of being divided and transmitted in parallel from the client device to the server system.

Referring to FIG. 2 , first, the client device 10 may transmit a file upload request to the application server 210 of the server system 20 ( S101 ). The file upload request may include a file name, file size, and other metadata.

Upon receiving the file upload request, the application server 210 may generate a UUID that is a unique identifier corresponding to a file to be received from the client device 10 and prepare to receive the file ( S101 ). For example, the application server 210 may provide a space such as a folder to store files, and may create a priority-based queue for sequentially merging files to be received after being divided into several chunks. .

Subsequently, the application server 210 may return the generated UUID to the client device 10 (S103).

The client device 10 may initiate an operation of dividing the transmission target file into M chunks having a predetermined size ( S111 ). The size of the chunks may be predetermined or may be a size dynamically determined by the client device 10 and the server system 20 . Meanwhile, M indicates a value obtained by dividing the total size of the transmission target file by the chunk size. The operation of dividing the transmission target file into M chunks may be an operation of actually generating and temporarily storing the divided chunks, but divides the entire section of the transmission target file into pieces having the same size, and separates each of the pieces. It may be an operation of mapping as one chunk.

Before or after the operation of dividing the transmission target file into M chunks is completed, the client device 10 establishes N channels or connections with the application server 210, and at the same time An operation of transmitting the N chunks to the application server 210 through the N channels may be initiated (S112). The client device 10 may transmit N chunks in parallel through the N channels at the same time. Here, N may be the maximum number of simultaneous transmission channels designated in advance, or the number of channels dynamically determined by the client device 10 and the server system 20 .

The client device 10 may sequentially transmit chunks that are sequentially generated by dividing the file to be transmitted. For example, the client device 10 first transmits N chunks including a chunk corresponding to the beginning of the transmission target file, and lastly transmits N chunks including a chunk corresponding to the end of the transmission target file. The chunks may be transmitted sequentially in a manner such as transmitting. Here, the client device 10 may initiate an operation of transmitting the initially generated N chunks to the application server 210 before the operation of dividing the transmission target file into a total of M chunks is completed. In other words, the client device 10 may start transmitting from the first generated chunks without waiting for all the chunks divided from the transmission target file to be generated. Accordingly, the total transmission time may be reduced, and the response delay time perceived by the user of the client device 10 may be reduced.

Each chunk may be transmitted from the client device 10 to the application server 210 through an HTTP request (HTTP Request).

In the header of the HTTP request for transmitting each chunk, an identifier indicating the transmission target file (eg, a UUID generated by the application server 210 for the transmission target file), and each chunk in the transmission target file Information indicating the location may be included. The position of each chunk in the transmission target file may be expressed, for example, by an offset of a start point and an offset of an end point of a portion corresponding to each chunk in the transmission target file.

The body of the HTTP request for transmitting each chunk may include file contents of a portion corresponding to each chunk in the transmission target file.

The application server 210 may receive chunks transmitted through N channels (S113). As will be described later, the application server 210 may receive chunks transmitted by the client device 10 through the chunk receiver 211 .

Also, the application server 210 may initiate an operation of merging the sequentially received chunks into one file through a chunk merging unit (CHUNK MERGER) 212, which will be described later (S120). The operation of merging the chunks into one file by the chunk merging unit 212 may be performed in parallel with the operation of receiving the chunks by the chunk receiving unit 211 . For example, the chunk merging unit 212 may sequentially merge the received chunks in an order according to positions corresponding to each of the received chunks in the transmission target file.

3 shows an exemplary state in which three chunks are transmitted in parallel from the client device 10 to the application server 210 through three channels or connections at the same time. Referring to FIG. 3 , chunks #1, #2, and #3 corresponding to the beginning of a transmission target file (“FILE A”) may be transmitted to the application server 210 in parallel.

In FIG. 3, it is assumed that the size of the transmission target file (FILE A) is 100, and chunk #1 (0-3) corresponds to points 0 to 3 when the transmission target file is logically divided into 100 sections. Chunk #2(3-6) indicates the chunks corresponding to points 3 to 6 of the transfer target file, and chunk #3(6-9) corresponds to points 6 to 9 of the transfer destination file. Represents a chunk of 4 to 10, which will be referenced continuously, are also indicated in the same manner.

It will be described again with reference to FIG. 2 .

When the transmission of the chunk is completed in any one of the N channels (first channel) in which parallel transmission is initiated in step S112, the application server 210 may return a message indicating the completion of transmission of the first channel. There is (S114).

Upon receiving the message, the client device 10 initiates transmission of the next chunk through the first channel regardless of whether or not transmission of chunks transmitted through a channel other than the first channel among the N channels is completed. can In other words, even if transmission of the chunk is not completed in channels other than the first channel among the N channels, transmission of the next chunk may be started immediately in the first channel in which the transmission of the chunk is completed. Here, the next chunk may indicate a chunk that has not yet been transmitted to the application server 210 among the chunks in which the transmission target file is divided.

Similarly, when the transmission of the chunk is completed in another channel (the second channel) among the N channels in which parallel transmission is started in step S112 , the application server 210 returns a message indicating the completion of the transmission of the second channel. and (S115), the client device 10 receiving the message may initiate transmission of the next chunk through the second channel regardless of whether the transmission of the other channel has been completed.

4 shows an exemplary state in which the transmission of chunks #1, #2, and #3 from the client device 10 to the application server 210 is completed. When the transmission of each of the chunks #1, #2, and #3 is completed, the application server 210 may return a message indicating the completion of transmission of each chunk to the client device 10 . The transfer-completed chunks #1, #2, and #3 are inserted into the priority queue of the chunk merging unit 212 in the order according to the positions of the respective chunks in the transfer target file, and the merging process is started. can be

5 shows an exemplary state in which chunks #4, #5, and #6 of a transmission target file are transmitted in parallel through three channels established simultaneously between the client device 10 and the application server 210. . Also, at the time described above with reference to FIG. 4, chunks #1, #2, and #3, which were inserted into the priority queue of the chunk merging unit and were the subject of merging, were sequentially merged into one file and stored in the temporary storage is shown in FIG. 5 is shown. In FIG. 5, as a result of merging chunks #1, #2, and #3, the merged files (0-9) including the contents of points 0 to 9 of the transmission target file are stored in the temporary storage of the application server 210. The saved image is shown.

When transmission of each chunk is completed in the state shown in FIG. 5 , the application server 210 may return a message informing the client device 10 of completion of transmission of the corresponding chunk. In addition, when the transmission of each chunk is completed in the state shown in FIG. 5 , the corresponding chunk is inserted into the priority queue of the chunk merging unit 212 and may be a target of a sequential merging operation.

FIG. 6 shows an exemplary state in which chunks #5, #7, and #8 are transmitted in parallel as a result of completion of transmission of chunks #4 and #6 in the state shown in FIG. 5 .

When the transmission of each of chunks #4 and #6 in the state shown in FIG. 5 is completed, the application server 210 returns a message to the client device 10 notifying the completion of transmission of each chunk, and the client device 10 may initiate transmission of chunks #7 and #8 in response to the transmission completion message of chunks #4 and #6.

When the transmission of each of chunks #4 and #6 is completed in the state shown in FIG. 5 , chunks #4 and #6 may first be inserted into the priority queue of the chunk merging unit 212 . A continuous chunk #4 (9-12) from the pre-merged file (0-9) may be extracted from the priority queue and merged at the end of the pre-merged file (0-9). As a result, the pre-merged files 0-12 shown in FIG. 6 may include contents 0 to 12 of the transmission target file. Meanwhile, in the state shown in FIG. 6 , since chunk #6 (15-18) is not a continuous chunk from the previously merged files (0-12), it may remain in the priority queue with merging pending.

To describe the above process in more detail, the first offset (eg, 9) in the transmission target file, which corresponds to the start point of the merge target chunk (eg, chunk #4), is identified, and corresponds to the end point of the merged file, A second offset (eg, 9) in the to-be-sent file may be identified. When the start point of the merge target chunk (eg, chunk #4) coincides with the end point of the merged file, the merge target chunk may be merged to the end of the merged file. For example, chunk #4 may be merged at the end of the merged file (0-9). On the other hand, a first offset (eg, 15) in the transmission target file, corresponding to the start point of the merge target chunk (eg, chunk #6), corresponds to the end point of the merged file, and a second offset (eg, 12) in the transmission target file ), the merge of the merge target chunk (eg, chunk #6) may be suspended.

In the state shown in FIG. 6 , when the transmission of chunks #5, #7, and #8 is completed, respectively, chunks #5, #7, and #8 may be inserted into the priority queue of the chunk merging unit 212 , respectively. . In this case, chunks #5, #7, and #8 may be inserted into the priority queue in order according to positions corresponding to the respective chunks in the transmission target file. In other words, even if chunk #6 is inserted into the priority queue before chunk #5, chunk #5 may be extracted from the priority queue before chunk #6.

After chunks #5, #7, #8, etc. are inserted into the priority queue, continuous chunks #5 (12-15) from the previously merged files (0-12) are extracted from the priority queue, merged at the end of file (0-12), then chunk #6 (15-18), chunk #7 (18-21), and chunk #8 (21-24) are sequentially extracted from the priority queue They may be sequentially merged at the end of the previously merged file.

7 shows that the transmission of the last chunks (chunk #32 (93-96), chunk #33 (96-99), chunk #34 (99-100)) from the client device 10 to the application server 210 is completed. The state is illustrated by way of example.

When the transmission of all chunks from the client device 10 to the application server 210 is completed, a file transmission completion message may be returned from the chunk receiver 211 of the application server 210 to the client device 10 . The file transfer completion message may be returned through a channel established between the client device 10 and the application server 210 for transmission of chunks or a separate connection different from the connection. In one embodiment, the connection for which the file transfer completion message is returned may be an asynchronous connection. In one embodiment, when transmission of all chunks is completed, the application server 210 establishes a websocket connection with the client device 10 and returns a file transfer completion message through the websocket connection. have.

When the transmission of all chunks from the client device 10 to the application server 210 is completed, the file transmission completion message may be immediately returned regardless of the merged state of the transmitted chunks. Specifically, the state shown in FIG. 7 is a state in which merging of transmitted chunks is not completed. Specifically, in the temporary storage of the application server 210, the merged files from 0 to 93 of the transmission target file are temporarily stored, chunk #32 (93-96), chunk #33 (96-99), Chunk #34 (99-100) is inserted into the priority queue of the chunk merging unit 212 and is waiting to be merged. Even if the merging of chunk #32 (93-96), chunk #33 (96-99), and chunk #34 (99-100) is not completed, the chunk receiving unit ( A file transfer completion message may be returned from the 211 to the client device 10 .

It will be described again with reference to FIG. 2 .

As described above with reference to FIG. 7 , when transmission of all chunks is completed, a file transmission completion message may be returned from the application server 210 to the client device regardless of the merged state of the transmitted chunks ( S118 ). When the client device 10 receives the file transfer completion message, the client device 10 may complete the file upload process (S130). For example, an upload completion message may be displayed to the user of the client device 10 .

Continuing to refer to FIG. 2 , when the operation of merging all received chunks into one is completed by the chunk merging unit 212 of the application server 210 , the application server 210 performs a post-processing process for the merged file. can be initiated (S141). As described above, post-processing refers to application services such as file split, encryption, compression, security application for digital content management (DRM), digital fingerprint acquisition such as hash value, and video codec conversion. There may be various treatments that may be required depending on the purpose.

When post-processing of the merged file is completed, the application server 210 may store the post-processed file. In an embodiment, the application server 210 may store the file in a storage device directly connected to the application server 210 . In another embodiment, such as the embodiment shown in FIG. 2 , the application server 210 may transmit the file to the storage server 220 ( S142 ), causing the storage server 220 to store the file ( S142 ). S143). When the storage server 220 completes the file storage, a file transfer completion message S144 is transmitted from the storage server 220 to the application server 210, and the application server 210 may complete the file storage process. (S150).

FIG. 8 is a diagram for explaining a process in which chunks are merged and post-processed in the application server 210 , and the post-processed file is transmitted to and stored in the storage server 220 . 8 shows an embodiment in which DRM including encryption processing is applied to the merged file, and the DRM-applied file is again divided into three chunks, and then the divided chunks are transmitted in parallel to the storage server 220 and stored. became In this case, information about each chunk is stored in the meta DB 215 and may be used in a process of merging files from the divided chunks in the future. As shown in FIG. 8 , the file divided into three chunks after DRM is applied may be stored in the storage server 220 .

9 is a flowchart illustrating a method of downloading a file from the server system 20 to the client device 10 according to an embodiment of the present invention, and FIG. 10 is a storage server 220 stored in a divided state. It is a reference diagram illustrating an exemplary process in which a transmission target file is sequentially transmitted to a client device without being merged into one file again.

Referring to FIG. 9 , the client device 10 may transmit a download request for a transmission target file to the application server 210 .

In response to the request of the client device 10 , the application server 210 may identify chunks corresponding to the file to be transmitted. In addition, the application server 210 may transmit a download request for the chunks to the storage server 220 . Referring to FIG. 10 , the application server 210 may identify the chunks #1, #2, and #3 corresponding to the transmission target file by referring to the data record stored in the meta DB 215 . Also, the application server 210 may request the storage server 220 to download chunks #1, #2, and #3.

In response to the request of the application server 210 , the storage server 220 may sequentially transmit the requested chunks to the application server 210 . The storage server 220 may transmit two or more chunks simultaneously and in parallel to the application server 210 using two or more network connections. Referring to FIG. 10 , the storage server 220 may transmit DRM-applied chunks #1, #2, and #3 stored in the storage device to the application server 210 in parallel.

The application server 210 may deliver the chunks received from the storage server 220 to the client device 10 . Specifically, the chunks may be streamed to the client device 10 in an order according to a location to which each chunk corresponds in the transmission target file. Referring to FIG. 10 , the application server 210 may provide a transmission target file to the client device 10 by sequentially streaming the received chunks #1, #2, and #3 without merging them into one file again. have.

So far, a method of uploading and downloading a transmission target file from the client device 10 to the server system 20 according to some embodiments of the present invention has been described with reference to FIGS. 2 to 10 .

According to the above-described embodiments, the divided chunks in the client device 10 may be simultaneously and in parallel transmitted from the client device 10 to the application server 210 through N channels or connections, whereby the transmission time can be shortened.

According to the above-described embodiments, when the chunks divided in the client device 10 are transmitted from the client device 10 to the application server 210 through N channels or connections, when any one channel is transmitted, Transmission of the next chunk may be started immediately regardless of the transmission status of other channels. Therefore, even if there is a speed difference between the transmission channels or a channel having a temporarily slow transmission speed exists, the number of transmission channels can always be maintained at the maximum value. In other words, the network bandwidth between the client device 10 and the application server 210 is maximally utilized, and the time when the transmission target file is completed can be advanced as much as possible.

According to the above-described embodiments, the operation of receiving the chunk from the application server 210 and the operation of merging the chunks may be simultaneously performed in parallel. Specifically, the chunks received by the chunk receiving unit 211 of the application server 210 are inserted into the priority queue in order according to positions corresponding to the respective chunks in the transmission target file, and The chunks stored in the priority queue may be sequentially merged by the chunk merging unit 212 . Through the above configuration, when the reception of all chunks is completed, the application server 210 may return a transmission completion message to the client device 10 irrespective of whether the merging of the chunks is completed. Accordingly, the user of the client device 10 does not need to wait until the chunk merging is completed in the application server 210 .

According to the above-described embodiments, when the transmission target file is completed from the client device 10 to the application server 220 , a WebSocket communication channel or connection is created between the application server 220 and the client device 10 , Through this, a transmission completion message may be returned. File upload from the client device 10 to the application server 220 may use, for example, HTTP communication, and the file transfer completion message may use WebSocket communication. Due to this, the client device 10 does not need to wait for a response from the application server 210 while the chunks are merged and post-processed in the application server 210 after the transmission of the chunks is completed, and the transmission completion message is Since it may be provided through an asynchronous channel or connection, the waiting time experienced by the user of the client device 10 may be reduced.

According to the above-described embodiments, the application server 210 merges the received chunks into one file, post-processing of the merged file may be performed, and the post-processed file is again divided into two or more chunks. It may be transmitted in parallel to the storage server 220 . As such, by using parallel transmission through chunking between the application server 210 and the storage server 220 , it is possible to increase the utilization rate of network bandwidth and shorten the transmission time.

According to the above-described embodiments, when there is a download request for a file to be transmitted from the client device 10 , the application server 210 is installed without merging the chunks stored in the storage server 220 into one file. Through this, it is possible to sequentially stream to the client device 10 .

Hereinafter, the configuration and operation of the client device 10 and the application server device 210 according to other embodiments of the present invention will be described with reference to FIGS. 11 and 12 . 11 and 12 are only some examples for achieving the object of the present invention, and some components may be added or deleted as necessary. Although not specifically mentioned, the embodiment described with reference to FIGS. 2 to 10 in understanding the configuration and operation of the client device 10 and the application server device 210 according to the embodiment shown in FIGS. 11 and 12 . Their technical ideas can be reflected.

11 is a block diagram of a client device 10 according to an embodiment of the present invention. The client device 10 may include a chunk generation unit 101 , a chunk transmission unit 102 , and a websocket communication unit 103 .

The chunk generator 101 may divide the transmission target file into chunks having a predetermined size.

The chunk transmitter 102 may sequentially transmit the divided chunks. The chunk transmitter 102 may establish a plurality of connections and transmit two or more chunks in parallel at the same time. The chunk transmitter 102 may transmit chunks through a first connection established by, for example, an HTTP request. The chunk transmission unit 102 may record the identifier of the transmission target file and the location information of each chunk in the transmission target file in the HTTP header part, and may record the contents of each chunk in the HTTP body part and transmit it.

When the transmission of any one of the chunks transmitted in parallel is completed, the chunk transmission unit 102 may start transmission of the untransmitted chunk regardless of whether the transmission of the remaining chunks transmitted in parallel is completed.

The websocket communication unit 103 may establish an asynchronous connection with a file transfer counterpart. When the transmission of all chunks by the chunk transmission unit 102 is completed, the websocket communication unit 103 performs a second connection different from the first connection established by the chunk transmission unit 102, for example, through a websocket communication connection. , it is possible to receive a message indicating the completion of the transmission of the target file.

12 is a block diagram of an application server device 210 according to an embodiment of the present invention. The application server device 10 may include a chunk receiving unit 211 , a chunk merging unit 212 , a WebSocket communication unit 213 , a post-processing unit 214 , and a storage unit 215 .

The chunk receiving unit 211 may receive a transmission target file or divided chunks from a transmission target file. The chunk receiving unit 211 may simultaneously receive two or more files or chunks in parallel through a plurality of connections. The chunk receiving unit 211 may provide the received files to the priority queue of the chunk merging unit 212 .

The chunk merging unit 212 may merge chunks sequentially received by the chunk receiving unit 211 into one. In order to sequentially merge chunks according to their positions in the transmission target file, the chunk merging unit 212 may appropriately manage the order of the chunks using a priority queue.

The post-processing unit 214 may perform a post-processing operation on the merged chunks. As described above, post-processing may be various processes that may be required depending on the purpose of the application service, such as file division, encryption, compression, security application for DRM, digital fingerprint acquisition such as hash value, and video codec conversion. The post-processing unit 214 may store the post-processing file in the storage unit 215 .

In the storage unit 215 , chunks received by the chunk receiving unit 211 and subject to merging by the chunk merging unit 212 are temporarily stored or merged by the chunk merging unit 212 to be subjected to post-processing. This file can be saved as an entrance exam. In the storage unit 215 , the post-processed file or the post-processed file may be divided into a plurality of chunks and stored.

So far, the configuration and operation of the client device 10 and the application server device 210 according to some embodiments of the present invention have been described with reference to FIGS. 11 and 12 . Hereinafter, an exemplary computing device 1500 in which the client device 10 , the application server device 210 , the storage device 220 , etc. may be implemented according to some embodiments of the present invention will be described with reference to FIG. 13 . let it do

13 is a hardware configuration diagram illustrating an exemplary computing device 1500 capable of performing methods according to some embodiments of the present invention.

13 , the computing device 1500 loads one or more processors 1510 , a bus 1550 , a communication interface 1570 , and a computer program 1591 executed by the processor 1510 . ) may include a memory 1530 and a storage 1590 for storing the computer program 1591 . However, only the components related to the embodiment of the present invention are illustrated in FIG. 13 . Accordingly, one of ordinary skill in the art to which the present invention pertains can see that other general-purpose components other than the components shown in FIG. 13 may be further included.

The processor 1510 controls the overall operation of each component of the computing device 1500 . The processor 1510 includes a central processing unit (CPU), a micro processor unit (MPU), a micro controller unit (MCU), a graphic processing unit (GPU), or any type of processor well known in the art. can be In addition, the processor 1510 may perform an operation on at least one application or program for executing the method according to the embodiments of the present invention. The computing device 1500 may include one or more processors.

The memory 1530 stores various data, commands, and/or information. The memory 1530 may load one or more programs 1591 from the storage 1590 to execute a method according to embodiments of the present invention. The memory 1530 may be implemented as a volatile memory such as RAM, but the technical scope of the present invention is not limited thereto.

The bus 1550 provides a communication function between components of the computing device 1500 . The bus 1550 may be implemented as various types of buses, such as an address bus, a data bus, and a control bus.

The communication interface 1570 supports wired/wireless Internet communication of the computing device 1500 . Also, the communication interface 1570 may support various communication methods other than Internet communication. To this end, the communication interface 1570 may be configured to include a communication module well-known in the art.

According to some embodiments, the communication interface 1570 may be omitted.

The storage 1590 may non-temporarily store the one or more programs 1591 and various data.

The storage 1590 is a non-volatile memory such as a read only memory (ROM), an erasable programmable ROM (EPROM), an electrically erasable programmable ROM (EEPROM), a flash memory, a hard disk, a removable disk, or well in the art to which the present invention pertains. It may be configured to include any known computer-readable recording medium.

The computer program 1591 may include one or more instructions that, when loaded into the memory 1530 , cause the processor 1510 to perform methods/operations in accordance with various embodiments of the present invention. That is, the processor 1510 may perform the methods/operations according to various embodiments of the present disclosure by executing the one or more instructions.

So far, various embodiments of the present invention and effects according to the embodiments have been described with reference to FIGS. 1 to 13 . Effects according to the technical spirit of the present invention are not limited to the above-mentioned effects, and other effects not mentioned will be clearly understood by those skilled in the art from the following description.

The technical ideas of the present invention described with reference to FIGS. 1 to 13 may be implemented as computer-readable codes on a computer-readable medium. The computer-readable recording medium may be, for example, a removable recording medium (CD, DVD, Blu-ray disk, USB storage device, removable hard disk) or a fixed recording medium (ROM, RAM, computer-equipped hard disk). can The computer program recorded on the computer-readable recording medium may be transmitted to another computing device through a network such as the Internet and installed in the other computing device, thereby being used in the other computing device.

In the above, even though all the components constituting the embodiment of the present invention are described as being combined or operating in combination, the technical spirit of the present invention is not necessarily limited to this embodiment. That is, within the scope of the object of the present invention, all the components may operate by selectively combining one or more.

Although acts are shown in a particular order in the drawings, it should not be understood that the acts must be performed in the specific order or sequential order shown, or that all illustrated acts must be performed to obtain a desired result. In certain circumstances, multitasking and parallel processing may be advantageous. Moreover, the separation of the various components in the embodiments described above should not be construed as necessarily requiring such separation, and the described program components and systems may generally be integrated together into a single software product or packaged into multiple software products. It should be understood that there is

Although embodiments of the present invention have been described above with reference to the accompanying drawings, those of ordinary skill in the art to which the present invention pertains can practice the present invention in other specific forms without changing the technical spirit or essential features. can understand that there is Therefore, it should be understood that the embodiments described above are illustrative in all respects and not restrictive. The protection scope of the present invention should be interpreted by the following claims, and all technical ideas within the equivalent range should be interpreted as being included in the scope of the technical ideas defined by the present invention.

Claims (18)

A method for transferring files between a client and a server, comprising:
initiating, by a client device, an operation of dividing a transmission target file into M chunks having a preset size;
transmitting the M chunks sequentially to the server, and transmitting the N chunks in parallel through a plurality of connections to the server; and
Initiating transmission of one untransmitted chunk among the M chunks when transmission of any one of the N chunks transmitted in parallel is completed, regardless of whether the transmission of the remaining chunks transmitted in parallel is completed
containing,
How to transfer files. According to claim 1,
receiving, by the client device, a message indicating completion of transmission of the file to be transmitted from the server
further comprising,
The message indicating the completion of the transmission is received through a connection different from the connection established between the client device and the server for transmission of the file to be transmitted,
How to transfer files. 3. The method of claim 2,
The message indicating the completion of the transmission is received through a websocket connection established between the client device and the server,
How to transfer files. According to claim 1,
receiving, by the server, the chunks sequentially from the client device;
merging, by the server, the received chunks into one in parallel with the sequential reception of the chunks; and
When the reception of the M chunks is completed, transmitting a message indicating completion of transmission of the transmission target file to the client device regardless of whether the M chunks are merged.
containing,
How to transfer files. According to claim 1,
receiving, by the server, the chunks sequentially from the client device; and
merging, by the server, the received chunks into one in parallel with the sequential reception of the chunks
further comprising,
The step of merging into one file is,
suspending merging of the merged chunks in response to determining that the merged chunks among the received chunks are not continuous chunks from the pre-merged file;
containing,
How to transfer files. 6. The method of claim 5,
The step of merging into one file is,
identifying a first offset in the transmission target file corresponding to a starting point of a merge target chunk among the received chunks; and
Identifying a second offset in the transmission target file corresponding to the end point of the pre-merged file
containing,
How to transfer files. 7. The method of claim 6,
Inserting the received chunks into a priority-based queue based on a position to which each of the received chunks corresponds in the transmission target file
further comprising,
How to transfer files. 7. The method of claim 6,
Transmitting the N chunks in parallel includes sending each chunk in each HTTP request,
The header part of the HTTP request includes location information of each chunk in the transmission target file,
The body part of the HTTP request includes the contents of each chunk,
How to transfer files. A method for transferring files between a client and a server, comprising:
receiving, by the server, M chunks divided from the target file sequentially from the client device;
generating, by the server, a merged file by merging the received chunks into one in parallel with the sequential reception of the chunks; and
When the reception of the M chunks is completed, transmitting a message indicating the completion of transmission of the target file to the client device regardless of whether the merge of the received chunks is completed
containing,
How to transfer files. 10. The method of claim 9,
generating a post-processed file by performing post-processing on the merged file when merging of the M chunks is completed;
dividing the post-processed file into N chunks; and
Storing the N chunks in storage
further comprising,
How to transfer files. 11. The method of claim 10,
In response to receiving a request to provide the target file,
obtaining, by the server, the N chunks from the storage; and
Sequentially transmitting, by the server, the N chunks to the client device that has transmitted the provision request
further comprising,
How to transfer files. chunk generation unit; and
chunk transport
A computing device comprising:
The chunk generator divides the target file into M chunks having a preset size,
The chunk transmission unit,
The M chunks are sequentially transmitted, and the N chunks are transmitted in parallel through a plurality of connections,
Upon completion of transmission of any one of the N chunks transmitted in parallel, transmission of one untransmitted chunk among the M chunks is started regardless of whether the transmission of the remaining chunks transmitted in parallel is completed.
computing device. 13. The method of claim 12,
The computing device further includes a websocket communication unit,
The chunk transmitter transmits the chunks through a first connection established by an HTTP request,
wherein the websocket communication unit receives a message indicating completion of transmission of the target file through a second connection different from the first connection when transmission of the N chunks is completed;
computing device. 14. The method of claim 13,
The chunk transmission unit,
Recording the location information of each chunk in the target file in the header part of the HTTP request,
Recording the contents of each chunk in the body part of the HTTP request,
computing device. chunk receiver;
chunk merging unit; and
websocket communication department
A computing device comprising:
The chunk receiving unit sequentially receives M chunks divided from the target file from the client device,
The chunk merging unit operates in parallel with the chunk receiving unit to merge the chunks sequentially received by the chunk receiving unit into one;
When the reception of the M chunks is completed by the chunk receiving unit, the WebSocket communication unit transmits a message indicating the completion of transmission of the target file to the client device regardless of whether the merge by the chunk merging unit is completed. ,
computing device. 16. The method of claim 15,
The computing device further comprises a post-processing unit,
The post-processing unit,
When merging of the M chunks is completed, post-processing is performed on the merged file,
Splitting the post-processed file into N chunks,
storing the N chunks,
computing device. A computer-readable non-transitory storage medium comprising instructions, comprising:
The instructions, when executed by a processor, cause the processor to:
initiating an operation of dividing the transmission target file into M chunks having a preset size;
transmitting the M chunks sequentially to a server, but transmitting the N chunks in parallel through a plurality of connections to the server; and
Initiating transmission of one untransmitted chunk among the M chunks when transmission of any one of the N chunks transmitted in parallel is completed, regardless of whether the transmission of the remaining chunks transmitted in parallel is completed
to perform operations including
A computer-readable non-transitory storage medium. 18. The method of claim 17,
The instructions, when executed by a processor, cause the processor to:
Receiving a message indicating completion of transmission of the transmission target file from the server
to perform operations including
The message indicating the completion of the transmission is received through a connection different from the connection established with the server for transmission of the transmission target file,
A computer-readable non-transitory storage medium.

Images