coconutrb 2.2.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 829f77888da3a43ad1e96692cbdd9ebad0285914
-  data.tar.gz: b9e83f5f453620333b8fcf3291ca9c45e52b1f82
+SHA256:
+  metadata.gz: 0786ab160e4d474202710a94f4484088da0b6d8917613dca342861ad18de9452
+  data.tar.gz: c07f1e5285cec5708268791435bb37a3d188dff3e3236fd5cb34d8e402432596
 SHA512:
-  metadata.gz: 8492e6a8c1264ba269c96e67385f042219df7aa4fda0258eb656be15c0ca4685fd7e26a1e53f3c64ce07ecbf3be053e58602de7d4f6ea6002e38026448a25263
-  data.tar.gz: ec5fead340bf6c0638217a1cd16fbe4c6c883642fbd69a680e2a0449d08e6a0a6776b20911582c79609722449af84a2dcaea03732cf73fc4d16966c1ba26c4f1
+  metadata.gz: 2fec4406607bccc87ae4eccb499daa8f549ac92524342da2f502d70b2efcd3429cb5e296116237d26d3cd362198ff8c2203732ee8e18a0bf79c0b749d4b68399
+  data.tar.gz: d712ec47de5bb2a9ae128aeb71a65ea0e9faf9150c2ec21cdfefb5be55c246ae7977c33c0ab0a91bb32fa47a74e46d75476143164f50068c8c453826eea63ce4

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+.testenv
+run_tests
+*.gem

data/README.md

