telestream_cloud 1.1.0 → 2.0.0.1

data/Gemfile

@@ -1,2 +0,0 @@
-source "http://rubygems.org"
-gemspec

data/lib/telestream_cloud/api_authentication.rb

@@ -1,66 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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
-