filestack 2.0.0

data/lib/filestack/models/filestack_transform.rb

@@ -0,0 +1,112 @@
+require 'filestack/config'
+require 'filestack/models/filestack_av'
+
+# Class for creating transformation chains and storing them to Filestack
+class Transform
+  include TransformUtils
+  attr_reader :handle, :external_url, :security
+
+  def initialize(handle: nil, external_url: nil, security: nil, apikey: nil)
+    @apikey = apikey
+    @handle = handle
+    @external_url = external_url
+    @security = security
+    @transform_tasks = []
+  end
+
+  # Catches method calls and checks to see if they exist in transformation list
+  #
+  # This is to avoid rewriting the same code
+  # over and over for transform chaining
+  #
+  # @return [Filestack::Transform] or Error
+  def method_missing(method_name, **args)
+    if TransformConfig::TRANSFORMATIONS.include? method_name.to_s
+      @transform_tasks.push(
+        add_transform_task(method_name, args)
+      )
+      self
+    else
+      super
+    end
+  end
+
+  # Converts one filetype to the other
+  #
+  # @param options
+  #
+  # @return [Filestack::Transform]
+  def filetype_conversion(options)
+    @transform_tasks.push(
+      add_transform_task('output', options)
+    )
+    self
+  end
+
+  # Converts video or audio based on user-provided parameters
+  #
+  # @param [Hash]              options        User-provided parameters
+  #
+  # @return [Filestack::AV]
+  def av_convert(options)
+    if @external_url
+      return 'av_convert does not support external URLs. Please upload file first.'
+    end
+    @transform_tasks.push(
+      add_transform_task('video_convert', options)
+    )
+    response = UploadUtils.make_call(url, 'post')
+    if response.code == 200
+      return AV.new(url, apikey: @apikey, security: @security)
+    end
+    response.body
+  end
+
+  # Add debug parameter to get information on transformation image
+  #
+  # @return [Unirest::Response]
+  def debug
+    @transform_tasks.push(
+      add_transform_task('debug')
+    )
+    UploadUtils.make_call(url, 'get').body
+  end
+
+  # Stores a transformation URL and returns a filelink
+  #
+  # @return [Filestack::Filelink]
+  def store
+    @transform_tasks.push(
+      add_transform_task('store', {})
+    )
+    response = UploadUtils.make_call(url, 'get')
+    handle = response.body['url'].split('/').last
+    Filelink.new(handle, apikey: @apikey, security: @security)
+  end
+
+  # Override default method (best practice when overriding method_missing)
+  def respond_to_missing?(method_name, *)
+    TransformConfig::TRANSFORMATIONS.include?(method_name.to_s || super)
+  end
+
+  # Creates a URL based on transformation instance state
+  #
+  # @return [String]
+  def url
+    base = [FilestackConfig::CDN_URL]
+    if @transform_tasks.include? 'debug'
+      @transform_tasks.delete('debug')
+      base.push('debug')
+    end
+    base.push(@apikey) if @apikey && @external_url
+    if @security
+      policy = @security.policy
+      signature = @security.signature
+      security_string = "security=policy:#{policy},signature:#{signature}"
+      base.push(security_string)
+    end
+    base += @transform_tasks
+    base.push(@handle || @external_url)
+    base.join('/')
+  end
+end

data/lib/filestack/ruby/version.rb

@@ -0,0 +1,5 @@
+module Filestack
+  module Ruby
+    VERSION = '2.0.0'.freeze
+  end
+end

data/lib/filestack/utils/multipart_upload_utils.rb

