cloudkey 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+pkg/*
+*.gem
+.bundle

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'spec/rake/spectask'
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+end

data/Readme.md

@@ -0,0 +1,31 @@
+Cloudkey
+========
+
+Introduction
+------------
+
+This gem, still under development, aims to provide an abstract interface to DailyMotion's Cloud service. 
+Currently, it's mostly a rewrite of the Python and Php version.
+
+Warning
+-------
+
+We were not able to use security features from the web service to craft restricted urls while testing the Python 
+or PHP versions, so we supposed they had not been activated yet. 
+
+Usage
+-----
+
+		# Fill in your credentials
+		@cloudkey = Cloudkey.authenticate USER_ID, KEY
+
+		# Grab a list of your medias
+		p @cloudkey.media.list(:fields => [:id])
+
+		# Get an embedded player for your video, with its usage restricted to a specific IP address
+		p @cloudkey.media.embedded_url VIDEO_ID, Cloudkey::SecurityPolicy.new(:ip => "88.0.0.1")
+		
+License
+-------
+
+Cloudkey is released under the MIT License. 

data/cloudkey.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cloudkey/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cloudkey"
+  s.version     = Cloudkey::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jean-Hadrien Chabran", "Boubacar Diallo"]
+  s.email       = ["jh@kareea.com"]
+  s.homepage    = "http://rubygems.org/gems/cloudkey"
+  s.summary     = %q{Bla bla}
+  s.description = %q{bla bla}
+
+  s.rubyforge_project = "cloudkey"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency "rspec", "~> 2.0.1"
+  s.add_dependency 'curb', "~> 0.7.8"
+end

data/lib/cloudkey.rb

@@ -0,0 +1,12 @@
+require 'curb'
+
+require 'cloudkey/version'
+require 'cloudkey/security_level'
+require 'cloudkey/security_policy'
+require 'cloudkey/api'
+
+module Cloudkey
+  def self.authenticate *args
+    API::new *args
+  end
+end

data/lib/cloudkey/api.rb

@@ -0,0 +1,86 @@
+require 'digest/md5'
+
+require 'cloudkey/client'
+
+require 'cloudkey/file'
+require 'cloudkey/media'
+
+module Cloudkey
+  class API
+    attr_accessor :user_id, :key, :base_url, :proxy, :act_as_user
+    attr_reader :target
+    
+    # New API versions that break compatibility would probably change the endpoint
+    END_POINT = "/api"
+    
+    def initialize user_id, key, options={}
+      raise "Can't connect without an user_id" unless user_id
+      raise "Can't connect without an key" unless key
+      
+      @user_id, @key = user_id, key
+      
+      @base_url = options[:base_url] || 'http://api.dmcloud.net'
+      @proxy = options[:proxy]
+      @act_as_user = options[:act_as_user]
+      
+      @target = @base_url + END_POINT
+    end
+    
+    def user_infos
+      if act_as_user
+        "#{user_id}/#{act_as_user}"
+      else
+        user_id
+      end
+    end
+    
+    def media
+      Media.new self 
+    end
+    
+    def file
+      File.new self
+    end
+    
+    def self.sign message, secret
+      Digest::MD5.hexdigest(message + secret)
+    end
+    
+    def self.sign_url url, secret, security_policy = SecurityPolicy.new
+      (url, query) = url.split("?")
+      
+      expires = security_policy.expires.to_s
+      
+      rand   = (('a'..'z').to_a + (1..9).to_a).shuffle[0..7].join('')
+      food   = security_policy.level.to_s
+      food  << url  << expires.to_s
+      food  << rand << secret << security_policy.private_parameters.join('')
+      food  << security_policy.encoded_public_parameters if security_policy.encoded_public_parameters
+      
+      digest = Digest::MD5.hexdigest(food) 
+      
+      result = url
+      result << "?"
+      result << query + '&' if query
+      result << "auth="
+      result << expires.to_s  << "-"
+      result << security_policy.level.to_s << "-"
+      result << rand << "-"
+      result << digest      
+      result << "-#{security_policy.encoded_public_parameters}" if security_policy.encoded_public_parameters
+      
+      result
+    end
+    
+    def self.normalize payload
+      case payload
+      when Array
+        payload.collect { |element| normalize element }.join('')
+      when Hash
+        payload.to_a.sort { |a,b| a.first <=> b.first }.collect {|array| array.first.to_s + normalize(array.last)}.join('')
+      else
+        payload.to_s
+      end
+    end
+  end
+end

data/lib/cloudkey/client.rb

@@ -0,0 +1,45 @@
+require 'json'
+
+module Cloudkey
+  class Client
+    def initialize api
+      @api = api
+    end
+    
+    def method_missing method_id, *args, &block
+      call(method_id, *args, &block)
+    end
+    
+    protected
+    def call method, args={}
+      @request = create_request self.class.name.gsub("Cloudkey::",'').downcase, method, args
+      authenticate_request @request
+      
+      curl do |c| 
+        c.http_post @request.to_json
+        JSON.parse c.body_str
+      end
+    end
+    
+    def authenticate_request request
+      request[:auth] = "#{@api.user_infos}:#{API::sign(@api.user_infos + API.normalize(request), @api.key)}"
+    end
+    
+    def curl url=nil, &block
+      c = Curl::Easy.new(url || @api.target) do |c|
+          c.useragent               = "cloudkey-rb #{Cloudkey::VERSION}"
+          c.headers['Content-Type'] = "application/json"
+          c.proxy_url               = @api.proxy if @api.proxy
+        end
+      
+      yield c
+    end
+    
+    def create_request name, method, args
+      {
+        :call => "#{name}.#{method}",
+        :args => args
+      }
+    end
+  end
+end

data/lib/cloudkey/file.rb

@@ -0,0 +1,29 @@
+module Cloudkey
+  class File < Client
+    def upload_file path, &block
+      raise "File not found" unless ::File.exists? path
+      
+      curl(fetch_upload_url) do |c|
+        puts "upload! #{c.url}"
+        c.multipart_form_post = true
+        c.headers             = false
+        c.follow_location     = true
+        if block_given?
+          c.on_progress  do |dl_total, dl_now, ul_total, ul_now|
+            block.call(ul_now, ul_total) if ul_total > 0.0
+            true
+          end
+        end
+
+        c.http_post Curl::PostField.file("file", path)
+        JSON.parse c.body_str
+      end
+    end
+    
+    protected
+    
+    def fetch_upload_url
+      upload["result"]["url"]
+    end
+  end
+end

data/lib/cloudkey/media.rb

@@ -0,0 +1,13 @@
+module Cloudkey
+  class Media < Client
+    def embedded_url id, security_level = SecurityPolicy.new
+      url = "#{@api.base_url}/embed/#{@api.user_id}/#{id}"      
+      API.sign_url url, @api.key, security_level
+    end
+    
+    def stream_url id, asset_name="mp4_h264_aac", security_level=SecurityPolicy.new, cdn_url='http://cdn.dmcloud.net'
+      url = "#{cdn_url}/route/#{@api.user_id}/#{id}/#{asset_name}.#{asset_name.split('_')[0]}"
+      API.sign_url url, @api.key, security_level
+    end
+  end
+end

data/lib/cloudkey/security_level.rb

@@ -0,0 +1,14 @@
+module Cloudkey
+  class API
+    module SecurityLevel
+      NONE              = 0
+      DELEGATE          = 1 << 0
+      AS_NUMBER         = 1 << 1
+      IP                = 1 << 2
+      USER_AGENT        = 1 << 3
+      USE_ONCE          = 1 << 4
+      COUNTRIES         = 1 << 5
+      REFERERS          = 1 << 6
+    end
+  end
+end

data/lib/cloudkey/security_policy.rb

@@ -0,0 +1,100 @@
+require "cgi"
+require "base64"
+require "zlib"
+
+module Cloudkey
+  class SecurityPolicy
+    IP_FORMAT_ERROR       = Class.new(Exception)
+    REFERERS_FORMAT_ERROR = Class.new(Exception)
+    
+    def initialize opts={}
+      @options = {:expires_in => 7200}.merge(opts)
+    end    
+      
+    def method_missing method_id, *args, &block
+      method_id = method_id.to_s
+      
+      affectation = method_id.include? "="
+      method_id.gsub!("=",'')
+      
+      if affectation
+        @options[method_id.to_sym] = args.first
+      end
+        
+      @options[method_id.to_sym]
+    end
+    
+    def expires
+      @options[:expires_in] + Time.now.tv_sec
+    end
+  
+    def none?
+      @options.empty? || @options.keys == [:expires_in]
+    end
+    
+    def delegate?
+      @options[:delegate]
+    end
+    
+    def as_number?
+      !!@options[:as_number]
+    end
+    
+    def ip?
+      if @options[:ip]
+        raise IP_FORMAT_ERROR unless @options[:ip].match(/\b(?:\d{1,3}\.){3}\d{1,3}\b/)
+        true
+      end
+    end
+    
+    def user_agent?
+      @options[:user_agent] && !@options[:user_agent].empty?
+    end
+    
+    def use_once?
+      @options[:use_once]
+    end
+    
+    def countries?
+      @options[:countries] && !@options[:countries].empty?
+    end
+    
+    def referers?
+      if @options[:referers] && !@options[:referers].empty?
+        raise REFERERS_FORMAT_ERROR unless @options[:referers].inject(true) { |result, url| result && url.match(/https?:\/\/(.*)/) }
+        true
+      end
+    end
+    
+    def set opts={}
+      @options = opts
+    end
+    
+    def private_parameters
+      parameters = []
+      parameters << as_number if as_number?
+      parameters << ip if ip?
+      parameters << user_agent if user_agent?
+      parameters 
+    end
+
+    def public_parameters
+      parameters = []
+      parameters << "cc=#{countries.collect{|c| c.downcase}.join(',')}" if countries?
+      parameters << "rf=#{CGI.escape(referers.collect{|r| r.gsub(' ', '%20')}.join(' '))}" if referers?
+      parameters unless parameters.empty?
+    end
+    
+    def encoded_public_parameters
+      Base64.encode64(Zlib::Deflate.deflate(public_parameters.join('&'))).chomp if public_parameters
+    end
+    
+    def level
+      result = 0
+      API::SecurityLevel.constants.each do |constant|
+        result |= API::SecurityLevel.const_get(constant) if send("#{constant.to_s.downcase}?")
+      end
+      result
+    end
+  end
+end

data/lib/cloudkey/version.rb

@@ -0,0 +1,3 @@
+module Cloudkey
+  VERSION = "0.0.1"
+end

data/spec/cloudkey/api_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Cloudkey::API do
+  describe "Authentication" do
+    it "should raise an error without an user_id" do
+      lambda {Cloudkey::API.new nil, "foobar"}.should raise_error
+    end
+
+    it "should raise an error without an api_key" do
+      lambda {Cloudkey::API.new "bob", nil}.should raise_error
+    end
+  end
+
+  describe "Helpers methods" do
+    before(:each) do
+      @api = Cloudkey::API.new "foo", "bar"
+    end
+
+    it "should return Cloudkey::File when sending :file" do
+      @api.file.should be_an_instance_of(Cloudkey::File)
+    end
+
+    it "should return Cloudkey::Media when sending :media" do
+      @api.media.should be_an_instance_of(Cloudkey::Media)      
+    end
+  end
+
+  describe "Normalizing" do
+    {
+      'foo42bar'                  => ['foo', 42, 'bar'],
+      'pink3red2yellow1'          => {'yellow' => 1, 'red' => 2, 'pink' => 3},
+      '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
+        Cloudkey::API.normalize(original).should == normalized
+      end
+    end
+  end
+
+  describe "Signing" do
+    it "should sign 'hello world' with sEcReT_KeY and returns 'b5d93121a6dc87562b46beb8ba809ace'" do
+      Cloudkey::API.sign("hello world", "sEcReT_KeY").should == 'b5d93121a6dc87562b46beb8ba809ace'
+    end
+    
+    it "it should sign an url" do
+      Cloudkey::API.sign_url("http://google.fr","olol", Cloudkey::SecurityPolicy.new(:ip => "192.168.0.1"))
+    end
+  end
+end

data/spec/cloudkey/security_policy_spec.rb

@@ -0,0 +1,53 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module Cloudkey
+  describe SecurityPolicy do
+    before(:each) do
+      @policy = SecurityPolicy.new
+    end
+    
+    describe "Default behavior" do  
+      it "should default to no policy" do
+        @policy.should be_none
+        @policy.expires_in.should == 7200
+      end
+    end
+    
+    describe "IP" do
+      it "should accept an IP" do
+        @policy.ip = "192.168.0.3"
+        (@policy.level & API::SecurityLevel::IP).should be_true
+      end
+      
+      it "should accept an IP and a user agent" do
+        @policy.set :ip => "192.168.0.1", :user_agent => "Mammouth Browser v0.1"
+        (@policy.level & API::SecurityLevel::IP).should be_true
+        (@policy.level & API::SecurityLevel::USER_AGENT).should be_true
+      end
+      
+      it "should raise an error on bad ip format" do
+        @policy.set :ip => "Bob Kelso"
+        -> {@policy.level}.should raise_error(SecurityPolicy::IP_FORMAT_ERROR)
+      end
+    end
+
+    describe "Referers" do
+      it "should accept referers" do
+        @policy.referers =  %w(http://google.com http://lolcat.com)
+        (@policy.level & API::SecurityLevel::REFERERS).should be_true  
+      end
+      
+      it "should accept only valid refers" do
+        @policy.referers =  ["http://google.com", ""]
+        -> { @policy.level }.should raise_error(SecurityPolicy::REFERERS_FORMAT_ERROR)
+      end      
+    end
+    
+    describe "Expires" do
+      it "should accept an expire time" do
+        @policy.expires_in = 5000
+        @policy.expires_in.should be(5000)
+      end
+    end
+  end    
+end

data/spec/cloudkey_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Cloudkey do
+  context "Public API" do
+    it "should provide an authenticate method on Cloudkey" do
+      Cloudkey.should respond_to :authenticate
+    end
+    
+    it "should count medias" do
+      pending
+      @cloudkey = Cloudkey.authenticate "foo", "bar"
+      @cloudkey.media.count
+    end
+    
+    it "should accept an optional proxy" do
+      @proxy = "http://my.awesome.proxy.com:3128"
+      Cloudkey.authenticate("foo", "bar", :proxy => @proxy).proxy.should == @proxy
+    end
+    
+    it "should accept an optional base_url" do
+      @base_url = "http://different.api.dmcloud.net"
+      Cloudkey.authenticate("foo", "bar", :base_url => @base_url).base_url.should == @base_url
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'cloudkey'

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification 
+name: cloudkey
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jean-Hadrien Chabran
+- Boubacar Diallo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-15 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 2
+        - 0
+        - 1
+        version: 2.0.1
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: curb
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 7
+        - 8
+        version: 0.7.8
+  type: :runtime
+  version_requirements: *id002
+description: bla bla
+email: 
+- jh@kareea.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- Readme.md
+- cloudkey.gemspec
+- lib/cloudkey.rb
+- lib/cloudkey/api.rb
+- lib/cloudkey/client.rb
+- lib/cloudkey/file.rb
+- lib/cloudkey/media.rb
+- lib/cloudkey/security_level.rb
+- lib/cloudkey/security_policy.rb
+- lib/cloudkey/version.rb
+- spec/cloudkey/api_spec.rb
+- spec/cloudkey/security_policy_spec.rb
+- spec/cloudkey_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/cloudkey
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: cloudkey
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Bla bla
+test_files: 
+- spec/cloudkey/api_spec.rb
+- spec/cloudkey/security_policy_spec.rb
+- spec/cloudkey_spec.rb
+- spec/spec_helper.rb