engineyard-cloud-client 0.1.2

data/LICENSE

@@ -0,0 +1,19 @@
+ Copyright (c) 2010 Engine Yard, Inc
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= engineyard-cloud-client
+
+The API client for awsm. Extracted from the engineyard gem because this piece is often all a project needs for EY Cloud API usage.
+
+See engineyard gem for a usage example. Bother someone if this is released and the documentation is still not updated.
+
+This is currently unreleased.

data/lib/engineyard-cloud-client.rb

@@ -0,0 +1,149 @@
+module EY
+  class CloudClient
+  end
+end
+
+require 'engineyard-cloud-client/ruby_ext'
+require 'engineyard-cloud-client/model_registry'
+require 'engineyard-cloud-client/models'
+require 'engineyard-cloud-client/rest_client_ext'
+require 'engineyard-cloud-client/resolver_result'
+require 'engineyard-cloud-client/version'
+require 'engineyard-cloud-client/errors'
+require 'multi_json'
+require 'pp'
+
+module EY
+  class CloudClient
+    attr_reader :token, :registry
+    attr_accessor :ui
+
+    USER_AGENT_STRING = "EngineYardCloudClient/#{EY::CloudClient::VERSION}"
+
+    def self.endpoint
+      @endpoint
+    end
+
+    def self.endpoint=(endpoint)
+      @endpoint = URI.parse(endpoint)
+      unless @endpoint.absolute?
+        raise BadEndpointError.new(endpoint)
+      end
+      @endpoint
+    end
+
+    def self.default_endpoint!
+      self.endpoint = "https://cloud.engineyard.com/"
+    end
+    default_endpoint!
+
+    def initialize(token, ui)
+      self.token = token
+      self.ui = ui
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && other.token == token
+    end
+
+    def registry
+      @registry ||= ModelRegistry.new
+    end
+
+    def token=(new_token)
+      unless new_token
+        raise ArgumentError, "EY Cloud API token required"
+      end
+      @token = new_token
+    end
+
+    def request(url, opts={})
+      opts[:headers] ||= {}
+      opts[:headers]["X-EY-Cloud-Token"] = token
+      ui.debug("Token", token)
+      self.class.request(url, ui, opts)
+    end
+
+    def resolve_environments(constraints)
+      EY::CloudClient::Environment.resolve(self, constraints)
+    end
+
+    def resolve_app_environments(constraints)
+      EY::CloudClient::AppEnvironment.resolve(self, constraints)
+    end
+
+    def environments
+      @environments ||= EY::CloudClient::Environment.all(self)
+    end
+
+    def apps
+      @apps ||= EY::CloudClient::App.all(self)
+    end
+
+    # TODO: unhaxor
+    # This should load an api endpoint that deals directly in app_deployments
+    def app_environments
+      @app_environments ||= apps.map { |app| app.app_environments }.flatten
+    end
+
+    def current_user
+      EY::CloudClient::User.from_hash(self, request('/current_user')['user'])
+    end
+
+    def self.request(path, ui, opts={})
+      url = self.endpoint + "api/v2#{path}"
+      method = (opts.delete(:method) || 'get').to_s.downcase.to_sym
+      params = opts.delete(:params) || {}
+      headers = opts.delete(:headers) || {}
+      headers["Accept"] ||= "application/json"
+      headers["User-Agent"] = USER_AGENT_STRING
+
+      begin
+        ui.debug("Request", "#{method.to_s.upcase} #{url}")
+        ui.debug("Params", params.inspect)
+        case method
+        when :get, :delete, :head
+          unless params.empty?
+            url.query = RestClient::Payload::UrlEncoded.new(params).to_s
+          end
+          resp = RestClient.send(method, url.to_s, headers)
+        else
+          resp = RestClient.send(method, url.to_s, params, headers)
+        end
+      rescue RestClient::Unauthorized
+        raise InvalidCredentials
+      rescue Errno::ECONNREFUSED
+        raise RequestFailed, "Could not reach the cloud API"
+      rescue RestClient::ResourceNotFound
+        raise ResourceNotFound, "The requested resource could not be found"
+      rescue RestClient::BadGateway
+        raise RequestFailed, "EY Cloud API is temporarily unavailable. Please try again soon."
+      rescue RestClient::RequestFailed => e
+        raise RequestFailed, "#{e.message} #{e.response}"
+      rescue OpenSSL::SSL::SSLError
+        raise RequestFailed, "SSL is misconfigured on your cloud"
+      end
+
+      if resp.body.empty?
+        data = ''
+      elsif resp.headers[:content_type] =~ /application\/json/
+        begin
+          data = MultiJson.decode(resp.body)
+          ui.debug("Response", "\n" + data.pretty_inspect)
+        rescue MultiJson::DecodeError
+          ui.debug("Raw response", resp.body)
+          raise RequestFailed, "Response was not valid JSON."
+        end
+      else
+        data = resp.body
+      end
+
+      data
+    end
+
+    def self.authenticate(email, password, ui)
+      request("/authenticate", ui, { :method => "post", :params => { :email => email, :password => password }})["api_token"]
+    end
+
+  end # API
+end # EY

