dmcloud 1.0

data/lib/dm_cloud/signing.rb

@@ -0,0 +1,189 @@
+require 'rubygems'
+
+module DmCloud
+  class Signing
+    # Generate auth token for request from Media
+    # Params:
+    #   request: A hash of params generated from Media methods and Media::MetaData
+    # Result :
+    #   return a string which contain the auth token for the request
+    #   <url>?auth=<expires>-<sec>-<nonce>-<md5sum>[-<pub-sec-data>]
+    def self.identify(request)
+      user_id  = DmCloud.config[:user_key]
+      api_key  = DmCloud.config[:secret_key]
+
+      normalized_request = normalize(request).to_s
+      # puts 'identify:: normalized_values : ' + normalized_request + "\n" + '-' * 80
+
+      params = user_id + normalized_request + api_key
+
+      # puts 'identify:: Values before MD5 encrypt  : ' + params + "\n" + '-' * 80
+
+      checksum = Digest::MD5.hexdigest(params)
+      auth_token = user_id + ':' + checksum
+
+      auth_token
+    end
+    
+    # To sign a URL, the client needs a secret shared with Dailymotion Cloud.
+    # This secret is call client secret and is available in the back-office interface.
+    # Params:
+    #   expires: An expiration timestamp.
+    #   sec-level: A security level mask.
+    #   url-no-query: The URL without the query-string.
+    #   nonce: A 8 characters-long random alphanumeric lowercase string to make the signature unique.
+    #   secret: The client secret.
+    #   sec-data: If sec-level doesn’t have the DELEGATED bit activated,
+    #     this component contains concatenated informations 
+    #     for all activated sec levels.
+    #   pub-sec-data: Some sec level data have to be passed in clear in the signature.
+    #     To generate this component the parameters are serialized using x-www-form-urlencoded, compressed with gzip and encoded in base64.
+    # Result :
+    #   return a string which contain the signed url like 
+    #   <expires>-<sec>-<nonce>-<md5sum>[-<pub-sec-data>]
+    def self.sign(stream, security_datas = nil)
+      raise StandardError, "missing :stream in params" unless stream
+      sec_level = security(DmCloud.config[:security_level])
+      sec_data = security_data(DmCloud.config[:security_level], security_datas) unless security_datas.nil?
+
+      base = { 
+        :sec_level => sec_level,
+        :url_no_query => stream,
+        :expires => 1.hours.from_now.to_i,
+        :nonce => SecureRandom.hex(16)[0,16],
+        :secret => DmCloud.config[:secret_key]
+      }
+      base.merge!(:sec_data => sec_data, :pub_sec_data => sec_data) unless sec_data.nil?
+
+      digest_struct = build_digest_struct(base)
+      check_sum = Digest::MD5.hexdigest(digest_struct)
+
+      signed_url = [base[:expires], base[:sec_level], base[:nonce], check_sum].compact
+      signed_url.merge!(:pub_sec_data => sec_data) unless sec_data.nil?
+      
+      # puts signed_url
+      
+      signed_url = signed_url.join('-')
+      signed_url
+    end
+    
+    # Prepare datas for signing
+    # Params :
+    #   base : contains media id and others for url signing
+    def self.build_digest_struct(base)
+      result = []
+      base.each_pair { |key, value| result << value }
+      result.join('')
+    end
+
+    # The client must choose a security level for the signature.
+    # Security level defines the mechanism used by Dailymotion Cloud architecture
+    # to ensure the signed URL will be used by a single end-user.
+    # Params :
+    #   type :
+    #     None: The signed URL will be valid for everyone
+    #     ASNUM: The signed URL will only be valid for the AS of the end-user.
+    #       The ASNUM (for Autonomous System Number) stands for the network identification,
+    #       each ISP have a different ASNUM for instance.
+    #     IP: The signed URL will only be valid for the IP of the end-user.
+    #       This security level may wrongly block some users
+    #       which have their internet access load-balanced between several proxies.
+    #       This is the case in some office network or some ISPs.
+    #     User-Agent: Used in addition to one of the two former levels, 
+    #       this level a limit on the exact user-agent of the end-user.
+    #       This is more secure but in some specific condition may lead to wrongly blocked users.
+    #     Use Once: The signed URL will only be usable once.
+    #       Note: should not be used with stream URLs.
+    #     Country: The URL can only be queried from specified countrie(s).
+    #       The rule can be reversed to allow all countries except some.
+    #     Referer: The URL can only be queried 
+    #       if the Referer HTTP header contains a specified value.
+    #       If the URL contains a Referer header with a different value,
+    #       the request is refused. If the Referer header is missing,
+    #       the request is accepted in order to prevent from false positives as some browsers, 
+    #       anti-virus or enterprise proxies may remove this header.
+    #     Delegate: This option instructs the signing algorithm 
+    #       that security level information won’t be embeded into the signature
+    #       but gathered and lock at the first use.
+    # Result :
+    #   Return a string which contain the signed url like 
+    #   http://cdn.DmCloud.net/route/<user_id>/<media_id>/<asset_name>.<asset_extension>?auth=<auth_token>
+    def self.security(type = nil)
+      type = :none unless type
+      type = type.to_sym if type.class == String
+      
+      case type
+        when :none
+          0 # None
+        when :delegate
+          1 << 0  # None
+        when :asnum
+          1 << 1  # The number part of the end-user AS prefixed by the ‘AS’ string (ie: as=AS41690)
+        when :ip
+          1 << 2  # The end-user quad dotted IP address (ie: ip=195.8.215.138)
+        when :user_agent
+          1 << 3  # The end-user browser user-agent (parameter name is ua)
+        when :use_once
+          1 << 4  # None
+        when :country
+          1 << 5  # A list of 2 characters long country codes in lowercase by comas. If the list starts with a dash, the rule is inverted (ie: cc=fr,gb,de or cc=-fr,it). This data have to be stored in pub-sec-data component
+        when :referer
+          1 << 6  # A list of URL prefixes separated by spaces stored in the pub-sec-data component (ex: rf=http;//domain.com/a/+http:/domain.com/b/).
+      end
+    end
+
+    def self.security_data(type, value = nil)
+      type = type.to_sym if type.class == String
+
+      case type
+        when :asnum
+          "as=#{value}"  # The number part of the end-user AS prefixed by the ‘AS’ string (ie: as=AS41690)
+        when :ip
+          "ip=#{value}"  # The end-user quad dotted IP address (ie: ip=195.8.215.138)
+        when :user_agent
+          "ua=#{value}"  # The end-user browser user-agent (parameter name is ua)
+        when :country
+          "cc=#{value}"  # A list of 2 characters long country codes in lowercase by comas. If the list starts with a dash, the rule is inverted (ie: cc=fr,gb,de or cc=-fr,it). This data have to be stored in pub-sec-data component
+        when :referer
+          "rf=#{value}"  # A list of URL prefixes separated by spaces stored in the pub-sec-data component (ex: rf=http;//domain.com/a/+http:/domain.com/b/).
+        else
+          nil
+      end
+    end
+
+    def self.security_pub_sec_data(type, value)
+      type = type.to_sym if type.class == String
+      
+      case type
+        when :country
+          "cc=#{value}"  # A list of 2 characters long country codes in lowercase by comas. If the list starts with a dash, the rule is inverted (ie: cc=fr,gb,de or cc=-fr,it). This data have to be stored in pub-sec-data component
+        when :referer
+          "rf=#{value}"  # A list of URL prefixes separated by spaces stored in the pub-sec-data component (ex: rf=http;//domain.com/a/+http:/domain.com/b/).
+        else
+          nil
+      end
+    end
+    
+    
+    # This block comes from Cloudkey gem.
+    # I discovered this gem far after I start this one 
+    # and I will try to add file upload from http or ftp.
+    # (Missing in their gem)
+    def self.normalize params
+          case params
+          when Array
+            params.collect { |element| normalize(element) }.join('')
+          when Hash
+            params.to_a.sort_by {|a,b| a.to_s }.collect {|array| array.first.to_s + normalize(array.last)}.join('')
+          else
+            params.to_s
+          end
+        end
+    
+    # def self.normalize(params)
+    #       str = params.to_json.to_s
+    #       str.gsub!(/[^A-Za-z0-9]/, '')
+    #       str
+    #     end
+  end
+end

