CN113411363A

CN113411363A - Uploading method of image file, related equipment and computer storage medium

Info

Publication number: CN113411363A
Application number: CN202010183182.6A
Authority: CN
Inventors: 孙思东; 申思
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2020-03-16
Filing date: 2020-03-16
Publication date: 2021-09-17
Also published as: WO2021184992A1

Abstract

The application provides an uploading method of an image file, related equipment and a computer storage medium, wherein the method comprises the following steps: acquiring a target mirror image file; the target mirror image file is fragmented to obtain fragments S₁,S₂,...,S_mAnd the total number m of the fragments, wherein m is a positive integer; to data packet P₁,P₂,...,P_nAnd the total number m of the fragments is sent to the uploading agent equipment, wherein, the data packet P₁Comprising a segment S₁And fragment sequence number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_nComprising a segment S_nAnd a fragment number I_nN is a positive integer, and n is not more than m.

Description

Uploading method of image file, related equipment and computer storage medium

Technical Field

The present application relates to the field of virtualization technologies, and in particular, to an uploading method of an image file, a related device, and a computer storage medium.

Background

In an application scenario of a cloud service, an image service is presented in the form of a portal, so that a user needs to complete registration and uploading of an image through a browser. In the process of uploading files by the browser, the problem of file uploading interruption or uploading failure caused by poor network environment often occurs, and the browser does not support fragment uploading of the files, so that when a user uploads a large image file through the browser and unsuccessfully uploads the large image file to the server, the large image file needs to be uploaded again, and the uploading efficiency of the large image file is greatly reduced.

Currently, for a public cloud image service, a user needs to open a commercial object storage service and upload an image file through a special tool (e.g., a Packer and an OBS Browser), and this way requires that the user can upload the image file after downloading and learning the tool, thereby reducing the usability. For the mirror image service of the private cloud, an enterprise needs to deploy a dedicated object storage service, so that the method consumes higher cost and reduces the usability to a certain extent.

Disclosure of Invention

The embodiment of the application discloses a method for uploading a mirror image file, related equipment and a computer storage medium, which can effectively solve the problems that a browser does not support the uploading of a large mirror image file and the uploading efficiency is low.

In a first aspect, the present application provides an image file uploading method, applied to a client, including:

acquiring a target mirror image file;

the target mirror image file is fragmented to obtain fragments S₁,S₂,...,S_mAnd the total number m of the fragments, wherein m is a positive integer;

to data packet P₁,P₂,...,P_nAnd the total number m of the fragments is sent to an uploading agent device, wherein, the data packet P₁Comprising a segment S₁And fragment sequence number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_nComprising a segment S_nAnd a fragment number I_nN is a positive integer, and n is not more than m.

In some possible designs, where n is less than m, the method further comprises: in case n is smaller than m, the methodThe method also comprises the following steps: sending a breakpoint resume request to the upload agent device to obtain the fragment sequence number I_nThe breakpoint continuous transmission request is used for requesting the fragment serial number corresponding to the fragment with the breakpoint; according to the fragment sequence number I_nData packet P_n+1And sending the data to the uploading agent equipment.

In some possible designs, the packet P is sent to a destination₁,P₂,...,P_nThe sending to the upload agent device includes: using l threads, the data packet P is divided₁,P₂,...,P_lSending the data to the uploading agent equipment in parallel; using the l threads, the data packet P is transmitted_l+1,P_l+2,...,P_2×lSending the data to the uploading agent equipment in parallel; …, respectively; using the l threads, the data packet P is transmitted_n-l+1,P_n-l+2,...,P_nAnd sending the data to the uploading agent equipment in parallel, wherein l is more than or equal to 1 and less than or equal to n/2, and l is a positive integer.

Therefore, the target image file to be uploaded can be fragmented in the client by using the method, and then the fragments of the target image file are sent to the uploading agent device. Therefore, when the uploading of the target image file is interrupted or fails in the uploading process, the client can re-upload the target image file from the fragment with failed transmission, and the uploading efficiency of the target image file is improved. And the client divides the target image file into pieces, and uploads the target image file by uploading the pieces, so that the uploading success rate of the target image file is improved. In addition, the client side can also send the fragments of the target image file to the uploading agent device in parallel, and the uploading efficiency of the target image file can be greatly improved.

In a second aspect, the present application provides another method for uploading an image file, which is applied to an upload agent device, and includes:

receiving the total number m of the fragments and the data packet P sent by the client₁,P₂,...,P_nWherein the data packet P₁Comprising a segment S₁And a fragment number I₁Data packet P₂Comprising a segment S₂And is divided intoChip number I₂…, packet P_nComprising a segment S_nAnd a fragment number I_nSeparation of S₁,S₂,...,S_mThe target image file is obtained by the client by fragmenting the target image file, wherein m and n are positive integers, and n is not more than m;

dividing the total number m of the fragments into S₁,S₂,...,S_nAnd sending the data to the object storage device.

In some possible designs, in the case where n is less than m, the total number of fragments m and the data packet P sent at the receiving client₁,P₂,...,P_nThereafter, the method further comprises: receiving a data packet P sent by the client_n+2,P_n+3,...,P_mAnd dividing into pieces S_n+2,S_n+3,...,S_mTo the object storage device, wherein the data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2Data packet P_n+3Comprising a segment S_n+3And a fragment number I_n+3…, packet P_mComprising a segment S_mAnd a fragment number I_m(ii) a Receiving a breakpoint continuous transmission request sent by the client; according to the breakpoint continuous transmission request, the fragment sequence number I corresponding to the fragment with the breakpoint_nSending the data to the client; receiving the sequence number I of the client according to the fragments_nTransmitted data packet P_n+1And sends the data packet P_n+1Sending the data to the object storage device for the object storage device to use according to the fragment S₁,S₂,...,S_mRestoring the target image file, wherein the data packet P_n+1Comprising a segment S_n+1And a fragment number I_n+1。

In some possible designs, where n is less than m, the method further comprises: receiving a breakpoint continuous transmission request sent by the client; according to the breakpoint continuous transmission request, the fragment sequence number I corresponding to the fragment with the breakpoint_nSending the data to the client; receiving the sequence number I of the client according to the fragments_nFrom said data packet P_n+1The remainder of the transmissionAnd sending the fragments corresponding to the remaining data packets to the object storage device, so that the object storage device can use the fragments S₁,S₂,...,S_mRestoring the target image file, wherein the remaining data packets comprise data packet P_n+1,P_n+2,...,P_mSaid data packet P_n+1Comprising a segment S_n+1And a fragment number I_n+1Said data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2…, packet P_mComprising a segment S_mAnd a fragment number I_m。

In some possible designs, the method further comprises: receiving the data packet P sent by the client₁And calling mirror image management equipment to create a mirror image identifier corresponding to the target mirror image file and storing the mirror image identifier.

In some possible designs, the method further comprises: and calling the mirror image management equipment to refresh the mirror image state corresponding to the target mirror image file.

In the method, the uploading agent equipment receives the fragments of the target image file sent by the client, forwards the fragments to the object storage equipment, and then restores the fragments into the target image file by the object storage equipment, thereby realizing the uploading of the target image file. Meanwhile, when the target image file is uploaded in the uploading process and is interrupted or fails to be uploaded, the uploading agent equipment can send the fragment serial numbers corresponding to the fragments with the breakpoints to the client, so that the client can continuously upload the target image file according to the fragment serial numbers corresponding to the fragments with the breakpoints, and the uploading efficiency and the uploading success rate of the image file are improved.

In a third aspect, the present application provides a client, including:

the acquisition unit is used for acquiring a target mirror image file;

a fragment processing unit for fragmenting the target image file to obtain a fragment S₁,S₂,...,S_mAnd the total number m of the fragments, wherein m is a positive integer;

a transmitting unit for transmitting the data packet P₁,P₂,...,P_nAnd the total number m of the fragments is sent to an uploading agent device, wherein, the data packet P₁Comprising a segment S₁And fragment sequence number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_nComprising a segment S_nAnd a fragment number I_nN is a positive integer, and n is not more than m.

In some possible designs, in case n is smaller than m, the sending unit is further configured to: sending a breakpoint resume request to the upload agent device to obtain the fragment sequence number I_nThe breakpoint continuous transmission request is used for requesting the fragment serial number corresponding to the fragment with the breakpoint; according to the fragment sequence number I_nData packet P_n+1And sending the data to the uploading agent equipment.

In some possible designs, the sending unit is specifically configured to: using l threads, the data packet P is divided₁,P₂,...,P_lSending the data to the uploading agent equipment in parallel; using the l threads, the data packet P is transmitted_l+1,P_l+2,...,P_2×lSending the data to the uploading agent equipment in parallel; …, respectively; using the l threads, the data packet P is transmitted₁,P₂,...,P_nAnd sending the data to the uploading agent equipment in parallel, wherein l is more than or equal to 1 and less than or equal to n/2, and l is a positive integer.

In the client, the fragment processing unit fragments the target image file, so that the client uploads the target image file fragment. When the uploading of the target image file is interrupted or fails in the uploading process, the breakpoint continuous transmission of the image file can be realized by using the client, so that the uploading efficiency of the target image file can be improved, and the uploading success rate of the target image file can be improved. Meanwhile, the sending unit can also realize the concurrent uploading of the fragments, so that the uploading efficiency of the target image file can be improved greatly when the client side is used for uploading the image file.

In a fourth aspect, the present application provides an upload agent apparatus, including:

an obtaining unit, configured to receive a total amount m of fragments and a data packet P sent by a client₁,P₂,...,P_nWherein the data packet P₁Comprising a segment S₁And a fragment number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_nComprising a segment S_nAnd a fragment number I_nSeparation of S₁,S₂,...,S_mThe target image file is obtained by the client by fragmenting the target image file, wherein m and n are positive integers, and n is not more than m;

a sending unit, configured to sum the total number of fragments m and the fragments S₁,S₂,...,S_nAnd sending the data to the object storage device.

