azure_media_service 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08fdee82fc0f65b5448bafb95f064da9ed031492
-  data.tar.gz: 47143a23d14af482ba7232029c680c69aa0ad629
+  metadata.gz: 00a545eccf5a1d981e5d5eacbced9300cef26fd0
+  data.tar.gz: 5981d595b2245482d11e4aa0ad15585f7a54e85c
 SHA512:
-  metadata.gz: 8a4528a7cebb310197623e84d367860596e42990b621d06a11935f8d0e9c0233e46ae19b832033a4cfcaf29749f08cd5b6bb331a9a460b1f4a2517c82c0b6f92
-  data.tar.gz: 5f65881823d38b3db53843a04e2194227d830c7bdfff79492cbac328453bf6c6831e96e07314d7588ba2cba1f5534544128e9eff35dc8ba0030c65599a54da24
+  metadata.gz: 0fc36138286d3f0ea302c3aa559fe74c417849980ea7834611abb640242ef54a32cbf42ae2dfc7d172029f1d1bb4c53e7bcaaa05b5a6b66eb8860a0900c5a5f7
+  data.tar.gz: 8ca181545faa585d65657ff09ff807683e54ae638ff54a6cca82a4fc542ae3bb191f964e687b899270f778c21231666e9498123bf09b5d37caee51f867ec173e

data/README.md

@@ -22,29 +22,30 @@ Or install it yourself as:
 
 # initialize
 AzureMediaService.configure do |config|
- cofig.id = 'xxxxxxxx' 
+ cofig.id = 'xxxxxxxx'
  config.secret = 'xxxxxxxxxxxxxxxxxx'
 end
 
-# service instance
-ams = AzureMediaService.service
-
 # upload file
+ams = AzureMediaService.service
 asset = ams.upload_media('path/to/example.mp4')
 
+# or
+
+asset = AzureMediaService::Asset.create(asset_name)
+asset.upload('path/to/example.mp4')
+
 # encode job
-asset = ams.assets('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx')
+asset = AzureMediaService::Asset.get('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')
+job = AzureMediaService::Job.create('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx', 'H264 Smooth Streaming 720p')
 
 # publish asset
-asset = ams.assets('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx')
+asset = AzureMediaService::Asset.get('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
@@ -54,11 +55,60 @@ 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 = AzureMediaService::Asset.get('nb:cid:UUID:xxxxxxxxxxx-xxxxxxxxxxx-xxxxxx-xxxxxxx')
 asset.encode_job('Custom Encode Task')
 ```
 
+### AES Protection
+
+```ruby
+asset = AzureMediaService::Asset.get(asset_id)
+
+key = ScureRandom::random_bytes(16)
+
+content_key = AzureMediaService::ContentKey.create({
+  content_key: key,
+  content_key_type: AzureMediaService::ContentKey::ContentKeyTypes[:EnvelopeEncryption],
+  name: 'content-key-name'
+})
+asset.content_key_link(content_key)
+
+
+content_key_policies = AzureMediaService::ContentKeyAuthorizationPolicy.get()
+content_key_policy = content_key_policies.fin { |p| p.name == 'your policy name' }
+unless content_key_policy
+  content_key_policy = AzureMediaService::ContentKeyAuthorizationPolicy.create('your policy name')
+  policy_options = AzureMediaService::ContentKeyAuthorizationPolicyOption.create({
+    name: 'policy option',
+    key_delivery_type: AzureMediaService::ContentKeyAuthorizationPolicyOption::KeyDeliveryTypes[:BaselineHttp],
+    key_delivery_configuration: nil,
+    restrictions: [
+      {
+        "Name" => "HLS Authorization Policy",
+        "KeyRestrictionType" => AzureMediaService::ContentKeyAuthorizationPolicyOption::KeyRestrictionTypes[:Open]
+      }
+    ]
+  })
+  content_key_policy.option_link(policy_options)
+end
+
+content_key.add_authorization_policy(content_key_policy.Id)
+
+protocols = AzureMediaService::AssetDeliveryPolicy::Protocol
+# Your need to register the key to your key delivery server
+kid = content_key.Id.split(':').last
+key_delivery_url = "your key delivery server url"
+delivery_policy = AzureMediaService::AssetDeliveryPolicy.create({
+  name: 'your delivery policy name',
+  protocol: protocols[:HLS] | protocols[:SmoothStreaming] | protocols[:Dash],
+  policy_type: AzureMediaService::AssetDeliveryPolicy::PolicyType[:DynamicEnvelopeEncryption],
+  configuration: JSON.generate([{Key: AzureMediaService::AssetDeliveryPolicy::ConfigurationKey[:EnvelopeBaseKeyAcquisitionUrl], Vlaue: key_delivery_url}])
+})
+asset.delivery_policy_link(delivery_policy)
+
+asset.publish(expire_minutes: 43200)
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/murayama/azure_media_service_ruby/fork )

