filestack 2.6.7 → 2.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4383af939a3a456f04f1d2f659d0bdfc16ce5cde
-  data.tar.gz: 5f9af58956f96c75937565cbdf2ae26f0515173a
+SHA256:
+  metadata.gz: 36cd3251f64e64ffcdb9d42c73cbf6d49bcda8a2533cb8053e0087229a077bf2
+  data.tar.gz: f2e38e698557c0b336c332be5b68775fe2624e046a56e1c521717554f23b6495
 SHA512:
-  metadata.gz: 6315edb6cd53d8e099b6f5d2e0e5d0bb35a7a7e62c6def902be28c82026ea8017e2e7d71d2f142aec986e5fce2044c4fc97c9f3383fc18a107cb7c4b6cd99367
-  data.tar.gz: b22bd6ba8d89f302152068d9718e1fca439c462f1ee15ba56e130f3c2eab56a96564a27bca25b6524cecb34b5776628299c546f17ba4f55fcfdd598ef8c03751
+  metadata.gz: 26a1b21b1ad69ae42708e94323e28d7656881824e668677b0dc27a4bb13a035ed6f5b104f90615a0e53bf3b454621fa3a3e129a6a412eed15dd7271f33100f84
+  data.tar.gz: 4d2c6c3e96da48df28e067f6990e3313669ffb2cf0f33f62964db5f708b42b0818c9992cec713c0b70acc6db72425bb727545726a1757c9c64c9dc7addcf6090

data/CHANGELOG.md

@@ -1,5 +1,8 @@
 # Filestack-Ruby Changelog
 
+## 2.7.0 (September 28, 2020)
+- Add workflows
+
 ## 2.6.7 (August 4, 2020)
 - Add content disposition task
 

data/README.md

@@ -44,41 +44,50 @@ Or install it yourself as:
 require 'filestack'
 ```
 Intialize the client using your API key, and security if you are using it.
+
 ```ruby
 client = FilestackClient.new('YOUR_API_KEY', security: security_object)
 ```
 ### Uploading
-Filestack uses multipart uploading by default, which is faster for larger files. This can be turned off by passing in ```multipart: false```. Multipart is disabled when uploading external URLs.
 ```ruby
-filelink = client.upload(filepath: '/path/to/file')
-
-filelink = client.upload(filepath: '/path/to/file', multipart: false)
+filelink = client.upload(filepath: '/path/to/localfile')
 
 # OR
 
-filelink = client.upload(external_url: 'http://someurl.com')
+filelink = client.upload(external_url: 'http://domain.com/image.png')
 ```
 
 To upload a local and an external file with query parameters:
 ```ruby
-filelink = client.upload(filepath: '/path/to/file', options: {mimetype: 'image/png'})
+filelink = client.upload(filepath: '/path/to/localfile', options: { mimetype: 'image/png' })
 
-filelink = client.upload(external_url: 'http://someurl.com/image.png', options: {mimetype: 'image/jpeg'})
+filelink = client.upload(external_url: 'http://domain.com/image.png', options: { mimetype: 'image/jpeg' })
 ```
 
 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`.
 
 ```ruby
-filelink = client.upload(filepath: '/path/to/file', storage: 'dropbox', options: {path: 'folder_name/'})
+filelink = client.upload(filepath: '/path/to/file', storage: 's3', options: { path: 'folder_name/', container: 'container_name', location: 's3', region: 'region_name' })
+
+filelink = client.upload(external_url: 'http://someurl.com/image.png', options: { location: 'dropbox', path: 'folder_name' })
+```
+
+### Workflows
+Workflows allow you to wire up conditional logic and image processing to enforce business processes, automate ingest, and save valuable development time. In order to trigger the workflow job for each upload:
+
+```ruby
+filelink = client.upload(filepath: '/path/to/file', options: { workflows: ["workflow_id_1", "workflow_id_2"] })
+
+#OR
 
-filelink = client.upload(external_url: 'http://someurl.com/image.png', storage: 'dropbox', options: {path: 'folder_name/'})
+filelink = client.upload(external_url: 'http://someurl.com/image.png', options: { workflows: ["workflow_id_1"] })
 ```
 
 ### Security
 If security is enabled on your account, or if you are using certain actions that require security (delete, overwrite and certain transformations), you will need to create a security object and pass it into the client on instantiation.
 
 ```ruby
-security = FilestackSecurity.new('YOUR_APP_SECRET', options: {call: %w[read store pick]})
+security = FilestackSecurity.new('YOUR_APP_SECRET', options: {call: %w[read store pick runWorkflow]})
 client = FilestackClient.new('YOUR_API_KEY', security: security)
 ```
 

