vidispine 1.4.0

data/lib/vidispine/api/client/http_client.rb

@@ -0,0 +1,291 @@
+require 'json'
+require 'net/https'
+
+module Vidispine
+  module API
+    class Client
+
+      class HTTPClient
+
+        class HTTPAuthorizationError < RuntimeError; end
+
+        attr_accessor :logger, :http, :http_host_address, :http_host_port, :base_uri, :default_base_path
+        attr_accessor :username, :password
+
+        attr_accessor :default_request_headers,
+                      :authorization_header_key, :authorization_header_value
+
+        attr_accessor :log_request_body, :log_response_body, :log_pretty_print_body
+
+        attr_accessor :request, :response, :use_exceptions
+
+        DEFAULT_HTTP_HOST_ADDRESS = 'localhost'
+        DEFAULT_HTTP_HOST_PORT = 8080
+
+        DEFAULT_USERNAME = 'admin'
+        DEFAULT_PASSWORD = 'password'
+        DEFAULT_BASE_PATH = 'API/'
+
+        DEFAULT_HEADER_CONTENT_TYPE = 'application/json; charset=utf-8'
+        DEFAULT_HEADER_ACCEPTS = 'application/json'
+
+        def initialize(args = { })
+          args = args.dup
+
+          @use_exceptions = args.fetch(:use_exceptions, true)
+
+          initialize_logger(args)
+          initialize_http(args)
+
+          logger.debug { "#{self.class.name}::#{__method__} Arguments: #{args.inspect}" }
+
+          @username = args[:username] || DEFAULT_USERNAME
+          @password = args[:password] || DEFAULT_PASSWORD
+          @authorization_header_value = args[:authorization_header_value]
+
+          @base_uri = args[:base_uri] || "http#{http.use_ssl? ? 's' : ''}://#{http.address}:#{http.port}"
+          @default_base_path = args[:default_base_path] || DEFAULT_BASE_PATH
+
+          # @user_agent_default = "#{@hostname}:#{@username} Ruby SDK Version #{Vidispine::VERSION}"
+
+          @authorization_header_key ||= 'Authorization' #CaseSensitiveHeaderKey.new('Authorization')
+          @authorization_header_value ||= %(Basic #{["#{username}:#{password}"].pack('m').delete("\r\n")})
+
+          content_type = args[:content_type_header] ||= DEFAULT_HEADER_CONTENT_TYPE
+          accepts = args[:accepts_header] ||= args[:accept_header] || DEFAULT_HEADER_ACCEPTS
+
+          @default_request_headers = {
+            'Content-Type' => content_type,
+            'Accept' => accepts,
+            authorization_header_key => authorization_header_value,
+          }
+
+          @log_request_body = args.fetch(:log_request_body, true)
+          @log_response_body = args.fetch(:log_response_body, true)
+          @log_pretty_print_body = args.fetch(:log_pretty_print_body, true)
+
+          @parse_response = args.fetch(:parse_response, true)
+        end
+
+        def initialize_logger(args = { })
+          @logger = args[:logger] ||= Logger.new(args[:log_to] || STDOUT)
+          log_level = args[:log_level]
+          if log_level
+            @logger.level = log_level
+            args[:logger] = @logger
+          end
+          @logger
+        end
+
+        def initialize_http(args = { })
+          @http_host_address = args[:http_host_address] ||= DEFAULT_HTTP_HOST_ADDRESS
+          @http_host_port = args[:http_host_port] ||= DEFAULT_HTTP_HOST_PORT
+          @http = Net::HTTP.new(http_host_address, http_host_port)
+
+          use_ssl = args[:http_host_use_ssl]
+          if use_ssl
+            # @TODO Add SSL Support
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+
+          http
+        end
+
+        # Formats a HTTPRequest or HTTPResponse body for log output.
+        # @param [HTTPRequest|HTTPResponse] obj
+        # @return [String]
+        def format_body_for_log_output(obj)
+          if obj.content_type == 'application/json'
+            if @log_pretty_print_body
+              _body = obj.body
+              output = JSON.pretty_generate(JSON.parse(_body)) rescue _body
+              return output
+            else
+              return obj.body
+            end
+          elsif obj.content_type == 'application/xml'
+            return obj.body
+          else
+            return obj.body.inspect
+          end
+        end
+
+        # @param [HTTPRequest] request
+        def send_request(request)
+          @response_parsed = nil
+          @request = request
+          logger.debug { %(REQUEST: #{request.method} http#{http.use_ssl? ? 's' : ''}://#{http.address}:#{http.port}#{request.path} HEADERS: #{request.to_hash.inspect} #{log_request_body and request.request_body_permitted? ? "\n-- BODY BEGIN --\n#{format_body_for_log_output(request)}\n-- BODY END --" : ''}) }
+
+          @request_time_start = Time.now
+          @response = http.request(request)
+          @request_time_end = Time.now
+          logger.debug { %(RESPONSE: #{response.inspect} HEADERS: #{response.to_hash.inspect} #{log_response_body and response.respond_to?(:body) ? "\n-- BODY BEGIN --\n#{format_body_for_log_output(response)}\n-- BODY END--" : ''}\nTook: #{@request_time_end - @request_time_start} seconds) }
+          #logger.debug { "Parse Response? #{@parse_response}" }
+
+          raise HTTPAuthorizationError if @use_exceptions && @response.code == '401'
+
+          @parse_response ? response_parsed : response.body
+        end
+
+        def response_parsed
+          @response_parsed ||= begin
+            response_body = response.respond_to?(:body) ? response.body : ''
+            logger.debug { "Parsing Response. #{response_body.inspect}" }
+
+            case response.content_type
+            when 'application/json'
+               response_body.empty? ? response_body : JSON.parse(response_body) # rescue response
+             else
+               response_body
+            end
+          end
+        end
+
+        # @param [String] path
+        # @param [Hash|String|Nil] query
+        # @return [URI]
+        def build_uri(path = '', query = nil)
+          _query = query.is_a?(Hash) ? query.map { |k,v| "#{CGI.escape(k.to_s)}=#{CGI.escape(v.respond_to?(:to_s) ? v.to_s : v)}" }.join('&') : query
+          _path = "#{path}#{_query and _query.respond_to?(:empty?) and !_query.empty? ? "?#{_query}" : ''}"
+          URI.parse(File.join(base_uri, _path))
+        end
+
+        if RUBY_VERSION.start_with? '1.8.'
+          def request_method_name_to_class_name(method_name)
+            method_name.to_s.capitalize
+          end
+        else
+          def request_method_name_to_class_name(method_name)
+            method_name.to_s.capitalize.to_sym
+          end
+        end
+
+        # @param [Symbol] method_name (:get)
+        # @param [Hash] args
+        # @option args [Hash] :headers ({})
+        # @option args [String] :path ('')
+        # @option args [Hash] :query ({})
+        # @option args [Any] :body (nil)
+        # @param [Hash] options
+        # @option options [Hash] :default_request_headers (@default_request_headers)
+        def call_method(method_name = :get, args = { }, options = { })
+          headers = args[:headers] || options[:headers] || { }
+          path = args[:path] || ''
+          query = args[:query] || { }
+          body = args[:body]
+
+          # Allow the default request headers to be overridden
+          _default_request_headers = options.fetch(:default_request_headers, default_request_headers)
+          _default_request_headers ||= { }
+          _headers = _default_request_headers.merge(headers)
+
+          @uri = build_uri(path, query)
+          klass_name = request_method_name_to_class_name(method_name)
+          klass = Net::HTTP.const_get(klass_name)
+
+          request = klass.new(@uri.request_uri, _headers)
+
+          if request.request_body_permitted?
+            _body = (body and !body.is_a?(String)) ? JSON.generate(body) : body
+            logger.debug { "Processing Body: '#{_body}'" }
+            request.body = _body if _body
+          end
+
+          send_request(request)
+        end
+
+        def delete(path, options = { })
+          query = options.fetch(:query, { })
+          base_path = options[:base_path] || ( path.start_with?(@default_base_path) ? '' : @default_base_path )
+          @uri = build_uri(File.join(base_path, path), query)
+          request = Net::HTTP::Delete.new(@uri.request_uri, default_request_headers)
+          send_request(request)
+        end
+
+        def get(path, options = { })
+          # Allow the default request headers to be overridden
+          headers = options[:headers] || { }
+          _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || { }
+          _headers = _default_request_headers.merge(headers)
+
+          query ||= options.fetch(:query, { })
+          base_path = options[:base_path] || ( path.start_with?(@default_base_path) ? '' : @default_base_path )
+          @uri = build_uri(File.join(base_path, path), query)
+          request = Net::HTTP::Get.new(@uri.request_uri, _headers)
+          send_request(request)
+        end
+
+        def head(path, options = { })
+          # Allow the default request headers to be overridden
+          headers = options[:headers] || { }
+          _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || { }
+          _headers = _default_request_headers.merge(headers)
+
+          query ||= options.fetch(:query, { })
+          base_path = options[:base_path] || ( path.start_with?(@default_base_path) ? '' : @default_base_path )
+          @uri = build_uri(File.join(base_path, path), query)
+
+          request = Net::HTTP::Head.new(@uri.request_uri, _headers)
+          send_request(request)
+        end
+
+        def options(path, options = { })
+          # Allow the default request headers to be overridden
+          headers = options[:headers] || { }
+          _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || { }
+          _headers = _default_request_headers.merge(headers)
+
+          query ||= options.fetch(:query, { })
+          base_path = options[:base_path] || ( path.start_with?(@default_base_path) ? '' : @default_base_path )
+          @uri = build_uri(File.join(base_path, path), query)
+          request = Net::HTTP::Options.new(@uri.request_uri, _headers)
+          send_request(request)
+        end
+
+        def put(path, body, options = { })
+          # Allow the default request headers to be overridden
+          headers = options[:headers] || { }
+          _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || { }
+          _headers = _default_request_headers.merge(headers)
+
+          query = options.fetch(:query, { })
+          base_path = options[:base_path] || ( path.start_with?(@default_base_path) ? '' : @default_base_path )
+          @uri = build_uri(File.join(base_path, path), query)
+          request = Net::HTTP::Put.new(@uri.request_uri, _headers)
+
+          body = JSON.generate(body) if body and !body.is_a?(String)
+
+          request.body = body if body
+          send_request(request)
+        end
+
+        def post(path, body, options = { })
+          # Allow the default request headers to be overridden
+          headers = options[:headers] || { }
+          _default_request_headers = options.fetch(:default_request_headers, default_request_headers) || { }
+          _headers = _default_request_headers.merge(headers)
+
+          query = options.fetch(:query, { })
+          base_path = options[:base_path] || ( path.start_with?(@default_base_path) ? '' : @default_base_path )
+          @uri = build_uri(File.join(base_path, path), query)
+
+          request = Net::HTTP::Post.new(@uri.request_uri, _headers)
+
+          body = JSON.generate(body) if body and !body.is_a?(String)
+
+          request.body = body if body
+          send_request(request)
+        end
+
+        # HTTPClient
+      end
+
+      # Client
+    end
+
+    # API
+  end
+
+  # Vidispine
+end

data/lib/vidispine/api/client/requests.rb

@@ -0,0 +1,27 @@
+require 'vidispine/api/client/requests/base_request'
+
+require 'vidispine/api/client/requests/collection_access_add'
+require 'vidispine/api/client/requests/collection_access_delete'
+require 'vidispine/api/client/requests/collection_metadata_set'
+
+require 'vidispine/api/client/requests/import_placeholder'
+require 'vidispine/api/client/requests/import_placeholder_item'
+require 'vidispine/api/client/requests/import_sidecar_file'
+require 'vidispine/api/client/requests/import_using_uri'
+
+require 'vidispine/api/client/requests/item_access_add'
+require 'vidispine/api/client/requests/item_access_delete'
+require 'vidispine/api/client/requests/item_delete'
+require 'vidispine/api/client/requests/item_export'
+require 'vidispine/api/client/requests/item_metadata_get'
+require 'vidispine/api/client/requests/item_metadata_set'
+require 'vidispine/api/client/requests/item_transcode'
+
+require 'vidispine/api/client/requests/items_search'
+
+require 'vidispine/api/client/requests/search'
+
+require 'vidispine/api/client/requests/storage_file_create'
+require 'vidispine/api/client/requests/storage_file_get'
+
+require 'vidispine/api/client/requests/storage_files_get'

data/lib/vidispine/api/client/requests/base_request.rb

@@ -0,0 +1,234 @@
+require 'cgi'
+require 'uri'
+
+module Vidispine
+  module API
+    class Client
+      module Requests
+
+        class BaseRequest
+
+          HTTP_METHOD = :get
+          HTTP_BASE_PATH = '/API/'
+          HTTP_PATH = ''
+          HTTP_SUCCESS_CODE = '200'
+
+          DEFAULT_PARAMETER_SEND_IN_VALUE = :query
+
+          PARAMETERS = [ ]
+
+          attr_accessor :client, :arguments, :options, :initial_arguments, :missing_required_arguments,
+                        :default_parameter_send_in_value, :processed_parameters
+
+          attr_writer :parameters, :path, :body, :query
+
+          def self.normalize_argument_hash_keys(hash)
+            return hash unless hash.is_a?(Hash)
+            Hash[ hash.dup.map { |k,v| [ normalize_parameter_name(k), v ] } ]
+          end
+
+          def self.normalize_parameter_name(name)
+            (name || '').respond_to?(:to_s) ? name.to_s.gsub('_', '').gsub('-', '').downcase : name
+          end
+
+          def self.process_parameters(params, args, options = { })
+            args = normalize_argument_hash_keys(args) || { }
+            args_out = options[:arguments_out] || { }
+            default_parameter_send_in_value = options[:default_parameter_send_in_value] || DEFAULT_PARAMETER_SEND_IN_VALUE
+            processed_parameters = options[:processed_parameters] || { }
+            missing_required_arguments = options[:missing_required_arguments] || [ ]
+
+            params.each do |param|
+              process_parameter(param, args, args_out, missing_required_arguments, processed_parameters, default_parameter_send_in_value)
+            end
+            { :arguments_out => args_out, :processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments }
+          end
+
+          # A method to expose parameter processing
+          #
+          # @param [Hash|Symbol] param The parameter to process
+          # @param [Hash] args ({ }) Arguments to possibly match to the parameter
+          # @param [Hash] args_out ({ }) The processed value of the parameter (if any)
+          # @param [Array] missing_required_arguments ([ ]) If the parameter was required and no argument found then it
+          # will be placed into this array
+          # @param [Hash] processed_parameters ({ }) The parameter will be placed into this array once processed
+          # @param [Symbol] default_parameter_send_in_value (DEFAULT_PARAMETER_SEND_IN_VALUE) The :send_in value that
+          # will be set if the :send_in key is not found
+          # @param [Hash] options
+          # @option options [True|False] :normalize_argument_hash_keys (false)
+          def self.process_parameter(param, args = { }, args_out = { }, missing_required_arguments = [ ], processed_parameters = { }, default_parameter_send_in_value = DEFAULT_PARAMETER_SEND_IN_VALUE, options = { })
+            args = normalize_argument_hash_keys(args) || { } if options.fetch(:normalize_argument_hash_keys, false)
+
+            _k = param.is_a?(Hash) ? param : { :name => param, :required => false, :send_in => default_parameter_send_in_value }
+            _k[:send_in] ||= default_parameter_send_in_value
+
+            proper_parameter_name = _k[:name]
+            param_name = normalize_parameter_name(proper_parameter_name)
+            arg_key = (has_key = args.has_key?(param_name)) ?
+                param_name :
+                ( (_k[:aliases] || [ ]).map { |a| normalize_parameter_name(a) }.find { |a| has_key = args.has_key?(a) } || param_name )
+
+            value = has_key ? args[arg_key] : _k[:default_value]
+            is_set = has_key || _k.has_key?(:default_value)
+
+            processed_parameters[proper_parameter_name] = _k.merge(:value => value, :is_set => is_set)
+
+            unless is_set
+              missing_required_arguments << proper_parameter_name if _k[:required]
+            else
+              args_out[proper_parameter_name] = value
+            end
+
+            { :arguments_out => args_out, :processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments }
+          end
+
+          def initialize(args = { }, options = { })
+            @initial_arguments = args.dup
+            @options = options.dup
+
+            after_initialize
+          end
+
+          def after_initialize
+            reset_attributes
+
+            process_parameters
+          end
+
+          def reset_attributes
+            @client = options[:client]
+            @missing_required_arguments = [ ]
+            @default_parameter_send_in_value = options[:default_parameter_send_in_value] || self.class::DEFAULT_PARAMETER_SEND_IN_VALUE
+            @processed_parameters = { }
+            @arguments = { }
+            @eval_http_path = options.fetch(:eval_http_path, true)
+            @base_path = options[:base_path]
+
+            @parameters = options[:parameters]
+            @http_method = options[:http_method]
+            @http_path = options[:http_path] ||= options[:path_raw]
+            @http_success_code = options[:http_success_code] ||= HTTP_SUCCESS_CODE
+
+            @path = options[:path]
+            @path_arguments = nil
+            @path_only = nil
+
+            @matrix = options[:matrix]
+            @matrix_arguments = nil
+
+            @query = options[:query]
+            @query_arguments = nil
+
+            @body = options[:body]
+            @body_arguments = nil
+          end
+
+          def process_parameters(params = parameters, args = @initial_arguments, options = @options)
+
+            before_process_parameters unless options.fetch(:skip_before_process_parameters, false)
+            self.class.process_parameters(params, args, options.merge(:processed_parameters => processed_parameters, :missing_required_arguments => missing_required_arguments, :default_parameter_send_in_value => default_parameter_send_in_value, :arguments_out => arguments))
+            after_process_parameters unless options.fetch(:skip_after_process_parameters, false)
+
+          end
+
+          def before_process_parameters
+            # TO BE IMPLEMENTED IN CHILD CLASS
+          end
+
+          def after_process_parameters
+            # TO BE IMPLEMENTED IN CHILD CLASS
+          end
+
+          # @!group Attribute Readers
+
+          def http_success_code
+            @http_success_code
+          end
+
+          def arguments
+            @arguments ||= { }
+          end
+
+          def base_path
+            @base_path ||= self.class::HTTP_BASE_PATH
+          end
+
+          def body_arguments
+            @body_arguments ||= arguments.dup.delete_if { |k,_| processed_parameters[k][:send_in] != :body }
+          end
+
+          def body
+            body_arguments.empty? ? nil : body_arguments
+          end
+
+          def client
+            @client ||= options[:client]
+          end
+
+          def eval_http_path?
+            @eval_http_path
+          end
+
+          def http_path
+            @http_path ||= self.class::HTTP_PATH #||= File.join(http.default_base_path, self.class::HTTP_PATH)
+          end
+
+          def http_method
+            @http_method ||= self.class::HTTP_METHOD
+          end
+
+          def parameters
+            @parameters ||= self.class::PARAMETERS.dup
+          end
+
+          # The URI Path including "matrix" arguments
+          def path
+            @path ||= [ path_only ].concat( [*matrix].delete_if { |v| v.respond_to?(:empty?) and v.empty? } ).join('')
+          end
+          alias :path_with_matrix :path
+
+          def path_arguments
+            @path_arguments ||= Hash[
+                arguments.dup.delete_if { |k, _| processed_parameters[k][:send_in] != :path }.
+                    map { |k,v| [ k, CGI.escape(v.respond_to?(:to_s) ? v.to_s : '').gsub('+', '%20') ] }
+            ]
+          end
+
+          def path_only
+            @path_only ||= File.join(base_path, (eval_http_path? ? eval(%("#{http_path}"), binding, __FILE__, __LINE__) : http_path))
+          end
+
+          def query
+            @query ||= begin
+              query_arguments.is_a?(Hash) ? query_arguments.map { |k,v| "#{CGI.escape(k.to_s).gsub('+', '%20')}=#{CGI.escape(v.respond_to?(:to_s) ? v.to_s : v).gsub('+', '%20')}" }.join('&') : query_arguments
+            end
+          end
+
+          def query_arguments
+            @query_arguments ||= arguments.dup.delete_if { |k,_| processed_parameters[k][:send_in] != :query }
+          end
+
+          def matrix
+            @matrix = matrix_arguments.map { |k,v| ";#{CGI.escape(k.to_s).gsub('+', '%20')}=#{CGI.escape(v.to_s).gsub('+', '%20')}" }.join('')
+          end
+
+          def matrix_arguments
+            @matrix_arguments ||= arguments.dup.delete_if { |k,_| processed_parameters[k][:send_in] != :matrix }
+          end
+
+          def uri_request_path
+            [ path_with_matrix ].concat( [*query].delete_if { |v| v.respond_to?(:empty?) and v.empty? } ).join('?')
+          end
+
+          def success?
+            _response = client.http_client.response
+            _response && (_response.code == http_success_code)
+          end
+
+          # @!endgroup
+
+        end
+      end
+    end
+  end
+end