data/lib/azure_media_service.rb

@@ -5,6 +5,9 @@ require 'azure_media_service/request'
 require 'azure_media_service/service'
 require 'azure_media_service/model'
 
+require 'base64'
+require 'openssl'
+require 'securerandom'
 require 'faraday'
 require 'faraday_middleware'
 require 'time'
@@ -12,6 +15,7 @@ require 'mime/types'
 require 'base64'
 require 'builder/xmlmarkup'
 
+
 module AzureMediaService
 
   @@tasks = {}

data/lib/azure_media_service/model.rb

@@ -5,3 +5,7 @@ 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'
+require 'azure_media_service/model/content_key'
+require 'azure_media_service/model/content_key_authorization_policy'
+require 'azure_media_service/model/content_key_authorization_policy_option'
+require 'azure_media_service/model/asset_delivery_policy'

data/lib/azure_media_service/model/access_policy.rb

@@ -1,7 +1,16 @@
 module AzureMediaService
-  module Model
-    class AccessPolicy < Base
+  class AccessPolicy < Model::Base
 
+    class << self
+      def create(name:'Policy', duration_minutes:300, permission:2)
+        post_body = {
+          "Name" => name,
+          "DurationInMinutes" => duration_minutes,
+          "Permissions" => permission
+        }
+        create_response(service.post("AccessPolicies", post_body))
+      end
     end
+
   end
 end

data/lib/azure_media_service/model/asset.rb

@@ -1,197 +1,245 @@
 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
+  class Asset < Model::Base
+
+    class << self
+
+      def create(name)
+        post_body = {
+          "Name" => name
+        }
+        create_response(service.post("Assets", post_body))
+      end
+
+      def get(asset_id=nil)
+        service.get('Assets', Asset, asset_id)
+      end
+    end
+
+    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 << Locator.new(v)
         end
-        @locators
       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
+    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 << AssetFile.new(v)
         end
-        @files
       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
+    def content_keys
+      @content_keys ||= []
+      if @content_keys.empty?
+        _uri = URI.parse(self.ContentKeys["__deferred"]["uri"])
+        url = _uri.path.gsub('/api/','')
+        res = @request.get(url)
+        res["d"]["results"].each do |v|
+          @content_keys << ContentKey.new(v)
+        end
+      end
+      @content_keys
+    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
+    def delivery_policies
+      @delivery_policies ||= []
+      if @delivery_policies.empty?
+        _uri = URI.parse(self.DeliveryPolicies["__deferred"]["uri"])
+        url = _uri.path.gsub('/api/','')
+        res = @request.get(url)
+        res["d"]["results"].each do |v|
+          @delivery_policies << AssetDeliveryPolicy.new(v)
+        end
+      end
+      @delivery_policies
+    end
 
