adobe_media_encoder 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '089631b4dd833020bc8e6e471852701e01bd9355dcf1770480a7c8ae31109668'
+  data.tar.gz: 21a8d51f1e12d65f4263dca135a32ae18c961e23956b17f94e8ccbcfd47cc156
+SHA512:
+  metadata.gz: 38b2bb824a77052772f572949df9761cc0b527650079a8ad49e595d2bbe1fb70b914e8f593f7a3aa6db9ea4431218116df1636861a2f10e41c6564d74e26bb95
+  data.tar.gz: cf9093dfa2d94d6257d6a5f8b8765ce8937a6893a428e9f045ef9e9c33ac8f0bad12758dba4ae5020cc9805d0d3779e7d80930634e362e704623688bb731275a

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/dev/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'json_pure', :platforms => :mri_18
+
+# Specify your gem's dependencies in adobe_media_encoder.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 John Whitson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,98 @@
+# Adobe Media Encoder (AME)
+
+    A library for interacting with the Adobe Media Encoder API
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'adobe_media_encoder'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install adobe_media_encoder
+
+## Command Line Utilitie(s)
+
+### AME API CLI [bin/ame_api](./bin/ame_api)
+An executable to interact with the Adobe Media Encoder API using a Command Line Interface
+
+### ADOBE MEDIA ENCODER 2015
+
+###  Start AME service from the Mac Command Line
+
+cd '/Applications/Adobe Media Encoder CC 2015.3/Adobe Media Encoder CC 2015.app/Contents/ame_webservice_console.app/Contents/MacOS/';./ame_webservice_console 
+
+
+###  Configure the Web Server ports
+
+vi /Applications/Adobe\ Media\ Encoder\ CC\ 2015.3/Adobe\ Media\ Encoder\ CC\ 2015.app/Contents/Resources/ame_webservice_config.ini
+
+
+### ADOBE MEDIA ENCODER 2017
+
+###  Start AME service from the Mac Command Line
+
+cd '/Applications/Adobe Media Encoder CC 2017/Adobe Media Encoder CC 2017.app/Contents/ame_webservice_console.app/Contents/MacOS/';./ame_webservice_console 
+
+
+###  Configure the Web Server ports
+
+vi /Applications/Adobe\ Media\ Encoder\ CC\ 2017/Adobe\ Media\ Encoder\ CC\ 2017.app/Contents/Resources/ame_webservice_config.ini
+ 
+
+#### Usage
+        --host-address HOSTADDRESS   The AME API server address.
+                                      default: localhost
+        --host-port PORT             The port on the AME API server to connect to.
+                                      default: 8080
+        --method-name METHODNAME
+        --method-arguments JSON
+        --pretty-print
+        --log-to FILENAME            Log file location.
+                                      default: STDERR
+        --log-level LEVEL            Logging level. Available Options: debug, info, warn, error, fatal
+                                      default: warn
+        --[no-]options-file [FILENAME]
+                                     Path to a file which contains default command line arguments.
+                                      default: ~/.options/ame_api
+    -h, --help                       Show this message.
+
+#### Examples of Usage
+
+    job_abort
+    ame_api --host-address localhost --host-port 8080 --method-name job_abort
+    ame_api --host-address localhost --host-port 8080 --method-name job_abort --method-arguments '{"jobId":""}'
+
+    job_history
+    ame_api --host-address localhost --host-port 8080 --method-name job_history
+
+    job_status
+    ame_api --host-address localhost --host-port 8080 --method-name job_status
+
+    job_submit
+    ame_api --host-address localhost --host-port 8080 --method-name job_status --method-arguments '{"SourcePresetPath":"","SourceFilePath":"","DestinationPath":"","OverwriteDestinationIfPresent":"","NotificationTarget":"","BackupNotificationTarget":"","NotificationRateInMilliseconds":""}'
+
+    server_kill
+    ame_api --host-address localhost --host-port 8080 --method-name server_kill
+
+    server_restart
+    ame_api --host-address localhost --host-port 8080 --method-name server_restart
+
+    server_status
+    ame_api --host-address localhost --host-port 8080 --method-name server_status
+
+ 
+## Contributing
+
+1. Fork it ( https://github.com/XPlatform-Consulting/adobe_media_encoder.git/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/adobe_media_encoder.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'adobe_media_encoder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'adobe_media_encoder'
+  spec.version       = AdobeMediaEncoder::VERSION
+  spec.authors       = ['John Whitson']
+  spec.email         = ['john.whitson@gmail.com']
+  spec.summary       = %q{A library for interacting with the Adobe Media Encoder API}
+  # spec.description   = %q{}
+  spec.homepage      = 'https://github.com/XPlatform-Consulting/adobe_media_encoder'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+
+  # spec.add_development_dependency 'sinatra'
+end

data/bin/ame_api

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+lib_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(lib_path) unless $:.include?(lib_path) or !File.exists?(lib_path)
+
+require 'adobe_media_encoder/api/cli'
+
+ARGV << '--help' if ARGV.empty?
+AdobeMediaEncoder::API::CLI.new

data/lib/adobe_media_encoder.rb

@@ -0,0 +1,5 @@
+require 'adobe_media_encoder/version'
+
+module AdobeMediaEncoder
+  # Your code goes here...
+end

data/lib/adobe_media_encoder/api/cli.rb

@@ -0,0 +1,97 @@
+require 'json'
+require 'logger'
+require 'optparse'
+require 'pp'
+
+require 'adobe_media_encoder/api/client'
+
+module AdobeMediaEncoder
+
+  module API
+
+    class CLI
+
+      LOGGING_LEVELS = {
+        :debug => Logger::DEBUG,
+        :info => Logger::INFO,
+        :warn => Logger::WARN,
+        :error => Logger::ERROR,
+        :fatal => Logger::FATAL
+      }
+
+      attr_accessor :logger, :api
+
+      def parse_arguments
+        arguments = {
+          :log_to => STDERR,
+          :log_level => Logger::WARN,
+          :options_file_path => File.expand_path(File.basename($0, '.*'), '~/.options'),
+          :host => AdobeMediaEncoder::API::Client::HTTPClient::DEFAULT_HTTP_HOST_ADDRESS,
+          :port => AdobeMediaEncoder::API::Client::HTTPClient::DEFAULT_HTTP_HOST_PORT,
+        }
+        op = OptionParser.new
+        op.on('--host-address HOSTADDRESS', 'The AdobeAnywhere server address.',
+              "\tdefault: #{arguments[:host]}") { |v| arguments[:host] = v }
+        op.on('--host-port PORT', 'The port on the AdobeAnywhere server to connect to.',
+              "\tdefault: #{arguments[:port]}") { |v| arguments[:port] = v }
+        op.on('--method-name METHODNAME', '') { |v| arguments[:method_name] = v }
+        op.on('--method-arguments JSON', '') { |v| arguments[:method_arguments] = v }
+        op.on('--pretty-print', '') { |v| arguments[:pretty_print] = v }
+        op.on('--log-to FILENAME', 'Log file location.', "\tdefault: STDERR") { |v| arguments[:log_to] = v }
+        op.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] }
+        op.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}
+        op.on_tail('-h', '--help', 'Show this message.') { puts op; exit }
+        op.parse!(ARGV.dup)
+
+        arguments_file_path = arguments[:options_file_path]
+        # Make sure that arguments from the command line override those from the arguments file
+        op.parse!(ARGV.dup) if op.load(arguments_file_path)
+        arguments
+      end
+
+
+      def initialize(args = {})
+        args = parse_arguments.merge(args)
+        @logger = Logger.new(args[:log_to])
+        logger.level = args[:log_level] if args[:log_level]
+        args[:logger] = logger
+
+        @api = AdobeMediaEncoder::API::Client.new(args)
+
+        ## LIST METHODS
+        #methods = api.methods; methods -= Object.methods; methods.sort.each { |method| puts "#{method} #{api.method(method).parameters rescue ''}" }; exit
+
+        # http.log_request_body = true
+        # http.log_response_body = true
+        # http.log_pretty_print_body = true
+
+
+        method_name = args[:method_name]
+        send(method_name, args[:method_arguments], :pretty_print => args[:pretty_print]) if method_name
+
+      end
+
+      def send(method_name, method_arguments, args = {})
+        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) if method_arguments.is_a?(String) and method_arguments.start_with?('{', '[')
+          send_arguments << method_arguments
+        end
+
+        response = api.__send__(*send_arguments)
+        puts response.respond_to?(:body) ? response.body : response
+
+        exit
+      end
+
+      # CLI
+    end
+    # API
+  end
+  # AdobeMediaEncoder
+end

