azure_media_service 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 08fdee82fc0f65b5448bafb95f064da9ed031492
+  data.tar.gz: 47143a23d14af482ba7232029c680c69aa0ad629
+SHA512:
+  metadata.gz: 8a4528a7cebb310197623e84d367860596e42990b621d06a11935f8d0e9c0233e46ae19b832033a4cfcaf29749f08cd5b6bb331a9a460b1f4a2517c82c0b6f92
+  data.tar.gz: 5f65881823d38b3db53843a04e2194227d830c7bdfff79492cbac328453bf6c6831e96e07314d7588ba2cba1f5534544128e9eff35dc8ba0030c65599a54da24

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in azure_media_service_ruby.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 murayama
+
+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,68 @@
+# AzureMediaServiceRuby
+
+Windows Azure Media Service API Client
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'azure_media_service'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install azure_media_service
+
+## Usage
+
+```ruby
+
+# initialize
+AzureMediaService.configure do |config|
+ cofig.id = 'xxxxxxxx' 
+ config.secret = 'xxxxxxxxxxxxxxxxxx'
+end
+
+# service instance
+ams = AzureMediaService.service
+
+# upload file
+asset = ams.upload_media('path/to/example.mp4')
+
+# encode job
+asset = ams.assets('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx')
+job = asset.encode_job('H264 Smooth Streaming 720p')
+
+# or
+job = ams.create_encode_job('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx', 'H264 Smooth Streaming 720p')
+
+# publish asset
+asset = ams.assets('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx')
+asset.publish(expire_minutes: 43200)
+
+# or
+ams.publish('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx', 43200)
+```
+
+### Custom Encode Task
+
+```ruby
+AzureMediaService.configure do |config|
+  config.add_encode_task('Custom Encode Task', File.read('path/to/custome_task.xml'))
+end
+
+ams = AzureMediaService.service
+asset = ams.assets('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx')
+asset.encode_job('Custom Encode Task')
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/murayama/azure_media_service_ruby/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,11 @@
+require "bundler/gem_tasks"
+
+Bundler.setup
+
+require 'rspec/core/rake_task'
+
+desc "run spec"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-c", "-fs"]
+end
+

data/azure_media_service.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'azure_media_service/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "azure_media_service"
+  spec.version       = AzureMediaService::VERSION
+  spec.authors       = ["murayama"]
+  spec.email         = ["mura869@gmail.com"]
+  spec.summary       = %q{Azure Media Service SDK for ruby}
+  spec.description   = %q{Azure Media Service SDK for ruby}
+  spec.homepage      = "https://github.com/murayama/azure_media_service_ruby"
+  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.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "faraday"
+  spec.add_dependency "faraday_middleware"
+  spec.add_dependency "mime-types"
+  spec.add_dependency "builder"
+end

data/lib/azure_media_service.rb

@@ -0,0 +1,58 @@
+require 'azure_media_service/version'
+require 'azure_media_service/errors'
+require 'azure_media_service/config'
+require 'azure_media_service/request'
+require 'azure_media_service/service'
+require 'azure_media_service/model'
+
+require 'faraday'
+require 'faraday_middleware'
+require 'time'
+require 'mime/types'
+require 'base64'
+require 'builder/xmlmarkup'
+
+module AzureMediaService
+
+  @@tasks = {}
+
+  class << self
+
+    def configure
+      yield self
+    end
+
+    def request
+      @@request ||= Request.new(client_id:@@id, client_secret:@@secret)
+    end
+
+    def service
+      @@service ||= Service.new
+    end
+
+    def id=(v)
+      @@id = v
+    end
+
+    def id
+      @@id
+    end
+
+    def secret=(v)
+      @@secret = v
+    end
+
+    def secret
+      @@secret
+    end
+
+    def add_encode_task(name, task)
+      @@tasks[name] = task
+    end
+
+    def encode_tasks
+      @@tasks ||= {}
+    end
+
+  end
+end

data/lib/azure_media_service/config.rb

@@ -0,0 +1,10 @@
+module AzureMediaService
+  class Config
+    UPLOAD_LIMIT_SIZE = 4194304 # 4MB
+    READ_BUFFER_SIZE       = 4000000
+
+    MEDIA_URI = "https://media.windows.net/api/"
+    TOKEN_URI = "https://wamsprodglobal001acs.accesscontrol.windows.net/v2/OAuth2-13"
+
+  end
+end

data/lib/azure_media_service/errors.rb

@@ -0,0 +1,2 @@
+class MediaServiceError < StandardError
+end

data/lib/azure_media_service/model.rb

@@ -0,0 +1,7 @@
+require 'azure_media_service/model/base'
+require 'azure_media_service/model/asset'
+require 'azure_media_service/model/access_policy'
+require 'azure_media_service/model/locator'
+require 'azure_media_service/model/asset_file'
+require 'azure_media_service/model/media_processor'
+require 'azure_media_service/model/job'

data/lib/azure_media_service/model/access_policy.rb

@@ -0,0 +1,7 @@
+module AzureMediaService
+  module Model
+    class AccessPolicy < Base
+
+    end
+  end
+end

data/lib/azure_media_service/model/asset.rb

@@ -0,0 +1,197 @@
+module AzureMediaService
+  module Model
+    class Asset < Base
+
+      def locators
+        @locators ||= []
+        if @locators.empty?
+          _uri = URI.parse(self.Locators["__deferred"]["uri"])
+          url = _uri.path.gsub('/api/','')
+          res = @request.get(url)
+          res["d"]["results"].each do |v|
+            @locators << Model::Locator.new(v)
+          end
+        end
+        @locators
+      end
+
+      def files
+        @files ||= []
+        if @files.empty?
+          _uri = URI.parse(self.Files["__deferred"]["uri"])
+          url = _uri.path.gsub('/api/','')
+          res = @request.get(url)
+          res["d"]["results"].each do |v|
+            @files << Model::AssetFile.new(v)
+          end
+        end
+        @files
+      end
+
+      def upload(filepath)
+        begin
+          mime_type = MIME::Types.type_for(filepath)[0].to_s
+          basename = File.basename(filepath, '.*')
+          filename = File.basename(filepath)
+          f = Faraday::UploadIO.new(filepath, mime_type)
+
+          # create policy
+          policy = @service.create_access_policy(name:"UploadPolicy", duration_minutes:1800, permission:2)
+
+          # create Locator
+          locator = @service.create_locator(policy_id:policy.Id, asset_id:self.Id, type:1)
+
+          # upload
+          upload_url = File.join(locator.BaseUri, filename)
+          upload_url += locator.ContentAccessComponent
+
+          if f.size > Config::UPLOAD_LIMIT_SIZE
+            # put block and put block list API
+            i = 1
+            blockids = []
+            while buf = f.read(Config::READ_BUFFER_SIZE) do
+              id = "%05d" % i # サイズを同じにしなければいけないので、5桁にする
+              blockid = Base64.strict_encode64("#{id}-#{filename}")
+              blockids << blockid
+              put_block_url = upload_url + "&comp=block&blockid=#{URI.escape(blockid)}"
+              res = put_blob(url:put_block_url, blob:buf)
+              i+=1
+            end
+
+            put_block_list_url = upload_url + "&comp=blocklist"
+            let = ''
+            xml = Builder::XmlMarkup.new(:target => let, :indent => 3)
+            xml.instruct!
+            xml.BlockList {
+              blockids.each do |id|
+                xml.Latest id
+              end
+            }
+
+            res = @request.put(put_block_list_url, let) do |headers|
+              headers['x-ms-date']      = Time.now.httpdate
+              headers['x-ms-version']   = '2014-02-14'
+              headers['Content-Type']   = 'text/plain; charset = UTF-8'
+              headers['Content-Length'] = let.size.to_s
+            end
+
+          else
+            res = put_blob(url:upload_url, blob:f)
+          end
+
+          # create metadata
+          @request.get("CreateFileInfos", {"assetid" => "'#{URI.encode(self.Id)}'"})
+
+          clear_cache
+        rescue => e
+          raise MediaServiceError.new(e.message)
+        end
+        self
+      end
+
+
+      def encode_job(encode_configuration) 
+        media_processor = @service.media_processor_id_by_name('Windows Azure Media Encoder')
+
+        conf_str = encode_configuration.gsub(' ', '_')
+
+        if AzureMediaService.encode_tasks.has_key?(encode_configuration)
+          encode_configuration = AzureMediaService.encode_tasks[encode_configuration]
+        end
+
+        job_name, output_name = job_and_output_name(asset_name:self.Name, conf:conf_str)
+
+        post_body = {}
+        post_body["Name"] = job_name
+        post_body["InputMediaAssets"] = [
+          {
+            "__metadata" => {
+              "uri" => self.__metadata["uri"]
+            }
+          }
+        ]
+        task_body = ''
+        xml = Builder::XmlMarkup.new(:target => task_body)
+        xml.instruct!
+        xml.taskBody {
+          xml.inputAsset 'JobInputAsset(0)'
+          xml.outputAsset 'JobOutputAsset(0)', :assetName => output_name
+        }
+        post_body["Tasks"] = [
+          {
+            "Configuration" => encode_configuration,
+            "MediaProcessorId" => media_processor.Id,
+            "TaskBody" => task_body
+          }
+        ]
+
+        res = @request.post('Jobs', post_body)
+        Model::Job.new(res["d"])
+      end
+
+
+      def publish(expire_minutes: 43200)
+        locator = locators.select {|l| l.Type == 2}.first
+        unless locator
+          policy = @service.create_access_policy(name:"PublishPolicy", duration_minutes: expire_minutes, permission:1)
+          locator = @service.create_locator(policy_id: policy.Id, asset_id: self.Id, type: 2)
+        end
+        locator
+      end
+
+      def publish_url
+        primary_file = files.select {|f| f.IsPrimary == true}.first
+        locator = locators.select {|l| l.Type == 2 }.first
+        if primary_file && locator
+          File.join(locator.Path, primary_file.Name, 'Manifest')
+        else
+          nil
+        end
+      end
+
+      def delete
+        begin 
+          res = @request.delete("Assets('#{self.Id}')")
+          clear_cache
+        rescue => e
+          raise MediaServiceError.new(e.message)
+        end
+        res
+      end
+
+      private
+
+      def clear_cache
+        @locators = nil
+        @files = nil
+        self
+      end
+
+      def job_and_output_name(asset_name:, conf:)
+        job_names = []
+        job_names << asset_name
+        job_names << 'EncodeJob'
+        job_names << conf
+        job_name = job_names.join('-')
+
+        output_names = []
+        output_names << asset_name
+        output_names << conf
+        output_names << 'Output'
+        output_name = output_names.join('-')
+
+        [job_name, output_name]
+      end
+
+      def put_blob(url:, blob:)
+        res = @request.put(url, blob) do |headers|
+          headers['x-ms-blob-type'] = 'BlockBlob'
+          headers['x-ms-version']   = '2014-02-14' # Storage API Version
+          headers['Content-Type']   = 'application/octet-stream'
+          headers['Content-Length'] = blob.size.to_s
+        end
+      end
+    end
+
+  end
+end

data/lib/azure_media_service/model/asset_file.rb

@@ -0,0 +1,7 @@
+module AzureMediaService
+  module Model
+    class AssetFile < Base
+
+    end
+  end
+end

data/lib/azure_media_service/model/base.rb

@@ -0,0 +1,16 @@
+require 'ostruct'
+module AzureMediaService
+  module Model
+    class Base < OpenStruct
+
+      attr_reader :original_data
+
+      def initialize(hash)
+        super
+        @original_data = hash
+        @request = AzureMediaService.request
+        @service = AzureMediaService.service
+      end
+    end
+  end
+end

data/lib/azure_media_service/model/job.rb

@@ -0,0 +1,32 @@
+module AzureMediaService
+  module Model
+    class Job < Base
+
+      def output_assets
+        @output_assets ||= []
+        if @output_assets.empty?
+          _uri = URI.parse(self.OutputMediaAssets["__deferred"]["uri"])
+          url = _uri.path.gsub('/api/','')
+          res = @request.get(url)
+          res["d"]["results"].each do |v|
+            @output_assets << Model::Asset.new(v)
+          end
+        end
+        @output_assets
+      end
+
+      def input_assets
+        @input_assets ||= []
+        if @input_assets.empty?
+          _uri = URI.parse(self.InputMediaAssets["__deferred"]["uri"])
+          url = _uri.path.gsub('/api/','')
+          res = @request.get(url)
+          res["d"]["results"].each do |v|
+            @input_assets << Model::Asset.new(v)
+          end
+        end
+        @input_assets
+      end
+    end
+  end
+end

data/lib/azure_media_service/model/locator.rb

@@ -0,0 +1,7 @@
+module AzureMediaService
+  module Model
+    class Locator < Base
+
+    end
+  end
+end

data/lib/azure_media_service/model/media_processor.rb

@@ -0,0 +1,7 @@
+module AzureMediaService
+  module Model
+    class MediaProcessor < Base
+
+    end
+  end
+end

data/lib/azure_media_service/request.rb

@@ -0,0 +1,140 @@
+module AzureMediaService
+  class Request
+
+    def initialize(config)
+      build_config(config) 
+    end
+
+    def get(endpoint, params={})
+
+      setToken() if token_expire?
+
+      res = conn(@config[:mediaURI]).get do |req|
+        req.url URI.escape(endpoint, '():')
+        req.headers = @default_headers
+        req.headers[:Authorization] = "Bearer #{@access_token}"
+        req.params = params
+      end
+
+      if res.status == 301
+        @config[:mediaURI] = res.headers['location']
+        get(endpoint, params)
+      else
+        res.body
+      end
+    end
+
+    def post(endpoint, body)
+      setToken if token_expire?
+
+      res = conn(@config[:mediaURI]).post do |req|
+        req.url endpoint
+        req.headers = @default_headers
+        req.headers[:Authorization] = "Bearer #{@access_token}"
+        req.body = body
+      end
+
+      if res.status == 301
+        @config[:mediaURI] = res.headers['location']
+        post(endpoint, body)
+      else
+        res.body
+      end
+    end
+
+    def put(url, body)
+
+      _conn = conn(url) do |builder|
+        builder.request :multipart
+      end
+
+      headers = {}
+
+      if block_given?
+        yield(headers)
+      end
+
+      res = _conn.put do |req|
+        req.headers = headers
+        req.body = body
+      end
+      if res.status == 301
+        @config[:mediaURI] = res.headers['location']
+        put(url, body)
+      else
+        res.body
+      end
+    end
+
+    def delete(endpoint, params={})
+
+      setToken() if token_expire?
+
+      res = conn(@config[:mediaURI]).delete do |req|
+        req.url URI.escape(endpoint, '():')
+        req.headers = @default_headers
+        req.headers[:Authorization] = "Bearer #{@access_token}"
+        req.params = params
+      end
+
+      if res.status == 301
+        @config[:mediaURI] = res.headers['location']
+        delete(endpoint, params)
+      else
+        res.body
+      end
+    end
+
+    private
+    def build_config(config)
+
+      @config = config || {}
+      # @config[:mediaURI] = "https://media.windows.net/API/"
+      @config[:mediaURI] = Config::MEDIA_URI
+      @config[:tokenURI] = Config::TOKEN_URI
+      @config[:client_id] ||= ''
+      @config[:client_secret] ||= ''
+
+      @default_headers = {
+        "Content-Type"          => "application/json;odata=verbose",
+        "Accept"                => "application/json;odata=verbose",
+        "DataServiceVersion"    => "3.0",
+        "MaxDataServiceVersion" => "3.0",
+        "x-ms-version"          => "2.5"
+      }
+    end
+
+    def conn(url)
+      conn = Faraday::Connection.new(:url => url, :ssl => {:verify => false}) do |builder|
+        builder.request :url_encoded
+        # builder.response :logger
+        builder.use FaradayMiddleware::EncodeJson
+        builder.use FaradayMiddleware::ParseJson, :content_type => /\bjson$/
+        builder.adapter Faraday.default_adapter
+        if block_given?
+          yield(builder)
+        end
+      end
+    end
+
+    def setToken
+      res = conn(@config[:tokenURI]).post do |req|
+        req.body = {
+          client_id: @config[:client_id], 
+          client_secret: @config[:client_secret],
+          grant_type: 'client_credentials',
+          scope: 'urn:WindowsAzureMediaServices'
+        }
+      end
+
+      @access_token = res.body["access_token"]
+      @token_expires = Time.now.to_i + res.body["expires_in"].to_i
+    end
+
+    def token_expire?
+      return true unless @access_token 
+      return true if Time.now.to_i >= @token_expires
+      return false
+    end
+  end
+end

data/lib/azure_media_service/service.rb

@@ -0,0 +1,97 @@
+module AzureMediaService
+  class Service
+
+    def initialize
+      @request = AzureMediaService.request
+    end
+
+    # assets
+    def assets(asset_id=nil)
+      get('Assets', Model::Asset, asset_id)
+    end
+
+    # assets create
+    def create_asset(name)
+      post_body = {
+        "Name" => name
+      }
+      res = @request.post("Assets", post_body)
+      Model::Asset.new(res["d"])
+    end
+
+    # access policy create
+    def create_access_policy(name:'Policy', duration_minutes:300, permission:2)
+      post_body = {
+        "Name" => name,
+        "DurationInMinutes" => duration_minutes,
+        "Permissions" => permission
+      }
+      res = @request.post("AccessPolicies", post_body)
+      Model::AccessPolicy.new(res["d"])
+    end
+
+    # locator create
+    def create_locator(policy_id:,asset_id:,type:1)
+      post_body = {
+        "AccessPolicyId" => policy_id,
+        "AssetId" => asset_id,
+        "Type" => type,
+        "StartTime" => (Time.now - 5*60).gmtime.strftime('%Y-%m-%dT%H:%M:%SZ')
+      }
+      res = @request.post("Locators", post_body)
+      Model::Locator.new(res["d"])
+    end
+
+    def upload_media(filepath)
+      basename = File.basename(filepath, '.*')
+      asset_name = "#{basename}-Source-#{Time.now.strftime('%Y%m%d%H%M%S')}"
+      asset = create_asset(asset_name)
+      asset.upload(filepath)
+    end
+
+    def create_encode_job(asset_id, encode_configuration)
+      asset = assets(asset_id)
+      asset.encode_job(encode_configuration)
+    end
+
+    def jobs(job_id=nil)
+      get('Jobs', Model::Job, job_id)
+    end
+
+    # publish asset
+    def publish(asset_id, expire_minutes=nil)
+      asset = assets(asset_id)
+      asset.publish(expire_minutes)
+    end
+
+    def publish_url(asset_id)
+      asset = assets(asset_id)
+      asset.publish_url
+    end
+
+    def media_processor_id_by_name(name)
+      res = @request.get('MediaProcessors')
+      mp = res["d"]["results"].select {|v| 
+        v["Name"] == 'Windows Azure Media Encoder'
+      }.sort{|a,b|
+        b["Version"].to_i <=> a["Version"].to_i
+      }.first
+      Model::MediaProcessor.new(mp)
+    end
+
+    def get(method, klass, id=nil)
+      if id.nil?
+        res = @request.get(method)
+        results = []
+        res["d"]["results"].each do |a|
+          results << klass.new(a)
+        end
+      else
+        res = @request.get("#{method}('#{id}')")
+        results = klass.new(res["d"])
+      end
+      results
+    end
+
+  end
+end

data/lib/azure_media_service/version.rb

@@ -0,0 +1,3 @@
+module AzureMediaService
+  VERSION = "0.1.3"
+end

data/spec/azure_media_service_ruby_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe hoge do
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'azure_media_service_ruby'
+

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: azure_media_service
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- murayama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Azure Media Service SDK for ruby
+email:
+- mura869@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- azure_media_service.gemspec
+- lib/azure_media_service.rb
+- lib/azure_media_service/config.rb
+- lib/azure_media_service/errors.rb
+- lib/azure_media_service/model.rb
+- lib/azure_media_service/model/access_policy.rb
+- lib/azure_media_service/model/asset.rb
+- lib/azure_media_service/model/asset_file.rb
+- lib/azure_media_service/model/base.rb
+- lib/azure_media_service/model/job.rb
+- lib/azure_media_service/model/locator.rb
+- lib/azure_media_service/model/media_processor.rb
+- lib/azure_media_service/request.rb
+- lib/azure_media_service/service.rb
+- lib/azure_media_service/version.rb
+- spec/azure_media_service_ruby_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/murayama/azure_media_service_ruby
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Azure Media Service SDK for ruby
+test_files:
+- spec/azure_media_service_ruby_spec.rb
+- spec/spec_helper.rb