data/VERSION

@@ -1 +1 @@
-2.6.7
+2.7.0

data/lib/filestack/config.rb

@@ -7,11 +7,6 @@ class FilestackConfig
   CDN_URL = 'https://cdn.filestackcontent.com'.freeze
   PROCESS_URL = 'https://process.filestackapi.com'.freeze
 
-  MULTIPART_START_URL = 'https://upload.filestackapi.com/multipart/start'.freeze
-  MULTIPART_UPLOAD_URL = 'https://upload.filestackapi.com/multipart/upload'.freeze
-  MULTIPART_COMMIT_URL = 'https://upload.filestackapi.com/multipart/commit'.freeze
-  MULTIPART_COMPLETE_URL = 'https://upload.filestackapi.com/multipart/complete'.freeze
-
   MULTIPART_PARAMS = %w[
     store_location store_region store_container
     store_path store_access
@@ -22,10 +17,28 @@ class FilestackConfig
   VERSION = Filestack::Ruby::VERSION
   HEADERS = {
     'User-Agent' => "filestack-ruby #{VERSION}",
-    'Filestack-Source' => "Ruby-#{VERSION}"
+    'Filestack-Source' => "Ruby-#{VERSION}",
+    'Content-Type' => "application/json",
+    'Accept-Encoding' => "application/json"
   }.freeze
 
   INTELLIGENT_ERROR_MESSAGES = ['BACKEND_SERVER', 'BACKEND_NETWORK', 'S3_SERVER', 'S3_NETWORK']
+
+  def self.multipart_start_url
+    "https://upload.filestackapi.com/multipart/start"
+  end
+
+  def self.multipart_upload_url(base_url)
+    "https://#{base_url}/multipart/upload"
+  end
+
+  def self.multipart_commit_url(base_url)
+    "https://#{base_url}/multipart/commit"
+  end
+
+  def self.multipart_complete_url(base_url)
+    "https://#{base_url}/multipart/complete"
+  end
 end
 
 class TransformConfig

data/lib/filestack/models/filestack_client.rb

@@ -26,26 +26,19 @@ class FilestackClient
   # Upload a local file or external url
   # @param [String]               filepath         The path of a local file
   # @param [String]               external_url     An external URL
-  # @param [Bool]                 multipart        Switch for miltipart
-  #                                                    (Default: true)
   # @param [Hash]                 options          User-supplied upload options
   #
   # return [Filestack::FilestackFilelink]
-  def upload(filepath: nil, external_url: nil, multipart: true, options: {}, storage: 's3', intelligent: false, timeout: 60)
-    if filepath && external_url
-      return 'You cannot upload a URL and file at the same time'
-    end
-    response = if filepath && multipart
+  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
+
+    response = if filepath
                  multipart_upload(@apikey, filepath, @security, options, timeout, storage, intelligent: intelligent)
                else
-                 send_upload(
-                   @apikey,
-                   filepath: filepath,
-                   external_url: external_url,
-                   options: options,
-                   security: @security,
-                   storage: storage
-                 )
+                 send_upload(@apikey,
+                             external_url: external_url,
+                             options: options,
+                             security: @security)
                end
     FilestackFilelink.new(response['handle'], security: @security, apikey: @apikey)
   end

data/lib/filestack/ruby/version.rb

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

data/lib/filestack/utils/multipart_upload_utils.rb

@@ -23,16 +23,6 @@ module MultipartUploadUtils
     [filename, filesize, mimetype.to_s]
   end
 
-  def multipart_options(options)
-    [:region, :container, :path, :access].each do |key|
-      if options.has_key?(key)
-        options[:"store_#{key}"] = options[key]
-        options.delete(key)
-      end
-    end
-    return options
-  end
-
   # Send start response to multipart endpoint
   #
   # @param [String]             apikey        Filestack API key
@@ -51,23 +41,21 @@ module MultipartUploadUtils
       filename: filename,
       mimetype: mimetype,
       size: filesize,
-      store_location: storage,
-      file: Tempfile.new(filename),
-      multipart: intelligent
+      store: { location: storage },
+      fii: intelligent
     }
 