In some possible designs, in the case that n is smaller than m, the total number m of fragments and the data packet P sent by the client are received at the obtaining unit₁,P₂,...,P_nThen, the obtaining unit is further configured to receive a data packet P sent by the client_n+2,P_n+3,...,P_mAnd dividing into pieces S_n+2,S_n+3,...,S_mTo the object storage device, wherein the data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2Data packet P_n+3Comprising a segment S_n+3And a fragment number I_n+3…, packet P_mComprising a segment S_mAnd a fragment number I_m(ii) a The acquisition unit is also used for receiving a breakpoint continuous transmission request sent by the client; the sending unit is further configured to send a breakpoint resume request to a corresponding fragment sequence number I of a fragment with a breakpoint_nSending the data to the client; the obtaining unit is further configured to receive the fragment sequence number I from the client_nTransmitted data packet P_n+1And sends the data packet P_n+1Sending the data to the object storage device for the object storage device to use according to the fragment S₁,S₂,...,S_mRestoring the target image file, wherein the data packetP_n+1Comprising a segment S_n+1And a fragment number I_n+1。

In some possible designs, in the case that n is smaller than m, the obtaining unit is further configured to receive a breakpoint resuming request sent by the client; the sending unit is further configured to send a breakpoint resume request to a corresponding fragment sequence number I of a fragment with a breakpoint_nSending the data to the client; the obtaining unit is further configured to receive the fragment sequence number I from the client_nFrom said data packet P_n+1Transmitting the remaining data packets to the object storage device for the object storage device to continue transmitting the remaining data packets according to the fragments S₁,S₂,...,S_mRestoring the target image file, wherein the remaining data packets comprise data packet P_n+1,P_n+2,...,P_mSaid data packet P_n+1Comprising a segment S_n+1And a fragment number I_n+1Said data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2…, packet P_mComprising a segment S_mAnd a fragment number I_m。

In some possible designs, the device further includes a call unit and a progress recording unit, where the call unit is configured to, upon receiving the data packet P sent by the client, send the data packet P to the client₁Then, calling mirror image management equipment to create a mirror image identifier corresponding to the target mirror image file; and the progress recording unit is used for storing the mirror image identifier.

In some possible designs, the calling unit is further configured to: and calling the mirror image management equipment to refresh the mirror image state corresponding to the target mirror image file.

After the acquisition unit receives the fragments of the target image file sent by the client, the sending unit forwards the fragments to the target storage device, so that the target storage device can restore the target image file according to the fragments, and the target image file is uploaded. Moreover, when the target image file is uploaded in the uploading process and is interrupted or fails to be uploaded, the sending unit can send the fragment sequence numbers corresponding to the fragments with the breakpoints to the client, so that the client can continue to upload the target image file according to the fragment sequence numbers corresponding to the fragments with the breakpoints, and the uploading efficiency and the uploading success rate of the image file are improved.

In a fifth aspect, the present application provides an image file uploading system, which is characterized in that the system includes the client described in the third aspect, the uploading agent device described in the fourth aspect, an object storage device, and an image service device, wherein,

the object storage device is used for receiving the fragments S sent by the uploading agent device₁,S₂,...,S_mAnd dividing the slice S₁,S₂,...,S_mRestoring the target image file;

the mirror image management equipment is used for creating a mirror image identifier corresponding to the target mirror image file;

the mirror image management device is also used for refreshing the mirror image state of the target mirror image file.

In the image file uploading system, the client-side fragments the image file, transmits the fragments to the uploading agent device, forwards the fragments to the object storage device by the uploading agent device, and restores the fragments into the target image file by the object storage device, thereby completing the uploading of the target image file. Meanwhile, in the uploading process of the target image file, the image management device refreshes the image state of the target image file so as to determine whether the target image file is uploaded successfully. Therefore, by using the image file uploading system, breakpoint continuous transmission and fragment concurrent uploading of the target image file can be realized, the uploading efficiency of the target image file can be improved, and the uploading success rate of the target image file can be improved.

In a sixth aspect, the present application provides a client comprising a processor and a memory, the processor executing code in the memory to implement some or all of the steps of the first aspect.

In a seventh aspect, the present application provides an upload agent device, comprising a processor and a memory, wherein the processor executes code in the memory to implement part or all of the steps of the second aspect.

In an eighth aspect, the present application provides a computer storage medium storing computer instructions; the computer instructions are for implementing some or all of the steps as described in the first aspect.

In a ninth aspect, the present application provides a computer storage medium storing computer instructions; the computer instructions are for implementing some or all of the steps as described in the second aspect.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings needed to be used in the description of the embodiments are briefly introduced below, and it is obvious that the drawings in the following description are some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.

Fig. 1 is a schematic structural diagram of a cloud system provided in the present application;

FIG. 2 is a schematic diagram of a specific cloud system provided herein;

FIG. 3 is a schematic structural diagram of an image file uploading system provided by the present application;

FIG. 4 is a schematic diagram of a mirror upload interface provided herein;

FIG. 5 is a schematic flow chart of uploading an image file provided by the present application;

FIG. 6 is a schematic flow chart of uploading an image file provided by the present application;

fig. 7 is a schematic structural diagram of a client provided in the present application;

fig. 8 is a schematic structural diagram of an upload agent apparatus provided in the present application;

fig. 9 is a schematic structural diagram of another client provided in the present application;

fig. 10 is a schematic structural diagram of another upload agent apparatus provided in the present application.

Detailed Description

Referring to fig. 1, fig. 1 shows a schematic structural diagram of a cloud system. The cloud system owner deploys the cloud computing infrastructure itself, i.e., deploys computing resources (e.g., servers) 110, deploys storage resources (e.g., memory) 120, and deploys network resources (e.g., network cards) 130, among others. An owner (e.g., an operator) of the public cloud virtualizes the computing resources, storage resources, and network resources of the cloud computing infrastructure and provides corresponding services to users (e.g., users) of the cloud for use. The operator can provide the following three services for the user to use: cloud computing infrastructure as a service (IaaS), platform as a service (PaaS), and software as a service (SaaS).

The services provided by IaaS to users are the utilization of the cloud computing infrastructure, including processing, storage, networking, and other basic computing resources, to enable users to deploy and run arbitrary software, including operating systems and applications. Users do not manage or control any cloud computing infrastructure, but can control operating system selection, storage space, deployment applications, and possibly limited network component (e.g., firewall, load balancer, etc.) control.

The services provided by PaaS to users are the deployment of applications developed or purchased by users in vendor-provided development languages and tools (e.g., Java, python, Net, etc.) onto the cloud computing infrastructure. The user does not need to manage or control the underlying cloud computing infrastructure, including networks, servers, operating systems, storage, etc., but the user can control the deployed applications and possibly also the hosting environment configuration in which the applications are run.

The services provided by SaaS to the user are applications that the operator runs on the cloud computing infrastructure, and the user can access the applications on the cloud computing infrastructure through a client interface (e.g., a browser) on various devices. The user does not need to manage or control any cloud computing infrastructure, including networks, servers, operating systems, storage, and the like.

Therefore, the user can run own business by using the service provided by the operator, such as deep learning, artificial intelligence, big data and the like.

Referring to fig. 2, fig. 2 shows a schematic diagram of a particular cloud system. The cloud system of the present application includes: a cloud management platform 210 and an infrastructure 220. The cloud management platform 210 provides cloud services for users by invoking the infrastructure 220, and the cloud management platform 210 may be OpenStack, cloudstock, Hadoop, AWS (Amazon Web Service), and the like, which is not limited herein.

Cloud management platform 210 may include a total 211, computing services 212, storage services 213, web services 214, and management services 215. Where protal211 may provide a user access to a cloud system or cloud service. The computing service 212 can be a component for deploying virtual machines and the like. The storage service 213 may be used to provide components of distributed, persistent virtual object storage, and the like. Network service 214 may be a component for providing network topology management of network nodes. The management service 215 may be a component for controlling other services.

Taking the cloud management platform 210 as OpenStack for example, the computing service 212 may be Nova, the storage service 213 may be Swift, Cinder, the web service 214 may be Neutron, and the management service 215 may be Glance, Nova, Horizon, Neutron, and Keystone, among others. The Glance is mainly responsible for managing metadata of various images provided in the cloud system, providing image management service for users, and specifically realizing functions of registering, searching, retrieving and the like of virtual machine images, so that users can conveniently select and install operating systems for the virtual machines. Furthermore, the backend storage of the gland supports interfacing with a plurality of storage types, such as Swift, simple storage service (S3), or container storage, and so on. Swift, as a default object storage scheme in OpenStack, is easier to build on a low-cost, standard hardware storage infrastructure than other storage schemes (e.g., S3, container storage, etc.), and supports fragmented upload of large object files (e.g., static large files and dynamic large files).

Therefore, the Swift is used as the back-end storage of the Glance to store the image file uploaded by the client browser. Referring specifically to fig. 3, fig. 3 illustrates an image file uploading system according to the present application. The image file uploading system may specifically include a client 310, an uploading agent device 320, an object storage device 330, and an image management device 340. In the present application, the object storage device 330 is a device with a Swift, and the mirror management device 340 is a device with a company, so the object storage device 330 is hereinafter referred to as the Swift, and the mirror management device 340 is hereinafter referred to as the company. The upload agent device 320, the object storage device 330, and the image management device 340 may be deployed on one computing device, or may be deployed on different computing devices, which is not limited herein.

In the application, when a user uploads a mirror image file through a client 310, firstly, the client 310 performs a fragmentation operation on the mirror image file, then, the fragment of the mirror image file is sent to an uploading proxy device 320, and after receiving the fragment of the mirror image file, the uploading proxy device 320 forwards the fragment of the mirror image file to a Swift330, and calls a Glance340 to refresh the state of the mirror image. Therefore, the system can upload the image file in a client fragment mode, namely, when the uploading of the image file is interrupted or fails in the uploading process, the client can continuously upload the image file from the breakpoint position without uploading the complete image file again, so that the transmission efficiency and the uploading success rate of the image file are greatly improved.

The present application will be described in detail below based on the image file upload system shown in fig. 3.

In a specific embodiment of the application, before the client sends the image file to be uploaded to the secondary management device, the client may receive a login request input by a user through a browser, and send the login request to the cloud management platform. The login request carries an account and a password, the login request is used for requesting to login the mirror image management system, and the mirror image management system is provided by the company. Then, the cloud management platform determines the login authority of the client according to the login request, and if the client has the login authority, a mirror image uploading interface is displayed in the browser interface, as shown in fig. 4. Taking fig. 4 as an example, the image files to be uploaded include a first image file, a second image file, and a third image file. The following description will be made in detail by taking the first image file as an example, and the uploading method of the image file provided by the present application can be specifically divided into the following two cases.

