telestream_cloud 1.0.0

data/lib/telestream_cloud/api_authentication.rb

@@ -0,0 +1,66 @@
+require 'rubygems'
+require 'cgi'
+require 'time'
+require 'hmac'
+require 'hmac-sha2'
+require 'base64'
+
+module TelestreamCloud
+  class ApiAuthentication
+    def self.generate_signature(verb, request_uri, host, secret_key, params_given={})
+      # Ensure all param keys are strings
+      params = {}; params_given.each {|k,v| params[k.to_s] = v }
+
+      query_string = canonical_querystring(params)
+
+      string_to_sign = verb.to_s.upcase + "\n" + 
+          host.downcase + "\n" +
+          request_uri + "\n" +
+          query_string
+
+      hmac = HMAC::SHA256.new( secret_key )
+      hmac.update( string_to_sign )
+      # chomp is important!  the base64 encoded version will have a newline at the end
+      Base64.encode64(hmac.digest).chomp
+    end
+
+    private
+
+    # param keys should be strings, not symbols please. return a string joined
+    # by & in canonical order. 
+    def self.canonical_querystring(h)
+      _recursion(h).join('&')
+    end
+    # Turns a hash into a query string, returns the query string.
+    # url-encodes everything to Amazon's specifications. 
+    def self.hash_to_query(hash)
+      hash.collect{|key, value| url_encode(key) + "=" + url_encode(value) }.join("&")
+    end
+
+    # It's kinda like CGI.escape, except CGI.escape is encoding a tilde when
+    # it ought not to be, so we turn it back. Also space NEEDS to be %20 not +.
+    def self.url_encode(string)
+      CGI.escape(string.to_s).gsub("%7E", "~").gsub("+", "%20")
+    end
+
+    def self._recursion(h, base = nil)
+      pairs = []
+      h.keys.sort.each do |key|
+        value = h[key]
+        if value.kind_of? Hash
+          pairs += _recursion(value, key)
+        else
+          new_pair = nil
+          if base
+            new_pair = "#{base}[#{url_encode(key)}]=#{url_encode(value)}"
+          else
+            new_pair = "#{url_encode(key)}=#{url_encode(value)}"
+          end
+          pairs << new_pair
+        end
+      end
+      pairs
+    end
+
+  end
+end

data/lib/telestream_cloud/base.rb

