voxcast_api 1.0.0

data/lib/voxcast_api/base.rb

@@ -0,0 +1,184 @@
+require 'time'
+require 'set'
+require 'digest/md5'
+require 'forwardable'
+require 'hpricot'
+
+class VoxcastApi::Base < VoxcastApi::Http
+  extend Forwardable
+
+  def_delegators :@entry, :device_id
+  attr_accessor :key, :secret_key
+
+  def initialize(entry = nil)
+    super(entry)
+    if @entry
+      @key = entry.purge_key
+      @secret_key = entry.purge_secret_key
+    end
+  end
+  
+  def lookup_method(key)
+    # this will default to the new 1.0 api, but 0.1 can override it
+    case key.to_s
+    when 'devices'
+      'voxel.devices.list'
+    when 'test'
+      'voxel.test.echo'
+    when 'purge_site'
+      'voxel.voxcast.ondemand.content.purge_site'
+    when 'purge_file'
+      'voxel.voxcast.ondemand.content.purge_file'
+    when 'purge_dir'
+      'voxel.voxcast.ondemand.content.purge_directory'
+    when 'populate'
+      'voxel.voxcast.ondemand.content.populate'
+    when 'status'
+      'voxel.voxcast.ondemand.content.transaction_status'
+    when 'auth_key'
+      'voxel.hapi.authkeys.read'
+    when 'log_list'
+      'voxel.voxcast.ondemand.logs.list'
+    when 'log_download'
+      'voxel.voxcast.ondemand.logs.download'
+    when 'live_log_list'
+      'voxel.voxcast.live.logs.list'
+    when 'live_log_download'
+      'voxel.voxcast.live.logs.download'
+    else
+      nil
+    end
+  end
+
+  def test(params = {})
+    execute_method(:test, params)
+  end
+
+  def populate(paths)
+    params = { 'device_id' => device_id,
+      'paths' => get_urls(paths)
+    }
+    execute(:populate, params)
+  end
+
+  def status(id)
+    execute_method(:status, {'transaction_id'=>id})
+  end
+
+  def devices
+    ret = execute_method(:devices)
+    devices = []
+    devices = ret['devices'] if ret
+  end
+
+  def log_list(params = {})
+    params[:complex_parser] = true
+    ret = execute_method(:log_list, params)
+    # parse the response with complex
+    return [] if ret[:status] != true
+    data = ret[:detail]
+    # get the log files
+    data.search('log_file')
+  end
+
+  def log_download(filename, dst_file)
+    # we just want the raw output, so skip the processing of the response and
+    # use the special params "raw"
+    params = {'filename' => filename, 'convert' => 'raw', :skip_process => true}
+    resp = execute_method(:log_download, params)
+    if resp.code.to_i == 200
+      File.open(dst_file, 'wb') {|f| f.write(resp.body)}
+      true
+    else
+      false
+    end
+  end
+
+  def execute_method(method, params = {})
+    url = nil
+    params['method'] = lookup_method(method)
+    if method.to_s == 'auth_key'
+      # if its auth key, replace http with https
+      url = @url
+      url = url.gsub('http://', 'https://')
+      url = "https://#{url}" if url.index('https://').blank?
+    end
+    execute(url, params)
+  end
+
+  def api_sig(params, secret)
+    sig = secret.to_s
+    p = params.sort {|a, b| a[0].to_s <=> b[0].to_s}
+    p.each {|k, v| sig += k.to_s + v.to_s}
+    Digest::MD5.hexdigest(sig)
+  end
+
+  def auth_key?(params = {})
+    params['method'] == 'voxel.hapi.authkeys.read'
+  end
+
+  def get_basic_auth(params = {})
+    return [@user, @password] if auth_key?(params)
+    super(params)
+  end
+
+  def get_path_and_params(params = {}, url = nil)
+    url = @url if url.blank?
+    uri = URI.parse(url)
+    get_params = {'method' => params['method']}
+    get_path = build_query_string(get_params)
+    path = "#{uri.path}?#{get_path}"
+    # return without params if its an authkey
+    return [path, ''] if auth_key?(params)
+    data = get_data(params)
+    [path, data]
+  end
+
+  def get_data(params = {}, key = nil, secret_key = nil, key_label = 'key')
+    key = @key if key.blank?
+    secret_key = @secret_key if secret_key.blank?
+    @logger.warn('warning, the key or secret key is blank, purging might not work') if key.blank? || secret_key.blank?
+    params = params.merge({'timestamp' => timestamp(),
+                            key_label => key})
+    sig = api_sig(params, secret_key)
+    params['api_sig'] = sig
+    data = build_query_string(params)
+  end
+
+  def get_method(params = {})
+    return :get if auth_key?(params)
+    super(params)
+  end
+
+  def process_response(resp, complex = false)
+    if resp.code.to_i == 200
+      body = resp.body
+      if complex
+        ret = Hpricot.parse(body) rescue {}
+        rsp = ret.find_element('rsp')
+        if rsp
+          stat = rsp.attributes['stat']
+          err = rsp.attributes['err']
+        end
+      else
+        ret = (Hash.from_xml(body) rescue {}) || {}
+        rsp = ret['rsp']
+        if rsp
+          stat = rsp['stat']
+          err = rsp['err']
+        end
+      end
+      return {:status => false, :detail => "return body does not appear valid #{body}"} if rsp.blank?
+      if stat == 'ok'
+        return {:status => true, :detail => rsp}
+      else
+        msg = "error purging content #{err['msg']}, #{err['code']}"
+        return {:status => false, :detail => msg}
+      end
+    else
+      msg = "purge failed with http error #{resp.code}"
+      @logger.warn(msg)
+      return {:status => false, :detail => msg}
+    end
+  end
+end