First, a case where the upload of the first image file is not interrupted or failed in the upload process is described. As shown in fig. 5, fig. 5 is a schematic flowchart illustrating an uploading method of an image file provided by the present application. The image file uploading method of the embodiment includes, but is not limited to, the following steps:

s101, the client side obtains a first mirror image file.

In a specific embodiment of the present application, after the client acquires the first image file, it is determined whether the size of the first image file is greater than a preset threshold. If the size of the first image file is larger than a preset threshold value, executing S102; and if the size of the first image file is smaller than or equal to the preset threshold, the client sends the first image file to the uploading proxy equipment, and the uploading proxy equipment forwards the first image file to the Swift for storage. When the Swift receives the first image file, the uploading agent device calls a Glance interface to refresh the image state of the first image file.

In a more specific embodiment, the client receives a dragging instruction input by a user through a browser, and acquires the first image file according to the dragging instruction. The image uploading interface provides a file reading interface, and the dragging instruction is used for dragging the first image file to the file reading interface. The client determines the size of the first image file based on the file reading interface, and if the size of the first image file is larger than a preset threshold, S102 is executed; if the size of the first image file is smaller than or equal to the preset threshold, S107 is executed. In addition, the client may also receive other types of instructions (e.g., a selection instruction) input by the user through the browser, so as to obtain the first image file.

S102, the client performs fragmentation operation on the first image file according to the preset fragmentation sizeTo obtain the fragment S of the first mirror image file₁,S₂,...,S_mAnd a fragmentation total m, wherein m is a positive integer.

In a specific embodiment of the present application, the client performs a fragment operation on the first image file according to a preset fragment size to obtain a fragment S₁,S₂,...,S_mAnd is a segment S₁Adding fragment sequence number I₁Separation of S₂Adding fragment sequence number I₂…, slicing S_mAdding fragment sequence number I_mThereby obtaining a data packet P₁,P₂,...,P_m. Wherein the data packet P₁Comprising a segment S₁And a fragment number I₁Data packet P₂Comprising a segment S₂And a fragment number I₂…, packet P_mComprising a segment S_mAnd a fragment number I_m. Wherein, the sequence number of the fragment I₁,I₂,...,I_mFor representing slices S₁,S₂,...,S_mIn a sequential order, i.e. slicing S₁Is the 1 st slice, slice S₂2 nd fragment, …, fragment S_mThe mth slice.

To be noted, packet P₁,P₂,...,P_mThe first mirror image file may also carry information such as a file name of the first mirror image file and a size of the corresponding fragment, and is not specifically limited herein.

S103, the client side sends the data packet P₁,P₂,...,P_mAnd the total number m of the fragments is sent to the uploading agent equipment.

In one possible embodiment, the client sends packet P₁,P₂,...,P_mAnd sequentially sending the data to the uploading agent equipment.

In another possible embodiment, the client uses l threads to simultaneously transmit packet P₁,P₂,...,P_lSending to the uploading agent device, when the uploading agent device receives the data packet P₁,P₂,...,P_lThen, the client uses the above-mentioned one thread to simultaneously transmit the data packet P_l+1,P_l+2,...,P_2×lTransmitting to the uploading agent device until the client side sends the data packet P₁,P₂,...,P_mAll sent to the upload agent device. Wherein l is more than or equal to 1 and less than or equal to m2, and l is a positive integer. Therefore, the uploading times and the file data stream can be effectively reduced by a fragmentation concurrency mode.

In particular embodiments of the present application, when a client first sends a data packet to an upload agent device (e.g., data packet P)₁Or a data packet P₁,P₂,...,P_l) And then, the uploading proxy equipment calls a Glance interface to create mirror image data, so as to obtain the mirror image Identification (ID) corresponding to the mirror image data. Then, the uploading agent device creates an empty object file named by the mirror ID according to the mirror ID. The mirror metadata is used to describe the first image, and may specifically include an image ID of the first image, a size of the first image, an image state of the first image, an image format (e.g., qcow2 format, vhd format) of the first image, and the like. The image ID is used to identify the first image.

S104, the uploading agent device divides the total number m of the fragments into D₁,D₂,...,D_mAnd sending to Swift.

In one possible embodiment, if the client sends packet P₁,P₂,...,P_mSequentially sending the data to the uploading agent equipment, and then the uploading agent equipment will segment D₁,D₂,...,D_mAnd in turn to Swift.

Specifically, the upload agent device receives the packet P₁Then, according to the data packet P₁And mirror ID, as shard S₁Add object prefix name N₁To obtain a segment D₁Then segment D₁Sent to Swift. Wherein, the object prefix name N₁Including mirror ID and segment D₁Corresponding segment sequence number, segment D₁The corresponding segment sequence number is the fragment sequence number I₁. If Swift receives segment D₁The upload agent device saves segment D in the segment upload record₁Mirror ID and segment D of₁The corresponding segment sequence number. Same as aboveThe transmission agent device receives the data packet P₂Then, according to the data packet P₂And mirror ID, as shard S₂Add object prefix name N₂To obtain a segment D₂Then segment D₂Sent to Swift. Wherein, the object prefix name N₂Including mirror ID and segment D₂Corresponding segment sequence number, segment D₂The corresponding segment sequence number is the fragment sequence number I₂. If Swift receives segment D₂The upload agent device saves segment D in the segment upload record₂Mirror ID and segment D of₂The corresponding segment sequence number. … are provided. The uploading agent equipment receives the data packet P_mThen, according to the data packet P_mAnd mirror ID, as shard S_mAdd object prefix name N_mTo obtain a segment D_mThen segment D_mSent to Swift. Wherein, the object prefix name N_mIncluding mirror ID and segment D_mCorresponding segment sequence number, segment D_mThe corresponding segment sequence number is the fragment sequence number I_m. If Swift receives segment D_mThe upload agent device saves segment D in the segment upload record_mMirror ID and segment D of_mThe corresponding segment sequence number.

The object prefix name may be specifically represented as a mirror ID-segment sequence number, the format of the mirror ID may be set to a storage format default to the global, such as xxxxxxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxxxxxxxxxxxxxx, the segment sequence number may also be set to a storage format default to the global, and the segment sequence numbers are in one-to-one correspondence, such as segment sequence number I₁₅(00015) The corresponding segment sequence number is 00015, so the object prefix name N₁₅Can be represented as xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxx-00015. The segment upload record can be seen in table 1, and the segment S can be seen from table 1₁The corresponding object prefix name is xxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxx-00001, slice S₂The corresponding object prefix name is xxxxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxx-00002, …, slice S_mThe corresponding object prefix name is xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx-m.

TABLE 1 segmented upload records

Mirror ID	Sequence number of segment
		xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx	00001
xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx	00002
		xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx	00003
….	…
		xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx	m

In another possible embodiment, if the client sends packet P₁,P₂,...,P_lSending the P to the uploading agent equipment in parallel_l+1,P_l+2,...,P_2×lIn parallel to the upload agent device …, sends the packet P_m-l+1,P_m-l+2,...,P_mSending the segments to the uploading agent device in parallel, and then the uploading agent device sends the segments D₁,D₂,...,D_lSending the segments D to Swift in parallel_l+1,D_l+2,...,D_2×lSend to Swift, … in parallel, segment D_m-l+1,D_m-l+2,...,D_mParallel transmissionGiven Swift.

Specifically, the upload agent device receives the packet P₁,P₂,...,P_lThen, according to the data packet P₁,P₂,...,P_lAnd mirror ID, respectively, as fragment S₁,S₂,...,S_lAdd object prefix name N₁,N₂,...,N_lTo obtain a segment D₁,D₂,...,D_lThen segment D₁,D₂,...,D_lAnd sent to Swift in parallel. Wherein, the object prefix name N₁Including mirror ID and segment D₁Corresponding segment sequence number, segment D₁The corresponding segment sequence number is the fragment sequence number I₁(ii) a Object prefix name N₂Including mirror ID and segment D₂Corresponding segment sequence number, segment D₂The corresponding segment sequence number is the fragment sequence number I₂(ii) a …, respectively; object prefix name N_lIncluding mirror ID and segment D_mCorresponding segment sequence number, segment D_lThe corresponding segment sequence number is the fragment sequence number I_l. If Swift receives segment D₁,D₂,...,D_lIf so, the upload agent device stores the segments D in the segment upload records respectively₁,D₂,...,D_lMirror ID and segment D of₁,D₂,...,D_lThe corresponding segment sequence number. It should be appreciated that the upload agent device will fragment S_l+1,S_l+2,...,S_2×lParallel to the Swift process, …, the slice S_m-l+1,S_m-l+2,...,S_mSending the same to the Swift process and uploading the agent device to segment S₁,S₂,...,S_lThe process of sending the Swift in parallel is similar, and detailed description is omitted here.

It can be seen that the above steps implement a process from an input stream of the uploading proxy device to an output stream of the Swift, that is, the image file is read from the uploading proxy device and written into the Swift, so that the image file is uploaded to the Swift without local cache, thereby not only improving the uploading efficiency of the image file, but also saving the storage space.

S105、SwiftBy object prefix name N₁,N₂,...,N_mWill divide into pieces S₁,S₂,...,S_mAnd merging the images into a first image file.

In a specific embodiment of the present application, Swift is based on the received segment D₁To obtain a fragment S₁And object prefix name N₁(ii) a Swift according to the received segment D₂To obtain a fragment S₂And object prefix name N₂(ii) a …, respectively; swift according to the received segment D_mTo obtain a fragment S_mAnd object prefix name N_m. Also, Swift is according to segment D₁,D₂,...D_mThe object prefix name of (2) can also obtain the fragment S₁,S₂,...,S_mAnd corresponding segment sequence number, thereby determining the segment S₁,S₂,...,S_mAll belong to a fragment of the first image file. When the Swift receives all the segments, that is, the uploading proxy device determines that the number of the segments recorded in the segment uploading record is the same as the total number m of the segments, the uploading proxy device sends an object file named by a mirror image ID to the Swift, and calls a Swift interface to enable the Swift to obtain the object prefix name N according to the object prefix name₁,N₂,...,N_mThe first mirror image file is divided into sections S₁,S₂,...,S_mAnd merging according to the segment sequence number to obtain a first mirror image file.

