Upload many objects

  import 
  
 com.google.cloud.storage.transfermanager. ParallelUploadConfig 
 
 ; 
 import 
  
 com.google.cloud.storage.transfermanager. TransferManager 
 
 ; 
 import 
  
 com.google.cloud.storage.transfermanager. TransferManagerConfig 
 
 ; 
 import 
  
 com.google.cloud.storage.transfermanager. UploadResult 
 
 ; 
 import 
  
 java.io.IOException 
 ; 
 import 
  
 java.nio.file.Path 
 ; 
 import 
  
 java.util.List 
 ; 
 class 
 UploadMany 
  
 { 
  
 public 
  
 static 
  
 void 
  
 uploadManyFiles 
 ( 
 String 
  
 bucketName 
 , 
  
 List<Path> 
  
 files 
 ) 
  
 throws 
  
 IOException 
  
 { 
  
  TransferManager 
 
  
 transferManager 
  
 = 
  
  TransferManagerConfig 
 
 . 
 newBuilder 
 (). 
 build 
 (). 
  getService 
 
 (); 
  
  ParallelUploadConfig 
 
  
 parallelUploadConfig 
  
 = 
  
  ParallelUploadConfig 
 
 . 
 newBuilder 
 (). 
 setBucketName 
 ( 
 bucketName 
 ). 
 build 
 (); 
  
 List<UploadResult> 
  
 results 
  
 = 
  
 transferManager 
 . 
  uploadFiles 
 
 ( 
 files 
 , 
  
 parallelUploadConfig 
 ). 
  getUploadResults 
 
 (); 
  
 for 
  
 ( 
  UploadResult 
 
  
 result 
  
 : 
  
 results 
 ) 
  
 { 
  
 System 
 . 
 out 
 . 
 println 
 ( 
  
 "Upload for " 
  
 + 
  
 result 
 . 
 getInput 
 (). 
 getName 
 () 
  
 + 
  
 " completed with status " 
  
 + 
  
 result 
 . 
 getStatus 
 ()); 
  
 } 
  
 } 
 } 
 

  /** 
 * TODO(developer): Uncomment the following lines before running the sample. 
 */ 
 // The ID of your GCS bucket 
 // const bucketName = 'your-unique-bucket-name'; 
 // The ID of the first GCS file to upload 
 // const firstFilePath = 'your-first-file-name'; 
 // The ID of the second GCS file to upload 
 // const secondFilePath = 'your-second-file-name'; 
 // Imports the Google Cloud client library 
 const 
  
 { 
 Storage 
 , 
  
 TransferManager 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/storage 
' 
 ); 
 // Creates a client 
 const 
  
 storage 
  
 = 
  
 new 
  
 Storage 
 (); 
 // Creates a transfer manager client 
 const 
  
 transferManager 
  
 = 
  
 new 
  
  TransferManager 
 
 ( 
 storage 
 . 
 bucket 
 ( 
 bucketName 
 )); 
 async 
  
 function 
  
 uploadManyFilesWithTransferManager 
 () 
  
 { 
  
 // Uploads the files 
  
 await 
  
 transferManager 
 . 
  uploadManyFiles 
 
 ([ 
 firstFilePath 
 , 
  
 secondFilePath 
 ]); 
  
 for 
  
 ( 
 const 
  
 filePath 
  
 of 
  
 [ 
 firstFilePath 
 , 
  
 secondFilePath 
 ]) 
  
 { 
  
 console 
 . 
 log 
 ( 
 ` 
 ${ 
 filePath 
 } 
 uploaded to 
 ${ 
 bucketName 
 } 
 .` 
 ); 
  
 } 
 } 
 uploadManyFilesWithTransferManager 
 (). 
 catch 
 ( 
 console 
 . 
 error 
 ); 
 

  def 
  
 upload_many_blobs_with_transfer_manager 
 ( 
 bucket_name 
 , 
 filenames 
 , 
 source_directory 
 = 
 "" 
 , 
 workers 
 = 
 8 
 ): 
  
 """Upload every file in a list to a bucket, concurrently in a process pool. 
 Each blob name is derived from the filename, not including the 
 `source_directory` parameter. For complete control of the blob name for each 
 file (and other aspects of individual blob metadata), use 
 transfer_manager.upload_many() instead. 
 """ 
 # The ID of your GCS bucket 
 # bucket_name = "your-bucket-name" 
 # A list (or other iterable) of filenames to upload. 
 # filenames = ["file_1.txt", "file_2.txt"] 
 # The directory on your computer that is the root of all of the files in the 
 # list of filenames. This string is prepended (with os.path.join()) to each 
 # filename to get the full path to the file. Relative paths and absolute 
 # paths are both accepted. This string is not included in the name of the 
 # uploaded blob; it is only used to find the source files. An empty string 
 # means "the current working directory". Note that this parameter allows 
 # directory traversal (e.g. "/", "../") and is not intended for unsanitized 
 # end user input. 
 # source_directory="" 
 # The maximum number of processes to use for the operation. The performance 
 # impact of this value depends on the use case, but smaller files usually 
 # benefit from a higher number of processes. Each additional process occupies 
 # some CPU and memory resources until finished. Threads can be used instead 
 # of processes by passing `worker_type=transfer_manager.THREAD`. 
 # workers=8 
 from 
  
 google.cloud.storage 
  
 import 
  Client 
 
 , 
  transfer_manager 
 
 storage_client 
 = 
 Client 
 () 
 bucket 
 = 
 storage_client 
 . 
  bucket 
 
 ( 
 bucket_name 
 ) 
 results 
 = 
  transfer_manager 
 
 . 
  upload_many_from_filenames 
 
 ( 
 bucket 
 , 
 filenames 
 , 
 source_directory 
 = 
 source_directory 
 , 
 max_workers 
 = 
 workers 
 ) 
 for 
 name 
 , 
 result 
 in 
 zip 
 ( 
 filenames 
 , 
 results 
 ): 
 # The results list is either `None` or an exception for each filename in 
 # the input list, in order. 
 if 
 isinstance 
 ( 
 result 
 , 
 Exception 
 ): 
 print 
 ( 
 "Failed to upload 
 {} 
 due to exception: 
 {} 
 " 
 . 
 format 
 ( 
 name 
 , 
 result 
 )) 
 else 
 : 
 print 
 ( 
 "Uploaded 
 {} 
 to 
 {} 
 ." 
 . 
 format 
 ( 
 name 
 , 
 bucket 
 . 
 name 
 ))