ubiquity-vdms 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a4a0f565b003c38872efd7383dbb1776a0e3d816cdc9cd6dda87439c122c15f5
+  data.tar.gz: fe5016b6d9936f6d82362c9c50dcb1ba2e8063385c358e8072742eeb6d9beafa
+SHA512:
+  metadata.gz: 3d32fafe3d91d674f4c56876cd1f15d95dcdc7e4cac77a10d3ea58953dc0cf6dd9a7f3953fc8c0bab22b1e15d61461f633f8d8aa7ee1c676404de4d5917c5590
+  data.tar.gz: dcdb7b6d99921f27dad2b6b7507880d7aaddc394fd6780d7c7dbf9ebdb0018cf575b78543a9a849efd133a0f6ce201966f62407bcf55cf739a0828b3066a43fd

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/dev/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 1.8.7
+before_install: gem install bundler -v 1.14.5

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'json', '~> 1.8', :platforms => :mri_18
+
+# Specify your gem's dependencies in ubiquity-vdms.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 TODO: Write your name
+
+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,41 @@
+# Ubiquity::VDMS
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ubiquity/vdms`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ubiquity-vdms'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ubiquity-vdms
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/XPlatform-Consulting/ubiquity-vdms.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ubiquity/vdms"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/ubiquity-vdms

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'ubiquity/vdms'

data/lib/ubiquity/vdms.rb

@@ -0,0 +1,7 @@
+require 'ubiquity/vdms/version'
+
+module Ubiquity
+  module VDMS
+
+  end
+end

data/lib/ubiquity/vdms/uplynk/api/client.rb

@@ -0,0 +1,199 @@
+require 'base64'
+require 'cgi'
+require 'json'
+require 'logger'
+require 'openssl'
+require 'uri'
+require 'zlib'
+
+require 'ubiquity/vdms/uplynk/api/client/http_client'
+
+module Ubiquity
+
+  module VDMS
+
+    module Uplynk
+
+      module API
+
+        class Client
+
+          attr_accessor :http_client, :request, :response, :logger
+
+          attr_accessor :owner, :secret
+
+          def initialize(args = { })
+            @http_client = HTTPClient.new(args)
+
+            @owner = args[:owner] || args[:username]
+            @secret = args[:secret] || args[:password]
+
+            @logger = http_client.logger
+          end
+
+          def message_encode(msg, _owner = owner)
+            msg['_owner'] = _owner
+            msg['_timestamp'] = Time.now.to_i
+            msg = JSON.generate(msg)
+
+            msg = Zlib::Deflate.deflate(msg, 9)
+            msg = Base64.encode64(msg).strip
+
+            msg
+          end
+
+          def signature_generate(encoded_msg, _secret = secret)
+            OpenSSL::HMAC.hexdigest('sha256', _secret, encoded_msg)
+          end
+
+          def encode_body(body)
+            msg = message_encode(body)
+            sig = signature_generate(msg)
+            _body = "msg=#{CGI.escape(msg)}&sig=#{CGI.escape(sig)}"
+          end
+
+          def post(path, body = { }, opts = { })
+            _body = encode_body(body)
+            http_client.post(path, _body, opts)
+          end
+
+          # Retrieves a specific asset from your library.
+          # @see https://support.uplynk.com/doc_integration_apis_asset.html
+          #
+          # Request parameters
+          # +--------------+--------+-------------------------------------------------------------------------------+
+          # | id           | string | (optional*) the asset's ID                                                    |
+          # | external_id  | string | (optional*) the asset's external ID                                           |
+          # | ids          | list   | (optional*) a list of assets' IDs to be returned as a list of assets          |
+          # | external_ids | list   | (optional*) a list of assets' external IDs to be returned as a list of assets |
+          # +--------------+--------+-------------------------------------------------------------------------------+
+          # * One of id, external_id, ids, external_ids must be specified.
+          #
+          # @param [Hash] args
+          # @option args [String] id
+          # @option args [String] external_id
+          # @option args [<Array>String] ids
+          # @option args [<Array>String] external_ids
+          #
+          # @param [Hash] opts
+          #
+          # @return [Hash]
+          def asset_get(args = { }, opts = { })
+            post('asset/get', args, opts)
+          end
+
+          # Returns a base64 representation of the specified frame from the highest bitrate variant of the specified asset.
+          #
+          # Request parameters
+          # +----+------------+-------------------------------------------------------------------------------------------------------------------+
+          # | id | int        | ID of the asset from which to grab a frame                                                                        |
+          # | ts | int/string | Timestamp of the frame to grab. Specify in milliseconds as an integer, or as a string in the 'hh:mm:ss.ms' format |
+          # +----+------------+-------------------------------------------------------------------------------------------------------------------+
+          #
+          # Response parameters
+          #
+          # @param [Hash] args
+          # @param [Hash] opts
+          # @return [Hash]
+          def asset_getframe(args = { }, opts = { })
+
+          end
+          alias :asset_get_frame :asset_getframe
+
+          # Lists or searches for assets.
+          #
+          # Request parameters
+          # +--------+---------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+          # | search | string  | (optional) Text to search for in the asset's description, ID, or external ID.                                                                                                                                                                                          |
+          # | limit  | integer | (optional) Cap the number of items returned, maximum of 100 items.                                                                                                                                                                                                     |
+          # | skip   | integer | (optional) Skip the first N results. The skip and limit parameters can be used together for paginated results.                                                                                                                                                         |
+          # | order  | string  | (optional) Sort the results by the given field. Supported fields include: desc, created, lastmod, duration, state, and external_id. Prefix the sort field with a minus sign for descending order (e.g. order='-desc' to retrieve values in reverse alphabetical order) |
+          # +--------+---------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+          #
+          # Response parameters
+          # +--------+------+----------------------------------------------------------------------+
+          # | assets | list | A list of assets, where each matches the form returned by asset/get. |
+          # +--------+------+----------------------------------------------------------------------+
+          #
+          # @param [Hash] args
+          # @param [Hash] opts
+          # @return [Hash]
+          def asset_list(args = { }, opts = { })
+            post('asset/list', args, opts)
+          end
+
+          # Modifies an asset in your library.
+          #
+          # Request parameters
+          # +------------------+--------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+          # | id               | string | (optional*) the ID of the asset to modify                                                                                                                                                                                                                                       |
+          # | external_id      | string | (optional*) A new external_id for the asset. Note: if you retrieved the asset by external ID, you cannot also update the external ID at the same time.                                                                                                                          |
+          # | desc             | string | (optional) A description for the asset                                                                                                                                                                                                                                          |
+          # | test_player_url  | any    | (optional) Specifying any value for this parameter will cause a new test player URL to be generated. Note that this does not expire any existing test players; it adds a new test player to the list of test players. To expire a test player please use the CMS web interface. |
+          # | embed_player_url | any    | (optional) Specifying any value for this parameter will cause a new embed player URL to be generated.                                                                                                                                                                           |
+          # | require_drm      | int    | (optional) Specify a 1 to enable required tokens. Specify a 0 to disable required tokens.                                                                                                                                                                                       |
+          # | meta             | string | (optional) The metadata to set on the asset. This must be a dictionary in JSON format. If the asset has existing meta, any new meta will be merged. To clear all metadata, set to '{}'.                                                                                         |
+          # | poster_img       | string | (optional) The image to be used for this asset's poster image, as a base64-encoded string. Limited to images that are smaller than 3MB before base64 encoding. To reset the asset's poster image, set to the empty string ''.                                                   |
+          # | autoexpire       | string | (optional) A timestamp in milliseconds after which the asset will be deleted automatically. Use a value of 0 to indicate that the asset should not auto-expire.                                                                                                                 |
+          # +------------------+--------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+          # * Either id or external_id must be specified.
+          #
+          # @param [Hash] args
+          # @param [Hash] opts
+          # @return [Hash]
+          def asset_update(args = { }, opts = { })
+            post('asset/update')
+          end
+
+
+
+          # @see https://support.uplynk.com/doc_integration_apis_cloudslicer.html#jobscancel
+          def cloudslicer_job_cancel(args = { }, opts = { })
+            post('cloudslicer/jobs/cancel', args, opts)
+          end
+
+          # @see https://support.uplynk.com/doc_integration_apis_cloudslicer.html#jobscreate
+          def cloudslicer_job_create(args = { }, opts = { })
+            post('cloudslicer/jobs/create', args, opts)
+          end
+
+          # @see https://support.uplynk.com/doc_integration_apis_cloudslicer.html#jobsdelete
+          def cloudslicer_job_delete(args, opts)
+            post('cloudslicer/jobs/delete', args, opts)
+          end
+
+          # @see https://support.uplynk.com/doc_integration_apis_cloudslicer.html#jobscexport
+          def cloudslicer_job_export_create(args = { }, opts = { })
+            post('cloudslicer/jobs/create_export', args, opts)
+          end
+
+          # @see https://support.uplynk.com/doc_integration_apis_cloudslicer.html#jobsget
+          def cloudslicer_job_get(args = { }, opts = { })
+            post('cloudslicer/jobs/get', args, opts)
+          end
+
+          # @see https://support.uplynk.com/doc_integration_apis_cloudslicer.html#jobsqc
+          def cloudslicer_job_quickclip_create(args = { }, opts = { })
+            post('cloudslicer/jobs/quickclip', args, opts)
+          end
+
+          # @see https://support.uplynk.com/doc_integration_apis_cloudslicer.html#jobslist
+          def cloudslicer_jobs_list(args = { }, opts = { })
+            post('cloudslicer/jobs/list', args, opts)
+          end
+
+          # Client
+        end
+
+        # API
+      end
+
+      # Uplynk
+    end
+
+
+    # VDMS
+  end
+
+  # Ubiquity
+end

data/lib/ubiquity/vdms/uplynk/api/client/http_client.rb

@@ -0,0 +1,312 @@
+require 'json'
+require 'net/http'
+
+class Net::HTTP::GetWithBody < Net::HTTPRequest
+  METHOD = 'GET'
+  REQUEST_HAS_BODY  = true
+  RESPONSE_HAS_BODY = true
+end
+
+
+module Ubiquity
+
+  module VDMS
+
+    module Uplynk
+
+      module API
+        class Client
+
+          class HTTPClient
+
+            class HTTPAuthorizationError < RuntimeError;
+            end
+
+            attr_accessor :logger, :http, :http_host_address, :http_host_port, :base_uri
+            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 = 'services.uplynk.com'
+            DEFAULT_HTTP_HOST_PORT = 80
+
+            DEFAULT_BASE_PATH = '/api2/'
+
+            DEFAULT_HEADER_CONTENT_TYPE = 'application/x-www-form-urlencoded'
+            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] || args[:owner]
+              @password = args[:password] || args[:secret]
+
+              @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,
+              }
+
+              @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
+                @http.use_ssl = true
+                http_verify_mode = args[:http_host_ssl_verify_mode] #|| OpenSSL::SSL::VERIFY_NONE
+                @http.verify_mode = http_verify_mode if http_verify_mode
+              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_name = :GetWithBody if klass_name == :GET || klass_name == 'GET'
+              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, 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::GetWithBody.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 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
+
+      # Uplynk
+    end
+
+    # VDMS
+  end
+
+  # Ubiquity
+end

data/lib/ubiquity/vdms/version.rb

@@ -0,0 +1,5 @@
+module Ubiquity
+  module VDMS
+    VERSION = '1.0.0'
+  end
+end

data/ubiquity-vdms.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ubiquity/vdms/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ubiquity-vdms'
+  spec.version       = Ubiquity::VDMS::VERSION
+  spec.authors       = ['John Whitson']
+  spec.email         = ['john.whitson@gmail.com']
+
+  spec.summary       = %q{Gem and utilities to interact with Verizon Digital Media Services.}
+  spec.description   = %q{}
+  spec.homepage      = 'https://github.com/XPlatform-Consulting/ubiquity-vdms/blob/837efb00b62fe8fe2850055aedfb16fbca808dba/README.md'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.14'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: ubiquity-vdms
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- John Whitson
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-05-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: ''
+email:
+- john.whitson@gmail.com
+executables:
+- ubiquity-vdms
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/ubiquity-vdms
+- lib/ubiquity/vdms.rb
+- lib/ubiquity/vdms/uplynk/api/client.rb
+- lib/ubiquity/vdms/uplynk/api/client/http_client.rb
+- lib/ubiquity/vdms/version.rb
+- ubiquity-vdms.gemspec
+homepage: https://github.com/XPlatform-Consulting/ubiquity-vdms/blob/837efb00b62fe8fe2850055aedfb16fbca808dba/README.md
+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: Gem and utilities to interact with Verizon Digital Media Services.
+test_files: []