data/lib/engineyard-cloud-client/errors.rb

@@ -0,0 +1,38 @@
+module EY
+  class CloudClient
+    class Error < RuntimeError
+    end
+
+    class RequestFailed      < Error; end
+    class InvalidCredentials < RequestFailed; end
+    class ResourceNotFound   < RequestFailed; end
+
+    class BadEndpointError < Error
+      def initialize(endpoint)
+        super "#{endpoint.inspect} is not a valid endpoint URI. Endpoint must be an absolute URI."
+      end
+    end
+
+    class AttributeRequiredError < Error
+      def initialize(attribute_name, klass = nil)
+        if klass
+          super "Attribute '#{attribute_name}' of class #{klass} is required for this action."
+        else
+          super "Attribute '#{attribute_name}' is required for this action."
+        end
+      end
+    end
+
+    class NoBridgeError < Error
+      def initialize(env_name)
+        super "The environment '#{env_name}' does not have a master instance."
+      end
+    end
+
+    class BadBridgeStatusError < Error
+      def initialize(bridge_status, endpoint)
+        super %|Application master's status is not "running" (green); it is "#{bridge_status}". Go to #{endpoint} to address this problem.|
+      end
+    end
+  end
+end

data/lib/engineyard-cloud-client/model_registry.rb

@@ -0,0 +1,21 @@
+module EY
+  class CloudClient
+    class ModelRegistry
+      def initialize
+        @registry = Hash.new { |h,k| h[k] = {} }
+      end
+
+      def find(klass, id)
+        if id
+          @registry[klass][id]
+        end
+      end
+
+      def set(klass, obj)
+        if obj.respond_to?(:id) && id = obj.id
+          @registry[klass][id] = obj
+        end
+      end
+    end
+  end
+end

data/lib/engineyard-cloud-client/models.rb

@@ -0,0 +1,14 @@
+module EY
+  class CloudClient
+    require 'engineyard-cloud-client/models/api_struct'
+    require 'engineyard-cloud-client/models/account'
+    require 'engineyard-cloud-client/models/app'
+    require 'engineyard-cloud-client/models/app_environment'
+    require 'engineyard-cloud-client/models/deployment'
+    require 'engineyard-cloud-client/models/environment'
+    require 'engineyard-cloud-client/models/log'
+    require 'engineyard-cloud-client/models/instance'
+    require 'engineyard-cloud-client/models/keypair'
+    require 'engineyard-cloud-client/models/user'
+  end
+end

data/lib/engineyard-cloud-client/models/account.rb

@@ -0,0 +1,38 @@
+require 'engineyard-cloud-client/models/api_struct'
+
+module EY
+  class CloudClient
+    class Account < ApiStruct.new(:id, :name)
+
+      def self.all(api)
+        self.from_array(api, api.request('/accounts')["accounts"])
+      end
+
+      def add_app(app)
+        @apps ||= []
+        existing_app = @apps.detect { |a| app.id == a.id }
+        unless existing_app
+          @apps << app
+        end
+        existing_app || app
+      end
+
+      def apps
+        @apps ||= []
+      end
+
+      def add_environment(environment)
+        @environments ||= []
+        existing_environment = @environments.detect { |env| environment.id == env.id }
+        unless existing_environment
+          @environments << environment
+        end
+        existing_environment || environment
+      end
+
+      def environments
+        @environments ||= []
+      end
+    end
+  end
+end

data/lib/engineyard-cloud-client/models/api_struct.rb

@@ -0,0 +1,50 @@
+module EY
+  class CloudClient
+    class ApiStruct < Struct
+      def self.new(*args, &block)
+        args = [:api] | args
+        super(*args) do |*block_args|
+          block.call(*block_args) if block
+
+          def self.from_array(api, array, common_values = {})
+            if array
+              array.map do |values|
+                from_hash(api, values.merge(common_values))
+              end
+            end
+          end
+
+          def self.from_hash(api, attrs_or_struct)
+            return nil unless attrs_or_struct
+
+            if attrs_or_struct.respond_to?(:attributes=)
+              # already a model
+              obj = attrs_or_struct
+            elsif obj = api.registry.find(self, attrs_or_struct['id'])
+              obj.attributes = attrs_or_struct
+            else
+              obj = new(api, attrs_or_struct)
+              api.registry.set(self, obj)
+            end
+            obj
+          end
+        end
+      end
+
+      def initialize(api, attrs)
+        self.api = api
+        self.attributes = attrs
+      end
+
+      def attributes=(attrs)
+        attrs.each do |key, val|
+          setter = :"#{key}="
+          if respond_to?(setter)
+            send(setter, val)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/engineyard-cloud-client/models/app.rb