data/lib/dm_cloud/streaming.rb

@@ -0,0 +1,80 @@
+require "time"
+require "openssl"
+require "base64"
+require 'digest/md5'
+
+# This module generate methods to generate video's fluxes
+# before signing it and request it.
+module DmCloud
+  class Streaming
+      # Default URL to get embed content ou direct url
+      DIRECT_STREAM = "[PROTOCOL]://cdn.dmcloud.net/route/[USER_ID]/[MEDIA_ID]/[ASSET_NAME].[ASSET_EXTENSION]".freeze
+      EMBED_STREAM = "[PROTOCOL]://api.dmcloud.net/embed/[USER_ID]/[MEDIA_ID]".freeze
+      EMBED_IFRAME = '<iframe width="[WIDTH]" height="[HEIGHT]" frameborder="0" scrolling="no" src="[EMBED_URL]"></iframe>'.freeze
+
+      # Get embeded player
+      # Params :
+      #   media_id: this is the id of the media (eg: 4c922386dede830447000009)
+      #   options:
+      #     skin_id: (optional) the id of the custom skin for the video player
+      #     width: (optional) the width for the video player frame
+      #     height: (optional) the height for the video player frame
+      # Result :
+      #   return a string which contain the signed url like
+      #   <iframe width="848" height="480" frameborder="0" scrolling="no" src="http://api.DmCloud.net/embed/<user_id>/<media_id>?auth=<auth_token>&skin=<skin_id>"></iframe>
+      def self.embed(media_id, options = {}, security = {})
+        raise StandardError, "missing :media_id in params" unless media_id
+
+        skin_id = options[:skin_id] ? options[:skin_id]  : 'modern1'
+        width   = options[:width]   ? options[:width].to_s    : '848'
+        height  = options[:height]  ? options[:height].to_s   : '480'
+
+        stream = EMBED_STREAM.dup
+        stream.gsub!('[PROTOCOL]', DmCloud.config[:protocol])
+        stream.gsub!('[USER_ID]', DmCloud.config[:user_key])
+        stream.gsub!('[MEDIA_ID]', media_id)
+        signed_url = DmCloud::Signing.sign(stream, security)
+        signed_url = stream + "?auth=#{signed_url}"
+
+        frame = EMBED_IFRAME.dup
+        frame.gsub!('[WIDTH]', width)
+        frame.gsub!('[HEIGHT]', height)
+        frame.gsub!('[EMBED_URL]', signed_url)
+
+        frame.html_safe
+      end
+
+      # Get media url for direct link to the file on DailyMotion Cloud
+      # Params :
+      #   media_id: this is the id of the media (eg: 4c922386dede830447000009)
+      #   asset_name: the name of the asset you want to stream (eg: mp4_h264_aac)
+      #   asset_extension: the extension of the asset, most of the time it is the first part of the asset name (eg: mp4)
+      # Result :
+      #   return a string which contain the signed url like
+      #   http://cdn.DmCloud.net/route/<user_id>/<media_id>/<asset_name>.<asset_extension>?auth=<auth_token>
+      def self.url(media_id, asset_name, asset_extension = nil, security = {})
+        raise StandardError, "missing :media_id in params" unless media_id
+        raise StandardError, "missing :asset_name in params" unless asset_name
+        asset_extension = asset_name.split('_').first unless asset_extension
+
+        stream = DIRECT_STREAM.dup
+        stream.gsub!('[PROTOCOL]', DmCloud.config[:protocol])
+        stream.gsub!('[USER_ID]', DmCloud.config[:user_key])
+        stream.gsub!('[MEDIA_ID]', media_id)
+        stream.gsub!('[ASSET_NAME]', asset_name)
+        stream.gsub!('[ASSET_EXTENSION]', asset_extension)
+
+        stream += '?auth=[AUTH_TOKEN]'.gsub!('[AUTH_TOKEN]', DmCloud::Signing.sign(stream, security))
+        stream
+      end
+
+      # Gets the real URL that points to the download link on DMCloud's specific server
+      def self.download_url(media_id, asset_name, asset_extension = nil, security = {})
+        download_url = self.url(media_id, asset_name, asset_extension, security)
+        response = Net::HTTP.get_response(URI.parse(download_url))
+        download_url = response.header["location"]
+
+        download_url
+      end
+  end
+end