data/lib/voxcast_api/http.rb

@@ -0,0 +1,75 @@
+class VoxcastApi::Http
+  include UrlMaker
+  attr_accessor :url, :user, :password
+
+  def initialize(entry = nil)
+    @entry = entry
+    if @entry
+      @url = entry.purge_url
+      @user = entry.purge_user
+      @password = entry.purge_password
+      @logger = entry.logger
+    else
+      @logger = ActiveRecord::Base.logger
+    end
+  end
+
+  def timestamp
+    Time.now.iso8601
+  end
+
+  def get_basic_auth(params = {})
+    [nil, nil]
+  end
+
+  def get_path_and_params(params = {})
+    uri = URI.parse(@url)
+    [uri.path, params]
+  end
+
+  def get_http(url = nil)
+    url ||= @url
+    return {:status => false, :detail => 'no purge url specified'} if url.blank?
+    uri = URI.parse(url)
+    if uri.scheme == 'https'
+      port = 443
+      use_ssl = true
+    else
+      port = uri.port
+      use_ssl = false
+    end
+    http = Net::HTTP.new(uri.host, port)
+    http.use_ssl = use_ssl
+    http
+  end
+
+  def get_method(params)
+    :post
+  end
+
+  def execute(url, params = {})
+    ret = get_http(url)
+    return ret if ret.is_a?(Hash)
+    skip_process = params.delete(:skip_process)
+    complex_parser = params.delete(:complex_parser)
+    ret.start do |http|
+      path, data = get_path_and_params(params, url)
+      user, pass = get_basic_auth(params)
+      if !user.blank? && !pass.blank?
+        if get_method(params) == :get
+          req = Net::HTTP::Get.new(path)
+        else
+          req = Net::HTTP::Post.new(path)
+          req.set_form_data(data)
+        end
+        req.basic_auth(user, pass)
+        resp = http.request(req)
+      else
+        data = data.map {|key, val| "#{CGI.escape(key.to_s)}=#{CGI.escape(val.to_s)}"}.join("&") if data.is_a?(Hash)
+        resp = http.post(path, data)
+      end
+      return process_response(resp, complex_parser == true) if skip_process != true
+      resp
+    end
+  end
+end

data/lib/voxcast_api/purge.rb