@@ -0,0 +1,77 @@
+require 'engineyard-cloud-client/errors'
+require 'engineyard-cloud-client/models'
+
+module EY
+  class CloudClient
+    class App < ApiStruct.new(:id, :name, :repository_uri, :app_type_id)
+
+      attr_reader :app_environments, :account
+
+      # Return list of all Apps linked to all current user's accounts
+      def self.all(api)
+        self.from_array(api, api.request('/apps')["apps"])
+      end
+
+      # An everything-you-need helper to create an App
+      # If successful, returns new App
+      # If unsuccessful, raises +EY::CloudClient::RequestFailed+
+      #
+      # Usage
+      # App.create(api,
+      #   account:        account         # requires: account.id
+      #   name:           "myapp",
+      #   repository_uri: "git@github.com:mycompany/myapp.git",
+      #   app_type_id:    "rails3",
+      # )
+      #
+      # NOTE: Syntax above is for Ruby 1.9. In Ruby 1.8, keys must all be strings.
+      def self.create(api, attrs = {})
+        account = attrs.delete("account")
+        params = attrs.dup # no default fields
+        raise EY::CloudClient::AttributeRequiredError.new("account", EY::CloudClient::Account) unless account
+        raise EY::CloudClient::AttributeRequiredError.new("name") unless params["name"]
+        raise EY::CloudClient::AttributeRequiredError.new("repository_uri") unless params["repository_uri"]
+        raise EY::CloudClient::AttributeRequiredError.new("app_type_id") unless params["app_type_id"]
+        response = api.request("/accounts/#{account.id}/apps", :method => :post, :params => {"app" => params})
+        from_hash(api, response['app'])
+      end
+
+      def account_name
+        account && account.name
+      end
+
+      def environments
+        (app_environments || []).map { |app_env| app_env.environment }
+      end
+
+      def add_app_environment(app_env)
+        @app_environments ||= []
+        existing_app_env = @app_environments.detect { |ae| app_env.environment == ae.environment }
+        unless existing_app_env
+          @app_environments << app_env
+        end
+        existing_app_env || app_env
+      end
+
+      def set_account(account_attrs)
+        @account = Account.from_hash(api, account_attrs)
+        @account.add_app(self)
+        @account
+      end
+
+      def set_environments(environments_attrs)
+        (environments_attrs || []).each do |env|
+          AppEnvironment.from_hash(api, {'app' => self, 'environment' => env})
+        end
+      end
+
+      def attributes=(attrs)
+        account_attrs      = attrs.delete('account')
+        environments_attrs = attrs.delete('environments')
+        super
+        set_account      account_attrs      if account_attrs
+        set_environments environments_attrs if environments_attrs
+      end
+    end
+  end
+end

data/lib/engineyard-cloud-client/models/app_environment.rb

@@ -0,0 +1,85 @@
+require 'launchy'
+require 'engineyard-cloud-client/models'
+require 'engineyard-cloud-client/errors'
+
+module EY
+  class CloudClient
+    class AppEnvironment < ApiStruct.new(:id, :app, :environment, :uri, :domain_name, :migrate_command, :migrate)
+
+      # Return a constrained list of app_environments given a set of constraints like:
+      #
+      # * app_name
+      # * account_name
+      # * environment_name
+      # * remotes:  An array of git remote URIs
+      #
+      def self.resolve(api, constraints)
+        clean_constraints = constraints.reject { |k,v| v.nil? }
+        params = {'constraints' => clean_constraints}
+        response = api.request("/app_environments/resolve", :method => :get, :params => params)['resolver']
+        matches = from_array(api, response['matches'])
+        ResolverResult.new(api, matches, response['errors'], response['suggestions'])
+      end
+
+      def initialize(api, attrs)
+        super
+
+        raise ArgumentError, 'AppEnvironment created without app!'         unless app
+        raise ArgumentError, 'AppEnvironment created without environment!' unless environment
+      end
+
+      def set_app(app_or_hash)
+        self.app = App.from_hash(api, app_or_hash)
+        app.add_app_environment(self)
+        app
+      end
+
+      def set_environment(env_or_hash)
+        self.environment = Environment.from_hash(api, env_or_hash)
+        environment.add_app_environment(self)
+        environment
+      end
+
+      def attributes=(attrs)
+        app_attrs         = attrs.delete('app')
+        environment_attrs = attrs.delete('environment')
+        super
+        set_app         app_attrs         if app_attrs
+        set_environment environment_attrs if environment_attrs
+      end
+
+      def account_name
+        app.account_name
+      end
+
+      def app_name
+        app.name
+      end
+
+      def environment_name
+        environment.name
+      end
+
+      def repository_uri
+        app.repository_uri
+      end
+
+      def to_hierarchy_str
+        [account_name, app_name, environment_name].join('/')
+      end
+
+      def last_deployment
+        Deployment.last(api, self)
+      end
+
+      def new_deployment(attrs)
+        Deployment.from_hash(api, attrs.merge(:app_environment => self))
+      end
+
+      def short_environment_name
+        environment.name.gsub(/^#{Regexp.quote(app.name)}_/, '')
+      end
+
+    end
+  end
+end