-    options = multipart_options(options)
-    params = params.merge!(options) if options
+    params[:store].merge!(options) if options
 
     unless security.nil?
       params[:policy] = security.policy
       params[:signature] = security.signature
     end
 
-    response = Typhoeus.post(
-      FilestackConfig::MULTIPART_START_URL, body: params,
-                                            headers: FilestackConfig::HEADERS
-    )
+    response = Typhoeus.post(FilestackConfig.multipart_start_url,
+                             body: params.to_json,
+                             headers: FilestackConfig::HEADERS)
+
     if response.code == 200
       JSON.parse(response.body)
     else
@@ -93,7 +81,7 @@ module MultipartUploadUtils
     seek_point = 0
     while seek_point < filesize
       part_info = {
-        seek: seek_point,
+        seek_point: seek_point,
         filepath: filepath,
         filename: filename,
         apikey: apikey,
@@ -104,10 +92,10 @@ module MultipartUploadUtils
         upload_id: start_response['upload_id'],
         location_url: start_response['location_url'],
         start_response: start_response,
-        store_location: storage
+        store: { location: storage }
       }
-      options = multipart_options(options)
-      part_info = part_info.merge!(options) if options
+
+      part_info[:store].merge!(options) if options
 
       if seek_point + FilestackConfig::DEFAULT_CHUNK_SIZE > filesize
         size = filesize - (seek_point)
@@ -135,9 +123,9 @@ module MultipartUploadUtils
   #                                            multipart uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk(job, apikey, filepath, options)
+  def upload_chunk(job, apikey, filepath, options, storage)
     file = File.open(filepath)
-    file.seek(job[:seek])
+    file.seek(job[:seek_point])
     chunk = file.read(FilestackConfig::DEFAULT_CHUNK_SIZE)
 
     md5 = Digest::MD5.new
@@ -150,14 +138,14 @@ module MultipartUploadUtils
       uri: job[:uri],
       region: job[:region],
       upload_id: job[:upload_id],
-      store_location: job[:store_location],
+      store: { location: storage },
       file: Tempfile.new(job[:filename])
     }
     data = data.merge!(options) if options
-    fs_response = Typhoeus.post(
-      FilestackConfig::MULTIPART_UPLOAD_URL, body: data,
-                                             headers: FilestackConfig::HEADERS
-    ).body
+
+    fs_response = Typhoeus.post(FilestackConfig.multipart_upload_url(job[:location_url]),
+                                body: data.to_json,
+                                headers: FilestackConfig::HEADERS).body
     fs_response = JSON.parse(fs_response)
     Typhoeus.put(
       fs_response['url'], headers: fs_response['headers'], body: chunk
@@ -172,17 +160,17 @@ module MultipartUploadUtils
   #                                            multipart uploads
   #
   # @return [Array]                            Array of parts/etags strings
-  def run_uploads(jobs, apikey, filepath, options)
+  def run_uploads(jobs, apikey, filepath, options, storage)
     bar = ProgressBar.new(jobs.length)
     results = Parallel.map(jobs, in_threads: 4) do |job|
       response = upload_chunk(
-        job, apikey, filepath, options
+        job, apikey, filepath, options, storage
       )
       if response.code == 200
         bar.increment!
         part = job[:part]
         etag = response.headers[:etag]
-        "#{part}:#{etag}"
+        { part_number: part, etag: etag }
       end
     end
     results
@@ -213,17 +201,14 @@ module MultipartUploadUtils
       filename: filename,
       size: filesize,
       mimetype: mimetype,
-      store_location: storage,
-      file: Tempfile.new(filename)
+      store: { location: storage },
     }
-    options = multipart_options(options)
-    data.merge!(options) if options
-    data.merge!(intelligent ? { multipart: intelligent } : { parts: parts_and_etags.join(';') })
+    data[:store].merge!(options) if options
+    data.merge!(intelligent ? { fii: intelligent } : { parts: parts_and_etags })
 
-    Typhoeus.post(
-      FilestackConfig::MULTIPART_COMPLETE_URL, body: data,
-                                               headers: FilestackConfig::HEADERS
-    )
+    Typhoeus.post(FilestackConfig.multipart_complete_url(start_response['location_url']),
+                  body: data.to_json,
+                  headers: FilestackConfig::HEADERS)
   end
 
   # Run entire multipart process through with file and options