data/lib/dm_cloud/version.rb

@@ -0,0 +1,3 @@
+module DmCloud
+  VERSION = "0.0.65"
+end

data/lib/dm_cloud.rb

@@ -0,0 +1,58 @@
+require 'yaml'
+
+# This gem's comments come from DailyMotion Cloud API,
+# that's the better way to see changes on new version and logic.
+# For parts more generals and not representating DailyMotion Cloud API,
+# I add some about my own opinion.
+module DmCloud
+  
+  # Configuration defaults
+  # I used this parts from Slainer68 paybox_system gem.
+  # I liked the concept and how he handle this part.
+  # Thx Slainer68, I created my first gem, 
+  # and next one will be an update to your paybox_system gem.
+  @@config = {
+    security_level: 'none',
+    protocol: 'http',
+    auto_call: true,
+    user_key: nil,
+    secret_key: nil
+  }
+
+  YAML_INITIALIZER_PATH = File.dirname(__FILE__)
+  @valid_config_keys = @@config.keys
+
+  # Configure through hash
+  def self.configure(opts = {})
+    opts.each {|k,v| @@config[k.to_sym] = v } # if @valid_config_keys.include? k.to_sym}
+  end
+
+  # Configure through yaml file
+  # for ruby scripting usage
+  def self.configure_with(yaml_file_path = nil)
+    yaml_file_path = YAML_INITIALIZER_PATH  unless yaml_file_path
+    begin
+      config = YAML::load(IO.read(path_to_yaml_file))
+    rescue Errno::ENOENT
+      log(:warning, "YAML configuration file couldn't be found. Using defaults."); return
+    rescue Psych::SyntaxError
+      log(:warning, "YAML configuration file contains invalid syntax. Using defaults."); return
+    end
+
+    configure(config)
+  end
+
+  # Access to config variables (security level, user_id and api_key)
+  def self.config
+    @@config = configure unless @@config
+    @@config
+  end
+
+  # Loading classes to easier access
+  # NOTE: I like this way to handle my classes,
+  #   sexiest than using require 'my_class_file' everywhere
+  autoload(:Streaming, 'dm_cloud/streaming')
+  autoload(:Media, 'dm_cloud/media')
+  autoload(:Request, 'dm_cloud/request')
+  autoload(:Signing, 'dm_cloud/signing')
+end

