sony_ci_api 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 606b8f73ec065decebb07d5b157a734f66254d39
+  data.tar.gz: 689a7849752c7a72dd26b26fb483ab8ad9e33d99
+SHA512:
+  metadata.gz: 6ccc8c7a290d7cbbc4a1a1540278c57c2ca8350dda7faeccb8ccd6064100ccac6a6ea25fd68b733afee4a28a612456bc0becaa94e3e4e6b12288ab1163c4bbf2
+  data.tar.gz: 78f9c3cc945ad04b82c9acf63925815b8ada6613602e47f750558008277d96bc16aed16790790ebbd0c61eddbf0bfa16fd0e65cc411ef97999e34caeeb9d87a1

data/bin/sony_ci_api

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/sony_ci_api/sony_ci_admin'
+
+args = begin
+  Hash[ARGV.slice_before { |a| a.match(/^--/) }.to_a.map { |a| [a[0].gsub(/^--/, ''), a[1..-1]] }]
+rescue
+  {}
+end
+
+ci = SonyCiAdmin.new(
+  # verbose: true,
+  credentials_path: 'config/ci.yml')
+
+begin
+  case args.keys.sort
+
+  when %w(log up)
+    fail ArgumentError.new if args['log'].empty? || args['up'].empty?
+    args['up'].each { |path| ci.upload(path, args['log'].first) }
+
+  when ['down']
+    fail ArgumentError.new if args['down'].empty?
+    args['down'].each { |id| puts ci.download(id) }
+
+  when ['list']
+    fail ArgumentError.new unless args['list'].empty?
+    ci.each { |asset| puts "#{asset['name']}\t#{asset['id']}" }
+
+  when ['recheck']
+    fail ArgumentError.new if args['recheck'].empty?
+    args['recheck'].each do |file|
+      File.foreach(file) do |line|
+        line.chomp!
+        id = line.split("\t")[2]
+        detail = ci.detail(id).to_s.gsub("\n", ' ')
+        puts line + "\t" + detail
+      end
+    end
+
+  else
+    fail ArgumentError.new
+  end
+rescue ArgumentError
+  abort 'Usage: --up GLOB --log LOG_FILE | --down ID | --list | --recheck LOG_FILE'
+end

data/lib/sony_ci_api/sony_ci_admin.rb

