files.com 1.1.794 → 1.1.796

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b13b897dc28165d84d3736775184a54e5fabc23d80109a575e87f2945512598
-  data.tar.gz: 6882635f60763cf6c6348051946fc2e9afb3c1d1d0021455d82d987e43dceaf3
+  metadata.gz: 86cf131c69ae6f5ed14759519a6eda0fc7418da517049dd58742d0d6e88e6f03
+  data.tar.gz: 1f12f821cf54a85007457ffbe4ece5d8188746fa91c649f136519b25da09e891
 SHA512:
-  metadata.gz: e9bd784476603c454fe028c45e09a2ed5f25380e60cace4b9cae1c5fe33fb6faf7091881ca609d171416fe73d48f29ff1aae339975b289b321800f4c0bcbeaf5
-  data.tar.gz: 4af70dc19ba7ccf9d8035e4633d78ba2c10e52e4ba677e5b41b440bf1c20b502722483e42966d4d01b94b093c494453575158cc6b5c105bf4b1ea2a77025abbd
+  metadata.gz: 1d9027441e8bec7da48773e17a0d588dbce31b6748569539fa1836db5330256cae1812ce8cfa54d48cea818c8261ce319b36fca8db570baf9314898bc6054fa0
+  data.tar.gz: 3f55c0d42f68137795ac00df50a0a5d5988c9d717f544b1124a5095af4a4c04dc0bf31808154ce7c70d9ef9c4726dc963a1853813a8689b8b3c9365f5804e087

data/Gemfile.lock

@@ -103,4 +103,4 @@ DEPENDENCIES
   rubocop
 
 BUNDLED WITH
-  4.0.21
+  4.0.23

data/_VERSION

@@ -1 +1 @@
-1.1.794
+1.1.796

data/lib/files.com/models/file.rb

@@ -72,9 +72,9 @@ module Files
       PathUtil.normalize("_", root, id.to_s, relative_path)
     end
 
-    def self.upload_to_remote_server(path, remote_server_id, destination = nil, options = {}, params: {})
+    def self.upload_to_remote_server(path, remote_server_id, destination = nil, options = {}, params: {}, progress: nil)
       destination ||= ::File.basename(path)
-      upload_file(path, underscore_destination_path("RemoteServers", remote_server_id, destination), options, params: params)
+      upload_file(path, underscore_destination_path("RemoteServers", remote_server_id, destination), options, params: params, progress: progress)
     end
 
     def self.copy_to_remote_server(path, remote_server_id, destination, params = {}, options = {})
@@ -85,9 +85,9 @@ module Files
       move(path, params.merge(destination: underscore_destination_path("RemoteServers", remote_server_id, destination)), options)
     end
 
-    def self.upload_to_snapshot(path, snapshot_id, destination = nil, options = {}, params: {})
+    def self.upload_to_snapshot(path, snapshot_id, destination = nil, options = {}, params: {}, progress: nil)
       destination ||= ::File.basename(path)
-      upload_file(path, underscore_destination_path("Snapshots", snapshot_id, destination), options, params: params)
+      upload_file(path, underscore_destination_path("Snapshots", snapshot_id, destination), options, params: params, progress: progress)
     end
 
     def self.copy_to_snapshot(path, snapshot_id, destination, params = {}, options = {})
@@ -98,9 +98,9 @@ module Files
       move(path, params.merge(destination: underscore_destination_path("Snapshots", snapshot_id, destination)), options)
     end
 
-    def self.upload_to_child_site(path, site_id, destination = nil, options = {}, params: {})
+    def self.upload_to_child_site(path, site_id, destination = nil, options = {}, params: {}, progress: nil)
       destination ||= ::File.basename(path)
-      upload_file(path, underscore_destination_path("Sites", site_id, destination), options, params: params)
+      upload_file(path, underscore_destination_path("Sites", site_id, destination), options, params: params, progress: progress)
     end
 
     def self.copy_to_child_site(path, site_id, destination, params = {}, options = {})
@@ -207,27 +207,59 @@ module Files
       paths.map { |p| delete(p) }
     end
 
-    def self.upload_chunks(io, path, options, upload = nil, etags = [], params: {})
+    # Uploads what io holds to path, a part at a time as the API grants each, and returns the last part, the parts'
+    # ETags and the bytes sent. Each part is filled from as many reads as it takes (read_part). With progress, a
+    # callable, each part's response must be a success (2xx) before the part counts as acknowledged; progress is then
+    # called with total_bytes (nil: unknown here), acknowledged_bytes (this call's bytes so far), part_number and
+    # part_bytes. Anything it raises ends the upload there, with no later part planned or sent.
+    def self.upload_chunks(io, path, options, upload = nil, etags = [], params: {}, progress: nil)
       etags ||= []
       bytes_written = 0
       request_parts = options[:size] && options[:size] < 5.megabytes ? 1 : 5
       loop do
         begin_upload = File.begin_upload(path, params.merge(ref: upload&.ref, parts: request_parts, part: (upload&.part_number || 0) + 1), options) if begin_upload.nil? || begin_upload.empty?
         upload = begin_upload.is_a?(Enumerable) ? begin_upload.shift : begin_upload
-        buf = io.read(upload.partsize) || ""
+        buf = read_part(io, upload.partsize)
         bytes_written += buf.length
         method = upload.http_method.downcase.to_sym
         response = client(options).remote_request(method, upload.upload_uri, { 'Content-Length': buf.length.to_s, 'Content-Type': 'application/octet-stream' }, buf)
+        raise APIError.new("Transfer request failed", http_status: response.status), cause: nil if progress && !response.status.between?(200, 299)
+
         etags << { etag: response.headers["ETag"], part: upload.part_number }
+        progress&.call({ total_bytes: nil, acknowledged_bytes: bytes_written, part_number: upload.part_number, part_bytes: buf.length })
         return upload, etags, bytes_written if io.eof?
       end
     end
 
-    def self.upload_file(path, destination = nil, options = {}, params: {})
+    # The next part's bytes from io: as many reads as it takes to fill length bytes. A read that gives nothing (nil or
+    # "") ends the part when io.eof? says the source has ended; before its end, the source made no progress, and the
+    # part is not sent.
+    private_class_method def self.read_part(io, length)
+      buf = String.new(encoding: Encoding::BINARY)
+      while buf.bytesize < length
+        chunk = io.read(length - buf.bytesize)
+        if chunk.nil? || chunk.empty?
+          break if io.eof?
+
+          raise InvalidParameterError, "The upload source returned no bytes before its end"
+        end
+        # A read that fills the part at once, as an IO's or a StringIO's does, is sent as it came.
+        return chunk if buf.empty? && chunk.bytesize == length
+
+        buf << chunk.b
+      end
+      buf
+    end
+
+    # With progress, a callable, it is called after each part is acknowledged, as upload_chunks reports it, with
+    # total_bytes the local file's size.
+    def self.upload_file(path, destination = nil, options = {}, params: {}, progress: nil)
       local_file = ::File.open(path, 'r')
       destination ||= File.basename(path)
       params[:size] ||= local_file.size
-      upload, etags = upload_chunks(local_file, destination, options, params: params)
+      total_bytes = local_file.size
+      report = progress && ->(part) { progress.call(part.merge(total_bytes: total_bytes)) }
+      upload, etags = upload_chunks(local_file, destination, options, params: params, progress: report)
 
       params = {
         action: "end",