engineyard 0.3.1 → 0.3.2

data/lib/engineyard.rb

@@ -1,12 +1,12 @@
 module EY
   require 'engineyard/ruby_ext'
 
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 
-  autoload :Account, 'engineyard/account'
   autoload :API,     'engineyard/api'
   autoload :Config,  'engineyard/config'
   autoload :Error,   'engineyard/error'
+  autoload :Model,   'engineyard/model'
   autoload :Repo,    'engineyard/repo'
 
   class UI

data/lib/engineyard/api.rb

@@ -1,3 +1,5 @@
+require 'engineyard/model'
+
 module EY
   class API
     attr_reader :token
@@ -20,9 +22,26 @@ module EY
       self.class.request(url, opts)
     end
 
+    def environments
+      @environments ||= EY::Model::Environment.from_array(request('/environments')["environments"], :api => self)
+    end
+
+    def apps
+      @apps ||= EY::Model::App.from_array(request('/apps')["apps"], :api => self)
+    end
+
+    def environment_named(name, envs = self.environments)
+      envs.find{|e| e.name == name }
+    end
+
+    def app_for_repo(repo)
+      apps.find{|a| repo.urls.include?(a.repository_uri) }
+    end
+
     class InvalidCredentials < EY::Error; end
     class RequestFailed < EY::Error; end
 
+
     def self.request(path, opts={})
       require 'rest_client'
       require 'json'

data/lib/engineyard/cli.rb

@@ -24,8 +24,8 @@ module EY
     method_option :install_eysd, :type => :boolean, :aliases => %(-s),
       :desc => "Force remote install of eysd"
     def deploy(env_name = nil, branch = nil)
-      require 'engineyard/action/deploy'
-      EY::Action::Deploy.call(env_name, branch, options)
+      require 'engineyard/cli/action/deploy'
+      EY::CLI::Action::Deploy.call(env_name, branch, options)
     end
 
 
@@ -47,15 +47,27 @@ module EY
 
     desc "rebuild [ENV]", "Rebuild environment (ensure configuration is up-to-date)"
     def rebuild(name = nil)
-      require 'engineyard/action/rebuild'
-      EY::Action::Rebuild.call(name)
+      env = if name
+              env = api.environment_named(name) or raise NoEnvironmentError.new(name)
+            end
+
+      unless env
+        repo = Repo.new
+        app = api.app_for_repo(repo) or raise NoAppError.new(repo)
+        env = app.one_and_only_environment or raise EnvironmentError, "Unable to determine a single environment for the current application (found #{app.environments.size} environments)"
+      end
+
+      EY.ui.debug("Rebuilding #{env.name}")
+      env.rebuild
     end
 
     desc "ssh ENV", "Open an ssh session to the environment's application server"
     def ssh(name)
-      env = account.environment_named(name)
-      if env
+      env = api.environment_named(name)
+      if env && env.app_master
         Kernel.exec "ssh", "#{env.username}@#{env.app_master.public_hostname}", *ARGV[2..-1]
+      elsif env
+        raise NoAppMaster.new(env.name)
       else
         EY.ui.warn %|Could not find an environment named "#{name}"|
       end
@@ -80,7 +92,7 @@ module EY
 
     desc "upload_recipes ENV", "Upload custom chef recipes from the current directory to ENV"
     def upload_recipes(name)
-      if account.upload_recipes_for(env_named(name))
+      if env_named(name).upload_recipes
         EY.ui.say "Recipes uploaded successfully"
       else
         EY.ui.error "Recipes upload failed"
@@ -94,8 +106,8 @@ module EY
     map ["-v", "--version"] => :version
 
     private
-    def account
-      @account ||= EY::Account.new(EY::CLI::API.new)
+    def api
+      @api ||= EY::CLI::API.new
     end
 
     def repo
@@ -103,7 +115,7 @@ module EY
     end
 
     def env_named(env_name)
-      env = account.environment_named(env_name)
+      env = api.environment_named(env_name)
 
       if env.nil?
         raise EnvironmentError, "Environment '#{env_name}' can't be found\n" +