@@ -0,0 +1,92 @@
+# Coconut Ruby Library
+
+The Coconut Ruby library provides access to the Coconut API for encoding videos, packaging media files into HLS and MPEG-Dash, generating thumbnails and GIF animation.
+
+This library is only compatible with the Coconut API v2.
+
+## Documentation
+
+See the [full documentation](https://docs.coconut.co).
+
+## Installation
+
+You can install it via rubygems:
+
+```console
+gem install coconutrb
+```
+
+### Bundler
+
+In Gemfile:
+
+```ruby
+gem 'coconutrb', '~> 3.0.0'
+```
+
+And then, type in your terminal:
+
+```console
+bundle install
+```
+
+## Usage
+
+The library needs you to set your API key which can be found in your [dashboard](https://app.coconut.co/api). Webhook URL and storage settings are optional but are very convenient because you set them only once.
+
+
+```ruby
+Coconut.api_key = 'k-api-key'
+
+Coconut.notification = {
+  type: "http",
+  url: "https://yoursite/api/coconut/webhook"
+}
+
+Coconut.storage = {
+  service: "s3",
+  bucket: "my-bucket",
+  region: "us-east-1",
+  credentials: {
+    access_key_id: "access-key",
+    secret_access_key: "secret-key"
+  }
+}
+```
+
+## Creating a job
+
+```ruby
+Coconut::Job.create(
+  input: { url: "https://mysite/path/file.mp4" },
+  outputs: {
+    "jpg:300x": { path: "/image.jpg" },
+    "mp4:1080p": { path: "/1080p.mp4" },
+    "httpstream": {
+      hls: { path: "hls/" }
+    }
+  }
+)
+```
+
+## Getting information about a job
+
+```ruby
+Coconut::Job.retrieve("OolQXaiU86NFki")
+```
+
+## Retrieving metadata
+
+```ruby
+Coconut::Metadata.retrieve("OolQXaiU86NFki")
+
+```
+
+## Per-request configuration
+
+```ruby
+cli = Coconut::Client.new(api_key: "k-api-key-prod")
+Coconut::Job.create(job, client: cli)
+```
+
+*Released under the [MIT license](http://www.opensource.org/licenses/mit-license.php).*

data/coconutrb.gemspec

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(::File.join(::File.dirname(__FILE__), "lib"))
+
+require "coconut/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "coconutrb"
+  gem.version     = Coconut::VERSION
+  gem.summary     = "Client library to transcode videos with coconut.co"
+  gem.description = "Official client library to transcode videos with Coconut Cloud Service"
+  gem.author      = "Coconut"
+  gem.email       = "support@coconut.co"
+  gem.homepage    = "https://coconut.co"
+  gem.license     = "MIT"
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- test/*`.split("\n")
+  gem.require_paths = ["lib"]
+  gem.add_runtime_dependency "http"
+end

data/lib/coconut/api.rb

@@ -0,0 +1,38 @@
+require "http"
+
+module Coconut
+  # Coconut::API is responsible for making API requests.
+  # It takes a Coconut::Client to send api_key, endpoint and region.
+  class API
+    def self.headers(cli)
+      if cli.api_key.nil?
+        raise Coconut::Error, "You must specify an API key with Coconut.api_key="
+      end
+
+      HTTP.basic_auth(user: cli.api_key, pass: "").
+        headers(:user_agent => "Coconut/v2 RubyBindings/#{Coconut::VERSION}")
+    end
+
+    def self.request(verb, path, options={})
+      cli = options[:client] || Coconut.default_client
+
+      case verb
+      when :get
+        resp = headers(cli).get("#{cli.endpoint}#{path}")
+      when :post
+        resp = headers(cli).post("#{cli.endpoint}#{path}", json: options[:json])
+      end
+
+      if resp.code > 399
+        # if response is 400 or 401, we return the error message and error code
+        if resp.code.between?(400, 401)
+          raise Coconut::Error, "#{resp.parse["message"]} (code=#{resp.parse["error_code"]})"
+        else
+          raise Coconut::Error, "Server returned HTTP status #{resp.code}."
+        end
+      end
+
+      return resp.parse
+    end
+  end
+end

data/lib/coconut/client.rb

@@ -0,0 +1,34 @@
+module Coconut
+  def self.default_client
+    Client.new({
+      api_key: Coconut.api_key,
+      region: Coconut.region,
+      endpoint: Coconut.endpoint
+    })
+  end
+
+  class Client
+    attr_accessor :api_key, :endpoint, :region
+
+    def initialize(options={})
+      @api_key = options[:api_key]
+      @region = options[:region]
+      @endpoint = options[:endpoint]
+    end
+
+    def endpoint
+      # if endpoint set, we return it
+      if @endpoint
+        return @endpoint
+      end
+      # if no endpoint but region is given, we
+      # build the endpoint following https://api-region.coconut.co/v2
+      if @region
+        return "https://api-#{@region}.coconut.co/v2"
+      end
+
+      # by default:
+      return Coconut::ENDPOINT
+    end
+  end
+end

data/lib/coconut/error.rb

@@ -0,0 +1,3 @@
+module Coconut
+  class Error < RuntimeError; end
+end

data/lib/coconut/job.rb

@@ -0,0 +1,42 @@
+module Coconut
+  class Job < API
+    attr_reader :id, :created_at, :completed_at, :status, :progress, :errors, :output_urls
+
+    def initialize(attrs={})
+      @id = attrs["id"]
+      @created_at = attrs["created_at"]
+      @completed_at = attrs["completed_at"]
+      @status = attrs["status"]
+      @progress = attrs["progress"]
+      @errors = attrs["errors"]
+      @output_urls = attrs["output_urls"]
+    end
+
+    def self.retrieve(job_id, options={})
+      resp = API.request(:get, "/jobs/#{job_id}", options)
+      return Job.new(resp)
+    end
+
+    def self.create(job, options={})
+      resp = API.request(:post, "/jobs", options.merge({
+        json: apply_settings(job)
+      }))
+
+      return Job.new(resp)
+    end
+
+    def self.apply_settings(job)
+      if notification = Coconut.notification
+        job[:notification] ||= {}
+        job[:notification].merge!(notification)
+      end
+
+      if storage = Coconut.storage
+        job[:storage] ||= {}
+        job[:storage].merge!(storage)
+      end
+
+      return job
+    end
+  end
+end

data/lib/coconut/metadata.rb

@@ -0,0 +1,7 @@
+module Coconut
+  class Metadata
+    def self.retrieve(job_id, options={})
+      API.request(:get, "/metadata/jobs/#{job_id}/#{options.delete(:key)}", options)
+    end
+  end
+end

data/lib/coconut/version.rb

@@ -0,0 +1,3 @@
+module Coconut
+  VERSION = "3.0.1"
+end

data/lib/coconutrb.rb

@@ -1,82 +1,50 @@
-require "net/http"
-require "multi_json"
-require "uri"
+require "coconut/api"
+require "coconut/error"
+require "coconut/client"
+require "coconut/job"
+require "coconut/metadata"
+require "coconut/version"
 
 module Coconut
-  class Error < RuntimeError; end
+  ENDPOINT = "https://api.coconut.co/v2"
 
-  COCONUT_URL = ENV["COCONUT_URL"] || "https://api.coconut.co"
-  USER_AGENT = "Coconut/2.2.0 (Ruby)"
-
-  API_KEY = ENV["COCONUT_API_KEY"] unless const_defined?(:COCONUT_API_KEY)
-
-  def self.submit(config_content, api_key=nil)
-    api_key ||= API_KEY
-    uri = URI("#{COCONUT_URL}/v1/job")
-    headers = {"User-Agent" => USER_AGENT, "Content-Type" => "text/plain", "Accept" => "application/json"}
-
-    req = Net::HTTP::Post.new(uri.path, headers)
-    req.basic_auth api_key, ''
-    req.body = config_content
-
-    response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme.include?("https")) do |http|
-      http.request(req)
-    end
-
-    return MultiJson.decode(response.body)
+  def self.api_key=(key)
+    @api_key = key
   end
 
-  def self.submit!(config_content, opts={})
-    result = submit(config_content, opts)
-    if result["status"] == "error"
-      raise Error, "#{result["message"]} (#{result["error_code"]})"
-    else
-      return result
-    end
+  def self.api_key
+    @api_key
   end
 
-  def self.config(options={})
-    if conf_file = options[:conf]
-      raise Error, "Config file `#{conf_file}' not found" if ! File.exists?(conf_file)
-      conf = File.read(conf_file).strip.split("\n")
-    else
-      conf = []
-    end
-
-    if vars = options[:vars]
-      vars.each do |name,value|
-        conf << "var #{name} = #{value}"
-      end
-    end
+  def self.region=(region)
+    @region = region
+  end
 
-    if source = options[:source]
-      conf << "set source = #{source}"
-    end
+  def self.region
+    @region
+  end
 
-    if webhook = options[:webhook]
-      conf << "set webhook = #{webhook}"
-    end
+  def self.endpoint=(endpoint)
+    @endpoint = endpoint
+  end
 
-    if outputs = options[:outputs]
-      outputs.each do |format, cdn|
-        conf << "-> #{format} = #{cdn}"
-      end
-    end
+  def self.endpoint
+    @endpoint
+  end
 
-    new_conf = []
+  def self.notification=(notification)
+    @notification = notification
+  end
 
-    new_conf.concat conf.select{|l| l.start_with?("var")}.sort
-    new_conf << ""
-    new_conf.concat conf.select{|l| l.start_with?("set")}.sort
-    new_conf << ""
-    new_conf.concat conf.select{|l| l.start_with?("->")}.sort
+  def self.notification
+    @notification
+  end
 
-    return new_conf.join("\n")
+  def self.storage=(storage)
+    @storage = storage
   end
 
-  class Job
-    def self.create(options={})
-      Coconut.submit(Coconut.config(options), options[:api_key])
-    end
+  def self.storage
+    @storage
   end
 end

data/test/coconut_test.rb

@@ -0,0 +1,90 @@
+$LOAD_PATH.unshift(::File.join(::File.dirname(__FILE__), "..", "lib"))
+
+require "test/unit"
+require "coconutrb"
+
+class CoconutTest < Test::Unit::TestCase
+  INPUT_URL = "https://s3-eu-west-1.amazonaws.com/files.coconut.co/bbb_800k.mp4"
+
+  def setup
+    Coconut.api_key = ENV["COCONUT_API_KEY"]
+    Coconut.endpoint = ENV["COCONUT_ENDPOINT"]
+
+    Coconut.storage = {
+      service: "s3",
+      region: ENV["AWS_REGION"],
+      credentials: { access_key_id: ENV["AWS_ACCESS_KEY_ID"], secret_access_key: ENV["AWS_SECRET_ACCESS_KEY"] },
+      bucket: ENV["AWS_BUCKET"],
+      path: "/coconutrb/tests/"
+    }
+
+    Coconut.notification = {
+      type: "http",
+      url: ENV["COCONUT_WEBHOOK_URL"]
+    }
+  end
+
+  def create_job(j={}, options={})
+    Coconut::Job.create({
+      input: { url: INPUT_URL },
+      outputs: {
+        mp4: { path: "/test_create_job.mp4", duration: 1 }
+      }
+    }.merge(j), options)
+  end
+
+  def test_coconut_api_key
+    Coconut.api_key = "apikey"
+    assert "apikey", Coconut.api_key
+  end
+
+  def test_coconut_region
+    Coconut.region = "us-east-1"
+    assert "us-east-1", Coconut.region
+  end
+
+  def test_coconut_default_endpoint
+    assert "https://api.coconut.co/v2", Coconut.endpoint
+  end
+
+  def test_coconut_endpoint_by_region
+    Coconut.region = "us-west-2"
+    assert "https://api-us-west-2.coconut.co/v2", Coconut.endpoint
+  end
+
+  def test_overwrite_endpoint
+    myendpoint = "https://coconut-private/v2"
+    Coconut.endpoint = myendpoint
+
+    assert myendpoint, Coconut.endpoint
+  end
+
+  def test_create_job
+    job = create_job
+    assert job.is_a?(Coconut::Job)
+    assert_not_nil job.id
+    assert_equal "job.starting", job.status
+  end
+
+  def test_retrieve_job
+    job = Coconut::Job.retrieve(create_job.id)
+    assert job.is_a?(Coconut::Job)
+    assert_not_nil job.id
+    assert_equal "job.starting", job.status
+  end
+
+  def test_create_job_error
+    create_job(input: {url: "notvalidurl"})
+  rescue => e
+    assert_equal e.class, Coconut::Error
+  end
+
+  def test_retrieve_metadata
+    job = create_job
+    sleep 10
+
+    md = Coconut::Metadata.retrieve(job.id)
+    assert md.is_a?(Hash)
+    assert_not_nil md["metadata"]["input"]
+  end
+end

metadata

@@ -1,37 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: coconutrb
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.0.1
 platform: ruby
 authors:
-- Bruno Celeste
+- Coconut
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-25 00:00:00.000000000 Z
+date: 2021-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: multi_json
+  name: http
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
-description: Official client library to transcode videos with coconut cloud service
-email: bruno@coconut.co
+        version: '0'
+description: Official client library to transcode videos with Coconut Cloud Service
+email: support@coconut.co
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- README.md
+- coconutrb.gemspec
+- lib/coconut/api.rb
+- lib/coconut/client.rb
+- lib/coconut/error.rb
+- lib/coconut/job.rb
+- lib/coconut/metadata.rb
+- lib/coconut/version.rb
 - lib/coconutrb.rb
-homepage: http://coconut.co
+- test/coconut_test.rb
+homepage: https://coconut.co
 licenses:
 - MIT
 metadata: {}
@@ -50,9 +60,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Client library to transcode videos with coconut.co
-test_files: []
+test_files:
+- test/coconut_test.rb