@@ -0,0 +1,184 @@
+require 'time'
+require 'set'
+
+class VoxcastApi::Purge < VoxcastApi::Base
+  def_delegators :@entry, :filter_files
+
+  def self.get(entry)
+    if entry.purge_url =~ /purge.php/
+      VoxcastApi::Version0.new(entry)
+    elsif entry.purge_url =~ /1\.0/
+      VoxcastApi::Purge.new(entry)
+    else
+      VoxcastApi::Version01.new(entry)
+    end
+  end
+
+  def limit
+    250
+  end
+  
+  def purge(files)
+    # this is a new purge which will use the new api calls to voxel.
+    # this is documented here 
+    # http://api.voxel.net/docs/
+    purge_all = files.detect {|f| f == '/'}
+    if purge_all
+      params = {'device_id' => device_id}
+      ret = execute_method(:purge_site, params)
+      if ret[:status]
+        resp = ret[:detail]
+        return resp['transaction']['id']
+      else
+        return ret
+      end
+    else
+      # take the files and break them up into directories and files
+      files_list, dirs_list = filter_files(files, limit = self.limit)
+      retError = {:status => true, :detail => []}
+      trans_ids = []
+      files_list.each do |f|
+        ret = _purge_files(f, :files)
+        if ret
+          if ret[:status]
+            trans_ids << ret[:detail]
+          else
+            retError[:status] = false
+            retError[:detail] << ret[:detail]
+          end
+        end
+      end
+      dirs_list.each do |d|
+        ret = _purge_files(d, :dirs)
+        if ret
+          if ret[:status]
+            trans_ids << ret[:detail]
+          else
+            retError[:status] = false
+            retError[:detail] << ret[:detail]
+          end
+        end
+      end
+    end
+    return retError if !retError[:status]
+    trans_ids
+  end
+
+  def _purge_files(files, type)
+    return if files.size == 0
+    if type == :files
+      method = :purge_file
+    elsif type == :dirs
+      method = :purge_dir
+    else
+      return {:status => false, :detail => "invalid type #{type}"}
+    end
+    params = { 'device_id' => device_id, 
+      'paths' => get_urls(files)
+    }
+    ret = execute_method(method, params)
+    if ret[:status]
+      resp = ret[:detail]
+      tran_id =  resp['transaction']['id']
+      @logger.info("purged #{files.size} #{type}, tran id #{tran_id}")
+      status = {:status => true, :detail => tran_id}
+    else
+      status = {:status => false, :detail => ret[:detail]}
+    end
+    status
+  end
+  
+  def get_urls(files)
+    paths = Set.new
+    files.each do |f| 
+      f = (f[0] != ?\/ ? '/'+f : f)
+      # remove trailling slashes
+      f = f.chomp('/')
+      paths << f
+    end
+    paths.to_a.join("\n")
+  end
+end
+  
+class VoxcastApi::Version0 < VoxcastApi::Http
+
+  def initialize(entry = nil)
+    super(entry)
+    @http_domain = @entry.http_domain if @entry
+  end
+
+  def get_urls(files)
+    files.join(13.chr+10.chr)
+  end
+
+  def get_path_and_params(params = {}, url = nil)
+    url = @url if url.blank?
+    uri = URI.parse(url)
+    site = "http://#{@http_domain}/"
+    args = {'source' => 'web', 'site' => site, 'submit' => 'Purge'}.merge(params)
+    [uri.path, args]
+  end
+
+  def get_basic_auth(params = {})
+    [ @user, @password ]
+  end
+
+  def process_response(resp, complex = false)
+    if resp.code.to_i == 200
+      return {:status => true, :detail => ''}
+    else
+      return {:status => false, :detail => resp.to_s}
+    end
+  end
+
+  def purge(files)
+    # this will purge the files the old way, since its possible some cdn entries will not work with the new way
+    # specifically the ones that are used by perez
+    return if files.empty?
+    url = @url || 'http://purge.voxcdn.com/purge.php?KEY=2caf5c2eaf'
+    # this will do mass purging
+    begin
+      start = Time.now
+      @logger.info("attempting to purge from site #{@http_domain}")
+      params = {'urls' =>  get_urls(files)}
+      execute(url, params)
+      taken = Time.now - start
+      @logger.info("purged #{files.size} files in #{taken.to_s} seconds")
+    rescue Exception => err
+      puts err.to_s
+      @logger.error("*** Could not purge urls #{url} : #{err.to_s}")
+      {:status => false, :detail => err.to_s}
+    end
+  end
+end
+
+class VoxcastApi::Version01 < VoxcastApi::Purge
+    
+  def lookup_method(key)
+    #override the default
+    case key.to_s
+    when 'purge_site'
+      'voxel.cdn.content.purgeSite'
+    when 'purge_file'
+      'voxel.cdn.content.purge'
+    when 'purge_dir'
+      'voxel.cdn.content.purgeDirectory'
+    when 'populate'
+      'voxel.cdn.content.populate'
+    when 'status'
+      'voxel.cdn.transaction.status'
+    else
+      super(key)
+    end
+  end
+
+  def get_path_and_params(params = {}, url = nil)
+    # override get_path_and_params to do a "dumbed" down version of the params
+    url = @url if url.blank?
+    uri = URI.parse(url)
+    # for version 01, the key/secret key is the user/password
+    data = get_data(params, @user, @password, 'user')
+    [uri.request_uri, data]
+  end
+
+end