@@ -0,0 +1,187 @@
+require 'yaml'
+require 'curb'
+require 'json'
+require_relative 'sony_ci_basic'
+
+class SonyCiAdmin < SonyCiBasic
+  include Enumerable
+
+  # Upload a document to Ci. Underlying API treats large and small files
+  # differently, but this should treat both alike.
+  def upload(file_path, log_file)
+    Uploader.new(self, file_path, log_file).upload
+  end
+
+  # Just the names of items in the workspace. This may include directories.
+  def list_names
+    list.map { |item| item['name'] } - ['Workspace']
+    # A self reference is present even in an empty workspace.
+  end
+
+  # Full metadata for a windowed set of items.
+  def list(limit = 50, offset = 0)
+    Lister.new(self).list(limit, offset)
+  end
+
+  # Iterate over all items.
+  def each
+    Lister.new(self).each { |asset| yield asset }
+  end
+
+  # Delete items by asset ID.
+  def delete(asset_id)
+    Deleter.new(self).delete(asset_id)
+  end
+
+  # Get detailed metadata by asset ID.
+  def detail(asset_id)
+    Detailer.new(self).detail(asset_id)
+  end
+
+  def multi_details(asset_ids, fields)
+    Detailer.new(self).multi_details(asset_ids, fields)
+  end
+
+  class Detailer < SonyCiClient #:nodoc:
+    def initialize(ci)
+      @ci = ci
+    end
+
+    def detail(asset_id)
+      curl = Curl::Easy.http_get('https:'"//api.cimediacloud.com/assets/#{asset_id}") do |c|
+        add_headers(c)
+      end
+      handle_errors(curl)
+      JSON.parse(curl.body_str)
+    end
+
+    def multi_details(asset_ids, fields)
+      curl = Curl::Easy.http_post('https:''//api.cimediacloud.com/assets/details/bulk',
+                                  JSON.generate('assetIds' => asset_ids,
+                                                'fields' => fields)
+                                 ) do |c|
+        add_headers(c, 'application/json')
+      end
+      handle_errors(curl)
+      JSON.parse(curl.body_str)
+    end
+  end
+
+  class Deleter < SonyCiClient #:nodoc:
+    def initialize(ci)
+      @ci = ci
+    end
+
+    def delete(asset_id)
+      curl = Curl::Easy.http_delete('https:'"//api.cimediacloud.com/assets/#{asset_id}") do |c|
+        add_headers(c)
+      end
+      handle_errors(curl)
+    end
+  end
+
+  class Lister < SonyCiClient #:nodoc:
+    include Enumerable
+
+    def initialize(ci)
+      @ci = ci
+    end
+
+    def list(limit, offset)
+      curl = Curl::Easy.http_get('https:''//api.cimediacloud.com/workspaces/' \
+                                 "#{@ci.workspace_id}/contents?limit=#{limit}&offset=#{offset}") do |c|
+        add_headers(c)
+      end
+      handle_errors(curl)
+      JSON.parse(curl.body_str)['items']
+    end
+
+    def each
+      limit = 5 # Small chunks so it's easy to spot windowing problems
+      offset = 0
+      loop do
+        assets = list(limit, offset)
+        break if assets.empty?
+        assets.each { |asset| yield asset }
+        offset += limit
+      end
+    end
+  end
+
+  class Uploader < SonyCiClient #:nodoc:
+
+    # Chunk size 10 for multipart upload.
+    CHUNK_SIZE = 10 * 1024 * 1024
+
+    def initialize(ci, path, log_path)
+      @ci = ci
+      @path = path
+      @log_file = File.open(log_path, 'a')
+    end
+
+    def upload
+      file = File.new(@path)
+      if file.size >= CHUNK_SIZE
+        initiate_multipart_upload(file)
+        part = 0
+        part = do_multipart_upload_part(file, part) while part
+        complete_multipart_upload
+      else
+        singlepart_upload(file)
+      end
+
+      row = [Time.now, File.basename(@path), @asset_id,
+             @ci.detail(@asset_id).to_s.gsub("\n", ' ')]
+      @log_file.write(row.join("\t") + "\n")
+      @log_file.flush
+
+      @asset_id
+    end
+
+    private
+
+    SINGLEPART_URI = 'https://io.cimediacloud.com/upload'
+    MULTIPART_URI = 'https://io.cimediacloud.com/upload/multipart'
+
+    def singlepart_upload(file)
+      params = [
+        Curl::PostField.file('filename', file.path, File.basename(file.path)),
+        Curl::PostField.content('metadata', JSON.generate('workspaceId' => @ci.workspace_id))
+      ]
+      curl = Curl::Easy.http_post(SINGLEPART_URI, params) do |c|
+        c.multipart_form_post = true
+        add_headers(c)
+      end
+      handle_errors(curl)
+      @asset_id = JSON.parse(curl.body_str)['assetId']
+    end
+
+    def initiate_multipart_upload(file)
+      params = JSON.generate('name' => File.basename(file),
+                             'size' => file.size,
+                             'workspaceId' => @ci.workspace_id)
+      curl = Curl::Easy.http_post(MULTIPART_URI, params) do |c|
+        add_headers(c, 'application/json')
+      end
+      handle_errors(curl)
+      @asset_id = JSON.parse(curl.body_str)['assetId']
+    end
+
+    def do_multipart_upload_part(file, part)
+      fragment = file.read(CHUNK_SIZE)
+      return unless fragment
+      curl = Curl::Easy.http_put("#{MULTIPART_URI}/#{@asset_id}/#{part + 1}", fragment) do |c|
+        add_headers(c, 'application/octet-stream')
+      end
+      handle_errors(curl)
+      part + 1
+    end
+
+    def complete_multipart_upload
+      curl = Curl::Easy.http_post("#{MULTIPART_URI}/#{@asset_id}/complete") do |c|
+        add_headers(c)
+      end
+      handle_errors(curl)
+    end
+  end
+end

data/lib/sony_ci_api/sony_ci_basic.rb