-          else
-            res = put_blob(url:upload_url, blob:f)
+    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 = AccessPolicy.create(name:"UploadPolicy", duration_minutes:1800, permission:2)
+
+        # create Locator
+        locator = Locator.create(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
 
-          # create metadata
-          @request.get("CreateFileInfos", {"assetid" => "'#{URI.encode(self.Id)}'"})
+          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_row(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
 
-          clear_cache
-        rescue => e
-          raise MediaServiceError.new(e.message)
+        else
+          res = put_blob(url:upload_url, blob:f)
         end
-        self
+
+        # 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')
+    def encode_job(encode_configuration) 
+      media_processor = @service.media_processor_id_by_name('Windows Azure Media Encoder')
 
-        conf_str = encode_configuration.gsub(' ', '_')
+      conf_str = encode_configuration.gsub(' ', '_')
 
-        if AzureMediaService.encode_tasks.has_key?(encode_configuration)
-          encode_configuration = AzureMediaService.encode_tasks[encode_configuration]
-        end
+      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)
+      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"]
-            }
+      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
-          }
-        ]
+      ]
+      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
+      res = @request.post('Jobs', post_body)
+      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
+    def publish(expire_minutes: 43200)
+      locator = locators.select {|l| l.Type == 2}.first
+      unless locator
+        policy = AccessPolicy.create(name:"PublishPolicy", duration_minutes: expire_minutes, permission:1)
+        locator = Locator.create(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
+    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
+    def delete
+      begin 
+        res = @request.delete("Assets('#{self.Id}')")
+        clear_cache
+      rescue => e
+        raise MediaServiceError.new(e.message)
       end
+      res
+    end
 
-      private
+    def content_key_link(content_key)
+      @request.post("Assets('#{CGI.escape(self.Id)}')/$links/ContentKeys", {uri: content_key.__metadata['uri']})
+    end
 
-      def clear_cache
-        @locators = nil
-        @files = nil
-        self
-      end
+    def delivery_policy_link(asset_delivery_policy)
+      @request.post("Assets('#{CGI.escape(self.Id)}')/$links/DeliveryPolicies", {uri: asset_delivery_policy.__metadata['uri']})
+    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('-')
+    private
 
-        output_names = []
-        output_names << asset_name
-        output_names << conf
-        output_names << 'Output'
-        output_name = output_names.join('-')
+    def clear_cache
+      @locators = nil
+      @files = nil
+      @content_keys = nil
+      @delivery_policies = nil
+      self
+    end
 
-        [job_name, output_name]
-      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('-')
 
-      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
+      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_row(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

data/lib/azure_media_service/model/asset_delivery_policy.rb

@@ -0,0 +1,57 @@
+module AzureMediaService
+  class AssetDeliveryPolicy < Model::Base
+
+    Protocol = {
+      None:            0x0,
+      SmoothStreaming: 0x1,
+      Dash:            0x2,
+      HLS:             0x4,
+      Hds:             0x8,
+      All:             0xFFFF
+    }
+
+    PolicyType = {
+      None:                      0,
+      Blocked:                   1,
+      NoDynamicEncryption:       2,
+      DynamicEnvelopeEncryption: 3,
+      DynamicCommonEncryption:   4
+    }
+
+    ConfigurationKey = {
+      None:                           0,
+      EnvelopeKeyAcquisitionUrl:      1,
+      EnvelopeBaseKeyAcquisitionUrl:  2,
+      EnvelopeEncryptionIVAsBase64:   3,
+      PlayReadyLicenseAcquisitionUrl: 4,
+      PlayReadyCustomAttributes:      5,
+      EnvelopeEncryptionIV:           6
+    }
+
+
+    class << self
+      def create(name:, protocol:, policy_type:, configuration:)
+        body = {
+          "Name" => name,
+          "AssetDeliveryProtocol" => protocol,
+          "AssetDeliveryPolicyType" => policy_type,
+          "AssetDeliveryConfiguration" => configuration
+        }
+        create_response(service.post("AssetDeliveryPolicies", body))
+      end
+
+      def get(asset_delivery_policy_id=nil)
+        service.get("AssetDeliveryPolicies", AssetDeliveryPolicy, asset_delivery_policy_id)
+      end
+    end
+
+    def delete
+      begin 
+        res = @request.delete("AssetDeliveryPolicies('#{self.Id}')")
+      rescue => e
+        raise MediaServiceError.new(e.message)
+      end
+      res
+    end
+  end
+end

data/lib/azure_media_service/model/asset_file.rb

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

data/lib/azure_media_service/model/base.rb

@@ -11,6 +11,22 @@ module AzureMediaService
         @request = AzureMediaService.request
         @service = AzureMediaService.service
       end
+
+      class << self
+
+        def service
+          AzureMediaService.service
+        end
+
+        def create_response(res)
+          if res["d"]
+            self.new(res["d"])
+          else
+            raise MediaServiceError.new(res["error"]["message"]["value"])
+        end
+        end
+
+      end
     end
   end
 end

data/lib/azure_media_service/model/content_key.rb

@@ -0,0 +1,71 @@
+module AzureMediaService
+  class ContentKey < Model::Base
+
+    ContentKeyTypes = {
+      CommonEncryption:        0,
+      StorageEncryption:       1,
+      ConfigurationEncryption: 2,
+      UrlEncryption:           3,
+      EnvelopeEncryption:      4
+    }
+
+    class << self
+      def create(content_key:, content_key_type: 4,protection_key_type: 0, name: nil )
+        id = "nb:kid:UUID:#{SecureRandom.uuid.upcase}"
+        # content_key = SecureRandom.random_bytes(16)
+        protection_key_id = service.get_protection_key_id(content_key_type)
+        protection_key = service.get_protection_key(protection_key_id) # X.509
+        x509 = OpenSSL::X509::Certificate.new(Base64.decode64(protection_key))
+        public_key = x509.public_key
+        encrypted_content_key = Base64.strict_encode64(public_key.public_encrypt(content_key, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING))
+
+        # create checksum
+        cipher = OpenSSL::Cipher.new('AES-128-ECB')
+        cipher.encrypt
+        cipher.key = content_key
+        cipher.padding = 0
+        encrypt_data = ""
+        encrypt_data << cipher.update(protection_key_id[0,16])
+        encrypt_data << cipher.final
+        check_sum = Base64.strict_encode64(encrypt_data[0,8])
+
+        post_body = {
+          "Id"                  => id,
+          "ContentKeyType"      => content_key_type,
+          "EncryptedContentKey" => encrypted_content_key,
+          "ProtectionKeyId"     => protection_key_id,
+          "ProtectionKeyType"   => protection_key_type,
+          "Checksum"            => check_sum,
+          "Name"                => name
+        }
+        create_response(service.post("ContentKeys", post_body))
+      end
+
+      def get(content_key_id=nil)
+        service.get('ContentKeys', ContentKey, content_key_id)
+      end
+    end
+
+    def add_authorization_policy(policy_id)
+      res = @request.put("ContentKeys('#{CGI.escape(self.Id)}')", {AuthorizationPolicyId: policy_id})
+    end
+
+    # GetKeyDeliveryUrl
+    #
+    # @params key_delivery_type 1: PlayReady license 2: EnvelopeEncryption
+    #
+    def get_key_delivery_url(key_delivery_type)
+      @request.post("ContentKeys('#{CGI.escape(self.Id)}')/GetKeyDeliveryUrl", {KeyDeliveryType: key_delivery_type})
+    end
+
+    def delete
+      begin 
+        res = @request.delete("ContentKeys('#{self.Id}')")
+        clear_cache
+      rescue => e
+        raise MediaServiceError.new(e.message)
+      end
+      res
+    end
+  end
+end

data/lib/azure_media_service/model/content_key_authorization_policy.rb

@@ -0,0 +1,27 @@
+module AzureMediaService
+  class ContentKeyAuthorizationPolicy < Model::Base
+
+    class << self
+      def create(name)
+        create_response(service.post("ContentKeyAuthorizationPolicies", {Name: name}))
+      end
+
+      def get(content_key_authorization_policy_id=nil)
+        service.get("ContentKeyAuthorizationPolicies", ContentKeyAuthorizationPolicy, content_key_authorization_policy_id)
+      end
+    end
+
+    def option_link(options)
+      @request.post("ContentKeyAuthorizationPolicies('#{CGI.escape(self.Id)}')/$links/Options", {uri: options.__metadata['uri']})
+    end
+
+    def delete
+      begin 
+        res = @request.delete("ContentKeyAuthorizationPolicies('#{self.Id}')")
+      rescue => e
+        raise MediaServiceError.new(e.message)
+      end
+      res
+    end
+  end
+end

data/lib/azure_media_service/model/content_key_authorization_policy_option.rb

@@ -0,0 +1,44 @@
+module AzureMediaService
+  class ContentKeyAuthorizationPolicyOption < Model::Base
+
+    KeyDeliveryTypes = {
+      None:             0,
+      PlayReadyLicense: 1,
+      BaselineHttp:     2
+    }
+
+    KeyRestrictionTypes = {
+      Open:            0,
+      TokenRestricted: 1,
+      IPRestricted:    2
+    }
+
+    class << self
+      def create(name:, key_delivery_type:, key_delivery_configuration: nil, restrictions:)
+        post_body = {
+          "Name" => name,
+          "KeyDeliveryType" => key_delivery_type,
+          "Restrictions" => {"results" => restrictions}
+        }
+        if key_delivery_configuration
+          post_body["KeyDeliveryConfiguration"] = key_delivery_configuration
+        end
+        create_response(service.post("ContentKeyAuthorizationPolicyOptions", post_body))
+      end
+
+      def get(content_key_authorization_policy_option_id=nil)
+        service.get("ContentKeyAuthorizationPolicyOptions", ContentKeyAuthorizationPolicyOption, content_key_authorization_policy_option_id)
+      end
+    end
+
+    def delete
+      begin 
+        res = @request.delete("ContentKeyAuthorizationPolicyOptions('#{self.Id}')")
+      rescue => e
+        raise MediaServiceError.new(e.message)
+      end
+      res
+    end
+  end
+end
+

data/lib/azure_media_service/model/job.rb

@@ -1,32 +1,41 @@
 module AzureMediaService
-  module Model
-    class Job < Base
+  class Job < Model::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
+    class << self
+      def create(asset_id, encode_configuration)
+        asset = Asset.get(asset_id)
+        asset.encode_job(encode_configuration)
+      end
+
+      def get(job_id=nil)
+        service.get('Jobs', Job, job_id)
+      end
+    end
+
+    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 << Asset.new(v)
         end
-        @output_assets
       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
+    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 << Asset.new(v)
         end
-        @input_assets
       end
+      @input_assets
     end
   end
 end

data/lib/azure_media_service/model/locator.rb

@@ -1,7 +1,17 @@
 module AzureMediaService
-  module Model
-    class Locator < Base
+  class Locator < Model::Base
 
+    class << self
+      def create(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')
+        }
+        create_response(service.post("Locators", post_body))
+      end
     end
+
   end
 end

data/lib/azure_media_service/model/media_processor.rb

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

data/lib/azure_media_service/request.rb

@@ -20,6 +20,9 @@ module AzureMediaService
         @config[:mediaURI] = res.headers['location']
         get(endpoint, params)
       else
+        if res.headers[:error]
+          raise MediaServiceError.new("#{res.headers[:error]}: #{res.headers[:error_description]}")
+        end
         res.body
       end
     end
@@ -38,11 +41,35 @@ module AzureMediaService
         @config[:mediaURI] = res.headers['location']
         post(endpoint, body)
       else
+        if res.headers[:error]
+          raise MediaServiceError.new("#{res.headers[:error]}: #{res.headers[:error_description]}")
+        end
         res.body
       end
     end
 
-    def put(url, body)
+    def put(endpoint, body)
+      setToken if token_expire?
+
+      res = conn(@config[:mediaURI]).put 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
+        if res.headers[:error]
+          raise MediaServiceError.new("#{res.headers[:error]}: #{res.headers[:error_description]}")
+        end
+        res.body
+      end
+    end
+
+    def put_row(url, body)
 
       _conn = conn(url) do |builder|
         builder.request :multipart
@@ -62,6 +89,9 @@ module AzureMediaService
         @config[:mediaURI] = res.headers['location']
         put(url, body)
       else
+        if res.headers[:error]
+          raise MediaServiceError.new("#{res.headers[:error]}: #{res.headers[:error_description]}")
+        end
         res.body
       end
     end
@@ -81,6 +111,9 @@ module AzureMediaService
         @config[:mediaURI] = res.headers['location']
         delete(endpoint, params)
       else
+        if res.headers[:error]
+          raise MediaServiceError.new("#{res.headers[:error]}: #{res.headers[:error_description]}")
+        end
         res.body
       end
     end
@@ -100,7 +133,7 @@ module AzureMediaService
         "Accept"                => "application/json;odata=verbose",
         "DataServiceVersion"    => "3.0",
         "MaxDataServiceVersion" => "3.0",
-        "x-ms-version"          => "2.5"
+        "x-ms-version"          => "2.9"
       }
     end
 

data/lib/azure_media_service/service.rb

@@ -7,31 +7,35 @@ module AzureMediaService
 
     # assets
     def assets(asset_id=nil)
-      get('Assets', Model::Asset, asset_id)
+      warn("DEPRECATION WARNING: Service#assets is deprecated. Use AzureMediaService::Asset.get() instead.")
+      get('Assets', Asset, asset_id)
     end
 
     # assets create
     def create_asset(name)
+      warn("DEPRECATION WARNING: Service#create_asset is deprecated. Use AzureMediaService::Asset.create() instead.")
       post_body = {
         "Name" => name
       }
       res = @request.post("Assets", post_body)
-      Model::Asset.new(res["d"])
+      Asset.new(res["d"])
     end
 
     # access policy create
     def create_access_policy(name:'Policy', duration_minutes:300, permission:2)
+      warn("DEPRECATION WARNING: Service#create_access_policy is deprecated. Use AzureMediaService::AccessPolicy.create() instead.")
       post_body = {
         "Name" => name,
         "DurationInMinutes" => duration_minutes,
         "Permissions" => permission
       }
       res = @request.post("AccessPolicies", post_body)
-      Model::AccessPolicy.new(res["d"])
+      AccessPolicy.new(res["d"])
     end
 
     # locator create
     def create_locator(policy_id:,asset_id:,type:1)
+      warn("DEPRECATION WARNING: Service#create_locator is deprecated. Use AzureMediaService::Locator.create() instead.")
       post_body = {
         "AccessPolicyId" => policy_id,
         "AssetId" => asset_id,
@@ -39,33 +43,38 @@ module AzureMediaService
         "StartTime" => (Time.now - 5*60).gmtime.strftime('%Y-%m-%dT%H:%M:%SZ')
       }
       res = @request.post("Locators", post_body)
-      Model::Locator.new(res["d"])
+      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 = Asset.create(asset_name)
       asset.upload(filepath)
     end
 
     def create_encode_job(asset_id, encode_configuration)
+      warn("DEPRECATION WARNING: Service#create_encode_job is deprecated. Use AzureMediaService::Job.create() instead.")
       asset = assets(asset_id)
       asset.encode_job(encode_configuration)
     end
 
     def jobs(job_id=nil)
-      get('Jobs', Model::Job, job_id)
+      warn("DEPRECATION WARNING: Service#jobs is deprecated. Use AzureMediaService::Job.get() instead.")
+      get('Jobs', Job, job_id)
     end
 
+
     # publish asset
     def publish(asset_id, expire_minutes=nil)
-      asset = assets(asset_id)
+      warn("DEPRECATION WARNING: Service#publish is deprecated. Use AzureMediaService::Asset#publish() instead.")
+      asset = Asset.get(asset_id)
       asset.publish(expire_minutes)
     end
 
     def publish_url(asset_id)
-      asset = assets(asset_id)
+      warn("DEPRECATION WARNING: Service#publish_url is deprecated. Use AzureMediaService::Asset#publish_url() instead.")
+      asset = Asset.get(asset_id)
       asset.publish_url
     end
 
@@ -76,22 +85,49 @@ module AzureMediaService
       }.sort{|a,b|
         b["Version"].to_i <=> a["Version"].to_i
       }.first