data/lib/adobe_media_encoder/api/client.rb

@@ -0,0 +1,250 @@
+require 'logger'
+require 'net/http'
+require 'net/https'
+require 'rexml/document'
+
+require 'adobe_media_encoder'
+
+class String
+
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').collect(&:capitalize).join
+  end
+  alias :camelize :camel_case
+
+  def camel_case_lower
+    camel_case.uncapitalize
+  end
+
+  def snake_case
+    self.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').tr('-', '_').downcase
+  end
+  alias :snakeize :snake_case
+
+  def uncapitalize
+    self[0, 1].downcase + self[1..-1]
+  end
+
+end
+
+module AdobeMediaEncoder
+
+  module API
+
+    class Client
+
+      class XMLHelper
+
+        def self.create_manifest(data)
+          <<-XML
+<?xml version='1.0'?>
+<manifest version='1.0'>#{ data.map { |k,v| _k = k.to_s.camel_case; "\n\t<#{_k}>#{v.to_s}</#{_k}>"}.join }
+</manifest>
+          XML
+        end
+
+        def self.parse_payload(xml)
+          doc = REXML::Document.new(xml)
+          Hash[doc.elements['/payload'].elements.map { |e| [ e.name, e.text ] } ]
+        end
+
+      end
+
+      class HTTPClient
+
+        DEFAULT_HTTP_HOST_ADDRESS = 'localhost'
+        DEFAULT_HTTP_HOST_PORT = 8080
+
+        attr_accessor :logger, :log_request_body, :log_response_body, :log_pretty_print_body,
+
+                      :host, :port, :http, :request, :response, :default_request_headers,
+
+                      :base_uri
+
+        def initialize(args = { })
+          initialize_logger(args)
+          initialize_http(args)
+
+          @default_request_headers = {
+              'Content-Type' => 'application/xml; charset=utf-8',
+              'Accept' => 'application/xml',
+          }
+          @parse_response = true
+
+          @base_uri = "http://#{host}:#{port}/"
+
+          @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)
+        end
+
+        def initialize_logger(args = { })
+          @logger = args[:logger] ||= Logger.new(args[:log_to] || STDERR)
+          log_level = args[:log_level]
+          if log_level
+            @logger.level = log_level
+            args[:logger] = @logger
+          end
+          @logger
+        end
+
+        def initialize_http(args = { })
+          @host = args[:host] ||= DEFAULT_HTTP_HOST_ADDRESS
+          @port = args[:port] ||= DEFAULT_HTTP_HOST_PORT
+          @http = Net::HTTP.new(host, port)
+        end
+
+        # Formats a HTTPRequest or HTTPResponse body for log output.
+        # @param [HTTPRequest|HTTPResponse] obj
+        # @return [String]
+        def format_body_for_log_output(obj)
+          output = ''
+          if obj.content_type == 'application/json'
+            if @log_pretty_print_body
+              _body = obj.body
+              output << "\n"
+              output << JSON.pretty_generate(JSON.parse(_body)) rescue _body
+              return output
+            else
+              return obj.body
+            end
+          else
+            return obj.body.inspect
+          end
+        end
+
+        def send_request(request)
+          @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? ? "BODY: #{format_body_for_log_output(request)}" : ''}) }
+
+          @response = http.request(request)
+          logger.debug { %(RESPONSE: #{response.inspect} HEADERS: #{response.to_hash.inspect} #{log_response_body and response.respond_to?(:body) ? "BODY: #{format_body_for_log_output(response)}" : ''}) }
+
+          @parse_response ? response_parsed : response.body
+        end
+
+        def response_parsed
+          XMLHelper.parse_payload(response.body) #rescue response
+        end
+
+        def build_uri(path = '', query = { })
+          _query = query.is_a?(Hash) ? query.map { |k,v| "#{CGI.escape(k)}=#{CGI.escape(v)}" }.join('&') : query
+          _path = "#{path}#{_query and _query.respond_to?(:empty?) and !_query.empty? ? "?#{_query}" : ''}"
+          URI.parse(File.join(base_uri, _path))
+        end
+
+        def delete(path, options = { })
+          query = options.fetch(:query, { })
+          @uri = build_uri(path, query)
+          request = Net::HTTP::Delete.new(@uri.request_uri, default_request_headers)
+          send_request(request)
+        end
+
+        def get(path, query = nil, options = { })
+          query ||= options.fetch(:query, { })
+          @uri = build_uri(path, query)
+          request = Net::HTTP::Get.new(@uri.request_uri, default_request_headers)
+          send_request(request)
+        end
+
+        def put(path, body, options = { })
+          query = options.fetch(:query, { })
+          @uri = build_uri(path, query)
+          #body = JSON.generate(body) unless body.is_a?(String)
+
+          request = Net::HTTP::Put.new(@uri.request_uri, default_request_headers)
+          request.body = body
+          send_request(request)
+        end
+
+        def post(path, body = nil, options = { })
+          query = options.fetch(:query, { })
+          @uri = build_uri(path, query)
+          #body = JSON.generate(body) unless body.is_a?(String)
+
+          request = Net::HTTP::Post.new(@uri.request_uri, default_request_headers)
+          request.body = body
+          send_request(request)
+        end
+
+      end
+
+      attr_accessor :http
+
+      def initialize(args = { })
+        initialize_logger(args)
+        @http = HTTPClient.new(args)
+      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 normalize_args(args = { }, options = { })
+        case args
+          when Array
+            [*args].map { |a| normalize_args(a, options) } if normalize_args.is_a?(Array)
+          when Hash
+            symbolize_keys = options.fetch(:symbolize_keys, true)
+            camelize_keys = options.fetch(:camelize_keys, false)
+            uncapitalize_keys = options.fetch(:uncapitalize_keys, false)
+            downcase_keys = options.fetch(:downcase_keys, false)
+            Hash[args.map do |k, v|
+                   _k = k.dup rescue k
+                   _k = _k.to_s.camel_case if camelize_keys rescue _k
+                   _k = _k.to_s.uncapitalize if uncapitalize_keys rescue _k
+                   _k = _k.to_s.downcase if downcase_keys rescue _k
+                   _k = symbolize_keys ? _k.to_sym : _k.to_s rescue _k
+                   [_k, v ]
+                 end]
+          else
+            args
+        end
+      end
+
+      def job_abort(args = { })
+        args = normalize_args(args, :symbolize_keys => true, :downcase_keys => true)
+        job_id = args[:id] || args[:job_id] || args[:jobid]
+        http.delete("job#{job_id ? "?jobID=#{job_id}" : ''}")
+      end
+
+      def job_history(args = { })
+        args = normalize_args(args, :symbolize_keys => true, :downcase_keys => true)
+        max_completed_jobs = args[:jobs] || args[:maxcompletedjobs]
+        http.get("history#{max_completed_jobs ? "?maxCompletedJobs=#{max_completed_jobs}" : ''}")
+      end
+
+      def job_status(args = { })
+        http.get('job')
+      end
+
+      def job_submit(args = { })
+        args = normalize_args(args, :symbolize_keys => false, :camelize_keys => true)
+        xml = XMLHelper.create_manifest(args)
+        http.post('job', xml)
+      end
+
+      def server_kill(args = { })
+        http.delete('server')
+      end
+
+      def server_restart(args = { })
+        http.post('server')
+      end
+
+      def server_status(args = { })
+        http.get('server')
+      end
+
+    end
+
+  end
+
+end

data/lib/adobe_media_encoder/version.rb

@@ -0,0 +1,3 @@
+module AdobeMediaEncoder
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: adobe_media_encoder
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Whitson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- john.whitson@gmail.com
+executables:
+- ame_api
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- adobe_media_encoder.gemspec
+- bin/ame_api
+- lib/adobe_media_encoder.rb
+- lib/adobe_media_encoder/api/cli.rb
+- lib/adobe_media_encoder/api/client.rb
+- lib/adobe_media_encoder/version.rb
+homepage: https://github.com/XPlatform-Consulting/adobe_media_encoder
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: A library for interacting with the Adobe Media Encoder API
+test_files: []