filestack 2.7.0 → 2.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36cd3251f64e64ffcdb9d42c73cbf6d49bcda8a2533cb8053e0087229a077bf2
-  data.tar.gz: f2e38e698557c0b336c332be5b68775fe2624e046a56e1c521717554f23b6495
+  metadata.gz: 8293c3bf008ad994166882a2029f0936ee64f4c070ef41040d2c97f492f37cb4
+  data.tar.gz: 7749e600bce0dc504a943553ea6e807a5ed4aab8f43813a2cc62fd78d61905ff
 SHA512:
-  metadata.gz: 26a1b21b1ad69ae42708e94323e28d7656881824e668677b0dc27a4bb13a035ed6f5b104f90615a0e53bf3b454621fa3a3e129a6a412eed15dd7271f33100f84
-  data.tar.gz: 4d2c6c3e96da48df28e067f6990e3313669ffb2cf0f33f62964db5f708b42b0818c9992cec713c0b70acc6db72425bb727545726a1757c9c64c9dc7addcf6090
+  metadata.gz: f44323a268793efb45679967fbeafe880ab3b21299744c5ab545d066bfe72007af5673d4e750e789d400469ae6e3888ba58459f8f5d41713d31d527bdc7f4147
+  data.tar.gz: 01d18cbf962f1548b8cdca6db43d15705d07c15647c638710eaf90d9bba419e315f2fc39ef15ee48bc0e247f4cf7cbcd0bb094525413ded7d4cf341584e90cec

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Filestack-Ruby Changelog
 
+## 2.8.0 (September 29, 2020)
+- Add IO object upload
+
 ## 2.7.0 (September 28, 2020)
 - Add workflows
 

data/README.md

@@ -55,13 +55,33 @@ filelink = client.upload(filepath: '/path/to/localfile')
 # OR
 
 filelink = client.upload(external_url: 'http://domain.com/image.png')
+
+# OR
+
+file = StringIO.new
+filelink = client.upload(io: file)
 ```
 
-To upload a local and an external file with query parameters:
+To upload a local, an IO object and an external file with following optional options:
+
 ```ruby
-filelink = client.upload(filepath: '/path/to/localfile', options: { mimetype: 'image/png' })
+options = {
+  filename: 'string',
+  location: 'string',
+  path: 'string',
+  container: 'string',
+  mimetype: 'string',
+  region: 'string',
+  workflows: ['workflow-id-1', 'workflow-id-2'],
+  upload_tags: {
+    key: 'value',
+    key2: 'value'
+  }
+}
+
+filelink = client.upload(filepath: '/path/to/localfile', options: { mimetype: 'image/png', filename: 'custom_filename.png' })
 