@@ -114,10 +126,10 @@ module EY
     end
 
     def app_and_envs(all_envs = false)
-      app = account.app_for_repo(repo)
+      app = api.app_for_repo(repo)
 
       if all_envs || !app
-        envs = account.environments
+        envs = api.environments
         EY.ui.warn(NoAppError.new(repo).message) unless app || all_envs
         [nil, envs]
       else

data/lib/engineyard/cli/action/deploy.rb

@@ -0,0 +1,112 @@
+module EY
+  class CLI
+    module Action
+      class Deploy
+
+        EYSD_VERSION = "~>0.3.0"
+
+        def self.call(env_name, branch, options)
+          env_name ||= EY.config.default_environment
+
+          app = fetch_app
+          env = fetch_environment(env_name, app)
+          branch = fetch_branch(env.name, branch, options[:force])
+
+          running = env.app_master && env.app_master.status == "running"
+          raise EnvironmentError, "No running instances for environment #{env.name}\nStart one at #{EY.config.endpoint}" unless running
+
+          master   = env.app_master
+
+          EY.ui.info "Connecting to the server..."
+          ensure_eysd_present(master, options[:install_eysd])
+
+          EY.ui.info "Running deploy for '#{env.name}' on server..."
+          deployed = master.deploy!(app, branch, options[:migrate], env.config)
+
+          if deployed
+            EY.ui.info "Deploy complete"
+          else
+            raise EY::Error, "Deploy failed"
+          end
+        end
+
+        private
+
+        def self.api
+          @api ||= EY::CLI::API.new
+        end
+
+        def self.repo
+          @repo ||= EY::Repo.new
+        end
+
+        def self.fetch_app
+          app = api.app_for_repo(repo)
+          raise NoAppError.new(repo) unless app
+          app
+        end
+
+        def self.fetch_environment(env_name, app)
+          # if the name's not specified and there's not exactly one
+          # environment, we can't figure out which environment to deploy
+          raise DeployArgumentError if !env_name && app.environments.size != 1
+
+          env = if env_name
+                  api.environment_named(env_name, app.environments)
+                else
+                  app.environments.first
+                end
+
+          # the environment exists, but doesn't have this app
+          if !env && api.environment_named(env_name)
+            raise EnvironmentError, "Environment '#{env_name}' doesn't run this application\nYou can add it at #{EY.config.endpoint}"
+          end
+
+          if !env
+            raise NoEnvironmentError.new(env_name)
+          end
+
+          env
+        end
+
+        def self.fetch_branch(env_name, user_specified_branch, force)
+          default_branch = EY.config.default_branch(env_name)
+
+          branch = if user_specified_branch
+                     if default_branch && (user_specified_branch != default_branch) && !force
+                       raise BranchMismatch.new(default_branch, user_specified_branch)
+                     end
+                     user_specified_branch
+                   else
+                     default_branch || repo.current_branch
+                   end
+
+          raise DeployArgumentError unless branch
+          branch
+        end
+
+        def self.ensure_eysd_present(instance, install_eysd)
+          eysd_status = instance.ey_deploy_check
+          case eysd_status
+          when :ssh_failed
+            raise EnvironmentError, "SSH connection to #{instance.hostname} failed"
+          when :eysd_missing
+            EY.ui.warn "Instance does not have server-side component installed"
+            EY.ui.info "Installing server-side component..."
+            instance.install_ey_deploy!
+          when :too_new
+            raise EnvironmentError, "server-side component too new; please upgrade your copy of the engineyard gem."
+          when :too_old
+            EY.ui.info "Upgrading server-side component..."
+            instance.upgrade_ey_deploy!
+          when :ok
+            # no action needed
+          else
+            raise EY::Error, "Internal error: Unexpected status from Instance#ey_deploy_check; got #{eysd_status.inspect}"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/engineyard/cli/api.rb

@@ -23,6 +23,10 @@ module EY
         @token = self.class.fetch_token
       end
 
+      def environment_named(env_name, envs = self.environments)
+        super || find_environment_by_unambiguous_substring(env_name, envs)
+      end
+
       def self.fetch_token
         EY.ui.warn("The engineyard gem is prerelease software. Please do not use")
         EY.ui.warn("this tool to deploy to mission-critical environments, yet.")
