vidispine 1.4.0

data/lib/vidispine/api/utilities/cli.rb

@@ -0,0 +1,168 @@
+require 'json'
+require 'pp'
+require 'rexml/document'
+
+require 'vidispine/cli'
+require 'vidispine/api/utilities'
+
+module Vidispine
+
+  module API
+
+    class Utilities
+
+      class CLI < Vidispine::CLI
+
+        def self.define_parameters
+          default_http_host_address = Vidispine::API::Client::HTTPClient::DEFAULT_HTTP_HOST_ADDRESS
+          default_http_host_port = Vidispine::API::Client::HTTPClient::DEFAULT_HTTP_HOST_PORT
+          default_accepts_header = Vidispine::API::Client::HTTPClient::DEFAULT_HEADER_ACCEPTS
+          default_content_type_header = Vidispine::API::Client::HTTPClient::DEFAULT_HEADER_CONTENT_TYPE
+
+          argument_parser.on('--host-address HOSTADDRESS', 'The address of the server to communicate with.', "\tdefault: #{default_http_host_address}") { |v| arguments[:http_host_address] = v }
+          argument_parser.on('--host-port HOSTPORT', 'The port to use when communicating with the server.', "\tdefault: #{default_http_host_port}") { |v| arguments[:http_host_port] = v }
+          argument_parser.on('--username USERNAME', 'The account username to authenticate with.') { |v| arguments[:username] = v }
+          argument_parser.on('--password PASSWORD', 'The account password to authenticate with.') { |v| arguments[:password] = v }
+
+          argument_parser.on('--accept-header VALUE', 'The value for the Accept header sent in each request.', "\tdefault: #{default_accepts_header}") { |v| arguments[:accepts_header] = v }
+          argument_parser.on('--content-type VALUE', 'The value for the Content-Type header sent in each request.', "\tdefault: #{default_content_type_header}") { |v| arguments[:content_type] = v }
+          argument_parser.on('--method-name METHODNAME', 'The name of the method to call.') { |v| arguments[:method_name] = v }
+          argument_parser.on('--method-arguments JSON', 'The arguments to pass when calling the method.') { |v| arguments[:method_arguments] = v }
+          argument_parser.on('--storage-map JSON', 'A map of file paths to storage ids to use in utility methods.') { |v| arguments[:storage_map] = v }
+          argument_parser.on('--metadata-map JSON', 'A map of field aliases to field names to use in utility methods.') { |v| arguments[:metadata_map] = v }
+          argument_parser.on('--pretty-print', 'Will format the output to be more human readable.') { |v| arguments[:pretty_print] = v }
+
+          argument_parser.on('--log-to FILENAME', 'Log file location.', "\tdefault: #{log_to_as_string}") { |v| arguments[:log_to] = v }
+          argument_parser.on('--log-level LEVEL', LOGGING_LEVELS.keys, "Logging level. Available Options: #{LOGGING_LEVELS.keys.join(', ')}",
+                "\tdefault: #{LOGGING_LEVELS.invert[arguments[:log_level]]}") { |v| arguments[:log_level] = LOGGING_LEVELS[v] }
+
+          argument_parser.on('--[no-]options-file [FILENAME]', 'Path to a file which contains default command line arguments.', "\tdefault: #{arguments[:options_file_path]}" ) { |v| arguments[:options_file_path] = v}
+          argument_parser.on_tail('-h', '--help', 'Display this message.') { puts help; exit }
+        end
+
+        attr_accessor :logger, :api
+
+        def after_initialize
+          initialize_api(arguments)
+        end
+
+        def initialize_api(args = { })
+          @api = Vidispine::API::Utilities.new(args )
+        end
+
+        def run(args = arguments, opts = options)
+          storage_map = args[:storage_map]
+          @api.default_storage_map = JSON.parse(storage_map) if storage_map.is_a?(String)
+
+          metadata_map = args[:metadata_map]
+          @api.default_metadata_map = JSON.parse(metadata_map) if metadata_map.is_a?(String)
+
+          method_name = args[:method_name]
+          send(method_name, args[:method_arguments], :pretty_print => args[:pretty_print]) if method_name
+
+          self
+        end
+
+        def send(method_name, method_arguments, params = {})
+          method_name = method_name.to_sym
+          logger.debug { "Executing Method: #{method_name}" }
+
+          send_arguments = [ method_name ]
+
+          if method_arguments
+            method_arguments = JSON.parse(method_arguments, :symbolize_names => true) if method_arguments.is_a?(String) and method_arguments.start_with?('{', '[')
+            send_arguments.concat  method_arguments.is_a?(Array) ? [ *method_arguments ] : [ method_arguments ]
+          end
+          #puts "Send Arguments: #{send_arguments.inspect}"
+          response = api.__send__(*send_arguments)
+
+          # if response.code.to_i.between?(500,599)
+          #   puts parsed_response
+          #   exit
+          # end
+          #
+          # if ResponseHandler.respond_to?(method_name)
+          #   ResponseHandler.client = api
+          #   ResponseHandler.response = response
+          #   response = ResponseHandler.__send__(*send_arguments)
+          # end
+
+          if params[:pretty_print]
+            if response.is_a?(String)
+              _response_cleaned = response.strip
+              if _response_cleaned.start_with?('{', '[')
+                puts prettify_json(response)
+              elsif _response_cleaned.start_with?('<') and _response_cleaned.end_with?('>')
+                puts prettify_xml(response)
+              else
+                #pp response.is_a?(String) ? response : JSON.pretty_generate(response) rescue response
+                puts response.is_a?(String) ? response : JSON.pretty_generate(response) rescue response
+              end
+            else
+              pp response.is_a?(String) ? response : JSON.pretty_generate(response) rescue response
+            end
+          else
+            response = JSON.generate(response) if response.is_a?(Hash) or response.is_a?(Array)
+            puts response
+          end
+          # send
+        end
+
+        def prettify_json(json)
+          JSON.pretty_generate(JSON.parse(json))
+        end
+
+        def prettify_xml(xml, options = { })
+          document = REXML::Document.new(xml)
+          document.write(output = '', options[:indent] || 1)
+
+          return output unless options.fetch(:collapse_tags, true)
+
+          last_open_tag = ''
+          #last_matching_close_tag = ''
+          last_was_tag = false
+          last_was_matching_close_tag = false
+
+          output.lines.map do |v|
+            _v = v.strip
+
+            is_tag = _v.start_with?('<') and _v.end_with?('>')
+            is_open_tag = (is_tag and !_v.start_with?('</'))
+            is_matching_close_tag = (is_tag and !is_open_tag and _v == "</#{(last_open_tag || '')[1..-1]}")
+
+            _output = if is_open_tag
+                        "#{(last_was_tag and !last_was_matching_close_tag) ? "\n" : ''}#{v.rstrip}"
+                      elsif is_matching_close_tag
+                        "#{_v}\n"
+                      elsif !is_tag
+                        _v
+                      else
+                        v
+                      end
+            #puts "V: '#{_v}' IT: #{is_tag} IOT: #{is_open_tag} ICT: #{is_matching_close_tag} LOT: '#{last_open_tag}' LCT: #{last_matching_close_tag} OUTPUT: '#{_output}'"
+
+            last_was_tag = is_tag
+            last_was_matching_close_tag = is_matching_close_tag
+            if is_open_tag
+              last_open_tag = _v.split(' ').first
+              last_open_tag << '>' unless last_open_tag.end_with?('>')
+            elsif is_matching_close_tag
+              #last_matching_close_tag = _v
+            end
+
+            _output
+          end.join('')
+        end
+
+        # CLI
+      end
+
+      # Utilities
+    end
+
+    # API
+  end
+
+  # Vidispine
+end
+def cli; @cli ||= Vidispine::API::Utilities::CLI end