-filelink = client.upload(external_url: 'http://domain.com/image.png', options: { mimetype: 'image/jpeg' })
+filelink = client.upload(external_url: 'http://domain.com/image.png', options: { mimetype: 'image/jpeg', filename: 'custom_filename.png' })
 ```
 
 To store file on `dropbox`, `azure`, `gcs` or `rackspace`, you must have the chosen provider configured in the developer portal to enable this feature. By default the file is stored on `s3`. You can add more details of the storage in `options`.

data/VERSION

@@ -1 +1 @@
-2.7.0
+2.8.0

data/lib/filestack/config.rb

@@ -22,6 +22,8 @@ class FilestackConfig
     'Accept-Encoding' => "application/json"
   }.freeze
 
+  DEFAULT_UPLOAD_MIMETYPE = 'application/octet-stream'
+
   INTELLIGENT_ERROR_MESSAGES = ['BACKEND_SERVER', 'BACKEND_NETWORK', 'S3_SERVER', 'S3_NETWORK']
 
   def self.multipart_start_url

data/lib/filestack/models/filestack_client.rb

@@ -23,23 +23,25 @@ class FilestackClient
     @security = security
   end
 
-  # Upload a local file or external url
+  # Upload a local file, external url or IO object
   # @param [String]               filepath         The path of a local file
   # @param [String]               external_url     An external URL
+  # @param [StringIO]             io               The IO object
   # @param [Hash]                 options          User-supplied upload options
+  # @param [Boolean]              intelligent      Upload file using Filestack Intelligent Ingestion
+  # @param [String]               storage          Default storage to be used for uploads
   #
   # return [Filestack::FilestackFilelink]
-  def upload(filepath: nil, external_url: nil, options: {}, intelligent: false, timeout: 60, storage: 'S3')
-    return 'You cannot upload a URL and file at the same time' if filepath && external_url
+  def upload(filepath: nil, external_url: nil, io: nil, options: {}, intelligent: false, timeout: 60, storage: 'S3')
+    return 'You cannot upload a URL and file at the same time' if (filepath || io) && external_url
 
-    response = if filepath
-                 multipart_upload(@apikey, filepath, @security, options, timeout, storage, intelligent: intelligent)
+    response = if external_url
+                send_upload(@apikey, external_url, @security, options)
                else
-                 send_upload(@apikey,
-                             external_url: external_url,
-                             options: options,
-                             security: @security)
+                return 'You cannot upload IO object and file at the same time' if io && filepath
+                multipart_upload(@apikey, filepath, io, @security, options, timeout, storage, intelligent)
                end
+
     FilestackFilelink.new(response['handle'], security: @security, apikey: @apikey)
   end
   # Transform an external URL

data/lib/filestack/ruby/version.rb

@@ -1,5 +1,5 @@
 module Filestack
   module Ruby
-    VERSION = '2.7.0'.freeze
+    VERSION = '2.8.0'.freeze
   end
 end

data/lib/filestack/utils/multipart_upload_utils.rb

@@ -13,13 +13,22 @@ include UploadUtils
 include IntelligentUtils
 # Includes all the utility functions for Filestack multipart uploads
 module MultipartUploadUtils
-  def get_file_info(file)
-    filename = File.basename(file)
+
+  def get_file_attributes(file, options = {})
+    filename = options[:filename] || File.basename(file)
+    mimetype = options[:mimetype] || MimeMagic.by_magic(File.open(file)) || FilestackConfig::DEFAULT_UPLOAD_MIMETYPE
     filesize = File.size(file)
-    mimetype = MimeMagic.by_magic(File.open(file))
-    if mimetype.nil?
-      mimetype = 'application/octet-stream'
-    end
+
+    [filename, filesize, mimetype.to_s]
+  end
+
+  def get_io_attributes(io, options = {})
+    filename = options[:filename] || 'unnamed_file'
+    mimetype = options[:mimetype] || FilestackConfig::DEFAULT_UPLOAD_MIMETYPE
+
+    io.seek(0, IO::SEEK_END)
+    filesize = io.tell
+
     [filename, filesize, mimetype.to_s]
   end
 
@@ -31,8 +40,10 @@ module MultipartUploadUtils
   # @param [String]             mimetype      Mimetype of incoming file
   # @param [FilestackSecurity]  security      Security object with
   #                                           policy/signature
+  # @param [String]             storage        Default storage to be used for uploads
   # @param [Hash]               options       User-defined options for
   #                                           multipart uploads
+  # @param [Bool]               intelligent   Upload file using Filestack Intelligent Ingestion
   #
   # @return [Typhoeus::Response]
   def multipart_start(apikey, filename, filesize, mimetype, security, storage, options = {}, intelligent)
@@ -67,22 +78,21 @@ module MultipartUploadUtils
   #
   # @param [String]             apikey         Filestack API key
   # @param [String]             filename       Name of incoming file
-  # @param [String]             filepath       Local path to file
   # @param [Int]                filesize       Size of incoming file
   # @param [Typhoeus::Response]  start_response Response body from
   #                                            multipart_start
+  # @param [String]             storage        Default storage to be used for uploads
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
   #
   # @return [Array]
-  def create_upload_jobs(apikey, filename, filepath, filesize, start_response, storage, options)
+  def create_upload_jobs(apikey, filename, filesize, start_response, storage, options)
     jobs = []
     part = 1
     seek_point = 0
     while seek_point < filesize
       part_info = {
         seek_point: seek_point,
-        filepath: filepath,
         filename: filename,
         apikey: apikey,
         part: part,
@@ -92,7 +102,7 @@ module MultipartUploadUtils
         upload_id: start_response['upload_id'],
         location_url: start_response['location_url'],
         start_response: start_response,
-        store: { location: storage }
+        store: { location: storage },
       }
 
       part_info[:store].merge!(options) if options
@@ -116,15 +126,16 @@ module MultipartUploadUtils
   # @param [Hash]               job            Hash of options needed
   #                                            to upload a chunk
   # @param [String]             apikey         Filestack API key
-  # @param [String]             location_url   Location url given back
+  # @param [String]             filepath       Location url given back
   #                                            from endpoint
-  # @param [String]             filepath       Local path to file
+  # @param [StringIO]           io             The IO object
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk(job, apikey, filepath, options, storage)
-    file = File.open(filepath)
+  def upload_chunk(job, apikey, filepath, io, options, storage)
+    file = filepath ? File.open(filepath) : io
     file.seek(job[:seek_point])
     chunk = file.read(FilestackConfig::DEFAULT_CHUNK_SIZE)
 
@@ -139,7 +150,6 @@ module MultipartUploadUtils
       region: job[:region],
       upload_id: job[:upload_id],
       store: { location: storage },
-      file: Tempfile.new(job[:filename])
     }
     data = data.merge!(options) if options
 
@@ -158,13 +168,14 @@ module MultipartUploadUtils
   # @param [String]             filepath       Local path to file
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
   #
   # @return [Array]                            Array of parts/etags strings
-  def run_uploads(jobs, apikey, filepath, options, storage)
+  def run_uploads(jobs, apikey, filepath, io, options, storage)
     bar = ProgressBar.new(jobs.length)
     results = Parallel.map(jobs, in_threads: 4) do |job|
       response = upload_chunk(
-        job, apikey, filepath, options, storage
+        job, apikey, filepath, io, options, storage
       )
       if response.code == 200
         bar.increment!
@@ -190,6 +201,8 @@ module MultipartUploadUtils
   #                                             part numbers
   # @param [Hash]               options         User-defined options for
   #                                             multipart uploads
+  # @param [String]             storage        Default storage to be used for uploads
+  # @param [Boolean]            intelligent     Upload file using Filestack Intelligent Ingestion
   #
   # @return [Typhoeus::Response]
   def multipart_complete(apikey, filename, filesize, mimetype, start_response, parts_and_etags, options, storage, intelligent = false)
@@ -215,32 +228,39 @@ module MultipartUploadUtils
   #
   # @param [String]             apikey          Filestack API key
   # @param [String]             filename        Name of incoming file
+  # @param [StringIO]           io              The IO object
   # @param [FilestackSecurity]  security        Security object with
   #                                             policy/signature
   # @param [Hash]               options         User-defined options for
   #                                             multipart uploads
+  # @param [String]             storage         Default storage to be used for uploads
+  # @param [Boolean]            intelligent     Upload file using Filestack Intelligent Ingestion
   #
   # @return [Hash]
-  def multipart_upload(apikey, filepath, security, options, timeout, storage, intelligent: false)
-    filename, filesize, mimetype = get_file_info(filepath)
+  def multipart_upload(apikey, filepath, io, security, options, timeout, storage, intelligent = false)
+    filename, filesize, mimetype = if filepath
+                                    get_file_attributes(filepath, options)
+                                   else
+                                    get_io_attributes(io, options)
+                                   end
 
     start_response = multipart_start(
       apikey, filename, filesize, mimetype, security, storage, options, intelligent
     )
 
     jobs = create_upload_jobs(
-      apikey, filename, filepath, filesize, start_response, storage, options
+      apikey, filename, filesize, start_response, storage, options
     )
 
     if intelligent
       state = IntelligentState.new
-      run_intelligent_upload_flow(jobs, state, storage)
+      run_intelligent_upload_flow(jobs, filepath, io, state, storage)
       response_complete = multipart_complete(
         apikey, filename, filesize, mimetype,
         start_response, nil, options, storage, intelligent
       )
     else
-      parts_and_etags = run_uploads(jobs, apikey, filepath, options, storage)
+      parts_and_etags = run_uploads(jobs, apikey, filepath, io, options, storage)
       response_complete = multipart_complete(
         apikey, filename, filesize, mimetype,
         start_response, parts_and_etags, options, storage

data/lib/filestack/utils/utils.rb

@@ -88,7 +88,7 @@ module UploadUtils
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
   # @return [Hash]
-  def send_upload(apikey, external_url: nil, security: nil, options: nil)
+  def send_upload(apikey, external_url = nil, security = nil, options = nil)
     base = "#{FilestackConfig::CDN_URL}/#{apikey}/#{build_store_task(options)}"
 
     if security
@@ -199,7 +199,7 @@ module IntelligentUtils
   # @param [IntelligentState]    state     An IntelligentState object
   #
   # @return [Array]
-  def run_intelligent_upload_flow(jobs, state, storage)
+  def run_intelligent_upload_flow(jobs, filepath, io, state, storage)
     bar = ProgressBar.new(jobs.length)
     generator = create_intelligent_generator(jobs)
     working_offset = FilestackConfig::DEFAULT_OFFSET_SIZE
@@ -207,7 +207,7 @@ module IntelligentUtils
       batch = get_generator_batch(generator)
       # run parts
       Parallel.map(batch, in_threads: 4) do |part|
-        state = run_intelligent_uploads(part, state, storage)
+        state = run_intelligent_uploads(part, filepath, io, state, storage)
         # condition: a chunk has failed but we have not reached the maximum retries
         while bad_state(state)
           # condition: timeout to S3, requiring offset size to be changed
@@ -219,7 +219,7 @@ module IntelligentUtils
             sleep(state.backoff)
           end
           state.add_retry
-          state = run_intelligent_uploads(part, state, storage)
+          state = run_intelligent_uploads(part, filepath, io, state, storage)
         end
         raise "Upload has failed. Please try again later." unless state.ok
         bar.increment!
@@ -275,7 +275,7 @@ module IntelligentUtils
   #                                             multipart_start
   #
   # @return [Dict]
-  def chunk_job(job, state, apikey, filename, filepath, filesize, start_response, storage)
+  def chunk_job(job, state, apikey, filename, filesize, start_response, storage)
     offset = 0
     seek_point = job[:seek_point]
     chunk_list = []
@@ -283,7 +283,6 @@ module IntelligentUtils
     while (offset < FilestackConfig::DEFAULT_CHUNK_SIZE) && (seek_point + offset) < filesize
       chunk_list.push(
         seek_point: seek_point,
-        filepath: filepath,
         filename: filename,
         apikey: apikey,
         part: job[:part],
@@ -307,15 +306,14 @@ module IntelligentUtils
   # @param [IntelligentState]  state     An IntelligentState object
   #
   # @return [IntelligentState]
-  def run_intelligent_uploads(part, state, storage)
+  def run_intelligent_uploads(part, filepath, io, state, storage)
     failed = false
     chunks = chunk_job(
-      part, state, part[:apikey], part[:filename], part[:filepath],
-      part[:filesize], part[:start_response], storage
+      part, state, part[:apikey], part[:filename], part[:filesize], part[:start_response], storage
     )
     Parallel.map(chunks, in_threads: 3) do |chunk|
       begin
-        upload_chunk_intelligently(chunk, state, part[:apikey], part[:filepath], part[:options], storage)
+        upload_chunk_intelligently(chunk, state, part[:apikey], filepath, io, part[:options], storage)
       rescue => e
         state.error_type = e.message
         failed = true
@@ -364,8 +362,8 @@ module IntelligentUtils
   #                                             multipart uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk_intelligently(job, state, apikey, filepath, options, storage)
-    file = File.open(filepath)
+  def upload_chunk_intelligently(job, state, apikey, filepath, io, options, storage)
+    file = filepath ? File.open(filepath) : io
     file.seek(job[:seek_point] + job[:offset])
 
     chunk = file.read(state.offset)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filestack
 version: !ruby/object:Gem::Version
-  version: 2.7.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Filestack
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-28 00:00:00.000000000 Z
+date: 2020-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus