Copy files

Updated at：2025-11-03

Copy files

Copy a file

Users can copy an object using the copy_object function, as shown in the following code:

                Cpp
                
                void copyObject(Client& client, std::string destBucketName, std::string destKey, const std::string& srcBucketName, const std::string& srcKey) {
    
 // Copy Object
 int ret = client.copy_object(srcBucketName, srcKey, destBucketName, destKey, "STANDARD");//The target object is standard storage
}

The CopyObjectResponse object contains the ETag and modification time of the new object.

Users can also copy object via CopyObjectRequest. the code is as follows:

                Cpp
                
            

                // Initialize a client
Client client = ...;
    
 // Create CopyObjectRequest object
CopyObjectRequest copyObjectRequest(destBucketName, destKey, srcBucketName, srcKey);
    
 // Set Metadata
ObjectMetaData* userMetadata = copyObjectRequest.mutable_meta();
userMetadata->set_user_meta("userMetaKey", "userMetaValue");
    
 // Copy Object
CopyObjectResponse copyObjectResponse;
int ret = client.copy_object(copyObjectRequest, &copyObjectResponse);
    
std::cout << "ETag: " + copyObjectResponse.etag() <<
 " LastModified: " << copyObjectResponse.last_modified());
            

Synchronous copy function

Currently, BOS’s CopyObject API operates in a synchronous manner. This means BOS waits until the copy operation is fully completed before returning a success status. While synchronous copying provides a more accurate status for users, it also takes longer and is proportional to the file size.

The synchronous copy approach aligns better with industry standards and improves compatibility with other platforms. It also simplifies the server’s business logic and enhances service efficiency.

Multipart copy

Apart from using the CopyObject API for copying, BOS offers another method—Multipart Upload Copy. This method is suitable for the following application scenarios (but not limited to these):

When a resumable copy process is required.
For copying files larger than 5GB.
When the connection to the BOS server frequently disconnects due to poor network conditions.

The following section introduces the step-by-step process for implementing the three-step copy method.

The three-step copy process includes three stages: initialization ("init"), "copy part," and completion. The initialization and completion steps are the same as those for multipart uploads.

For easier understanding, the complete code for three-step copy is provided below:

                Cpp
                
            

                //Step I: init
InitMultiUploadRequest initMultiUploadRequest("targetBucketName","targetObjectName");
InitMultiUploadResponse initMultiUploadResponse;
client.init_multipart_upload(initMultiUploadRequest, &initMultiUploadResponse);
 //Get object size
HeadObjectRequest request("targetBucketName", "targetObjectName");
HeadObjectResponse response;
client.head_object(request, &response);
if (response.is_fail()) {
    return RET_SERVICE_ERROR;
}
long left_size = response.meta().content_length();
 //Step II: Multipart copy
long skipBytes = 0;
int partNumber = 1;
std::vector<part_t> partETags;
while (left_size > 0) {
    long partSize = 1024 * 1024 * 5L;
    if (left_size < partSize) {
        partSize = left_size;
    }
    CopyPartRequest copyPartRequest;
    copyPartRequest.set_upload_id(initMultiUploadResponse.upload_id());
    copyPartRequest.set_bucket_name("targetBucketName");
    copyPartRequest.set_object_name("targetObjectName");
    copyPartRequest.set_source_bucket_name("sourceBucketName");
    copyPartRequest.set_source_object_name("sourceObjectName");
    copyPartRequest.set_range(skipBytes, skipBytes + partSize - 1);
    copyPartRequest.set_part_number(partNumber);
    CopyPartResponse copyPartResponse;
    client.copy_part(copyPartRequest, &copyPartResponse);
 //Save the returned partNumber and ETag to the vector
    part_t partInfo;
    partInfo.etag = copyPartResponse.etag();
    partInfo.part_number = partNumber;
    partETags.push_back(partInfo);
    left_size -= partSize;
    skipBytes += partSize;
    partNumber+=1;
}
 //Step III: complete
CompleteMultipartUploadRequest completeMultipartUploadRequest("targetBucketName", "targetObjectName", initMultiUploadResponse.upload_id());
 //Add part information, i.e., the order of part merging
for (part_t partInfo : partEtags) {
    completeMultipartUploadRequest.add_part(partInfo.part_number, partInfo.etag);
}
    
 // Complete multipart upload
CompleteMultipartUploadResponse completeMultipartUploadResponse;
int ret = client.complete_multipart_upload(completeMultipartUploadRequest, &completeMultipartUploadResponse);
    
 // Print Object's ETag
std::cout << completeMultipartUploadResponse.etag() << std::endl;
            

Note:

The offset parameter is specified in bytes and represents the starting position of the part within the file.

The size parameter is in bytes and defines the size of each part. Except for the last part, the size of other Parts must be larger than 5MB。

Using convenience APIs

parallel_copy uses a concurrent API to improve request throughput and implement multipart copy

                C++
                
                client.parallel_copy(srcBucketName, sourceObjectName, destBucketName, destObjectName);

Bucket management

Object permission control