maestrano 0.1.0

data/lib/maestrano/api/operation/base.rb

@@ -0,0 +1,216 @@
+module Maestrano
+  module API
+    module Operation
+      module Base
+        # class << self
+        #   attr_accessor :api_key, :api_base, :verify_ssl_certs, :api_version
+        # end
+        
+        def self.api_url(url='')
+          Maestrano.param('api_host') + Maestrano.param('api_base') + url
+        end
+        
+        # Perform remote request
+        def self.request(method, url, api_key, params={}, headers={})
+          unless api_key ||= Maestrano.param('api_key')
+            raise Maestrano::API::Error::AuthenticationError.new('No API key provided.')
+          end
+
+          request_opts = { :verify_ssl => false }
+
+          if self.ssl_preflight_passed?
+            request_opts.update(
+              verify_ssl: OpenSSL::SSL::VERIFY_PEER,
+              ssl_ca_file: Maestrano.param('ssl_bundle_path')
+            )
+          end
+
+          params = Util.objects_to_ids(params)
+          url = api_url(url)
+
+          case method.to_s.downcase.to_sym
+          when :get, :head, :delete
+            # Make params into GET parameters
+            url += "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params && params.any?
+            payload = nil
+          else
+            payload = uri_encode(params)
+          end
+
+          request_opts.update(:headers => request_headers(api_key).update(headers),
+                              :method => method, :open_timeout => 30,
+                              :payload => payload, :url => url, :timeout => 80)
+
+          begin
+            response = execute_request(request_opts)
+          rescue SocketError => e
+            handle_restclient_error(e)
+          rescue NoMethodError => e
+            # Work around RestClient bug
+            if e.message =~ /\WRequestFailed\W/
+              e = APIConnectionError.new('Unexpected HTTP response code')
+              handle_restclient_error(e)
+            else
+              raise
+            end
+          rescue RestClient::ExceptionWithResponse => e
+            if rcode = e.http_code and rbody = e.http_body
+              handle_api_error(rcode, rbody)
+            else
+              handle_restclient_error(e)
+            end
+          rescue RestClient::Exception, Errno::ECONNREFUSED => e
+            handle_restclient_error(e)
+          end
+
+          [parse(response), api_key]
+        end
+
+        private
+
+        def self.ssl_preflight_passed?
+          if !Maestrano.param('verify_ssl_certs')
+            #$stderr.puts "WARNING: Running without SSL cert verification. " +
+            #  "Execute 'Maestrano.configure { |config| config.verify_ssl_certs = true' } to enable verification."
+            return false
+          elsif !Util.file_readable(Maestrano.param('ssl_bundle_path'))
+            $stderr.puts "WARNING: Running without SSL cert verification " +
+              "because #{Maestrano.param('ssl_bundle_path')} isn't readable"
+
+            return false
+          end
+
+          return true
+        end
+
+        def self.user_agent
+          @uname ||= get_uname
+          lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+          {
+            :bindings_version => Maestrano::VERSION,
+            :lang => 'ruby',
+            :lang_version => lang_version,
+            :platform => RUBY_PLATFORM,
+            :publisher => 'maestrano',
+            :uname => @uname
+          }
+
+        end
+
+        def self.get_uname
+          `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+        rescue Errno::ENOMEM => ex # couldn't create subprocess
+          "uname lookup failed"
+        end
+
+        def self.uri_encode(params)
+          Util.flatten_params(params).
+            map { |k,v| "#{k}=#{Util.url_encode(v)}" }.join('&')
+        end
+
+        def self.request_headers(api_key)
+          headers = {
+            :user_agent => "Maestrano/v1 RubyBindings/#{Maestrano::VERSION}",
+            :authorization => "Basic #{Base64.encode64(api_key + ':')}",
+            :content_type => 'application/x-www-form-urlencoded'
+          }
+
+          api_version = Maestrano.param('api_version')
+          headers[:maestrano_version] = api_version if api_version
+
+          begin
+            headers.update(:x_maestrano_client_user_agent => JSON.generate(user_agent))
+          rescue => e
+            headers.update(:x_maestrano_client_raw_user_agent => user_agent.inspect,
+                           :error => "#{e} (#{e.class})")
+          end
+        end
+
+        def self.execute_request(opts)
+          RestClient::Request.execute(opts)
+        end
+
+        def self.parse(response)
+          begin
+            # Would use :symbolize_names => true, but apparently there is
+            # some library out there that makes symbolize_names not work.
+            response = JSON.parse(response.body)
+          rescue JSON::ParserError
+            raise general_api_error(response.code, response.body)
+          end
+
+          response = Util.symbolize_names(response)
+          response[:data]
+        end
+
+        def self.general_api_error(rcode, rbody)
+          Maestrano::API::Error::BaseError.new("Invalid response object from API: #{rbody.inspect} " +
+                       "(HTTP response code was #{rcode})", rcode, rbody)
+        end
+
+        def self.handle_api_error(rcode, rbody)
+          begin
+            error_obj = JSON.parse(rbody)
+            error_obj = Util.symbolize_names(error_obj)
+            errors = error_obj[:errors] or raise Maestrano::API::Error::BaseError.new # escape from parsing
+
+          rescue JSON::ParserError, Maestrano::API::Error::BaseError
+            raise general_api_error(rcode, rbody)
+          end
+
+          case rcode
+          when 400, 404
+            raise invalid_request_error(errors, rcode, rbody, error_obj)
+          when 401
+            raise authentication_error(errors, rcode, rbody, error_obj)
+          else
+            raise api_error(errors, rcode, rbody, error_obj)
+          end
+
+        end
+
+        def self.invalid_request_error(errors, rcode, rbody, error_obj)
+          Maestrano::API::Error::InvalidRequestError.new(errors.first.join(" "), errors.keys.first.to_s, rcode,
+                                  rbody, error_obj)
+        end
+
+        def self.authentication_error(errors, rcode, rbody, error_obj)
+          Maestrano::API::Error::AuthenticationError.new(errors.first.join(" "), rcode, rbody, error_obj)
+        end
+
+        def self.api_error(errors, rcode, rbody, error_obj)
+          Maestrano::API::Error::BaseError.new(errors[:message], rcode, rbody, error_obj)
+        end
+
+        def self.handle_restclient_error(e)
+          case e
+          when RestClient::ServerBrokeConnection, RestClient::RequestTimeout
+            message = "Could not connect to Maestrano. " +
+              "Please check your internet connection and try again. " +
+              "If this problem persists, you should check Maestrano service status at " +
+              "https://twitter.com/maestrano, or let us know at support@maestrano.com."
+
+          when RestClient::SSLCertificateNotVerified
+            message = "Could not verify Maestrano's SSL certificate. " +
+              "Please make sure that your network is not intercepting certificates. " +
+              "(Try going to https://maestrano.com/api/v1/ping in your browser.) " +
+              "If this problem persists, let us know at support@maestrano.com."
+
+          when SocketError
+            message = "Unexpected error communicating when trying to connect to Maestrano. " +
+              "You may be seeing this message because your DNS is not working. " +
+              "To check, try running 'host maestrano.com' from the command line."
+
+          else
+            message = "Unexpected error communicating with Maestrano. " +
+              "If this problem persists, let us know at support@maestrano.com."
+
+          end
+
+          raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+        end
+      end
+    end
+  end
+end

data/lib/maestrano/api/operation/create.rb

@@ -0,0 +1,18 @@
+module Maestrano
+  module API
+    module Operation
+      module Create
+        module ClassMethods
+          def create(params={}, api_key=nil)
+            response, api_key = Maestrano::API::Operation::Base.request(:post, self.url, api_key, params)
+            Util.convert_to_maestrano_object(response, api_key)
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end

data/lib/maestrano/api/operation/delete.rb

@@ -0,0 +1,13 @@
+module Maestrano
+  module API
+    module Operation
+      module Delete
+        def delete(params = {})
+          response, api_key = Maestrano::API::Operation::Base.request(:delete, url, @api_key, params)
+          refresh_from(response, api_key)
+          self
+        end
+      end
+    end
+  end
+end

data/lib/maestrano/api/operation/list.rb

@@ -0,0 +1,18 @@
+module Maestrano
+  module API
+    module Operation
+      module List
+        module ClassMethods
+          def all(filters={}, api_key=nil)
+            response, api_key = Maestrano::API::Operation::Base.request(:get, url, api_key, filters)
+            Util.convert_to_maestrano_object(response, api_key)
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end

data/lib/maestrano/api/operation/update.rb

@@ -0,0 +1,59 @@
+module Maestrano
+  module API
+    module Operation
+      module Update
+        def save(opts={})
+          values = serialize_params(self).merge(opts)
+
+          if @values[:metadata]
+            values[:metadata] = serialize_metadata
+          end
+
+          if values.length > 0
+            values.delete(:id)
+
+            response, api_key = Maestrano::API::Operation::Base.request(:put, url, @api_key, values)
+            refresh_from(response, api_key)
+          end
+          self
+        end
+
+        def serialize_metadata
+          if @unsaved_values.include?(:metadata)
+            # the metadata object has been reassigned
+            # i.e. as object.metadata = {key => val}
+            metadata_update = @values[:metadata]  # new hash
+            new_keys = metadata_update.keys.map(&:to_sym)
+            # remove keys at the server, but not known locally
+            keys_to_unset = @previous_metadata.keys - new_keys
+            keys_to_unset.each {|key| metadata_update[key] = ''}
+
+            metadata_update
+          else
+            # metadata is a Maestrano::API::Object, and can be serialized normally
+            serialize_params(@values[:metadata])
+          end
+        end
+
+        def serialize_params(obj)
+          case obj
+          when nil
+            ''
+          when Maestrano::API::Object
+            unsaved_keys = obj.instance_variable_get(:@unsaved_values)
+            obj_values = obj.instance_variable_get(:@values)
+            update_hash = {}
+
+            unsaved_keys.each do |k|
+              update_hash[k] = serialize_params(obj_values[k])
+            end
+
+            update_hash
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maestrano/api/resource.rb

@@ -0,0 +1,39 @@
+module Maestrano
+  module API
+    class Resource < Maestrano::API::Object
+      def self.class_name
+        self.name.split('::').reject { |w| w.to_s == "Maestrano" }
+      end
+
+      def self.url
+        if self == Maestrano::API::Resource
+          raise NotImplementedError.new('Maestrano::API::Resource is an abstract class.  You should perform actions on its subclasses (Bill, Customer, etc.)')
+        end
+        if class_name.is_a?(Array)
+          class_name.map { |w| CGI.escape(w.downcase) }.join("/") + 's'
+        else
+          "#{CGI.escape(class_name.downcase)}s"
+        end
+      end
+
+      def url
+        unless id = self['id']
+          raise Maestrano::API::Error::InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
+        end
+        "#{self.class.url}/#{CGI.escape(id)}"
+      end
+
+      def refresh
+        response, api_key = Maestrano::API::Operation::Base.request(:get, url, @api_key, @retrieve_options)
+        refresh_from(response, api_key)
+        self
+      end
+
+      def self.retrieve(id, api_key=nil)
+        instance = self.new(id, api_key)
+        instance.refresh
+        instance
+      end
+    end
+  end
+end

data/lib/maestrano/api/util.rb

@@ -0,0 +1,121 @@
+module Maestrano
+  module API
+    module Util
+      def self.objects_to_ids(h)
+        case h
+        when Maestrano::API::Resource
+          h.id
+        when Hash
+          res = {}
+          h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+          res
+        when Array
+          h.map { |v| objects_to_ids(v) }
+        when Time
+          h.iso8601
+        else
+          h
+        end
+      end
+
+      def self.object_classes
+        @object_classes ||= {
+          'account_bill' => Maestrano::Account::Bill,
+          'internal_list_object' => Maestrano::API::ListObject
+        }
+      end
+
+      def self.convert_to_maestrano_object(resp, api_key)
+        case resp
+        when Array
+          if resp.empty? || !resp.first[:object]
+            resp
+          else
+            list = convert_to_maestrano_object({
+              object: 'internal_list_object', 
+              data:[],
+              url: convert_to_maestrano_object(resp.first, api_key).class.url
+            },api_key)
+            
+            resp.each do |i|
+              list.data.push(convert_to_maestrano_object(i, api_key))
+            end
+            list
+          end
+        when Hash
+          # Try converting to a known object class.  If none available, fall back to generic Maestrano::API::Object
+          object_classes.fetch(resp[:object], Maestrano::API::Object).construct_from(resp, api_key)
+        else
+          # Automatically parse iso8601 dates
+          if resp =~ /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/
+            Time.iso8601(resp).utc
+          else
+            resp
+          end
+        end
+      end
+
+      def self.file_readable(file)
+        # This is nominally equivalent to File.readable?, but that can
+        # report incorrect results on some more oddball filesystems
+        # (such as AFS)
+        begin
+          File.open(file) { |f| }
+        rescue
+          false
+        else
+          true
+        end
+      end
+
+      def self.symbolize_names(object)
+        case object
+        when Hash
+          new = {}
+          object.each do |key, value|
+            key = (key.to_sym rescue key) || key
+            new[key] = symbolize_names(value)
+          end
+          new
+        when Array
+          object.map { |value| symbolize_names(value) }
+        else
+          object
+        end
+      end
+
+      def self.url_encode(key)
+        URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+      end
+
+      def self.flatten_params(params, parent_key=nil)
+        result = []
+        params.each do |key, value|
+          calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+          if value.is_a?(Hash)
+            result += flatten_params(value, calculated_key)
+          elsif value.is_a?(Array)
+            result += flatten_params_array(value, calculated_key)
+          else
+            result << [calculated_key, value]
+          end
+        end
+        result
+      end
+
+      def self.flatten_params_array(value, calculated_key)
+        result = []
+        value.each do |elem|
+          if elem.is_a?(Hash)
+            result += flatten_params(elem, calculated_key)
+          elsif elem.is_a?(Array)
+            result += flatten_params_array(elem, calculated_key)
+          else
+            result << ["#{calculated_key}[]", elem]
+          end
+        end
+        result
+      end
+    end
+  end
+end