@@ -0,0 +1,223 @@
+require 'base64'
+require 'digest'
+require 'mimemagic'
+require 'json'
+require 'parallel'
+require 'unirest'
+
+require 'filestack/config'
+require 'filestack/utils/utils'
+
+include UploadUtils
+
+# Includes all the utility functions for Filestack multipart uploads
+module MultipartUploadUtils
+  def get_file_info(file)
+    filename = File.basename(file)
+    filesize = File.size(file)
+    mimetype = MimeMagic.by_magic(File.open(file))
+    [filename, filesize, mimetype.to_s]
+  end
+
+  # Send start response to multipart endpoint
+  #
+  # @param [String]             apikey        Filestack API key
+  # @param [String]             filename      Name of incoming file
+  # @param [Int]                filesize      Size of incoming file
+  # @param [String]             mimetype      Mimetype of incoming file
+  # @param [FilestackSecurity]  security      Security object with
+  #                                           policy/signature
+  # @param [Hash]               options       User-defined options for
+  #                                           multipart uploads
+  #
+  # @return [Unirest::Response]
+  def multipart_start(apikey, filename, filesize, mimetype, security, options)
+    params = {
+      apikey: apikey,
+      filename: filename,
+      mimetype: mimetype,
+      size: filesize,
+      store_location: options.nil? ? 's3' : options[:store_location],
+      file: Tempfile.new(filename)
+    }
+
+    params = params.merge!(options) if options
+
+    unless security.nil?
+      params[:policy] = security.policy
+      params[:signature] = security.signature
+    end
+
+    response = Unirest.post(
+      FilestackConfig::MULTIPART_START_URL, parameters: params,
+                                            headers: FilestackConfig::HEADERS
+    )
+    if response.code == 200
+      response.body
+    else
+      raise Exception(response.body)
+    end
+  end
+
+  # Create array of jobs for parallel uploading
+  #
+  # @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 [Unirest::Response]  start_response Response body from
+  #                                            multipart_start
+  # @param [FilestackSecurity]  security       Security object with
+  #                                            policy/signature
+  # @param [Hash]               options        User-defined options for
+  #                                            multipart uploads
+  #
+  # @return [Array]
+  def create_upload_jobs(apikey, filename, filepath, filesize, start_response, options)
+    jobs = []
+    part = 1
+    seek_point = 0
+    while seek_point < filesize
+      jobs.push(
+        seek: seek_point,
+        filepath: filepath,
+        filename: filename,
+        apikey: apikey,
+        part: part,
+        uri: start_response['uri'],
+        region: start_response['region'],
+        upload_id: start_response['upload_id'],
+        location_url: start_response['location_url'],
+        store_location: options.nil? ? 's3' : options[:store_location]
+      )
+      part += 1
+      seek_point += FilestackConfig::DEFAULT_CHUNK_SIZE
+    end
+    jobs
+  end
+
+  # Uploads one chunk of the file
+  #
+  # @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
+  #                                            from endpoint
+  # @param [String]             filepath       Local path to file
+  # @param [Hash]               options        User-defined options for
+  #                                            multipart uploads
+  #
+  # @return [Unirest::Response]
+  def upload_chunk(job, apikey, filepath, options)
+    file = File.open(filepath)
+    file.seek(job[:seek])
+    chunk = file.read(FilestackConfig::DEFAULT_CHUNK_SIZE)
+    md5 = Digest::MD5.new
+    md5 << chunk
+    data = {
+      apikey: apikey,
+      part: job[:part],
+      size: chunk.length,
+      md5: md5.base64digest,
+      uri: job[:uri],
+      region: job[:region],
+      upload_id: job[:upload_id],
+      store_location: options.nil? ? 's3' : options[:store_location],
+      file: Tempfile.new(job[:filename])
+    }
+    data = data.merge!(options) if options
+    fs_response = Unirest.post(
+      FilestackConfig::MULTIPART_UPLOAD_URL, parameters: data,
+                                             headers: FilestackConfig::HEADERS
+    ).body
+    Unirest.put(
+      fs_response['url'], headers: fs_response['headers'], parameters: chunk
+    )
+  end
+
+  # Runs all jobs in parallel
+  #
+  # @param [Array]              jobs           Array of jobs to be run
+  # @param [String]             apikey         Filestack API key
+  # @param [String]             filepath       Local path to file
+  # @param [Hash]               options        User-defined options for
+  #                                            multipart uploads
+  #
+  # @return [Array]                            Array of parts/etags strings
+  def run_uploads(jobs, apikey, filepath, options)
+    results = Parallel.map(jobs) do |job|
+      response = upload_chunk(
+        job, apikey, filepath, options
+      )
+      part = job[:part]
+      etag = response.headers[:etag]
+      "#{part}:#{etag}"
+    end
+    results
+  end
+
+  # Send complete call to multipart endpoint
+  #
+  # @param [String]             apikey          Filestack API key
+  # @param [String]             filename        Name of incoming file
+  # @param [Int]                filesize        Size of incoming file
+  # @param [String]             mimetype        Mimetype of incoming file
+  # @param [Unirest::Response]  start_response  Response body from
+  #                                             multipart_start
+  # @param [FilestackSecurity]  security        Security object with
+  #                                             policy/signature
+  # @param [Array]              parts_and_etags Array of strings defining
+  #                                             etags and their associated
+  #                                             part numbers
+  # @param [Hash]               options         User-defined options for
+  #                                             multipart uploads
+  #
+  # @return [Unirest::Response]
+  def multipart_complete(apikey, filename, filesize, mimetype, start_response, parts_and_etags, options)
+    data = {
+      apikey: apikey,
+      uri: start_response['uri'],
+      region: start_response['region'],
+      upload_id: start_response['upload_id'],
+      filename: filename,
+      size: filesize,
+      mimetype: mimetype,
+      parts: parts_and_etags.join(';'),
+      store_location: options.nil? ? 's3' : options[:store_location],
+      file: Tempfile.new(filename)
+    }
+
+    data = data.merge!(options) if options
+
+    Unirest.post(
+      FilestackConfig::MULTIPART_COMPLETE_URL, parameters: data,
+                                               headers: FilestackConfig::HEADERS
+    )
+  end
+
+  # Run entire multipart process through with file and options
+  #
+  # @param [String]             apikey          Filestack API key
+  # @param [String]             filename        Name of incoming file
+  # @param [FilestackSecurity]  security        Security object with
+  #                                             policy/signature
+  # @param [Hash]               options         User-defined options for
+  #                                             multipart uploads
+  #
+  # @return [Unirest::Response]
+  def multipart_upload(apikey, filepath, security, options)
+    filename, filesize, mimetype = get_file_info(filepath)
+    start_response = multipart_start(
+      apikey, filename, filesize, mimetype, security, options
+    )
+    jobs = create_upload_jobs(
+      apikey, filename, filepath, filesize, start_response, options
+    )
+    parts_and_etags = run_uploads(jobs, apikey, filepath, options)
+    response_complete = multipart_complete(
+      apikey, filename, filesize, mimetype,
+      start_response, parts_and_etags, options
+    )
+    response_complete.body
+  end
+end