data/lib/vidispine/api/utilities/http_server.rb

@@ -0,0 +1,230 @@
+require 'pp'
+
+require 'sinatra/base'
+require 'vidispine/api/utilities'
+
+module Vidispine
+
+  module API
+
+    class Utilities
+
+      class HTTPServer < Sinatra::Base
+
+        configure do
+          enable :show_exceptions
+          enable :dump_errors
+          #enable :lock # ensure single request concurrency with a mutex lock
+        end
+
+        DEFAULT_ADDRESS_BINDING = 'localhost'
+        DEFAULT_PORT = '4567'
+
+        attr_accessor :global_arguments,
+                      :metadata_file_path_field_id,
+                      :relative_file_path_collection_name_position,
+                      :storage_path_map
+
+        # @!group Routes
+
+        get '/collection-by-name/:collection_name' do
+          log_request_match(__method__)
+          _response = api.dup.collection_get_by_name(params)
+          logger.debug { "Response: #{_response}" }
+          format_response(_response)
+        end
+
+        post '/collection-file-add-using-path/?' do
+          log_request_match(__method__)
+          _params = merge_params_from_body
+
+          #args_out = _params
+          args_out = indifferent_hash.merge({
+            :storage_path_map => initial_arguments[:storage_path_map],
+            :relative_file_path_collection_name_position => initial_arguments[:relative_file_path_collection_name_position],
+            :metadata_file_path_field_id => initial_arguments[:metadata_file_path_field_id],
+          })
+
+          args_out.merge!(_params)
+          _response = api.dup.collection_file_add_using_path(args_out)
+          format_response(_response)
+        end
+
+        # Shows what gems are within scope. Used for diagnostics and troubleshooting.
+        get '/gems' do
+          stdout_str = `gem list -b`
+          stdout_str ? stdout_str.gsub("\n", '<br/>') : stdout_str
+        end
+
+        get '/favicon.ico' do; end
+
+        get '/:method_name?' do
+          logger.debug { "GET #{params.inspect}" }
+          method_name = params[:method_name]
+          pass unless api.respond_to?(method_name)
+          log_request_match(__method__)
+          _params = merge_params_from_body
+
+          _response = api.dup.send(method_name, _params)
+          format_response(_response)
+        end
+
+        post '/:method_name?' do
+          logger.debug { "POST #{params.inspect}" }
+          method_name = params[:method_name]
+          pass unless api.respond_to?(method_name)
+          log_request_match(__method__)
+
+          _params = merge_params_from_body
+
+          _response = api.dup.send(method_name, _params)
+          format_response(_response)
+        end
+
+
+
+        ### CATCH ALL ROUTES BEGIN
+        get /.*/ do
+          log_request_match(__method__)
+          request_to_s.gsub("\n", '<br/>')
+        end
+
+        post /.*/ do
+          log_request_match(__method__)
+        end
+        ### CATCH ALL ROUTES END
+
+        # @!endgroup Routes
+
+        def format_response(response, args = { })
+          supported_types = %w(application/json application/xml text/xml)
+          case request.preferred_type(supported_types)
+            when 'application/json'
+              content_type :json
+              _response = (response.is_a?(Hash) || response.is_a?(Array)) ? JSON.generate(response) : response
+            #when 'application/xml', 'text/xml'
+            #  content_type :xml
+            #  _response = XmlSimple.xml_out(response, { :root_name => 'response' })
+            else
+              content_type :json
+              _response = (response.is_a?(Hash) || response.is_a?(Array)) ? JSON.generate(response) : response
+          end
+          _response
+        end # output_response
+
+        def parse_body
+          if request.media_type == 'application/json'
+            request.body.rewind
+            body_contents = request.body.read
+            logger.debug { "Parsing: '#{body_contents}'" }
+            if body_contents
+              json_params = JSON.parse(body_contents)
+              return json_params
+            end
+          end
+
+        end # parse_body
+
+        # Will try to convert a body to parameters and merge them into the params hash
+        # Params will override the body parameters
+        #
+        # @params [Hash] _params (params) The parameters parsed from the query and form fields
+        def merge_params_from_body(_params = params)
+          _params = _params.dup
+          _params_from_body = parse_body
+          _params = _params_from_body.merge(_params) if _params_from_body.is_a?(Hash)
+          indifferent_hash.merge(_params)
+        end # merge_params_from_body
+
+        # @param [Hash] args
+        # @option args [Request] :request
+        def request_to_s(args = { })
+          _request = args[:request] || request
+          output = <<-OUTPUT
+------------------------------------------------------------------------------------------------------------------------
+    REQUEST
+    Method:         #{_request.request_method}
+    URI:            #{_request.url}
+
+    Host:           #{_request.host}
+    Path:           #{_request.path}
+    Script Name:    #{_request.script_name}
+    Query String:   #{_request.query_string}
+    XHR?            #{_request.xhr?}
+
+    Remote
+    Host:           #{_request.env['REMOTE_HOST']}
+    IP:             #{_request.ip}
+    User Agent:     #{_request.user_agent}
+    Cookies:        #{_request.cookies}
+    Accepts:        #{_request.accept.inspect}
+    Preferred Type: #{_request.preferred_type}
+
+    Media Type:     #{_request.media_type}
+    BODY BEGIN:
+#{_request.body.read}
+    BODY END.
+
+    Parsed Parameters:
+    #{PP.pp(_request.params, '', 60)}
+
+------------------------------------------------------------------------------------------------------------------------
+          OUTPUT
+          _request.body.rewind
+          output
+        end # request_to_s
+
+        def log_request(route = '')
+          return if request.path == '/favicon.ico'
+          logger.debug { "\n#{request_to_s}" }
+          #puts requests.insert(request_to_hash)
+        end # log_request
+
+        def log_request_match(route)
+          log_request(route)
+          logger.debug { "MATCHED: #{request.url} -> #{route}\nParsed Parameters: #{params.inspect}" }
+        end # log_request_match
+
+        def self.initialize_logger(args = { })
+          logger = args[:logger] ||= Logger.new(args[:log_to] || STDOUT)
+          logger.level = args[:log_level] if args[:log_level]
+          logger
+        end
+
+        # @param [Hash] args
+        # @option args [Logger] :logger
+        # @option args [String] :binding
+        # @option args [String] :local_port
+        def self.init(args = {})
+          logger = initialize_logger(args)
+          set(:logger, logger)
+
+          logger.debug { "Initializing HTTP Server. Arguments: #{args.inspect}" }
+
+          _binding = args.delete(:binding) { DEFAULT_ADDRESS_BINDING }
+          _port = args.delete(:port) { DEFAULT_PORT }
+          set(:bind, _binding)
+          set(:port, _port)
+          set(:initial_arguments, args)
+
+          set(:api, args[:api])
+        end
+
+        def logger
+          #self.class.logger
+          settings.logger
+        end
+
+        def api
+          #self.class.api
+          settings.api
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/vidispine/api/utilities/http_server/cli.rb