S106, the uploading agent device obtains the uploading progress of the first mirror image file according to the segmented uploading record and the total fragment amount m, and then calls a Glance interface to refresh the mirror image state of the first mirror image.

The mirror state includes a queue state, a viewing state, an active state, a kill state, and the like. The queued state represents waiting for the image file to be uploaded; the saving state indicates that the image file is being uploaded; the active state represents that the uploading of the mirror image file is finished, and the mirror image can be used at the moment; the kill state indicates that an error occurred during the uploading of the image file.

In a specific embodiment of the application, the upload agent device determines an upload progress of the first image file according to the segmented upload record, and then calls a Glance interface to refresh an image state corresponding to the first image file. If the image ID and the segment serial number of any segment are not stored in the segment uploading record, the uploading progress of the first image file is 0, and the state of the first image file is queued. If the mirror image IDs of the k segments and the corresponding k segment serial numbers of the k segments are stored in the segment uploading record, it indicates that the uploading progress of the first mirror image file is k/m, and the state of the first mirror image is a saving state at this time. If the mirror image IDs of the m segments and the corresponding m segment serial numbers are stored in the segment uploading record, the uploading progress of the first mirror image file is 100%, and at this time, the state of the first mirror image is an active state. If the uploading process is interrupted or fails, the state of the first mirror image is a killed state.

In the specific embodiment of the present application, when Swift divides a slice S₁,S₂,...,S_mAfter the first mirror image file is combined, the uploading proxy equipment calls a Glance interface to refresh the mirror image state of the first mirror image, and the first mirror image is determined to be in an available state, so that the registration of the first mirror image is completed.

For example, assume that the size of the first image file is 130GB, and the preset fragment size is 50 Megabytes (MB). After the file reading interface receives the first image file, the client processes the first image file into 2663 fragments according to the preset fragment size, namely fragment S₁,S₂,...,S₂₆₆₃Wherein the total number of the fragments is 2663, and the fragments S₁,S₂,...,S₂₆₆₂Are all 50MB, slice S₂₆₆₃Is 20 MB. The client is a fragment S₁,S₂,...,S₂₆₆₃Sequentially adding fragment sequence numbers to obtain a data packet P₁,P₂,...,P₂₆₆₃Wherein the sheet S is divided₁Fragment sequence number I of₁00001, slice S₂Fragment sequence number I of₂Is recorded as 00002, …, slice S₂₆₆₃Fragment sequence number I of₂₆₆₃Noted as 02663. Client side sends data packet P₁And the total amount of the fragments is transmitted to an uploading agent device which receives the data packet P₁And calls the Glance interface to create mirror elementsAnd (4) acquiring a mirror ID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxxxx), and then creating a target object file named by the mirror ID according to the mirror ID. Then, the uploading agent device is based on the data packet P₁And mirror ID, which is the acquired fragment S₁Add object prefix name N₁(xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx-00001) to obtain the segment D₁And segment D₁And forwarded to Swift. When Swift receives segment D₁The uploading agent device will segment D₁The corresponding mirror ID and segment sequence number (00001) are saved in the segment upload record. Similarly, the client will package P₂Sending the data packet to an uploading agent device which sends the data packet to the uploading agent device according to the data packet P₂And mirror ID, to the received fragment S₂Add object prefix name N₂(xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx-00002) to obtain the segment D₂And segment D₂Forwarding to Swift, when Swift receives segment D₂The upload agent device will segment D₂The corresponding mirror image ID and the segment serial number (00002) are stored in the segment uploading record; …, respectively; client side sends data packet P₂₆₆₃Sending the data packet to an uploading agent device which sends the data packet to the uploading agent device according to the data packet P₂₆₆₃And mirror ID, to the received fragment S₂₆₆₃Add object prefix name N₂₆₆₃(xxxxxxxx-xxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxxxxxxxxxx-02663) to give a section D₂₆₆₃And segment D₂₆₆₃Forwarding to Swift, when Swift receives segment D₂₆₆₃The upload agent device will segment D₂₆₆₃The corresponding image ID and segment sequence number (02663) are stored in the segment upload record. At this time, the uploading proxy equipment sends the target object file to the Swift, and will call the Swift interface, so that the Swift can obtain the object prefix name N₁,N₂,...,N₂₆₆₃Will divide into pieces S₁,S₂,...,S₂₆₆₃And merging the images into a first image file. In addition, the uploading agent device also calls a Glance interface periodically to refresh the mirror image state of the first mirror image according to the segmented uploading record and the total amount of the fragments in the uploading process of the first mirror image file. Slicing S at Swift₁,S₂,...,S₂₆₆₃Merge into a first mirror imageAfter the file is stored, the uploading agent device refreshes the mirror image state of the first mirror image by calling a Glance interface, and the mirror image state of the first mirror image is obtained to be an available state, so that the registration of the first mirror image is completed.

In the method, when the uploading interruption or uploading failure of the mirror image file does not occur in the uploading process, the client divides the mirror image file, sends the divided pieces of the mirror image file to the uploading agent device, and forwards the divided pieces corresponding to the divided pieces to the Swift by the uploading agent device, so that the Swift can combine the divided pieces into the mirror image file according to the received divided pieces and the object prefix name. Therefore, the method can realize uploading by using the fragments of the image files instead of the image files, thereby improving the uploading success rate of the image files. In addition, the client can also send the fragments of the image file to the uploading agent device in parallel, and then the uploading agent device sends the fragments to the Swift in parallel, so that the uploading efficiency of the image file is improved.

When the client sends the fragments of the first image file to the upper-generation proxy device, the upload proxy device may not completely receive all the fragments S of the first image file due to network reasons or abnormal upload proxy device₁,S₂,...,S_m. Then, the image file uploading method provided by the present application will be described next by taking an example that an uploading interruption occurs in the uploading process of the first image file or that a single fragmented uploading fails. As shown in fig. 6, fig. 6 is a schematic flowchart illustrating a method for uploading an image file provided by the present application. The image file uploading method of the embodiment includes, but is not limited to, the following steps:

s201, the client sends a breakpoint resuming request to the uploading agent device.

The breakpoint continuous transmission request carries a mirror image ID corresponding to the first mirror image file, and is used for requesting a fragment serial number corresponding to a fragment at the breakpoint when the uploading is interrupted or fails.

In a specific embodiment of the present application, a situation that uploading of a single fragment fails occurs when a client uploads a fragment of a first image file, for example, the client uploads a fragment of a first image fileThe uploading agent device does not receive the fragment S_n+1. Or, when the client uploads the fragment of the first image file, the uploading is interrupted, that is, the uploading agent device does not receive the fragment S_n+1,S_n+2,...,S_m. Wherein n is more than or equal to 1<m and n are positive integers.

In one possible embodiment, when the client sends a packet P to the upload agent device_n+1In time, network interruption, uploading of a data packet which is not supported by the current network environment, abnormality of the uploading agent device and the like occur, so that the uploading agent device does not receive the data packet P_n+1. When the client sends a data packet P to the uploading agent device_n+2When the network environment or the uploading agent equipment and the like return to normal, the uploading agent equipment can receive the data packet P_n+2,P_n+3,...,P_mIn other words, the upload agent apparatus receives the packet P₁,P₂,...,P_n,P_n+2,P_n+3,...,P_m。

In another possible embodiment, when the client sends a packet P to the upload agent device_n+1In time, network interruption, uploading of a data packet which is not supported by the current network environment, abnormality of the uploading agent device and the like occur, so that the uploading agent device cannot receive the slave data packet P_n+1The remaining data packet (P) of the beginning_n+1,P_n+2,...,P_m) At this time, the uploading agent device only receives the data packet P₁,P₂,...,P_n。

S202, the uploading agent equipment sends the fragment sequence number I corresponding to the fragment at the breakpoint to the client according to the breakpoint continuous transmission request_n。

In a specific embodiment of the application, after the upload agent device receives the breakpoint resume request, a company interface is called to refresh the mirror state of the first mirror according to the mirror ID corresponding to the first mirror file, so as to obtain a file upload token (token). Then, the uploading agent device uploads the fragment sequence number I corresponding to the fragment (fragment) with the breakpoint in the record in the fragment uploading mode according to the file uploading token_n(segment sequence number) to the client, so that the clientCan be according to the fragment sequence number I_nFrom the data packet P_n+1And starting the rest data packets which are continuously transmitted.

S203, the client side according to the fragment sequence number I_nAnd sending a data packet corresponding to the uploading failed fragment to the uploading agent equipment, and sending the segment corresponding to the uploading failed fragment to the Swift by the uploading agent equipment.

In one possible embodiment, the client end is based on the fragment sequence number I_nSending data packet P only to upper sub-management device_n+1. Wherein the data packet P_n+1Comprising fragmentation S_n+1And fragment sequence number I_n+1. The uploading agent equipment receives the data packet P_n+1Then, according to the data packet P_n+1And the mirror image ID of the first mirror image file is a fragment S_n+1Add object prefix name N_n+1To obtain a segment D_n+1Then segment D_n+1Sent to Swift. Wherein, the object prefix name N_n+1Including mirror ID and segment D_n+1Corresponding segment sequence number, segment D_n+1The corresponding segment sequence number is the fragment sequence number I_n+1. If Swift receives segment D_n+1The upload agent device saves segment D in the segment upload record_n+1Mirror ID and segment D of_n+1The corresponding segment sequence number.

