telestream_cloud 1.1.0 → 2.0.0.1

data/qc/lib/telestream_cloud_qc/models/video_upload_body.rb

@@ -0,0 +1,242 @@
+=begin
+#Qc API
+
+#QC API
+
+OpenAPI spec version: 2.0.0
+Contact: cloudsupport@telestream.net
+Generated by: https://github.com/swagger-api/swagger-codegen.git
+Swagger Codegen version: 2.3.0
+
+=end
+
+require 'date'
+
+module TelestreamCloud::Qc
+
+  class VideoUploadBody
+    # Size of the file that will be uploaded in `bytes`.
+    attr_accessor :file_size
+
+    # Name of the file that will be uploaded.
+    attr_accessor :file_name
+
+    # A list of names of additional files that will be uploaded.
+    attr_accessor :extra_files
+
+    # A comma-separated list of profile names or IDs to be used during encoding. Alternatively, specify none so no encodings will created right away.
+    attr_accessor :profiles
+
+    attr_accessor :multi_chunk
+
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'file_size' => :'file_size',
+        :'file_name' => :'file_name',
+        :'extra_files' => :'extra_files',
+        :'profiles' => :'profiles',
+        :'multi_chunk' => :'multi_chunk'
+      }
+    end
+
+    # Attribute type mapping.
+    def self.swagger_types
+      {
+        :'file_size' => :'Integer',
+        :'file_name' => :'String',
+        :'extra_files' => :'Array<ExtraFile>',
+        :'profiles' => :'String',
+        :'multi_chunk' => :'BOOLEAN'
+      }
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      return unless attributes.is_a?(Hash)
+
+      # convert string to symbol for hash key
+      attributes = attributes.each_with_object({}){|(k,v), h| h[k.to_sym] = v}
+
+      if attributes.has_key?(:'file_size')
+        self.file_size = attributes[:'file_size']
+      end
+
+      if attributes.has_key?(:'file_name')
+        self.file_name = attributes[:'file_name']
+      end
+
+      if attributes.has_key?(:'extra_files')
+        if (value = attributes[:'extra_files']).is_a?(Array)
+          self.extra_files = value
+        end
+      end
+
+      if attributes.has_key?(:'profiles')
+        self.profiles = attributes[:'profiles']
+      end
+
+      if attributes.has_key?(:'multi_chunk')
+        self.multi_chunk = attributes[:'multi_chunk']
+      else
+        self.multi_chunk = true
+      end
+
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      if @file_size.nil?
+        invalid_properties.push("invalid value for 'file_size', file_size cannot be nil.")
+      end
+
+      if @file_name.nil?
+        invalid_properties.push("invalid value for 'file_name', file_name cannot be nil.")
+      end
+
+      return invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      return false if @file_size.nil?
+      return false if @file_name.nil?
+      return true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          file_size == o.file_size &&
+          file_name == o.file_name &&
+          extra_files == o.extra_files &&
+          profiles == o.profiles &&
+          multi_chunk == o.multi_chunk
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Fixnum] Hash code
+    def hash
+      [file_size, file_name, extra_files, profiles, multi_chunk].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.swagger_types.each_pair do |key, type|
+        if type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end # or else data not found in attributes(hash), not an issue as the data can be optional
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        temp_model = TelestreamCloud::Qc.const_get(type).new
+        temp_model.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        next if value.nil?
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map{ |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/qc/lib/telestream_cloud_qc/uploader.rb

@@ -0,0 +1,244 @@
+require 'pathname'
+require 'json'
+require 'concurrent'
+
+module TelestreamCloud::Qc
+  class Uploader
+    class FileReader
+      attr_reader :file
+
+      def initialize(path)
+        @mutex = Mutex.new
+        @path = path
+        reopen
+      end
+
+      def [](range)
+        @mutex.synchronize do
+          file.seek(range.begin)
+          file.read(range.size)
+        end
+      end
+
+      def size
+        @size ||= file.size
+      end
+
+      def name
+        Pathname.new(file.path).basename
+      end
+
+      def close
+        @file.close
+        @file = nil
+      end
+
+      def reopen
+        @file ||= File.open(@path)
+      end
+    end
+
+    class FileUploadSession
+      attr_reader :uploader, :reader, :tag
+
+      def initialize(uploader, path, tag = nil)
+        @uploader = uploader
+        @reader = FileReader.new(path)
+        @tag = tag
+        @status = :ready
+      end
+
+      def success?
+        @status == :success
+      end
+
+      def params
+        upload_params = {
+          file_size: reader.size,
+          file_name: reader.name
+        }
+
+        upload_params[:tag] = @tag if @tag
+        upload_params
+      end
+
+      def upload!
+        reader.reopen
+
+        upload_chunks(missing_parts)
+
+        raise MissingPartError unless missing_parts.empty?
+
+        @status = :success
+      ensure
+        reader.close
+      end
+
+      private
+
+      def upload_chunks(indexes)
+        indexes.each do |index|
+          send_chunk(index)
+        end
+      end
+
+      def session
+        uploader.send(:session)
+      end
+
+      def send_chunk(index)
+        range = (index * part_size...[(index + 1) * part_size, reader.size].min)
+
+        # TODO: remove when 1.9 dropped
+        unless range.respond_to?(:size)
+          def range.size; self.end - self.begin + (exclude_end? ? 0 : 1); end
+        end
+
+        response = Typhoeus.put(
+          session.location,
+          body: reader[range],
+          headers: {
+            'Content-Type'     => 'application/octet-stream',
+            'X-Part'           => index.to_s,
+            'Content-Length'   => range.size.to_s,
+            'X-Extra-File-Tag' => tag,
+          }.reject { |_, v| v.nil? }
+        )
+
+        puts response.body
+
+        uploader.send(:set_resource_id, response)
+        response
+      end
+
+      def missing_parts
+        upload_status['missing_parts']
+      end
+
+      def upload_status
+        response = Typhoeus.get(
+          session.location,
+          headers: {
+            'X-Extra-File-Tag' => @tag
+          }.reject { |_, v| v.nil? }
+        )
+        JSON.parse(response.body)
+      end
+
+      def parts;           session.parts;           end
+      def part_size;       session.part_size;       end
+      def max_connections; session.max_connections; end
+    end
+
+    class ConcurrentFileUploadSession < FileUploadSession
+      def upload_chunks(indexes)
+
+        indexes.map do |index|
+          Concurrent::Future.execute(executor: uploader.thread_pool) do
+            send_chunk(index)
+          end
+        end.map(&:value)
+      end
+    end
+
+    class UploadError < StandardError; end
+    class MissingPartError < StandardError; end
+
+    attr_reader :reader, :status, :error, :thread_pool, :concurrency
+
+    def self.upload(options)
+      retries = options.delete(:retries)
+      new(options).tap { |x| x.upload(*[retries].compact) }.video
+    end
+
+    def initialize(client, options)
+      @client = client
+
+      @thread_pool = Concurrent::ThreadPoolExecutor.new(
+        min_threads: 5,
+        max_threads: 5,
+        max_queue: 100,
+        fallback_policy: :caller_runs
+      )
+
+      file = options.delete(:file) do |key|
+        raise KeyError, "key not found: #{key}"
+      end
+
+      @extra_files = parse_extra_files(options.delete(:extra_files))
+
+      @upload_session = upload_session(file)
+
+      defaults = {
+        multi_chunk: true
+      }.merge(@upload_session.params)
+
+      @params = defaults.merge(options)
+
+      @params[:extra_files] = @extra_files.map(&:params) if @extra_files
+
+      @status = :ready
+    end
+
+    def parse_extra_files(extra_files)
+      return [] unless extra_files
+
+      extra_files.flat_map do |tag, paths|
+        paths = [paths] unless paths.kind_of?(Array)
+
+        paths.each_with_index.map do |path, i|
+          upload_session(path, paths.size > 1 ? "#{tag}.index-#{i}" : tag)
+        end
+      end
+    end
+
+    def upload(retries = 5)
+      session
+
+      count = 0
+      begin
+        count += 1
+        upload!
+        raise MissingPartError unless success?
+      rescue StandardError => e
+        puts e
+        @error = e
+        retry if count < retries
+      end
+
+      @resource_id
+    end
+
+    def success?
+      @resource_id && @upload_session.success? && Array(@extra_files).all?(&:success?)
+    end
+
+    def upload_session(path, tag = nil)
+      ConcurrentFileUploadSession.new(self, path, tag)
+    end
+
+    private
+
+    def upload!
+      @upload_session.upload!
+      @extra_files.each(&:upload!)
+    end
+
+    def set_resource_id(response)
+      return if response.code != 200 || response.body.empty?
+      @resource_id = JSON.parse(response.body).fetch('id')
+    end
+
+    def session
+      return @session if defined?(@session)
+      @session = case @client.class.name
+                 when "TelestreamCloud::Flip::FlipApi"
+                   @factory_id ||= @params.delete(:factory_id) do |key|
+                     raise KeyError, "key not found: #{key}"
+                   end
+
+                   @client.upload_video(@factory_id, @params)
+                 end
+    end
+  end
+end