engineyard-cloud-client 0.1.2

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

@@ -0,0 +1,105 @@
+require 'engineyard-cloud-client/models'
+require 'engineyard-cloud-client/errors'
+
+module EY
+  class CloudClient
+    class Deployment < ApiStruct.new(:id, :app_environment, :created_at, :commit, :finished_at, :migrate_command, :ref, :resolved_ref, :successful, :user_name, :extra_config)
+      def self.api_root(app_id, environment_id)
+        "/apps/#{app_id}/environments/#{environment_id}/deployments"
+      end
+
+      def self.last(api, app_environment)
+        get(api, app_environment, 'last')
+      end
+
+      def self.get(api, app_environment, id)
+        uri = api_root(app_environment.app.id, app_environment.environment.id) + "/#{id}"
+        response = api.request(uri, :method => :get)
+        load_from_response api, app_environment, response
+      rescue EY::CloudClient::ResourceNotFound
+        nil
+      end
+
+      def self.load_from_response(api, app_environment, response)
+        dep = from_hash(api, {:app_environment => app_environment})
+        dep.update_with_response(response)
+        dep
+      end
+
+      def app
+        app_environment.app
+      end
+
+      def environment
+        app_environment.environment
+      end
+
+      def migrate
+        !migrate_command.nil? && !migrate_command.to_s.empty?
+      end
+      alias migrate? migrate
+      alias migration_command migrate_command
+      alias migration_command= migrate_command=
+
+      alias successful? successful
+
+      alias deployed_by user_name
+      alias deployed_by= user_name=
+
+      def config
+        @config ||= {'deployed_by' => deployed_by}.merge(extra_config)
+      end
+
+      def start
+        params = { :migrate => migrate, :ref => ref }
+        params[:migrate_command] = migrate_command if migrate
+        post_to_api(params)
+      end
+
+      def output
+        @output ||= StringIO.new
+      end
+
+      def out
+        output
+      end
+
+      def err
+        output
+      end
+
+      def finished
+        output.rewind
+        put_to_api({:successful => successful, :output => output.read})
+      end
+
+      def finished?
+        !finished_at.nil?
+      end
+
+      def update_with_response(response)
+        response['deployment'].each do |key,val|
+          send("#{key}=", val) if respond_to?("#{key}=")
+        end
+      end
+
+      private
+
+      def post_to_api(params)
+        update_with_response api.request(collection_uri, :method => :post, :params => {:deployment => params})
+      end
+
+      def put_to_api(params)
+        update_with_response api.request(member_uri("/finished"), :method => :put, :params => {:deployment => params})
+      end
+
+      def collection_uri
+        self.class.api_root(app.id, environment.id)
+      end
+
+      def member_uri(path = nil)
+        collection_uri + "/#{id}#{path}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,240 @@
+require 'engineyard-cloud-client/models'
+require 'engineyard-cloud-client/errors'
+
+module EY
+  class CloudClient
+    class Environment < ApiStruct.new(:id, :name, :framework_env, :instances_count,
+                                      :username, :app_server_stack_name,
+                                      :load_balancer_ip_address
+                                     )
+      attr_accessor :ignore_bad_bridge, :apps, :account
+
+      def attributes=(attrs)
+        account_attrs    = attrs.delete('account')
+        apps_attrs       = attrs.delete('apps')
+        instances_attrs  = attrs.delete('instances')
+
+        super
+
+        set_account   account_attrs   if account_attrs
+        set_apps      apps_attrs      if apps_attrs
+        set_instances instances_attrs if instances_attrs
+      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 app_environments
+        @app_environments ||= []
+      end
+
+      def set_account(account_attrs)
+        @account = Account.from_hash(api, account_attrs)
+        @account.add_environment(self)
+        @account
+      end
+
+      # Creating an AppEnvironment will come back and call add_app_environment
+      # (above) to associate this model with the AppEnvironment. (that's why we
+      # don't save anything here.)
+      def set_apps(apps_attrs)
+        (apps_attrs || []).each do |app|
+          AppEnvironment.from_hash(api, {'app' => app, 'environment' => self})
+        end
+      end
+
+      def apps
+        app_environments.map { |app_env| app_env.app }
+      end
+
+      def set_instances(instances_attrs)
+        @instances = load_instances(instances_attrs)
+      end
+
+      def instances
+        @instances ||= request_instances
+      end
+
+      # Return list of all Environments linked to all current user's accounts
+      def self.all(api)
+        self.from_array(api, api.request('/environments')["environments"])
+      end
+
+      # Return a constrained list of 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("/environments/resolve", :method => :get, :params => params)['resolver']
+        matches = from_array(api, response['matches'])
+        ResolverResult.new(api, matches, response['errors'], response['suggestions'])
+      end
+
+      # Usage
+      # Environment.create(api, {
+      #      app: app,                            # requires: app.id
+      #      name: 'myapp_production',
+      #      region: 'us-west-1',                 # default: us-east-1
+      #      app_server_stack_name: 'nginx_thin', # default: nginx_passenger3
+      #      framework_env: 'staging'             # default: production
+      #      cluster_configuration: {
+      #        configuration: 'single'            # default: single, cluster, custom
+      #      }
+      # })
+      #
+      # NOTE: Syntax above is for Ruby 1.9. In Ruby 1.8, keys must all be strings.
+      #
+      # TODO - allow any attribute to be sent through that the API might allow; e.g. region, ruby_version, stack_label
+      def self.create(api, attrs={})
+        app    = attrs.delete("app")
+        cluster_configuration = attrs.delete('cluster_configuration')
+        raise EY::CloudClient::AttributeRequiredError.new("app", EY::CloudClient::App) unless app
+        raise EY::CloudClient::AttributeRequiredError.new("name") unless attrs["name"]
+
+        params = {"environment" => attrs.dup}
+        unpack_cluster_configuration(params, cluster_configuration)
+        response = api.request("/apps/#{app.id}/environments", :method => :post, :params => params)
+        self.from_hash(api, response['environment'])
+      end
+
+      def account_name
+        account && account.name
+      end
+
+      def ssh_username=(user)
+        self.username = user
+      end
+
+      def logs
+        Log.from_array(api, api.request("/environments/#{id}/logs", :method => :get)["logs"])
+      end
+
+      def deploy_to_instances
+        instances.select { |inst| inst.has_app_code? }
+      end
+
+      def bridge
+        @bridge ||= instances.detect { |inst| inst.bridge? }
+      end
+
+      def bridge!
+        if bridge.nil?
+          raise NoBridgeError.new(name)
+        elsif !ignore_bad_bridge && bridge.status != "running"
+          raise BadBridgeStatusError.new(bridge.status, EY::CloudClient.endpoint)
+        end
+        bridge
+      end
+
+      def rebuild
+        api.request("/environments/#{id}/update_instances", :method => :put)
+      end
+
+      def run_custom_recipes
+        api.request("/environments/#{id}/run_custom_recipes", :method => :put)
+      end
+
+      def download_recipes
+        if File.exist?('cookbooks')
+          raise EY::CloudClient::Error, "Could not download, cookbooks already exists"
+        end
+
+        require 'tempfile'
+        tmp = Tempfile.new("recipes")
+        tmp.write(api.request("/environments/#{id}/recipes"))
+        tmp.flush
+        tmp.close
+
+        cmd = "tar xzf '#{tmp.path}' cookbooks"
+
+        unless system(cmd)
+          raise EY::CloudClient::Error, "Could not unarchive recipes.\nCommand `#{cmd}` exited with an error."
+        end
+      end
+
+      def upload_recipes_at_path(recipes_path)
+        recipes_path = Pathname.new(recipes_path)
+        if recipes_path.exist?
+          upload_recipes recipes_path.open('rb')
+        else
+          raise EY::CloudClient::Error, "Recipes file not found: #{recipes_path}"
+        end
+      end
+
+      def tar_and_upload_recipes_in_cookbooks_dir
+        require 'tempfile'
+        unless File.exist?("cookbooks")
+          raise EY::CloudClient::Error, "Could not find chef recipes. Please run from the root of your recipes repo."
+        end
+
+        recipes_file = Tempfile.new("recipes")
+        cmd = "tar czf '#{recipes_file.path}' cookbooks/"
+
+        unless system(cmd)
+          raise EY::CloudClient::Error, "Could not archive recipes.\nCommand `#{cmd}` exited with an error."
+        end
+
+        upload_recipes(recipes_file)
+      end
+
+      def upload_recipes(file_to_upload)
+        api.request("/environments/#{id}/recipes", {
+          :method => :post,
+          :params => {:file => file_to_upload}
+        })
+      end
+
+      def shorten_name_for(app)
+        name.gsub(/^#{Regexp.quote(app.name)}_/, '')
+      end
+
+      private
+
+      def request_instances
+        instances_attrs = api.request("/environments/#{id}/instances")["instances"]
+        load_instances(instances_attrs)
+      end
+
+      def load_instances(instances_attrs)
+        Instance.from_array(api, instances_attrs, 'environment' => self)
+      end
+
+      def no_migrate?(deploy_options)
+        deploy_options.key?('migrate') && deploy_options['migrate'] == false
+      end
+
+      # attrs["cluster_configuration"]["cluster"] can be 'single', 'cluster', or 'custom'
+      # attrs["cluster_configuration"]["ip"] can be
+      #   * 'host' (amazon public hostname)
+      #   * 'new' (Elastic IP assigned, default)
+      #   * or an IP id
+      # if 'custom' cluster, then...
+      def self.unpack_cluster_configuration(attrs, configuration)
+        if configuration
+          attrs["cluster_configuration"] = configuration
+          attrs["cluster_configuration"]["configuration"] ||= 'single'
+          attrs["cluster_configuration"]["ip_id"] = configuration.delete("ip") || 'new' # amazon public hostname; alternate is 'new' for Elastic IP
+
+          # if cluster_type == 'custom'
+          #   attrs['cluster_configuration'][app_server_count] = options[:app_instances] || 2
+          #   attrs['cluster_configuration'][db_slave_count]   = options[:db_instances] || 0
+          #   attrs['cluster_configuration'][instance_size]    = options[:app_size] if options[:app_size]
+          #   attrs['cluster_configuration'][db_instance_size] = options[:db_size] if options[:db_size]
+          # end
+          # at
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'engineyard-cloud-client/errors'
+
+module EY
+  class CloudClient
+    class Instance < ApiStruct.new(:id, :role, :name, :status, :amazon_id, :public_hostname, :environment, :bridge)
+      alias hostname public_hostname
+      alias bridge? bridge
+
+      def has_app_code?
+        !["db_master", "db_slave"].include?(role.to_s)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'engineyard-cloud-client/models/api_struct'
+
+module EY
+  class CloudClient
+    class Keypair < ApiStruct.new(:id, :name, :public_key)
+
+      def self.all(api)
+        self.from_array(api, api.request('/keypairs')["keypairs"])
+      end
+
+      # Create a Keypair with your SSH public key so that you can access your Instances
+      # via SSH
+      # If successful, returns new Keypair and EY Cloud will have registered your public key
+      # If unsuccessful, raises +EY::CloudClient::RequestFailed+
+      #
+      # Usage
+      # Keypair.create(api,
+      #   name:       "laptop",
+      #   public_key: "ssh-rsa OTHERKEYPAIR"
+      # )
+      #
+      # NOTE: Syntax above is for Ruby 1.9. In Ruby 1.8, keys must all be strings.
+      def self.create(api, attrs = {})
+        params = attrs.dup # no default fields
+        raise EY::CloudClient::AttributeRequiredError.new("name") unless params["name"]
+        raise EY::CloudClient::AttributeRequiredError.new("public_key") unless params["public_key"]
+        response = api.request("/keypairs", :method => :post, :params => {"keypair" => params})
+        self.from_hash(api, response['keypair'])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'engineyard-cloud-client/models'
+
+module EY
+  class CloudClient
+    class Log < ApiStruct.new(:id, :role, :main, :custom)
+      def instance_name
+        "#{role} #{id}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'engineyard-cloud-client/models'
+
+module EY
+  class CloudClient
+    class User < ApiStruct.new(:id, :name, :email)
+      def accounts
+        EY::CloudClient::Account.all(api)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module EY
+  class CloudClient
+    class ResolverResult
+      attr_reader :api, :matches, :errors, :suggestions
+
+      def initialize(api, matches, errors, suggestions)
+        @api, @matches, @errors, @suggestions = api, matches, errors, suggestions
+      end
+
+      def one_match?()    matches.size == 1 end
+      def no_matches?()   matches.empty?    end
+      def many_matches?() matches.size > 1  end
+
+      def one_match(&block)    one_match?    && block && block.call(matches.first)       end
+      def no_matches(&block)   no_matches?   && block && block.call(errors, suggestions) end
+      def many_matches(&block) many_matches? && block && block.call(matches)             end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'rest_client'
+
+module RestClient
+  module AbstractResponse
+    private
+
+    def parse_cookie(cookie_content)
+      {}
+    end
+  end
+end