-      Model::MediaProcessor.new(mp)
+      MediaProcessor.new(mp)
+    end
+
+    def get_protection_key_id(content_key_type)
+      res = @request.get("GetProtectionKeyId", contentKeyType: content_key_type)
+      if res["d"]
+        res["d"]["GetProtectionKeyId"]
+      else
+        raise MediaServiceError.new(res["error"]["message"]["value"])
+      end
+    end
+
+    def get_protection_key(protection_key_id)
+      res = @request.get("GetProtectionKey", ProtectionKeyId: "'#{protection_key_id}'")
+      if res["d"]
+        res["d"]["GetProtectionKey"]
+      else
+        raise MediaServiceError.new(res["error"]["message"]["value"])
+      end
     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)
+        if res["d"]
+          res["d"]["results"].each do |a|
+            results << klass.new(a)
+          end
         end
       else
         res = @request.get("#{method}('#{id}')")
-        results = klass.new(res["d"])
+        results = nil
+        if res["d"]
+          results = klass.new(res["d"])
+        end
       end
       results
     end
 
+    def post(method, body)
+      @request.post(method, body)
+    end
+
   end
 end

data/lib/azure_media_service/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: azure_media_service
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - murayama
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-04 00:00:00.000000000 Z
+date: 2015-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -127,8 +127,12 @@ files:
 - 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_delivery_policy.rb
 - lib/azure_media_service/model/asset_file.rb
 - lib/azure_media_service/model/base.rb
+- lib/azure_media_service/model/content_key.rb
+- lib/azure_media_service/model/content_key_authorization_policy.rb
+- lib/azure_media_service/model/content_key_authorization_policy_option.rb
 - lib/azure_media_service/model/job.rb
 - lib/azure_media_service/model/locator.rb
 - lib/azure_media_service/model/media_processor.rb
@@ -157,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Azure Media Service SDK for ruby