In another possible embodiment, the client end is based on the fragment sequence number I_nSequentially sending data packets P to the upper sub-management device_n+1,P_n+2,...,P_m. Wherein the data packet P_n+1Comprising fragmentation S_n+1And fragment sequence number I_n+1Data packet P_n+2Comprising fragmentation S_n+2And fragment sequence number I_n+2…, packet P_mComprising fragmentation S_mAnd fragment sequence number I_m. The uploading agent equipment receives the data packet P_n+1Then, according to the data packet P_n+1And mirror ID, as shard S_n+1Add object prefix name N_n+1To obtain a segment D_n+1Then segment D_n+1Sent to Swift. Wherein, the object prefix name N_n+1Including mirror ID and segment D_n+1Corresponding segment sequence number, segment D_n+1The corresponding segment sequence number is the fragment sequence number I_n+1. If Swift receives segment D_n+1The upload agent device saves segment D in the segment upload record_n+1Mirror ID and segment D of_n+1The corresponding segment sequence number. The uploading agent equipment receives the data packet P_n+2Then, according to the data packet P_n+2And mirror ID, as shard S_n+2Add object prefix name N_n+2To obtain a segment D_n+2Then segment D_n+2Sent to Swift. Wherein, the object prefix name N_n+2Including mirror ID and segment D_n+2Corresponding segment sequence number, segment D_n+2The corresponding segment sequence number is the fragment sequence number I_n+2. If Swift receives segment D_n+2The upload agent device saves segment D in the segment upload record_n+2Mirror ID and segment D of_n+2The corresponding segment sequence number. … are provided. The uploading agent equipment receives the data packet P_mThen, according to the data packet P_mAnd mirror ID, as shard S_mAdd object prefix name N_mTo obtain a segment D_mThen segment D_mSent to Swift. Wherein, the object prefix name N_mIncluding mirror ID and segment D_mCorresponding segment sequence number, segment D_mThe corresponding segment sequence number is the fragment sequence number I_m. If Swift receives segment D_mThe upload agent device saves segment D in the segment upload record_mMirror ID and segment D of_mThe corresponding segment sequence number.

In another possible embodiment, the client uses l threads to transmit packet P_n+1,P_n+2,...,P_n+lThe data packets are sent to the uploading agent device in parallel until the uploading agent device receives the data packet P_m. The uploading agent equipment receives the data packet P_n+1,P_n+2,...,P_n+lThen, according to the data packet P_n+1,P_n+2,...,P_n+lAnd mirror ID, respectively, as fragment S_n+1,S_n+2,...,S_n+lAdd object prefix name N_n+1,N_n+2,...,N_n+lThereby obtaining a segment D_n+1,D_n+2,...,D_n+lThen segment D_n+1,D_n+2,...,D_n+lAnd sent to Swift in parallel. Wherein, the object prefix name N_n+1Including mirror ID and segment D_n+1Corresponding segment sequence number, segment D_n+1The corresponding segment sequence number is the fragment sequence number I_n+1(ii) a Object prefix name N_n+2Including mirror ID and segment D_n+2Corresponding segment sequence number, segment D_n+2The corresponding segment sequence number is the fragment sequence number I_n+2(ii) a …, respectively; object prefix name N_n+lIncluding mirror ID and segment D_n+lCorresponding segment sequence number, segment D_n+lThe corresponding segment sequence number is the fragment sequence number I_n+l. If Swift receives segment D_n+1,D_n+2,...,D_n+lIf so, the upload agent device stores the segments D in the segment upload records respectively_n+1,D_n+2,...,D_n+lMirror ID and segment D of_n+1,D_n+2,...,D_n+lThe corresponding segment sequence number.

S205, Swift divides S₁,S₂,...,S_mAnd merging the images into a first image file.

In one possible embodiment, before the client sends the breakpoint resume request to the upload agent device, the Swift stores the segment D₁,D₂,...,D_n,D_n+2,D_n+3,...,D_m. Wherein segment D₁,D₂,...,D_n,D_n+2,D_n+3,...,D_mIs based on data packet P by the uploading agent device₁,P₂,...,P_n,P_n+2,P_n+3,...,P_mAnd mirror ID, respectively, as fragment S₁,S₂,...,S_n,S_n+2,S_n+3,...,S_mAdd object prefix name N₁,N₂,...,N_n,N_n+2,N_n+3,...,N_mAnd then obtaining the product. When Swift receives segment D_nThen Swift according to segment D₁,D₂,...,D_n,D_n+1,D_n+2,...,D_mObject prefix name of (N)₁,N₂,...,N_n,N_n+1,N_n+2,...,N_mWill divide into pieces S₁,S₂,...,S_mAnd merging the images into a first image file.

In another possible embodiment, before the client sends the breakpoint resume request to the upload agent device, the fragment D is saved in the Swift₁,D₂,...,D_n. Wherein segment D₁,D₂,...,D_nIs based on data packet P by the uploading agent device₁,P₂,...,P_nAnd mirror ID, respectively, as fragment S₁,S₂,...,S_nAdd object prefix name N₁,N₂,...,N_nAnd then obtaining the product. When Swift receives segment D_n+1,D_n+2,...,D_mThen Swift according to segment D₁,D₂,...,D_n,D_n+1,D_n+2,...,D_mObject prefix name of (N)₁,N₂,...,N_n,N_n+1,N_n+2,...,N_mWill divide into pieces S₁,S₂,...,S_mAnd merging the images into a first image file.

S206, the uploading agent device obtains the uploading progress of the first mirror image file according to the segmented uploading record and the total fragment amount m, and then calls a Glance interface to refresh the mirror image state of the first mirror image.

In the specific embodiment of the present application, when Swift divides a slice S₁,S₂,...,S_mAfter the first mirror image file is combined, the agent component calls a Glance interface to refresh the mirror image state of the first mirror image, and the first mirror image is determined to be in an available state, so that the registration of the first mirror image is completed. In addition, in the process of breakpoint continuous transmission of the fragments which are failed to upload, the upload agent device can call the Glance interface to refresh the mirror state of the first mirror.

For example, assume that the size of the first image file is 500GB, and the preset fragment size is 200 MB. After the file reading interface receives the first image file, the client browser processes the first image file into 2560 fragments according to the preset fragment size, namely fragment S₁,S₂,...,S₂₅₆₀. Wherein the total number of the slices is 2560Separation of S₁,S₂,...,S₂₅₆₀Are all 200MB in size. The browser is divided into S₁,S₂,...,S₂₅₆₀Sequentially adding fragment sequence numbers to obtain a data packet P₁,P₂,...,P₂₅₆₀. Wherein, the slice S₁Fragment sequence number I of₁00001, slice S₂Fragment sequence number I of₂Is recorded as 00002, …, slice S₂₅₆₀Fragment sequence number I of₂₅₆₀Noted as 02560. Client side sends data packet P₁And the total amount of the fragments is transmitted to an uploading agent device which receives the data packet P₁And calling a Glance interface to create mirror metadata so as to obtain a mirror ID (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxxxxxx), and then creating a target object file named by the mirror ID according to the mirror ID. The uploading agent equipment receives the data packet P₁Then, according to the data packet P₁And mirror ID as fragment S₁Add object prefix name N₁(xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxx-00001), to give segment D₁And segment D₁Sending to Swift, when Swift receives segment D₁The upload agent device saves segment D in the segment upload record₁The corresponding mirror ID and its segment sequence number (00001); client side sends data packet P₂Sending the data packet to an uploading agent device which receives the data packet P₂Then, according to the data packet P₂And mirror ID as fragment S₂Add object prefix name N₂(xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxx-00002) to obtain the segment D₂And segment D₂Sending to Swift, when Swift receives segment D₂The upload agent device saves segment D in the segment upload record₂The corresponding mirror ID and its segment sequence number (00002); …, respectively; client side sends data packet P₂₀₀₀Sending the data packet to an uploading agent device which receives the data packet P₂₀₀₀Then, according to the data packet P₂₀₀₀And mirror ID as fragment S₂₀₀₀Add object prefix name N₂₀₀₀(xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxx-02000) to give a segment D₂₀₀₀And segment D₂₀₀₀Sent to SwiftWhen Swift receives segment D₂₀₀₀The upload agent device saves segment D in the segment upload record₂₀₀₀The corresponding mirror ID and its segment number (02000). When the client sends a data packet P to the uploading agent device₂₀₀₁When, due to network interruption, packet P₂₀₀₁And the remaining data packets cannot be transmitted to the upload agent device. When the network is restored, the client sends a breakpoint resuming request to the uploading agent device. The uploading agent equipment sends the fragment sequence number I to the client according to the breakpoint resume request₂₀₀₀(02000). Then, the client end processes the fragment sequence number I₂₀₀₀Sending data packet P to an upload agent device₂₀₀₁The uploading agent equipment receives the data packet P₂₀₀₁Then, according to the data packet P₂₀₀₁And mirror ID as fragment S₂₀₀₁Add object prefix name N₂₀₀₁(xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxxxxxxxx-02001), thereby obtaining a segment D₂₀₀₁And segment D₂₀₀₁Sending to Swift, when Swift receives segment D₂₀₀₁The upload agent device saves segment D in the segment upload record₂₀₀₁The corresponding mirror ID and its segment number (02001); …, respectively; the client sends a data packet P to the uploading agent device₂₅₆₀The uploading agent equipment receives the data packet P₂₅₆₀Then, according to the data packet P₂₅₆₀And mirror ID as fragment S₂₅₆₀Add object prefix name N₂₅₆₀(xxxxxxxx-xxxx-xxxx-xxxx-xxxxxx-xxxxxxxxxxxxxxxxxx-02560), thereby obtaining a segment D₂₅₆₀And segment D₂₅₆₀Sending to Swift, when Swift receives segment D₂₅₆₀The upload agent device saves segment D in the segment upload record₂₅₆₀The corresponding mirror ID and its segment sequence number (02560). At this time, the upload agent apparatus calls the Swift interface so that the Swift is according to the object prefix name N₁,N₂,...,N₂₅₆₀Will divide into pieces S₁,S₂,...,S₂₅₆₀And merging the images into a first image file. In addition, the uploading agent device also calls a Glance interface periodically to refresh the mirror image state of the first mirror image according to the segmented uploading record and the total amount of the fragments in the uploading process of the first mirror image file. Slicing S at Swift₁,S₂,...,S₂₅₆₀After the first mirror image file is merged, the uploading proxy equipment refreshes the mirror image state of the first mirror image by calling a Glance interface to obtain that the mirror image state of the first mirror image is in an available state, and therefore the registration of the first mirror image is completed.

It should be understood that, when the size of the first image file is smaller than or equal to the preset threshold and the uploading of the first image file is interrupted or failed in the uploading process, the browser uploads the first image file to the uploading agent again, and then the uploading agent forwards the first image file to the Swift for storage. When the Swift receives the first image file again, the uploading agent device calls a Glance interface to refresh the image state of the first image file.

