maestrano-ruby-test 0.8.3

data/lib/maestrano/api/object.rb

@@ -0,0 +1,187 @@
+module Maestrano
+  module API
+    class Object
+      include Enumerable
+
+      attr_accessor :api_token
+      @@permanent_attributes = Set.new([:api_token, :id])
+
+      # The default :id method is deprecated and isn't useful to us
+      if method_defined?(:id)
+        undef :id
+      end
+
+      def initialize(id=nil, api_token=nil)
+        # parameter overloading!
+        if id.kind_of?(Hash)
+          @retrieve_options = id.dup
+          @retrieve_options.delete(:id)
+          id = id[:id]
+        else
+          @retrieve_options = {}
+        end
+
+        @api_token = api_token
+        @values = {}
+        # This really belongs in API::Resource, but not putting it there allows us
+        # to have a unified inspect method
+        @unsaved_values = Set.new
+        @transient_values = Set.new
+        @values[:id] = id if id
+      end
+
+      def self.construct_from(values, api_token=nil)
+        obj = self.new(values[:id], api_token)
+        obj.refresh_from(values, api_token)
+        obj
+      end
+
+      def to_s(*args)
+        JSON.pretty_generate(@values)
+      end
+
+      def inspect()
+        id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+        "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + JSON.pretty_generate(@values)
+      end
+
+      def refresh_from(values, api_token, partial=false)
+        @api_token = api_token
+
+        @previous_metadata = values[:metadata]
+        removed = partial ? Set.new : Set.new(@values.keys - values.keys)
+        added = Set.new(values.keys - @values.keys)
+        # Wipe old state before setting new.
+
+        instance_eval do
+          remove_accessors(removed)
+          add_accessors(added)
+        end
+        removed.each do |k|
+          @values.delete(k)
+          @transient_values.add(k)
+          @unsaved_values.delete(k)
+        end
+        values.each do |k, v|
+          @values[k] = Util.convert_to_maestrano_object(v, api_token)
+          @transient_values.delete(k)
+          @unsaved_values.delete(k)
+        end
+      end
+
+      def [](k)
+        @values[k.to_sym]
+      end
+
+      def []=(k, v)
+        send(:"#{k}=", v)
+      end
+
+      def keys
+        @values.keys
+      end
+
+      def values
+        @values.values
+      end
+
+      def to_json(*a)
+        JSON.generate(@values)
+      end
+
+      def as_json(*a)
+        @values.as_json(*a)
+      end
+
+      def to_hash
+        @values
+      end
+
+      def each(&blk)
+        @values.each(&blk)
+      end
+
+      def _dump(level)
+        Marshal.dump([@values, @api_token])
+      end
+
+      def self._load(args)
+        values, api_token = Marshal.load(args)
+        construct_from(values, api_token)
+      end
+
+      if RUBY_VERSION < '1.9.2'
+        def respond_to?(symbol)
+          @values.has_key?(symbol) || super
+        end
+      end
+
+      protected
+
+      def metaclass
+        class << self; self; end
+      end
+
+      def remove_accessors(keys)
+        metaclass.instance_eval do
+          keys.each do |k|
+            next if @@permanent_attributes.include?(k)
+            k_eq = :"#{k}="
+            remove_method(k) if method_defined?(k)
+            remove_method(k_eq) if method_defined?(k_eq)
+          end
+        end
+      end
+
+      def add_accessors(keys)
+        metaclass.instance_eval do
+          keys.each do |k|
+            next if @@permanent_attributes.include?(k)
+            k_eq = :"#{k}="
+            define_method(k) { @values[k] }
+            define_method(k_eq) do |v|
+              if v == ""
+                raise ArgumentError.new(
+                  "You cannot set #{k} to an empty string." +
+                  "We interpret empty strings as nil in requests." +
+                  "You may set #{self}.#{k} = nil to delete the property.")
+              end
+              @values[k] = v
+              @unsaved_values.add(k)
+            end
+          end
+        end
+      end
+
+      def method_missing(name, *args)
+        # TODO: only allow setting in updateable classes.
+        if name.to_s.end_with?('=')
+          attr = name.to_s[0...-1].to_sym
+          add_accessors([attr])
+          begin
+            mth = method(name)
+          rescue NameError
+            raise NoMethodError.new("Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}")
+          end
+          return mth.call(args[0])
+        else
+          return @values[name] if @values.has_key?(name)
+        end
+
+        begin
+          super
+        rescue NoMethodError => e
+          if @transient_values.include?(name)
+            raise NoMethodError.new(e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Maestrano's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}")
+          else
+            raise
+          end
+        end
+      end
+
+      def respond_to_missing?(symbol, include_private = false)
+        @values.has_key?(symbol) || super
+      end
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+module Maestrano
+  module API
+    module Operation
+      module Base
+        # class << self
+        #   attr_accessor :api_token, :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_token, params={}, headers={})
+          unless api_token ||= Maestrano.param('api_token')
+            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_token).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_token]
+        end
+
+        private
+
+        def self.ssl_preflight_passed?
+          if !Maestrano.param('api.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
+
+          {
+            :bindings_version => Maestrano.param('api.version'),
+            :lang => Maestrano.param('api.lang'),
+            :lang_version => Maestrano.param('api.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_token)
+          headers = {
+            :user_agent => "Maestrano/v1 RubyBindings/#{Maestrano.param('api.version')}",
+            :authorization => "Basic #{Base64.encode64(api_token)}",
+            :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_token=nil)
+            response, api_token = Maestrano::API::Operation::Base.request(:post, self.url, api_token, params)
+            Util.convert_to_maestrano_object(response, api_token)
+          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_token = Maestrano::API::Operation::Base.request(:delete, url, @api_token, params)
+          refresh_from(response, api_token)
+          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_token=nil)
+            response, api_token = Maestrano::API::Operation::Base.request(:get, url, api_token, filters)
+            Util.convert_to_maestrano_object(response, api_token)
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+      end
+    end
+  end
+end