@@ -238,27 +223,24 @@ module MultipartUploadUtils
   # @return [Hash]
   def multipart_upload(apikey, filepath, security, options, timeout, storage, intelligent: false)
     filename, filesize, mimetype = get_file_info(filepath)
+
     start_response = multipart_start(
       apikey, filename, filesize, mimetype, security, storage, options, intelligent
     )
 
-    unless start_response['upload_type'].nil?
-      intelligent_enabled = ((start_response['upload_type'].include? 'intelligent_ingestion')) && intelligent
-    end
-
     jobs = create_upload_jobs(
       apikey, filename, filepath, filesize, start_response, storage, options
     )
 
-    if intelligent_enabled
+    if intelligent
       state = IntelligentState.new
-      run_intelligent_upload_flow(jobs, state)
+      run_intelligent_upload_flow(jobs, 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)
+      parts_and_etags = run_uploads(jobs, apikey, filepath, options, storage)
       response_complete = multipart_complete(
         apikey, filename, filesize, mimetype,
         start_response, parts_and_etags, options, storage

data/lib/filestack/utils/utils.rb

@@ -62,36 +62,42 @@ module UploadUtils
     )
   end
 
+  def build_store_task(options = {})
+    return 'store' if options.empty?
+    tasks = []
+    options.each do |key, value|
+      value = case key
+              when :workflows
+                [value.join('","')]
+              when :path
+                "\"#{value}\""
+              else
+                value
+              end
+      tasks.push("#{key}:#{value.to_s.downcase}")
+    end
+    "store=#{tasks.join(',')}"
+  end
+
   # Uploads to v1 REST API (for external URLs or if multipart is turned off)
   #
   # @param [String]             apikey         Filestack API key
-  # @param [String]             filepath       Local path to file
   # @param [String]             external_url   External URL to be uploaded
   # @param [FilestackSecurity]  security       Security object with
   #                                            policy/signature
   # @param [Hash]               options        User-defined options for
   #                                            multipart uploads
-  # @param [String]             storage        Storage destination
-  #                                            (s3, rackspace, etc)
   # @return [Hash]
-  def send_upload(apikey, filepath: nil, external_url: nil, security: nil, options: nil, storage: 'S3')
-    data = if filepath
-             { fileUpload: File.open(filepath) }
-           else
-             { url: external_url }
-           end
-
-    # adds any user-defined upload options to request payload
-    data = data.merge!(options) unless options.nil?
-    base = "#{FilestackConfig::API_URL}/store/#{storage}?key=#{apikey}"
+  def send_upload(apikey, external_url: nil, security: nil, options: nil)
+    base = "#{FilestackConfig::CDN_URL}/#{apikey}/#{build_store_task(options)}"
 
     if security
       policy = security.policy
       signature = security.signature
-      base = "#{base}&signature=#{signature}&policy=#{policy}"
+      base = "#{base}/security=s:#{signature},p:#{policy}"
     end
 
-    response = Typhoeus.post(base, body: data, headers: FilestackConfig::HEADERS)
+    response = Typhoeus.post("#{base}/#{external_url}", headers: FilestackConfig::HEADERS)
 
     if response.code == 200
       response_body = JSON.parse(response.body)
@@ -193,7 +199,7 @@ module IntelligentUtils
   # @param [IntelligentState]    state     An IntelligentState object
   #
   # @return [Array]
-  def run_intelligent_upload_flow(jobs, state)
+  def run_intelligent_upload_flow(jobs, state, storage)
     bar = ProgressBar.new(jobs.length)
     generator = create_intelligent_generator(jobs)
     working_offset = FilestackConfig::DEFAULT_OFFSET_SIZE