It should be noted that the preset slice size may be 50MB or 200MB, or 60MB or 150MB, etc. in the above embodiments, which is not limited herein.

For simplicity, the data packet P is not described in this embodiment₁,P₂,...,P_n-1,P_n+1,...,P_mP₁,P₂,...,P_mData packet P₁,P₂,...,P_n-1Definition and acquisition procedure of, segment D₁,D₂,...,D_n-1,D_n+1,...,D_mSegment D₁,D₂,...,D_n-1The definition and the acquisition process of (A) are explained in detail, and the Swift is not divided into the slices S₁,S₂,…,S_mThe specific process of merging into the first image file and the process of calling the global interface by the upload agent device to refresh the image state are described in detail, and details of the segment upload record are not described yet, which may be specifically referred to as S101-S107 and related embodiments thereof, and are not described herein again. In this embodiment, only an application scenario where a single fragment upload fails is described, and the similar method may also be applied to an application scenario where multiple fragments upload fails, which is not described herein again. In addition, only the uploading method of the first image file is described in detail in the above two embodiments, and in practical application, the uploading method of the second image file, the third image file and so on is similar to the uploading process of the first image file, and hereAnd will not be described in detail.

In the method, when the uploading of the image file is interrupted or fails in the uploading process, the client sends the breakpoint continuous transmission request to the uploading agent device, so that the fragment serial number corresponding to the fragment with the breakpoint is obtained, the client can resend the fragment with the uploading failure to the uploading agent device, and the uploading process of the image file is completed. Therefore, the method can realize breakpoint continuous transmission of the image file, and improve the uploading success rate and uploading efficiency of the image file. In addition, the client can also send the fragments of the image file to the uploading agent device in parallel, and then the uploading agent device sends the fragments to the Swift in parallel, so that the uploading efficiency of the image file is improved.

With reference to fig. 1 to fig. 6 and the related embodiments, the following will describe related apparatuses related to the embodiments in detail by taking the uploading process of the first image file as an example.

In this embodiment, the client 310 may be an entity for receiving or transmitting a signal at a user side, such as a new generation User Equipment (UE), and specifically may include a mobile phone, a tablet computer, a Personal Digital Assistant (PDA), a Mobile Internet Device (MID), a notebook computer, an intelligent wearable device (e.g., a smart watch, a smart bracelet), and the like. Specifically, referring to fig. 7, fig. 7 is a schematic structural diagram of a client according to the present application. The client 310 may include an acquisition unit 410, a fragment processing unit 420, and a transmission unit 430. Wherein the content of the first and second substances,

the obtaining unit 410 is configured to obtain a first image file.

The fragment processing unit 420 is configured to perform a fragment operation on the first image file according to a preset fragment size to obtain a fragment S of the first image file₁,S₂,...,S_mAnd a fragmentation total m, wherein m is a positive integer.

The sending unit 430 is used for sending the data packet P₁,P₂,...,P_mAnd the total number m of the fragments is sent to the uploading agent equipment.

In a specific embodiment of the present application, the obtaining unit 410 is further configured to determine whether the size of the first image file is greater than a preset threshold after obtaining the first image file, and send the first image file 311 to the fragment processing unit 420 if the size of the first image file is greater than the preset threshold; if the size of the first image file is smaller than or equal to the preset threshold, the first image file is sent to the sending unit 430, and then the sending unit 430 sends the first image file to the upload agent device.

In a more specific embodiment, the obtaining unit 410 may obtain the first image file by receiving a drag instruction input by a user, and obtaining the first image file according to the drag instruction; the obtaining unit 410 may further obtain the first image file and the like according to a selection instruction input by a user, and is not limited in particular here.

In a specific embodiment of the present application, the fragment processing unit 420 is specifically configured to perform a fragment operation on the first image file according to a preset fragment size to obtain a fragment S₁,S₂,...,S_mAnd is a segment S₁Adding fragment sequence number I₁Separation of S₂Adding fragment sequence number I₂…, slicing S_mAdding fragment sequence number I_mThereby obtaining a data packet P₁,P₂,...,P_m. Wherein the data packet P₁Comprising a segment S₁And a fragment number I₁Data packet P₂Comprising a segment S₂And a fragment number I₂…, packet P_mComprising a segment S_mAnd a fragment number I_m. Wherein, the sequence number of the fragment I₁,I₂,...,I_mFor representing slices S₁,S₂,...,S_mIn a sequential order, i.e. slicing S₁Is the 1 st slice, slice S₂2 nd fragment, …, fragment S_mThe mth slice.

In a possible embodiment, when the uploading of the first image file is not interrupted or the uploading fails during the uploading process, the sending unit 430 may send the data packet P₁,P₂,...,P_mAnd sequentially sending the data to the uploading agent equipment. Alternatively, the sending unit 430 uses l threads to simultaneously send the data packet P₁,P₂,...,P_lSending to the uploading agent device, when the uploading agent device receives the data packet P₁,P₂,...,P_lThereafter, the sending unit 430 reuses the l threads to simultaneously send the data packet P_l+1,P_l+2,...,P_2×lTransmitting to the upload agent device until the transmitting unit 430 transmits the packet P₁,P₂,...,P_mAll sent to the upload agent device. Wherein l is more than or equal to 1 and less than or equal to m2, and l is a positive integer. Therefore, the uploading times and the file data stream can be effectively reduced by a fragmentation concurrency mode.

In another possible embodiment, a single fragment (e.g., packet to P) occurs during the upload of the first image file_n+1Corresponding segment S_n+1) When the upload fails, the sending unit 430 is further configured to send a breakpoint resume request to the upload agent device to obtain the fragment sequence number I_nThe breakpoint continuous transmission request carries a mirror image ID corresponding to the first mirror image file, and is used for requesting a fragment serial number corresponding to a fragment where a breakpoint occurs; according to the fragment sequence number I_nData packet P_n+1And sending the data to the uploading agent equipment. It should be understood that the case that the uploading failure of multiple fragments occurs in the uploading process of the first image file is similar to the case that the uploading failure of a single fragment occurs, and the detailed description is omitted here.

In another possible embodiment, the uploading interruption occurs when the first image file is uploaded (for example, in the data packet P)_n+1Where interruption occurs), the sending unit 430 is further configured to send a breakpoint resume request to the upload agent device to obtain the fragment sequence number I_n. The breakpoint continuous transmission request carries a mirror image ID corresponding to the first mirror image file, and is used for requesting a fragment serial number corresponding to a fragment where a breakpoint occurs; according to the fragment sequence number I_nData packet P_n+1,P_n+2,...,P_mAnd sending the data to the uploading agent equipment. Wherein, the sending unit 430 can send the data packet P_n+1,P_n+2,...,P_mSequentially sending the data packets to the uploading agent equipment, and adopting a concurrent uploading mode to transmit the data packets P_n+1,P_n+2,...,P_mAnd sending the request to the upload agent device, specifically please refer to S203.

In the client, the fragment processing unit fragments the mirror image file, so that the client uploads the mirror image file fragments. Moreover, the sending unit can also realize the concurrent uploading of the fragments, so that the uploading efficiency of the target image file can be improved greatly when the client side is used for uploading the image file. In addition, when the uploading of the image file is interrupted or the uploading fails in the uploading process, the sending unit sends a breakpoint continuous transmission request through the upper sub-management device to obtain the fragment serial number corresponding to the fragment with the breakpoint, so that the sending unit can send the data packet corresponding to the fragment with the uploading failure to the upper sub-management device according to the fragment serial number corresponding to the fragment with the breakpoint. Therefore, when the mirror image file is uploaded by the client, breakpoint continuous transmission and fragment concurrent uploading of the mirror image file can be realized, the uploading efficiency of the mirror image file can be improved, and the uploading success rate of the mirror image file can be improved.

The uploading proxy equipment provided by the application can be a software device or a hardware device, and when the uploading proxy equipment is a software device, the uploading proxy equipment can be independently deployed on one computing equipment in any environment (such as a cloud environment, an edge environment, terminal computing equipment and the like), or can be deployed on the same computing equipment with Swift and Glance; when the upload agent device is a hardware device, the upload agent device may be a computing device in any environment. The unit modules in the upload agent device may also be divided into various partitions, and each module may be a software module, a hardware module, or a part of the software module and a part of the hardware module, which are not limited in the present application. Fig. 8 is an exemplary division manner, and as shown in fig. 8, the upload agent device 320 may include an obtaining unit 510, a sending unit 520, a calling unit 530, and a progress recording unit 540. The function of each functional unit is described separately below.

The obtaining unit 510 is configured to receive a total amount m of fragments and a data packet P sent by a client₁,P₂,...,P_mWherein the data packet P₁Comprising a segment S₁And a fragment number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_mComprising a segment S_mAnd a fragment number I_mSeparation of S₁,S₂,...,S_mThe target image file is obtained by fragmenting a target image file by a client, and m is a positive integer.

The transmitting unit 520 is used for transmitting the total number m of the fragments and the fragments S₁,S₂,...,S_mSent to Swift.

The invoking unit 530 is used for receiving the data packet P sent by the client₁And calling the Glance to create the image ID corresponding to the first image file.

The progress recording unit 540 is configured to store the image ID of the first image file, the image size of the first image file, and the segment S₁,S₂,...,S_mSize of (2) and fragment number I₁,I₂,...,I_m。

In a specific embodiment of the present application, the sending unit 520 is sending the slice S to the Swift₁,S₂,...,S_mThe sending unit 520 is also used for the pair of slices S before₁,S₂,...,S_mAdding corresponding object prefix names to obtain a segment D₁,D₂,...,D_mThen segment D₁,D₂,...,D_mSent to Swift. Wherein, the slice S₁Corresponding object prefix name N₁Comprises mirror image ID and fragment sequence number I₁Separation of S₂Corresponding object prefix name N₂Comprises mirror image ID and fragment sequence number I₂…, slicing S_mCorresponding object prefix name N_mComprises mirror image ID and fragment sequence number I_m。