@@ -37,6 +41,15 @@ module EY
         end
       end
 
+      private
+      def find_environment_by_unambiguous_substring(env_name, envs)
+        candidates = envs.find_all{|e| e.name[env_name] }
+        if candidates.size > 1
+          raise AmbiguousEnvironmentName.new(env_name, candidates.map {|e| e.name})
+        end
+        candidates.first
+      end
+
     end
   end
-end
+end

data/lib/engineyard/error.rb

@@ -1,6 +1,12 @@
 module EY
   class Error < RuntimeError; end
 
+  class NoRemotesError < EY::Error
+    def initialize(path)
+      super "fatal: No git remotes found in #{path}"
+    end
+  end
+
   class NoAppError < Error
     def initialize(repo)
       @repo = repo
@@ -14,9 +20,30 @@ module EY
     end
   end
 
+  class NoAppMaster < EY::Error
+    def initialize(env_name)
+      @env_name = env_name
+    end
+
+    def message
+      "The environment '#{@env_name}' does not have a master instance."
+    end
+  end
+
   class EnvironmentError < EY::Error
   end
 
+  class AmbiguousEnvironmentName < EY::Error
+    def initialize(name, matches)
+      @name, @matches = name, matches
+    end
+
+    def message
+      pretty_names = @matches.map {|x| "'#{x}'"}.join(', ')
+      "The name '#{@name}' is ambiguous; it matches all of the following environment names: #{pretty_names}.\nPlease use a longer, unambiguous substring or the entire environment name."
+    end
+  end
+
   class NoEnvironmentError < EY::Error
     def initialize(env_name=nil)
       @env_name = env_name

data/lib/engineyard/model.rb

@@ -0,0 +1,9 @@
+module EY
+  module Model
+    autoload :ApiStruct,   'engineyard/model/api_struct'
+    autoload :App,         'engineyard/model/app'
+    autoload :Environment, 'engineyard/model/environment'
+    autoload :Log,         'engineyard/model/log'
+    autoload :Instance,    'engineyard/model/instance'
+  end
+end

data/lib/engineyard/{account → model}/api_struct.rb

@@ -1,13 +1,13 @@
 module EY
-  class Account
+  module Model
     class ApiStruct < Struct
       def self.new(*args, &block)
         super(*args) do |*block_args|
           block.call(*block_args) if block
 
-          def self.from_array(array, account = nil)
+          def self.from_array(array, common_values = {})
             array.map do |values|
-              from_hash(values.merge(:account => account))
+              from_hash(values.merge(common_values))
             end if array
           end
 
@@ -20,6 +20,11 @@ module EY
 
         end
       end
+
+      def api_get(uri, options = {})
+        api.request(uri, options.merge(:method => :get))
+      end
+
     end
   end
 end

data/lib/engineyard/{account → model}/app.rb

@@ -1,10 +1,10 @@
 module EY
-  class Account
-    class App < ApiStruct.new(:name, :repository_uri, :environments, :account)
+  module Model
+    class App < ApiStruct.new(:name, :repository_uri, :environments, :api)
 
       def self.from_hash(hash)
         super.tap do |app|
-          app.environments = Environment.from_array(app.environments, app.account)
+          app.environments = Environment.from_array(app.environments, :api => app.api)
         end
       end
 

data/lib/engineyard/{account → model}/environment.rb

@@ -1,24 +1,31 @@
 module EY
-  class Account
-    class Environment < ApiStruct.new(:id, :name, :instances_count, :apps, :app_master, :username, :account)
+  module Model
+    class Environment < ApiStruct.new(:id, :name, :instances_count, :apps, :app_master, :username, :api)
       def self.from_hash(hash)
         super.tap do |env|
           env.username = hash['ssh_username']
-          env.apps = App.from_array(env.apps, env.account)
-          env.app_master = AppMaster.from_hash(env.app_master)
+          env.apps = App.from_array(env.apps, :api => env.api)
+          env.app_master = Instance.from_hash(env.app_master.merge(:environment => env)) if env.app_master
         end
       end
 
       def logs