data/spec/dm_cloud/media_spec.rb

@@ -0,0 +1,48 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'dm_cloud/media'
+
+describe DmCloud::Media do
+  use_vcr_cassette
+
+  context "Using test account" do
+    before :each do
+      DmCloud.configure({:user_key => TEST_USER_KEY, :secret_key => TEST_SECRET_KEY, auto_call: false})
+    end
+
+    context "Having a collection" do
+      it "should list four medias" do
+        subject { list(:per_page => 20)['result']['total'].should == (4) }
+      end
+
+      it "should get all the titles" do
+        result = DmCloud::Media.list(:fields => {:meta => [:title]}, :per_page => 20) #['result']['list']
+        result[:call].should == "media.list"
+        result[:params][:args][:fields].should include("meta.title")
+      end
+
+      it "should get page 2 with 2 records per page" do
+        result = DmCloud::Media.list(:per_page => 2, :page => 2)
+        result[:params][:page].should == 2
+        result[:params][:per_page].should == 2
+      end
+    end
+
+    context "Querying a single media" do
+      it "should have an default fields" do
+        result = DmCloud::Media.info('4f33ddbc94a6f6517c001577')
+        fields = result[:params][:args][:fields]
+        puts fields.to_yaml
+        fields.should include('embed_url')
+      end
+
+      # it "should have a stream url" do
+      #         subject { stream_url('4f33ddbc94a6f6517c001577').should include("http://cdn.DmCloud.net/route/4f33d9c8f325e11c830016af/4f33ddbc94a6f6517c001577/mp4_h264_aac.mp4")
+      #       end
+      # 
+      #       it "should have http detected as protocol" do
+      #         @cloudkey.media.stream_url('4f33ddbc94a6f6517c001577', 'mp4_h264_aac',Cloudkey::SecurityPolicy.new, :download => true).should include("/http/")
+      #       end
+    end
+  end
+end