@@ -201,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)
+        state = run_intelligent_uploads(part, 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
@@ -213,7 +219,7 @@ module IntelligentUtils
             sleep(state.backoff)
           end
           state.add_retry
-          state = run_intelligent_uploads(part, state)
+          state = run_intelligent_uploads(part, state, storage)
         end
         raise "Upload has failed. Please try again later." unless state.ok
         bar.increment!
@@ -269,13 +275,14 @@ module IntelligentUtils
   #                                             multipart_start
   #
   # @return [Dict]
-  def chunk_job(job, state, apikey, filename, filepath, filesize, start_response)
+  def chunk_job(job, state, apikey, filename, filepath, filesize, start_response, storage)
     offset = 0
-    seek_point = job[:seek]
+    seek_point = job[:seek_point]
     chunk_list = []
+
     while (offset < FilestackConfig::DEFAULT_CHUNK_SIZE) && (seek_point + offset) < filesize
       chunk_list.push(
-        seek: seek_point,
+        seek_point: seek_point,
         filepath: filepath,
         filename: filename,
         apikey: apikey,
@@ -285,7 +292,7 @@ module IntelligentUtils
         region: start_response['region'],
         upload_id: start_response['upload_id'],
         location_url: start_response['location_url'],
-        store_location: job[:store_location],
+        store: { location: storage },
         offset: offset
       )
       offset += state.offset
@@ -300,15 +307,15 @@ module IntelligentUtils
   # @param [IntelligentState]  state     An IntelligentState object
   #
   # @return [IntelligentState]
-  def run_intelligent_uploads(part, state)
+  def run_intelligent_uploads(part, state, storage)
     failed = false
     chunks = chunk_job(
       part, state, part[:apikey], part[:filename], part[:filepath],
-      part[:filesize], part[:start_response]
+      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])
+        upload_chunk_intelligently(chunk, state, part[:apikey], part[:filepath], part[:options], storage)
       rescue => e
         state.error_type = e.message
         failed = true
@@ -322,6 +329,7 @@ module IntelligentUtils
     else
       state.ok = true
     end
+
     commit_params = {
       apikey: part[:apikey],
       uri: part[:uri],
@@ -329,12 +337,14 @@ module IntelligentUtils
       upload_id: part[:upload_id],
       size: part[:filesize],
       part: part[:part],
-      location_url: part[:location_url],
-      store_location: part[:store_location],
-      file: Tempfile.new(part[:filename])
+      location_url: part[:start_response]['location_url'],
+      store: { location: storage }
     }
-    response = Typhoeus.post(FilestackConfig::MULTIPART_COMMIT_URL, body: commit_params,
-                                                                   headers: FilestackConfig::HEADERS)
+
+    response = Typhoeus.post(FilestackConfig.multipart_commit_url(commit_params[:location_url]),
+                             body: commit_params.to_json,
+                             headers: FilestackConfig::HEADERS)
+
     if response.code == 200
       state.reset
     else
@@ -354,9 +364,10 @@ module IntelligentUtils
   #                                             multipart uploads
   #
   # @return [Typhoeus::Response]
-  def upload_chunk_intelligently(job, state, apikey, filepath, options)
+  def upload_chunk_intelligently(job, state, apikey, filepath, options, storage)
     file = File.open(filepath)
-    file.seek(job[:seek] + job[:offset])
+    file.seek(job[:seek_point] + job[:offset])
+
     chunk = file.read(state.offset)
     md5 = Digest::MD5.new
     md5 << chunk
@@ -368,17 +379,17 @@ module IntelligentUtils
       uri: job[:uri],
       region: job[:region],
       upload_id: job[:upload_id],
-      store_location: job[:store_location],
+      store: { location: storage },
       offset: job[:offset],
-      file: Tempfile.new(job[:filename]),
-      'multipart' => 'true'
+      fii: true
     }
 
     data = data.merge!(options) if options
-    fs_response = Typhoeus.post(
-      FilestackConfig::MULTIPART_UPLOAD_URL, body: data,
-                                             headers: FilestackConfig::HEADERS
-    )
+
+    fs_response = Typhoeus.post(FilestackConfig.multipart_upload_url(job[:location_url]),
+                                body: data.to_json,
+                                headers: FilestackConfig::HEADERS)
+
     # POST to multipart/upload
     begin
       unless fs_response.code == 200

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: filestack
 version: !ruby/object:Gem::Version
-  version: 2.6.7
+  version: 2.7.0
 platform: ruby
 authors:
 - Filestack
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-08-04 00:00:00.000000000 Z
+date: 2020-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: typhoeus
@@ -201,7 +201,7 @@ homepage: https://github.com/filestack/filestack-ruby
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -216,9 +216,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
-signing_key: 
+rubygems_version: 3.0.8
+signing_key:
 specification_version: 4
 summary: Official Ruby SDK for the Filestack API
 test_files: []