data/lib/filestack/utils/utils.rb

@@ -0,0 +1,107 @@
+require 'base64'
+require 'digest'
+require 'mimemagic'
+require 'json'
+require 'unirest'
+
+require 'filestack/config'
+
+# Includes general utility functions for the Filestack Ruby SDK
+module UploadUtils
+  # General request function
+  # @param [String]           url          The URL being called
+  # @param [String]           action       The specific HTTP action
+  #                                        ('get', 'post', 'delete', 'put')
+  # @param [Hash]             parameters   The query and/or body parameters
+  #
+  # @return [Unirest::Request]
+  def make_call(url, action, parameters: nil, headers: nil)
+    headers = if headers
+                headers.merge!(FilestackConfig::HEADERS)
+              else
+                FilestackConfig::HEADERS
+              end
+    Unirest.public_send(
+      action, url, parameters: parameters, headers: headers
+    )
+  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 [Unirest::Response]
+  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}"
+
+    if security
+      policy = security.policy
+      signature = security.signature
+      base = "#{base}&signature=#{signature}&policy=#{policy}"
+    end
+
+    response = make_call(base, 'post', parameters: data)
+    if response.code == 200
+      handle = response.body['url'].split('/').last
+      return { 'handle' => handle }
+    end
+    raise response.body
+  end
+
+  # Generates the URL for a Filelink object
+  # @param [String]           base          The base Filestack URL
+  # @param [String]           handle        The Filelink handle (optional)
+  # @param [String]           path          The specific API path (optional)
+  # @param [String]           security      Security for the Filelink (optional)
+  #
+  # return [String]
+  def get_url(base, handle: nil, path: nil, security: nil)
+    url_components = [base]
+
+    url_components.push(path) unless path.nil?
+    url_components.push(handle) unless handle.nil?
+    url = url_components.join('/')
+
+    if security
+      policy = security.policy
+      signature = security.signature
+      security_path = "policy=#{policy}&signature=#{signature}"
+      url = "#{url}?#{security_path}"
+    end
+    url
+  end
+end
+
+# Utility functions for transformations
+module TransformUtils
+  # Creates a transformation task to be sent back to transform object
+  #
+  # @return [String]
+  def add_transform_task(transform, options = {})
+    options_list = []
+    if !options.empty?
+      options.each do |key, array|
+        options_list.push("#{key}:#{array}")
+      end
+      options_string = options_list.join(',')
+      "#{transform}=#{options_string}"
+    else
+      transform.to_s
+    end
+  end
+end