@@ -0,0 +1,74 @@
+require 'yaml'
+require 'curb'
+require 'json'
+require_relative 'sony_ci_client'
+
+class SonyCiBasic
+  attr_reader :access_token
+  attr_reader :verbose
+  attr_reader :workspace_id
+
+  # Either +credentials_path+ or a +credentials+ object itself must be supplied.
+  def initialize(opts = {}) # rubocop:disable PerceivedComplexity, CyclomaticComplexity
+    unrecognized_opts = opts.keys - [:verbose, :credentials_path, :credentials]
+    fail "Unrecognized options #{unrecognized_opts}" unless unrecognized_opts == []
+
+    @verbose = opts[:verbose] ? true : false
+
+    fail 'Credentials specified twice' if opts[:credentials_path] && opts[:credentials]
+    fail 'No credentials given' if !opts[:credentials_path] && !opts[:credentials]
+    credentials = opts[:credentials] || YAML.load_file(opts[:credentials_path])
+
+    credentials.keys.sort.tap do |actual|
+      expected = %w(username password client_id client_secret workspace_id).sort
+      fail "Expected #{expected} in ci credentials, not #{actual}" if actual != expected
+    end
+
+    params = {
+      'grant_type' => 'password',
+      'client_id' => credentials['client_id'],
+      'client_secret' => credentials['client_secret']
+    }.map { |k, v| Curl::PostField.content(k, v) }
+
+    curl = Curl::Easy.http_post('https://api.cimediacloud.com/oauth2/token', *params) do |c|
+      c.verbose = @verbose
+      c.http_auth_types = :basic
+      c.username = credentials['username']
+      c.password = credentials['password']
+      # c.on_missing { |curl, data| puts "4xx: #{data}" }
+      # c.on_failure { |curl, data| puts "5xx: #{data}" }
+    end
+
+    @access_token = JSON.parse(curl.body_str)['access_token']
+    fail 'OAuth failed' unless @access_token
+
+    @workspace_id = credentials['workspace_id']
+  end
+
+  # Generate a temporary download URL for an asset.
+  def download(asset_id)
+    Downloader.new(self).download(asset_id)
+  end
+
+  class Downloader < SonyCiClient #:nodoc:
+    @@cache = {}
+
+    def initialize(ci)
+      @ci = ci
+    end
+
+    def download(asset_id)
+      hit = @@cache[asset_id]
+      if !hit || hit[:expires] < Time.now
+
+        curl = Curl::Easy.http_get('https'"://api.cimediacloud.com/assets/#{asset_id}/download") do |c|
+          add_headers(c)
+        end
+        handle_errors(curl)
+        url = JSON.parse(curl.body_str)['location']
+        @@cache[asset_id] = { url: url, expires: Time.now + 3 * 60 * 60 }
+      end
+      @@cache[asset_id][:url]
+    end
+  end
+end

data/lib/sony_ci_api/sony_ci_client.rb

@@ -0,0 +1,15 @@
+class SonyCiClient #:nodoc:
+  def add_headers(curl, mime = nil)
+    # on_missing and on_failure exist...
+    # but any exceptions are caught and turned into warnings:
+    # You need to check the response code at the end
+    # if you want the execution path to change.
+    curl.verbose = @ci.verbose
+    curl.headers['Authorization'] = "Bearer #{@ci.access_token}"
+    curl.headers['Content-Type'] = mime if mime
+  end
+
+  def handle_errors(curl)
+    fail "#{curl.status}: #{curl.url}\nHEADERS: #{curl.headers}\nPOST: #{curl.post_body}\nRESPONSE: #{curl.body}" if curl.response_code.to_s !~ /^2../
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: sony_ci_api
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Chuck McCallum
+- Andrew Myers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-06 00:00:00.000000000 Z
+dependencies: []
+description: Wrapper for the Sony Ci API (http://developers.cimediacloud.com/)
+email: andrew_myers@wgbh.org
+executables:
+- sony_ci_api
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/sony_ci_api
+- lib/sony_ci_api/sony_ci_admin.rb
+- lib/sony_ci_api/sony_ci_basic.rb
+- lib/sony_ci_api/sony_ci_client.rb
+homepage: https://github.com/WGBH/sony_ci_api
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Sony Ci API
+test_files: []