-        account.logs_for(self)
+        Log.from_array(api_get("/environments/#{id}/logs")["logs"])
       end
 
       def instances
-        account.instances_for(self)
+        Instance.from_array(api_get("/environments/#{id}/instances")["instances"], :environment => self)
       end
 
       def rebuild
-        account.rebuild(self)
+        api.request("/environments/#{id}/rebuild", :method => :put)
+      end
+
+      def upload_recipes(file_to_upload = recipe_file)
+        api.request("/environments/#{id}/recipes",
+          :method => :post,
+          :params => {:file => file_to_upload}
+          )
       end
 
       def recipe_file

data/lib/engineyard/model/instance.rb

@@ -0,0 +1,91 @@
+require 'escape'
+
+module EY
+  module Model
+    class Instance < ApiStruct.new(:id, :role, :status, :amazon_id, :public_hostname, :environment)
+      EYSD_VERSION = "~>0.3.2"
+      CHECK_SCRIPT = <<-SCRIPT
+require "rubygems"
+requirement = Gem::Requirement.new("#{EYSD_VERSION}")
+required_version = requirement.requirements.last.last # thanks thanks rubygems rubygems
+
+# this will be a ["name-version", Gem::Specification] two-element array if present, nil otherwise
+ey_deploy_geminfo = Gem.source_index.find{ |(name,_)| name =~ /^ey-deploy-\\\d/ }
+exit(104) unless ey_deploy_geminfo
+
+current_version = ey_deploy_geminfo.last.version
+exit(0) if requirement.satisfied_by?(current_version)
+exit(70) if required_version > current_version
+exit(17) # required_version < current_version
+      SCRIPT
+      EXIT_STATUS = Hash.new { |h,k| raise EY::Error, "ey-deploy version checker exited with unknown status code #{k}" }
+      EXIT_STATUS.merge!({
+        255 => :ssh_failed,
+        104 => :eysd_missing,
+        70  => :too_old,
+        17  => :too_new,
+        0   => :ok,
+      })
+
+      alias :hostname :public_hostname
+
+      def deploy!(app, ref, migration_command=nil, extra_configuration=nil)
+        deploy_cmd = [eysd_path, 'deploy', '--app', app.name, '--branch', ref]
+
+        if extra_configuration
+          deploy_cmd << '--config' << extra_configuration.to_json
+        end
+
+        if migration_command
+          deploy_cmd << "--migrate" << migration_command
+        end
+
+        ssh Escape.shell_command(deploy_cmd)
+      end
+
+      def ey_deploy_check
+        require 'base64'
+        encoded_script = Base64.encode64(CHECK_SCRIPT).gsub(/\n/, '')
+        ssh "#{ruby_path} -r base64 -e \"eval Base64.decode64(ARGV[0])\" #{encoded_script}", false
+        EXIT_STATUS[$?.exitstatus]
+      end
+
+      def install_ey_deploy!
+        ssh(Escape.shell_command(['sudo', gem_path, 'install', 'ey-deploy', '-v', EYSD_VERSION]))
+      end
+
+      def upgrade_ey_deploy!
+        ssh "sudo #{gem_path} uninstall -a -x ey-deploy"
+        install_ey_deploy!
+      end
+
+    private
+
+      def ssh(remote_command, output = true)
+        user = environment.username
+
+        cmd = Escape.shell_command(%w[ssh -o StrictHostKeyChecking=no -q] << "#{user}@#{hostname}" << remote_command)
+        cmd << " > /dev/null" unless output
+        output ? puts(cmd) : EY.ui.debug(cmd)
+        unless ENV["NO_SSH"]
+          system cmd
+        else
+          true
+        end
+      end
+
+      def eysd_path
+        "/usr/local/ey_resin/ruby/bin/eysd"
+      end
+
+      def gem_path
+        "/usr/local/ey_resin/ruby/bin/gem"
+      end
+
+      def ruby_path
+        "/usr/local/ey_resin/ruby/bin/ruby"
+      end
+
+    end
+  end
+end