data/spec/dm_cloud/signing_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'dm_cloud/signing'
+
+describe DmCloud::Signing do
+
+  before do
+    DmCloud.configure({ :user_key => "hello world", :secret_key => "sEcReT_KeY" })
+  end
+
+  it "should sign 'hello world' with sEcReT_KeY and returns 'b5d93121a6dc87562b46beb8ba809ace'" do
+    auth_token = subject { identify() }
+    auth_token.should == 'b5d93121a6dc87562b46beb8ba809ace'
+  end
+
+  it "it should sign an url" do
+    let(:signed_url) { stub(:sign).with("http://google.fr","olol") }
+  end
+  
+  context "Normalizing" do
+      {
+        'foo42bar'                  => ['foo', 42, 'bar'],
+        'pink3red2yellow1'          => {'yellow' => 1, 'red' => 2, 'pink' => 3},
+        'foo42pink3red2yellow1bar'  => ['foo', 42, {'yellow' => 1, 'red' => 2, 'pink' => 3}, 'bar'],
+        'foo42pink3red2yellow1bar'  => [:foo, 42, {:yellow => 1, :red => 2, :pink => 3}, :bar],
+        '12'                        => [nil, 1,2],
+        ''                          => nil,
+        '212345'                    => {2 => [nil, 1,2], 3 => nil, 4 => 5}
+      }.each do |normalized, original| 
+        it "should normalize #{original.inspect} into #{normalized}" do
+          subject { normalize(original).should == normalized }
+        end
+      end
+    end
+  
+end

data/spec/dm_cloud/streaming_spec.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'dm_cloud/streaming'
+
+
+describe DmCloud::Streaming do
+  use_vcr_cassette
+
+  context "check " do
+    before :each do
+      DmCloud.configure({user_key: TEST_USER_KEY, secret_key: TEST_SECRET_KEY, auto_execute: false})
+    end
+
+    context "Querying a single media" do
+      it "should have an embedded url" do
+        DmCloud::Streaming.embed('4f33ddbc94a6f6517c001577').should include("http://api.DmCloud.net/embed/4f33d9c8f325e11c830016af/4f33ddbc94a6f6517c001577")
+      end
+
+      it "should have a stream url" do
+        DmCloud::Streaming.url('4f33ddbc94a6f6517c001577', 'source').should include("http://cdn.DmCloud.net/route/4f33d9c8f325e11c830016af/4f33ddbc94a6f6517c001577/mp4_h264_aac.mp4")
+      end
+    end
+  end
+end

data/spec/dm_cloud_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'dm_cloud'
+
+describe DmCloud do
+  context "configuration" do
+    use_vcr_cassette
+
+    it "should provide a config on DmCloud" do
+      DmCloud.should respond_to :config
+    end
+    
+    it "should be initialized with default values" do
+      DmCloud.configure
+      DmCloud.config[:security_level].should == 'none'
+      DmCloud.config[:protocol].should == 'http'
+      DmCloud.config[:auto_call].should be_true
+    end
+
+    context "after configuration setted" do
+      it "should be properly set" do
+        DmCloud.configure({user_key: TEST_USER_KEY, secret_key: TEST_SECRET_KEY, auto_call: false })
+        DmCloud.config[:user_key].should == TEST_USER_KEY
+        DmCloud.config[:secret_key].should == TEST_SECRET_KEY
+        DmCloud.config[:auto_call].should == false
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,57 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '/../', 'lib'))
+require 'rubygems'
+require 'rspec'
+require 'rspec/autorun'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+#  def self.behavior(obj)
+#    if @methods
+#      @methods = @methods.select{|met| @methods.member? met }
+#    else
+#      @methods = obj.public_methods
+#    end
+#  end
+# puts "Common Methods: #{@methods.sort.join(', ')}" if @methods
+
+module Compare
+  def self.type(obj)
+    @objects ||= []
+    @objects << obj
+  end
+
+  def self.report
+    puts "Object Types: #{@objects.collect{|o| o.class}.join(', ')}" if @objects
+  end
+end
+
+class Object
+  def put_methods(regex=/.*/)
+    puts self.methods.grep(regex)
+  end
+end
+
+RSpec.configure do |config|
+  config.after(:suite) do
+    Compare.report
+  end
+end
+
+# Hook on http requests
+require 'vcr'
+
+TEST_USER_KEY  = "my_user_key"
+TEST_SECRET_KEY = "my_secret_key"
+
+VCR.configure do |c|
+  c.cassette_library_dir     = 'spec/cassettes'
+  # c.stub_with                :fakeweb
+  c.default_cassette_options = { :record => :new_episodes }
+end
+
+RSpec.configure do |c|
+  c.extend VCR::RSpec::Macros
+end