@@ -0,0 +1,111 @@
+require 'forwardable'
+
+module TelestreamCloud
+  class Base
+    attr_accessor :attributes, :errors
+    extend Forwardable
+    
+    include TelestreamCloud::Router
+    include TelestreamCloud::Builders
+    include TelestreamCloud::Finders
+
+    def initialize(attributes = {})
+      clear_attributes
+      load(attributes)
+    end
+
+    class << self
+      def sti_name
+        "#{name.split('::').last}"
+      end
+    end
+
+    def changed?
+      !@changed_attributes.empty?
+    end
+
+    def new?
+      id.nil?
+    end
+
+    def id
+      attributes['id']
+    end
+
+    def id=(id)
+      attributes['id'] = id
+    end
+
+    def reload
+      perform_reload
+      self
+    end
+
+    def inspect
+      attributes_as_nice_string = self.attributes.map {|k,v| "#{k}: #{v.inspect}"}.compact.join(", ")
+      "#<#{self.class} #{attributes_as_nice_string}>"
+    end
+
+    def to_json(*args)
+      MultiJson.encode(self.attributes)
+    end
+
+    private
+
+    def load_and_reset(response)
+      load_response(response)
+    end
+
+    def perform_reload(args={})
+      raise "RecordNotFound" if new?
+
+      url = self.class.create_rest_url(self.class.one_path, :id => id)
+      response = connection.get(url)
+      load_response(response.merge(args))
+    end
+
+    def clear_attributes
+      @attributes = {}
+      @changed_attributes = {}
+      @errors = []
+    end
+
+    def load(attributes)
+      not_a_response = !(attributes['id'] || attributes[:id])
+      attributes.each do |key, value|
+        @attributes[key.to_s] = value
+        @changed_attributes[key.to_s] = value if not_a_response
+      end
+      true
+    end
+
+    def load_response(response)
+      if response['error'] || response['id'].nil?
+        @errors << APIError.new(response)
+        @loaded = false
+      else
+        clear_attributes
+        load(response)
+        @changed_attributes = {};
+        @loaded = true
+      end
+    end
+
+    def method_missing(method_symbol, *arguments)
+      method_name = method_symbol.to_s
+      if method_name =~ /(=|\?)$/
+        case $1
+        when '='
+          attributes[$`] = arguments.first
+          @changed_attributes[$`] = arguments.first
+        when '?'
+          !! attributes[$`]
+        end
+      else
+        return attributes[method_name] if attributes.include?(method_name)
+        super
+      end
+    end
+
+  end
+end

data/lib/telestream_cloud/config.rb

@@ -0,0 +1,87 @@
+require 'uri'
+
+module TelestreamCloud
+  class Config
+
+    def self.from_panda_url(panda_url)
+      panda_uri = URI.parse(panda_url)
+
+      config = new
+      config.access_key = panda_uri.user
+      config.secret_key = panda_uri.password
+      config.factory_id   = panda_uri.path[1..-1]
+      config.api_host   = panda_uri.host
+      config.api_port   = panda_uri.port
+      config
+    end
+
+    def self.from_hash(auth_params)
+      config = new
+      auth_params.each_key do |key|
+        config.send("#{key}=", auth_params[key])
+      end
+      config
+    end
+
+    def config
+      @config ||= {}
+    end
+    
+    [:api_host, :api_port, 
+     :access_key, :secret_key, 
+     :api_version, :factory_id].each do |attr|
+      define_method "#{attr}" do |value|
+        config["#{attr.to_s}"] = value
+      end
+
+      define_method "#{attr}=" do |value|
+        config["#{attr.to_s}"] = value
+      end
+    end
+    
+    def to_hash
+      config
+    end
+    
+    def adapter(adapter_name)
+      TelestreamCloud.adapter = adapter_name
+    end
+    
+    def adapter=(adapter_name)
+      TelestreamCloud.adapter = adapter_name
+    end
+    
+    # Set the correct api_host for US/EU
+    def region(region)
+      if(region.to_s == 'us')
+        config['api_host'] = US_API_HOST
+      elsif(region.to_s == 'eu')
+        config['api_host'] = EU_API_HOST
+      else
+        raise "Region Unknown"
+      end
+    end
+
+    def validate!
+      errs = validation_errors
+      raise TelestreamCloud::ConfigurationError, errs.join(', ') if errs.any?
+      true
+    end
+
+    def valid?
+      validation_errors.empty?
+    end
+
+    def validation_errors
+      err = []
+      if config["access_key"].to_s.empty?
+        err << "access_key is missing"
+      end
+      if config["secret_key"].to_s.empty?
+        err << "secret_key is missing"
+      end
+      err
+    end
+
+  end
+end

data/lib/telestream_cloud/connection.rb

@@ -0,0 +1,101 @@
+module TelestreamCloud
+
+  API_PORT = 443
+  US_API_HOST = "api.pandastream.com"
+  EU_API_HOST = "api-eu.pandastream.com"
+  GCE_API_HOST = "api-gce.pandastream.com"
+
+  class Connection
+    attr_accessor :api_host, :api_port, :access_key, :secret_key, :api_version, :factory_id
+
+    def initialize(auth_params={})
+      params = { :api_host => US_API_HOST, :api_port => API_PORT }.merge!(auth_params)
+      @api_version = '3.0'
+
+      @factory_id = params["factory_id"]  || params[:factory_id]
+      @access_key = params["access_key"]  || params[:access_key]
+      @secret_key = params["secret_key"]  || params[:secret_key]
+      @api_host   = params["api_host"]    || params[:api_host]
+      @api_port   = params["api_port"]    || params[:api_port]
+      @prefix     = params["prefix_url"]  || "v#{api_version}"
+    end
+
+    def http_client
+      TelestreamCloud::HttpClient::Faraday.new(api_url)
+    end
+
+    # Authenticated requests
+    def get(request_uri, params={})
+      sp = signed_params("GET", request_uri, params)
+      http_client.get(request_uri, sp)
+    end
+
+    def post(request_uri, params={})
+      sp = signed_params("POST", request_uri, params)
+      http_client.post(request_uri, sp)
+    end
+
+    def put(request_uri, params={})
+      sp = signed_params("PUT", request_uri, params)
+      http_client.put(request_uri, sp)
+    end
+
+    def delete(request_uri, params={})
+      sp = signed_params("DELETE", request_uri, params)
+      http_client.delete(request_uri, sp)
+    end
+
+    # Signing methods
+    def signed_query(*args)
+      ApiAuthentication.hash_to_query(signed_params(*args))
+    end
+
+    def signed_params(verb, request_uri, params = {}, timestamp_str = nil)
+      auth_params = stringify_keys(params)
+      auth_params['factory_id'] = factory_id unless request_uri =~ /^\/factories/
+      auth_params['access_key'] = access_key
+      auth_params['timestamp']  = timestamp_str || Time.now.utc.iso8601(6)
+
+      params_to_sign = auth_params.reject{|k,v| ['file'].include?(k.to_s)}
+      auth_params['signature']  = ApiAuthentication.generate_signature(verb, request_uri, api_host, secret_key, params_to_sign)
+      auth_params
+    end
+
+    def api_url
+      "#{api_scheme}://#{api_host}:#{api_port}/#{@prefix}"
+    end
+
+    def api_scheme
+      api_port.to_i == 443 ? 'https' : 'http'
+    end
+
+    # Shortcut to setup your bucket
+    def setup_bucket(params={})
+      granting_params = {
+        :s3_videos_bucket => params[:bucket],
+        :aws_access_key => params[:access_key],
+        :aws_secret_key => params[:secret_key]
+      }
+
+      put("/factories/#{@factory_id}.json", granting_params)
+    end
+
+    def to_hash
+      hash = {}
+      [:api_host, :api_port, :access_key, :secret_key, :api_version, :factory_id].each do |a|
+        hash[a] = send(a)
+      end
+      hash
+    end
+
+    private
+
+    def stringify_keys(params)
+      params.inject({}) do |options, (key, value)|
+        options[key.to_s] = value
+        options
+      end
+    end
+
+  end
+end

data/lib/telestream_cloud/errors.rb

@@ -0,0 +1,17 @@
+module TelestreamCloud
+  
+  class Error < StandardError; end
+  
+  class APIError < TelestreamCloud::Error
+    def initialize(options)
+      super("#{options['error']}: #{options['message']}")
+    end
+  end
+
+  class ServiceNotAvailable < TelestreamCloud::Error
+  end
+
+  class ConfigurationError < TelestreamCloud::Error
+  end
+
+end

data/lib/telestream_cloud/faraday.rb

@@ -0,0 +1,84 @@
+require 'faraday'
+require 'multi_json'
+
+
+module TelestreamCloud
+  module HttpClient
+    class Faraday
+      
+      def initialize(api_url)
+        @api_url = api_url
+      end
+      
+      def get(request_uri, params)
+        rescue_json_parsing do
+          connection.get do |req|
+            req.url File.join(connection.path_prefix, request_uri), params
+          end.body
+        end
+      end
+
+      def post(request_uri, params)
+        # multipart upload
+        params['file'] = ::Faraday::UploadIO.new(params['file'], 'multipart/form-data') if params['file']
+
+        rescue_json_parsing do
+          connection.post do |req|
+            req.url File.join(connection.path_prefix, request_uri)
+            req.body = params
+          end.body
+        end
+      end
+
+      def put(request_uri, params)
+        rescue_json_parsing do
+          connection.put do |req|
+            req.url File.join(connection.path_prefix, request_uri)
+            req.body = params
+          end.body
+        end
+      end
+
+      def delete(request_uri, params)
+        rescue_json_parsing do
+          connection.delete do |req|
+            req.url File.join(connection.path_prefix, request_uri), params
+          end.body
+        end
+      end
+      
+      private
+      
+      def connection
+        @conn ||= ::Faraday.new(:url => @api_url) do |builder|
+          builder.request :multipart
+          builder.request :url_encoded
+          builder.adapter TelestreamCloud.default_adapter
+        end
+      end
+
+      def rescue_json_parsing(&block)
+        begin
+          data = yield
+          MultiJson.load(data) if data and data != ""
+        rescue MultiJson::DecodeError
+          raise ServiceNotAvailable, data
+        end
+      end
+      
+    end
+  end
+end
+
+if defined?(Typhoeus)
+  TelestreamCloud.default_adapter = :typhoeus
+elsif defined?(Excon)
+  TelestreamCloud.default_adapter = :excon
+elsif defined?(Patron)
+  TelestreamCloud.default_adapter = :patron
+elsif defined?(NetHttpPersistent)
+  TelestreamCloud.default_adapter = :net_http_persisten
+else
+  TelestreamCloud.default_adapter = :net_http
+end
+