@@ -0,0 +1,77 @@
+require 'vidispine/cli'
+require 'vidispine/api/utilities/http_server'
+
+module Vidispine
+
+  module API
+
+    class Utilities
+
+      class HTTPServer
+
+        class CLI < Vidispine::CLI
+
+          def self.define_parameters
+            default_http_host_address = Vidispine::API::Client::HTTPClient::DEFAULT_HTTP_HOST_ADDRESS
+            default_http_host_port = Vidispine::API::Client::HTTPClient::DEFAULT_HTTP_HOST_PORT
+            default_vidispine_username = Vidispine::API::Client::HTTPClient::DEFAULT_USERNAME
+            default_vidispine_password = Vidispine::API::Client::HTTPClient::DEFAULT_PASSWORD
+
+            default_port = Vidispine::API::Utilities::HTTPServer::DEFAULT_PORT
+
+            argument_parser.on('--vidispine-http-host-address HOSTADDRESS', 'The address of the server to communicate with.', "\tdefault: #{default_http_host_address}") { |v| arguments[:http_host_address] = v }
+            argument_parser.on('--vidispine-http-host-port HOSTPORT', 'The port to use when communicating with the server.', "\tdefault: #{default_http_host_port}") { |v| arguments[:http_host_port] = v }
+            argument_parser.on('--vidispine-username USERNAME', 'The account username to authenticate with.', "\tdefault: #{default_vidispine_username}") { |v| arguments[:username] = v }
+            argument_parser.on('--vidispine-password PASSWORD', 'The account password to authenticate with.', "\tdefault: #{default_vidispine_password}") { |v| arguments[:password] = v }
+
+            argument_parser.on('--storage-path-map MAP', 'A path=>storage-id mapping to match incoming file paths to storages.') { |v| arguments[:storage_path_map] = v }
+            argument_parser.on('--metadata-field-map MAP', 'A path=>portal-field-id mapping to match incoming metadata fields to portal metadata fields.') { |v| arguments[:metadata_map] = v }
+            argument_parser.on('--relative-file-path-collection-name-position NUM',
+                'The relative position from the storage base path in which to select the collection name.',
+                "\tdefault: 0") { |v| arguments[:relative_file_path_collection_name_position] = v }
+            argument_parser.on('--metadata-file-path-field-id ID',
+                               'The Id of the metadata field where the file path is to be stored.'
+                              ) { |v| arguments[:metadata_file_path_field_id] = v }
+            argument_parser.on('--bind-to-address ADDRESS', 'The local address to bind the server to.') { |v| arguments[:bind] = v }
+            argument_parser.on('--port PORT', 'The port to bind to.', "\tdefault: #{default_port}") { |v| arguments[:port] = v }
+            argument_parser.on('--log-to FILENAME', 'Log file location.', "\tdefault: #{log_to_as_string}") { |v| arguments[:log_to] = v }
+            argument_parser.on('--log-level LEVEL', LOGGING_LEVELS.keys, "Logging level. Available Options: #{LOGGING_LEVELS.keys.join(', ')}",
+                               "\tdefault: #{LOGGING_LEVELS.invert[arguments[:log_level]]}") { |v| arguments[:log_level] = LOGGING_LEVELS[v] }
+
+            argument_parser.on('--[no-]options-file [FILENAME]', 'Path to a file which contains default command line arguments.', "\tdefault: #{arguments[:options_file_path]}" ) { |v| arguments[:options_file_path] = v}
+            argument_parser.on_tail('-h', '--help', 'Display this message.') { puts help; exit }
+          end
+
+          attr_accessor :logger, :api, :app
+
+          def after_initialize
+            initialize_api(arguments)
+            initialize_app(arguments)
+          end
+
+          def initialize_api(args = { })
+            @api = Vidispine::API::Utilities.new(args)
+          end
+
+          def initialize_app(args = { })
+            @app = Vidispine::API::Utilities::HTTPServer
+            args_out = args
+            args_out[:api] = api
+            app.init(args)
+          end
+
+          def run(args = arguments, opts = options)
+            app.run!
+            self
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end
+def cli; @cli ||= Vidispine::API::Utilities::HTTPServer::CLI end