In a possible embodiment, when the first image file is not interrupted or failed to be uploaded during the uploading process, the sending unit 520 is the fragment S₁Add object prefix name N₁To obtain a segment D₁Then segment D₁Sending to Swift, if Swift receives segment D₁Then segment D is saved in the progress recording unit 540₁Mirror image ID and fragment sequence number I of₁(ii) a The transmitting unit 520 is a slice S₂Add object prefix name N₂To obtain a segment D₂Then segment D₂Sending to Swift, if Swift receives segment D₂Then segment D is saved in the progress recording unit 540₂Mirror image ID and fragment sequence number I of₂(ii) a …, respectively; the transmitting unit 520 is a slice S_mAdd object prefix name N_mTo obtain a segment D_mThen segment D_mSending to Swift, if Swift receives segment D_mThen segment D is saved in the progress recording unit 540_mMirror ID and fragment sequence number I_m。

In another possible embodiment, when the first image file is not interrupted or failed to be uploaded during the uploading process, the sending unit 520 respectively is the fragment S₁,S₂,...,S_lAdd object prefix name N₁,N₂,...,N_lTo obtain a segment D₁,D₂,...,D_lThen segment D₁,D₂,...,D_lAnd sent to Swift in parallel. If Swift receives segment D₁,D₂,...,D_lThen the segments D are saved separately in the progress recording unit 540₁,D₂,...,D_lMirror ID and segment D of₁,D₂,...,D_lCorresponding fragment sequence number I₁,I₂,...,I_l. It should be appreciated that the upload agent device will fragment S_l+1,S_l+2,...,S_2×lParallel to the Swift process, …, the slice S_m-l+1,S_m-l+2,...,S_mSending the same to the Swift process and uploading the agent device to segment S₁,S₂,...,S_lThe process of sending the Swift in parallel is similar, and detailed description is omitted here.

In another possible embodiment, a single fragment (e.g., a packet) may appear during the upload of the first image fileCorresponds to P_n+1Corresponding segment S_n+1) The case of uploading failure, that is, the obtaining unit 510 only receives the data packet P sent by the client₁,P₂,...,P_n,P_n+2,P_n+3,...,P_mMeanwhile, the obtaining unit 510 is further configured to receive a breakpoint resume request sent by the client, and the sending unit 520 is further configured to store the fragment sequence number I stored in the progress recording unit 540_nAnd sending the data to the client. Afterwards, the obtaining unit 510 is further configured to receive the client according to the fragment sequence number I_nTransmitted data packet P_n+1The sending unit 520 is also used for being the slice S_n+1Add object prefix name N_n+1Obtaining a segment D_n+1And segment D_n+1Sent to Swift. If Swift receives segment D_n+1Then segment D is saved in the progress recording unit 540_n+1Mirror image ID and fragment sequence number I of_n+1. It should be understood that the case that the uploading failure of multiple fragments occurs in the uploading process of the first image file is similar to the case that the uploading failure of a single fragment occurs, and the detailed description is omitted here.

In another possible embodiment, the upload interruption occurs when the first image file is uploaded (for example, in the data packet P)_n+1Where an interrupt occurs), that is, the obtaining unit 510 receives only the data packet P sent by the client₁,P₂,...,P_nMeanwhile, the obtaining unit 510 is further configured to receive a breakpoint resume request sent by the client, and the sending unit 520 is further configured to store the fragment sequence number I stored in the progress recording unit 540_nAnd sending the data to the client. Afterwards, the obtaining unit 510 is further configured to receive the client according to the fragment sequence number I_nFrom the data packet P_n+1The remaining data packet (P) to be transmitted continuously_n+1,P_n+2,...,P_m) The sending unit 520 is also used for being the slice S_n+1,S_n+2,...,S_mAdd object prefix name N_n+1,N_n+2,...,N_mObtaining a segment D_n+1,D_n+2,...,D_mAnd segment D_n+1,D_n+2,...,D_mSent to Swift. If Swift receives segment D_n+1,D_n+2,...,D_mThen the segments D are saved separately in the progress recording unit 540_n+1,D_n+2,...,D_mCorresponding mirror ID and fragment sequence number I_n+1,I_n+2,...,I_m。

In a specific embodiment of the present application, segment D is received at Swift_mThereafter, that is, the progress recording unit 540 holds the segment D₁,D₂,...,D_mMirror image ID and corresponding fragment sequence number I of₁,I₂,...,I_mAfter that, the calling unit 530 is further configured to call Swift to restore the first image file.

In a specific embodiment of the present application, the invoking unit 530 is further configured to fragment S in Swift₁,S₂,...,S_mAnd after the first image file is merged into the first image file, calling the Glance to refresh the image state of the first image to determine that the first image is in an available state, thereby finishing the registration of the first image. In addition, the invoking unit 530 may also invoke the company to refresh the image state of the first image in real time during the uploading process of the first image file, which is not specifically limited herein.

For simplicity, in this embodiment, a detailed description is not given to a specific process of the upload agent device calling the Swift to restore the first image file, a detailed description is not given to a specific process of the upload agent device calling the global to refresh the image state of the first image, and a detailed description is not given to a specific process of the upload agent device sending the segment corresponding to the segment.

It can be seen that the acquisition unit of the upload agent device receives the data packet sent by the client, may obtain the fragment of the image file, and then the sending unit forwards the segment corresponding to the fragment to the Swift, so that the Swift can obtain the object prefix name and the fragment according to the fragment, thereby reducing the fragment to the image file on the basis of not needing the local cache, and implementing the upload of the target image file. Moreover, when the uploading of the target image file is interrupted or fails in the uploading process, the sending unit can send the fragment serial numbers corresponding to the fragments with the breakpoints to the client, so that the client can continuously upload the fragments with the uploading failure in the image file according to the fragment serial numbers corresponding to the fragments with the breakpoints, and the uploading efficiency and the uploading success rate of the image file are greatly improved.

As shown in fig. 9, fig. 9 shows a schematic structural diagram of another client provided in the present application. Client 310 may specifically include a processor 610, a communication interface 620, and a memory 630. Wherein processor 610, communication interface 620, and memory 630 are coupled by a bus 640.

The processor 610 may be a Central Processing Unit (CPU), a general purpose processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA) or other Programmable Logic Device (PLD), a transistor logic device, a hardware component, or any combination thereof. The processor 610 may implement or perform various exemplary methods described in connection with the present disclosure. Specifically, the processor 610 reads the program code stored in the memory 630 and performs a part or all of the steps of S101 to S103, S201, and S203 in cooperation with the communication interface 620.

The communication interface 620 may be a wired interface, such as an ethernet interface, a controller area network interface, a Local Interconnect Network (LIN) interface, and a FlexRay interface, or a wireless interface, such as a cellular network interface or a wireless lan interface, for communicating with other modules or devices. In particular, the communication interface 620 may be coupled to the upload agent device 320, and so on.

Memory 630 may include volatile memory, such as Random Access Memory (RAM); the memory 630 may also include a non-volatile memory, such as a Read Only Memory (ROM), a flash memory, a Hard Disk Drive (HDD), or a Solid State Drive (SSD), and the memory 630 may also include a combination of the above types of memories. Memory 630 may store program codes as well as program data.The program code is composed of codes of some or all units in the client shown in fig. 7, for example, a code of the acquiring unit 410, a code of the fragment processing unit 420, a code of the transmitting unit 430, and the like. Program data generated by the client shown in fig. 7 during execution of the program, for example, the slice S₁,S₂,...,S_mData packet P₁,P₂,...,P_mThe size of the image file, the number of slices, and so on.

Bus 640 may be a Controller Area Network (CAN) or other implementation internal bus. The bus 640 may be divided into an address bus, a data bus, a control bus, and the like. For ease of illustration, only one thick line is shown in fig. 9, but this does not represent only one bus or one type of bus.

As shown in fig. 10, fig. 10 is a schematic structural diagram illustrating another upload agent device provided in the present application. The upload agent device 320 may specifically include a processor 710, a communication interface 720, and a memory 730. Processor 710, communication interface 720, and memory 730 are coupled by a bus 740.

The processor 710 may be a CPU, general purpose processor, DSP, ASIC, FPGA or other PLD, transistor logic, hardware component, or any combination thereof. The processor 710 may implement or perform various exemplary methods described in connection with the present disclosure. Specifically, processor 710 reads program codes stored in memory 730 and cooperates with communication interface 720 to perform some or all of steps S103-S106, S202-S205.

The communication interface 720 may be a wired interface, such as ethernet interface, controller area network interface, LIN, and FlexRay interface, or a wireless interface, such as a cellular network interface or a wireless lan interface, for communicating with other modules or devices. In particular, communication interface 720 may interface with network device 750, and network device 750 may include, among other things, client 310, Swift330, and pane 340.

Memory 730 may include volatile memory such as RAM; memory 730Non-volatile memory may also be included, such as ROM, flash memory, HDD, or SSD, and memory 730 may also include combinations of the above types of memory. Memory 730 may store program codes as well as program data. The program code is composed of codes of some or all units in the upload agent apparatus shown in fig. 8, for example, a code of the acquiring unit 510, a code of the sending unit 520, a code of the calling unit 530, and the like. Program data generated by the uploading apparatus shown in fig. 8 during the execution of the program, for example, the segment D₁,D₂,...,D_mObject prefix name N₁,N₂,...,N_mSegment upload records, and the like.

The bus 740 may be a CAN or other implementation internal bus. The bus 740 may be divided into an address bus, a data bus, a control bus, and the like. For ease of illustration, only one thick line is shown in fig. 10, but this does not represent only one bus or one type of bus.

The present application also provides a computer storage medium storing computer instructions that are executed by hardware (e.g., a processor, etc.) to implement some or all of the steps (e.g., S101-103, S201, S203) performed by the client 310 in the present application.

The present application also provides a computer storage medium storing computer instructions, which are executed by hardware (e.g., a processor, etc.) to implement some or all of the steps (e.g., S103-S106, S202-S205) executed by the upload agent device 320 in the present application.