data/lib/voxcast_api.rb

@@ -0,0 +1,4 @@
+module VoxcastApi; end
+require 'voxcast_api/http'
+require 'voxcast_api/base'
+require 'voxcast_api/purge'

data/xml/log_list.xml

@@ -0,0 +1,12 @@
+<?xml version="1.0"?>
+<rsp stat="ok">
+<log_files>
+<sites>
+<hostname name="2946.voxcdn.com">
+<log_file start="2009-08-16 01:15:00" end="2009-08-16 01:30:00" size="31232">2946.voxcdn.com.log.1250399700-1250400600.log</log_file>
+<log_file start="2009-09-03 06:30:00" end="2009-09-03 06:45:00" size="42240">2946.voxcdn.com.log.1251973800-1251974700.log</log_file>
+</hostname>
+<hostname name="api.twistage.com">
+<log_file start="2009-08-14 14:00:00" end="2009-08-14 14:15:00" size="16275">api.twistage.com.log.1250272800-1250273700.log</log_file>
+<log_file start="2009-08-15 09:30:00" end="2009-08-15 09:45:00" size="36252">api.twistage.com.log.1250343000-1250343900.log</log_file>
+</hostname></sites></log_files></rsp>

data/xml/log_list2.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<rsp stat="ok">
+<log_files>
+<sites>
+<hostname name="video-svc.kidzbop.com">
+<log_file start="2009-08-16 01:15:00" end="2009-08-16 01:30:00" size="31232">video-svc.kidzbop.com.log.1250399700-1250400600.log</log_file>
+</hostname>
+<hostname name="video-svc-wow.kidz-bop.com">
+<log_file start="2009-09-03 06:30:00" end="2009-09-03 06:45:00" size="42240">video-svc-wow.kidz-bop.com.log.1251973800-1251974700.log</log_file>
+</hostname></sites></log_files></rsp>

data/xml/purge.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0"?>
+<rsp stat="ok"><transaction><type>remove-url</type><id>048c7546-b4f8-42f4-89da-3544cbd13c4c</id><expiration>1260432137</expiration><status>inprogress</status></transaction></rsp>

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: voxcast_api
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Bruce Wang
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-11-02 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Provides a ruby interface for interacting with the VoxCAST service
+email: bwang@twistage.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- xml/log_list2.xml
+- xml/log_list.xml
+- xml/purge.xml
+- lib/voxcast_api.rb
+- lib/voxcast_api/base.rb
+- lib/voxcast_api/http.rb
+- lib/voxcast_api/purge.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/voxcast_api
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: VoxCAST API
+test_files: []
+