coconutrb 2.4.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5d080f48508838a97c4a7aa3d7022008741ca5b2
-  data.tar.gz: be3d0ec286c2d79774e68edec3b9c1634d1dd32b
+SHA256:
+  metadata.gz: 7aa3f69b0c70c759598d976f4d17b5bd0fd7f6606af16d0963997357de1990f6
+  data.tar.gz: fc07ef5a74c85511ecd75d0f2e1d3106828ba843f887ff50a9f6274d868a44ad
 SHA512:
-  metadata.gz: bd2260ce0933b9bbcc6906285c1fa3416caf08845e7ee4b30f22ed29c912e67dde5abe17b1c6b669072bcc281b216275f520496e7efd8f6d97de9030988c34b1
-  data.tar.gz: 12825f9470666421d7dbbb5755f035eb818dd17454d9307cf6e83f71c94dd37f1755d5ed479cd631c17303d4a2fc4789befcfa4dd460b07353272a46daadc78a
+  metadata.gz: 640e39db9a079f9a77560a0c600c25debdab49e69db0c91e551f872a9060a8e6a1e90c0ad305c73df566d31d578fe6cce9cee431380f67c66fe63a0ed2aff419
+  data.tar.gz: 9ad2757fb32aee75a13051ad793483ba06c332519cdfb4638ef0fb5969e52c1b8b2e1e1b0e91d3083904b7a723f7e5d18b5380a5aa6ef0a0e1841da5fb78b530

data/.gitignore

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

data/README.md

@@ -0,0 +1,91 @@
+# 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.rb

@@ -0,0 +1,50 @@
+require "coconut/api"
+require "coconut/error"
+require "coconut/client"
+require "coconut/job"
+require "coconut/metadata"
+require "coconut/version"
+
+module Coconut
+  ENDPOINT = "https://api.coconut.co/v2"
+
+  def self.api_key=(key)
+    @api_key = key
+  end
+
+  def self.api_key
+    @api_key
+  end
+
+  def self.region=(region)
+    @region = region
+  end
+
+  def self.region
+    @region
+  end
+
+  def self.endpoint=(endpoint)
+    @endpoint = endpoint
+  end
+
+  def self.endpoint
+    @endpoint
+  end
+
+  def self.notification=(notification)
+    @notification = notification
+  end
+
+  def self.notification
+    @notification
+  end
+
+  def self.storage=(storage)
+    @storage = storage
+  end
+
+  def self.storage
+    @storage
+  end
+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.0"
+end

data/test/coconut_test.rb

@@ -0,0 +1,90 @@
+$LOAD_PATH.unshift(::File.join(::File.dirname(__FILE__), "..", "lib"))
+
+require "test/unit"
+require "coconut"
+
+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.4.0
+  version: 3.0.0
 platform: ruby
 authors:
-- Bruno Celeste
+- Coconut
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-18 00:00:00.000000000 Z
+date: 2021-04-15 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:
-- lib/coconutrb.rb
-homepage: http://coconut.co
+- ".gitignore"
+- README.md
+- coconutrb.gemspec
+- lib/coconut.rb
+- lib/coconut/api.rb
+- lib/coconut/client.rb
+- lib/coconut/error.rb
+- lib/coconut/job.rb
+- lib/coconut/metadata.rb
+- lib/coconut/version.rb
+- 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.5.2.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

data/lib/coconutrb.rb

@@ -1,135 +0,0 @@
-require "net/http"
-require "multi_json"
-require "uri"
-
-module Coconut
-  class Error < RuntimeError; end
-
-  COCONUT_URL = ENV["COCONUT_URL"] || "https://api.coconut.co"
-  USER_AGENT = "Coconut/2.4.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)
-  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
-  end
-
-  def self.get(path, api_key=nil)
-    api_key ||= API_KEY
-    uri = URI("#{COCONUT_URL}#{path}")
-    headers = {"User-Agent" => USER_AGENT, "Content-Type" => "text/plain", "Accept" => "application/json"}
-
-    req = Net::HTTP::Get.new(uri.path, headers)
-    req.basic_auth api_key, ''
-
-    response = Net::HTTP.start(uri.hostname, uri.port, :use_ssl => uri.scheme.include?("https")) do |http|
-      http.request(req)
-    end
-
-    if response.code.to_i != 200
-      return nil
-    else
-      return MultiJson.decode(response.body)
-    end
-  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
-
-    if source = options[:source]
-      conf << "set source = #{source}"
-    end
-
-    if webhook = options[:webhook]
-      if webhook.is_a?(Hash)
-        webhook = hash_params_to_string(webhook)
-      end
-
-      conf << "set webhook = #{webhook}"
-    end
-
-    if api_version = options[:api_version]
-      conf << "set api_version = #{api_version}"
-    end
-
-    if outputs = options[:outputs]
-      outputs.each do |format, cdn|
-        if cdn.is_a?(Hash)
-          cdn = hash_params_to_string(cdn)
-        end
-
-        conf << "-> #{format} = #{cdn}"
-      end
-    end
-
-    new_conf = []
-
-    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
-
-    return new_conf.join("\n")
-  end
-
-  def self.hash_params_to_string(params)
-    params.map{|k,v|
-      if k.to_s == "url"
-        "#{v}"
-      else
-        "#{k}=#{v}"
-      end
-    }.join(", ")
-  end
-
-  class Job
-    def self.create(options={})
-      Coconut.submit(Coconut.config(options), options[:api_key])
-    end
-
-    def self.get(jid, api_key=nil)
-      Coconut.get("/v1/jobs/#{jid}", api_key)
-    end
-
-    def self.get_all_metadata(jid, api_key=nil)
-      Coconut.get("/v1/metadata/jobs/#{jid}", api_key)
-    end
-
-    def self.get_metadata_for(jid, source_or_output, api_key=nil)
-      Coconut.get("/v1/metadata/jobs/#{jid}/#{source_or_output}", api_key)
-    end
-  end
-end