In the above embodiments, the implementation may be wholly or partially realized by software, hardware, firmware, or any combination thereof. When implemented in software, may be implemented in whole or in part in the form of a computer instruction product. The computer instruction product includes one or more computer instructions. The processes or functions described in accordance with the embodiments of the present application occur, in whole or in part, when the computer instruction instructions described above are loaded and executed on a computer. The computer may be a general purpose computer, a special purpose computer, a network of computers, or other programmable device. The computer instructions may be stored on a computer readable storage medium or transmitted from one computer readable storage medium to another, for example, the computer instructions may be transmitted from one website, computer, server, or data center to another website, computer, server, or data center via wired (e.g., coaxial cable, fiber optic, digital subscriber line) or wireless (e.g., infrared, wireless, microwave, etc.) means. The computer-readable storage medium can be any available medium that can be accessed by a computer or a data storage device, such as a server, a data center, etc., that includes one or more of the available media. The usable medium may be a magnetic medium (e.g., floppy disk, memory disk, magnetic tape), an optical medium (e.g., DVD), or a semiconductor medium (e.g., SSD), among others. In the foregoing embodiments, the descriptions of the respective embodiments have respective emphasis, and for parts that are not described in detail in a certain embodiment, reference may be made to related descriptions of other embodiments.

In the embodiments provided in the present application, it should be understood that the disclosed apparatus may be implemented in other manners. For example, the above-described embodiments of the apparatus are merely illustrative, and for example, the division of the units is only one type of division of logical functions, and there may be other ways of dividing the actual implementation, for example, a plurality of units or components may be combined or may be integrated into another system, or some features may be omitted or not executed. In addition, the indirect coupling or direct coupling or communication connection between each other shown or discussed may be through some interfaces, indirect coupling or communication connection of devices or units, and may be electrical or in other forms.

The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the elements may be selected according to actual needs to achieve the purpose of the solution of the embodiments of the present application.

In addition, functional units in the embodiments of the present application may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, and can also be realized in a form of a software functional unit.

The integrated unit may be stored in a computer-readable storage medium if it is implemented in the form of a software functional unit and sold or used as a separate product. Based on such understanding, the technical solution of the present application may be substantially implemented or contributed to by the prior art, or all or part of the technical solution may be embodied in a software product, which is stored in a storage medium and includes instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage media may include, for example: u disk, removable hard disk, read only memory, random access memory, magnetic or optical disk, and other various media capable of storing program codes and data files.

While the invention has been described with reference to specific embodiments, the scope of the invention is not limited thereto, and those skilled in the art can easily conceive various equivalent modifications or substitutions within the technical scope of the invention. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims

1. A method for uploading a mirror image file is applied to a client and is characterized by comprising the following steps:

acquiring a target mirror image file;

to data packet P₁,P₂,...,P_nAnd the total number m of the fragments is sent toA sub-management device, wherein the data packet P₁Comprising a segment S₁And fragment sequence number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_nComprising a segment S_nAnd a fragment number I_nN is a positive integer, and n is not more than m.

2. The method of claim 1, wherein in the case that n is less than m, the method further comprises: sending a breakpoint resume request to the upload agent device to obtain the fragment sequence number I_nThe breakpoint continuous transmission request is used for requesting the fragment serial number corresponding to the fragment with the breakpoint;

according to the fragment sequence number I_nData packet P_n+1And sending the data to the uploading agent equipment.

3. Method according to claim 2, characterized in that said packet P is transmitted₁,P₂,...,P_nThe sending to the upload agent device includes:

using l threads, the data packet P is divided₁,P₂,...,P_lSending the data to the uploading agent equipment in parallel; using the l threads, the data packet P is transmitted_l+1,P_l+2,...,P_2×lSending the data to the uploading agent equipment in parallel; …, respectively; using the l threads, the data packet P is transmitted_n-l+1,P_n-l+2,...,P_nAnd sending the data to the uploading agent equipment in parallel, wherein l is more than or equal to 1 and less than or equal to n/2, and l is a positive integer.

4. An uploading method of an image file is applied to an uploading agent device, and is characterized by comprising the following steps:

receiving the total number m of the fragments and the data packet P sent by the client₁,P₂,...,P_nWherein the data packet P₁Comprising a segment S₁And a fragment number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_nComprising segmentsS_nAnd a fragment number I_nSeparation of S₁,S₂,...,S_mThe target image file is obtained by the client by fragmenting the target image file, wherein m and n are positive integers, and n is not more than m;

5. The method according to claim 4, wherein in case n is smaller than m, the total number of fragments m and the data packet P sent at the receiving client are₁,P₂,...,P_nThereafter, the method further comprises:

receiving a data packet P sent by the client_n+2,P_n+3,...,P_mAnd dividing into pieces S_n+2,S_n+3,...,S_mTo the object storage device, wherein the data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2Data packet P_n+3Comprising a segment S_n+3And a fragment number I_n+3…, packet P_mComprising a segment S_mAnd a fragment number I_m；

Receiving a breakpoint continuous transmission request sent by the client;

according to the breakpoint continuous transmission request, the fragment sequence number I corresponding to the fragment with the breakpoint_nSending the data to the client;

receiving the sequence number I of the client according to the fragments_nTransmitted data packet P_n+1And sends the data packet P_n+1Sending the data to the object storage device for the object storage device to use according to the fragment S₁,S₂,...,S_mRestoring the target image file, wherein the data packet P_n+1Comprising a segment S_n+1And a fragment number I_n+1。

6. The method of claim 4, wherein in the case that n is less than m, the method further comprises:

receiving a breakpoint continuous transmission request sent by the client;

receiving the sequence number I of the client according to the fragments_nFrom said data packet P_n+1Transmitting the remaining data packets to the object storage device for the object storage device to continue transmitting the remaining data packets according to the fragments S₁,S₂,...,S_mRestoring the target image file, wherein the remaining data packets comprise data packet P_n+1,P_n+2,...,P_mSaid data packet P_n+1Comprising a segment S_n+1And a fragment number I_n+1Said data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2…, packet P_mComprising a segment S_mAnd a fragment number I_m。

7. The method of claim 5 or 6, further comprising:

receiving the data packet P sent by the client₁And calling mirror image management equipment to create a mirror image identifier corresponding to the target mirror image file and storing the mirror image identifier.

8. The method according to any one of claims 4 to 7, further comprising: and calling the mirror image management equipment to refresh the mirror image state corresponding to the target mirror image file.

9. A client, comprising:

the acquisition unit is used for acquiring a target mirror image file;

a transmission unit forTo data packet P₁,P₂,...,P_nAnd the total number m of the fragments is sent to an uploading agent device, wherein, the data packet P₁Comprising a segment S₁And fragment sequence number I₁Data packet P₂Comprising a segment S₂And fragment sequence number I₂…, packet P_nComprising a segment S_nAnd a fragment number I_nN is a positive integer, and n is not more than m.

10. The client according to claim 9, wherein in case n is smaller than m, the sending unit is further configured to:

sending a breakpoint resume request to the upload agent device to obtain the fragment sequence number I_nThe breakpoint continuous transmission request is used for requesting the fragment serial number corresponding to the fragment with the breakpoint;

11. The client according to claim 10, wherein the sending unit is specifically configured to:

using l threads, the data packet P is divided₁,P₂,...,P_lSending the data to the uploading agent equipment in parallel; using the l threads, the data packet P is transmitted_l+1,P_l+2,...,P_2×lSending the data to the uploading agent equipment in parallel; …, respectively; using the l threads, the data packet P is transmitted₁,P₂,...,P_nAnd sending the data to the uploading agent equipment in parallel, wherein l is more than or equal to 1 and less than or equal to n/2, and l is a positive integer.

12. An upload agent apparatus, comprising:

13. The apparatus according to claim 12, wherein in case that n is smaller than m, the obtaining unit receives the total amount of fragments m and the data packet P sent by the client₁,P₂,...,P_nAfter that time, the user can use the device,

the obtaining unit is further configured to receive a data packet P sent by the client_n+2,P_n+3,...,P_mAnd dividing into pieces S_n+2,S_n+3,...,S_mTo the object storage device, wherein the data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2Data packet P_n+3Comprising a segment S_n+3And a fragment number I_n+3…, packet P_mComprising a segment S_mAnd a fragment number I_m；

The acquisition unit is also used for receiving a breakpoint continuous transmission request sent by the client;

the sending unit is further configured to send a breakpoint resume request to a corresponding fragment sequence number I of a fragment with a breakpoint_nSending the data to the client;

the obtaining unit is further configured to receive the fragment sequence number I from the client_nTransmitted data packet P_n+1And sends the data packet P_n+1Sending the data to the object storage device for the object storage device to use according to the fragment S₁,S₂,...,S_mRestoring the target image file, wherein the data packet P_n+1Comprising a segment S_n+1And a fragment number I_n+1。

14. The apparatus of claim 12, wherein in the case where n is less than m,

the obtaining unit is further configured to receive the fragment sequence number I from the client_nFrom said data packet P_n+1Transmitting the remaining data packets to the object storage device for the object storage device to continue transmitting the remaining data packets according to the fragments S₁,S₂,...,S_mRestoring the target image file, wherein the remaining data packets comprise data packet P_n+1,P_n+2,...,P_mSaid data packet P_n+1Comprising a segment S_n+1And a fragment number I_n+1Said data packet P_n+2Comprising a segment S_n+2And a fragment number I_n+2…, packet P_mComprising a segment S_mAnd a fragment number I_m。

15. The apparatus according to claim 13 or 14, characterized in that the apparatus further comprises a call unit and a progress recording unit,

the calling unit is used for receiving the data packet P sent by the client₁Then, calling mirror image management equipment to create a mirror image identifier corresponding to the target mirror image file;

and the progress recording unit is used for storing the mirror image identifier.

16. The apparatus according to any one of claims 12 to 15, wherein the invoking unit is further configured to: and calling the mirror image management equipment to refresh the mirror image state corresponding to the target mirror image file.

17. An image file uploading system, comprising the client terminal of any one of claims 9 to 11, the uploading agent device of any one of claims 12 to 16, the object storage device, and the image service device, wherein,

18. A client comprising a processor and a memory, the processor executing code in the memory to implement the method of any one of claims 1 to 3.

19. An upload agent apparatus comprising a processor and a memory, the processor executing code in the memory to implement the method of any of claims 4 to 8.

20. A computer storage medium having stored thereon computer instructions; the computer instructions are for implementing the method of any one of claims 1 to 3.

21. A computer storage medium having stored thereon computer instructions; the computer instructions are for implementing the method of any one of claims 4 to 8.