engineyard-serverside 1.2.2 → 1.3.0

data/lib/engineyard-serverside/cli.rb

@@ -1,4 +1,5 @@
 require 'thor'
+require 'pathname'
 
 module EY
   class CLI < Thor
@@ -10,50 +11,61 @@ module EY
       exit(1)
     end
 
-    method_option :migrate,       :type     => :string,
-                                  :desc     => "Run migrations with this deploy",
-                                  :aliases  => ["-m"]
+    method_option :migrate,         :type     => :string,
+                                    :desc     => "Run migrations with this deploy",
+                                    :aliases  => ["-m"]
 
-    method_option :branch,        :type     => :string,
-                                  :desc     => "Git ref to deploy, defaults to master. May be a branch, a tag, or a SHA",
-                                  :aliases  => %w[-b --ref --tag]
+    method_option :branch,          :type     => :string,
+                                    :desc     => "Git ref to deploy, defaults to master. May be a branch, a tag, or a SHA",
+                                    :aliases  => %w[-b --ref --tag]
 
-    method_option :repo,          :type     => :string,
-                                  :desc     => "Remote repo to deploy",
-                                  :aliases  => ["-r"]
+    method_option :repo,            :type     => :string,
+                                    :desc     => "Remote repo to deploy",
+                                    :aliases  => ["-r"]
 
-    method_option :app,           :type     => :string,
-                                  :required => true,
-                                  :desc     => "Application to deploy",
-                                  :aliases  => ["-a"]
+    method_option :app,             :type     => :string,
+                                    :required => true,
+                                    :desc     => "Application to deploy",
+                                    :aliases  => ["-a"]
 
-    method_option :framework_env, :type     => :string,
-                                  :required => true,
-                                  :desc     => "Ruby web framework environment",
-                                  :aliases  => ["-e"]
+    method_option :framework_env,   :type     => :string,
+                                    :required => true,
+                                    :desc     => "Ruby web framework environment",
+                                    :aliases  => ["-e"]
 
-    method_option :config,        :type     => :string,
-                                  :desc     => "Additional configuration"
+    method_option :config,          :type     => :string,
+                                    :desc     => "Additional configuration"
 
-    method_option :stack,         :type     => :string,
-                                  :desc     => "Web stack (so we can restart it correctly)"
+    method_option :stack,           :type     => :string,
+                                    :desc     => "Web stack (so we can restart it correctly)"
 
-    method_option :instances,     :type     => :array,
-                                  :desc     => "Instances in cluster"
+    method_option :instances,       :type     => :array,
+                                    :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
 
-    method_option :verbose,       :type     => :boolean,
-                                  :default  => false,
-                                  :desc     => "Verbose output",
-                                  :aliases  => ["-v"]
+    method_option :instance_roles,  :type     => :hash,
+                                    :default  => {},
+                                    :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
+
+    method_option :instance_names,  :type     => :hash,
+                                    :default  => {},
+                                    :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
+
+    method_option :verbose,         :type     => :boolean,
+                                    :default  => false,
+                                    :desc     => "Verbose output",
+                                    :aliases  => ["-v"]
 
     desc "deploy", "Deploy code from /data/<app>"
     def deploy(default_task=:deploy)
-      EY::Server.all = parse_instances(options[:instances])
+      config = EY::Deploy::Configuration.new(options)
+      EY::Server.load_all_from_array(assemble_instance_hashes(config))
+
       EY::LoggedOutput.verbose = options[:verbose]
       EY::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-deploy.log")
 
       invoke :propagate
-      EY::Deploy.run(options.merge("default_task" => default_task))
+
+      EY::Deploy.new(config).send(default_task)
     end
 
     method_option :app,           :type     => :string,
@@ -65,8 +77,8 @@ module EY
                                   :desc     => "Value for #release_path in hooks (mostly for internal coordination)",
                                   :aliases  => ["-r"]
 
-    method_option :current_role,  :type     => :string,
-                                  :desc     => "Value for #current_role in hooks"
+    method_option :current_roles, :type     => :array,
+                                  :desc     => "Value for #current_roles in hooks"
 
     method_option :framework_env, :type     => :string,
                                   :required => true,
@@ -84,6 +96,70 @@ module EY
       EY::DeployHook.new(options).run(hook_name)
     end
 
+
+    method_option :app,             :type     => :string,
+                                    :required => true,
+                                    :desc     => "Application to deploy",
+                                    :aliases  => ["-a"]
+
+    method_option :framework_env,   :type     => :string,
+                                    :required => true,
+                                    :desc     => "Ruby web framework environment",
+                                    :aliases  => ["-e"]
+
+    method_option :stack,           :type     => :string,
+                                    :desc     => "Web stack (so we can restart it correctly)"
+
+    method_option :instances,       :type     => :array,
+                                    :desc     => "Hostnames of instances to deploy to, e.g. --instances localhost app1 app2"
+
+    method_option :instance_roles,  :type     => :hash,
+                                    :default  => {},
+                                    :desc     => "Roles of instances, keyed on hostname, comma-separated. e.g. instance1:app_master,etc instance2:db,memcached ..."
+
+    method_option :instance_names,  :type     => :hash,
+                                    :default  => {},
+                                    :desc     => "Instance names, keyed on hostname. e.g. instance1:name1 instance2:name2"
+
+    method_option :verbose,         :type     => :boolean,
+                                    :default  => false,
+                                    :desc     => "Verbose output",
+                                    :aliases  => ["-v"]
+    desc "integrate", "Integrate other instances into this cluster"
+    def integrate
+      EY::LoggedOutput.verbose = options[:verbose]
+      EY::LoggedOutput.logfile = File.join(ENV['HOME'], "#{options[:app]}-integrate.log")
+
+      app_dir = Pathname.new "/data/#{options[:app]}"
+      current_app_dir = app_dir + "current"
+
+      # so that we deploy to the same place there that we have here
+      integrate_options = options.dup
+      integrate_options[:release_path] = current_app_dir.realpath.to_s
+
+      # we have to deploy the same SHA there as here
+      integrate_options[:branch] = (current_app_dir + 'REVISION').read.strip
+
+      config = EY::Deploy::Configuration.new(integrate_options)
+
+      EY::Server.load_all_from_array(assemble_instance_hashes(config))
+
+      invoke :propagate
+
+      EY::Server.all.each do |server|
+        server.sync_directory app_dir
+        # we're just about to recreate this, so it has to be gone
+        # first. otherwise, non-idempotent deploy hooks could screw
+        # things up, and since we don't control deploy hooks, we must
+        # assume the worst.
+        server.run("rm -rf #{current_app_dir}")
+      end
+
+      # deploy local-ref to other instances into /data/$app/local-current
+      EY::Deploy.new(config).cached_deploy
+    end
+
+
     desc "install_bundler [VERSION]", "Make sure VERSION of bundler is installed (in system ruby)"
     def install_bundler(version)
       egrep_escaped_version = version.gsub(/\./, '\.')
@@ -99,7 +175,7 @@ module EY
       end
     end
 
-    desc "propagate", "Propagate the engineyard-serverside gem to the other instances in the cluster. This will install exactly version #{VERSION} and remove other versions if found."
+    desc "propagate", "Propagate the engineyard-serverside gem to the other instances in the cluster. This will install exactly version #{VERSION}."
     def propagate
       config          = EY::Deploy::Configuration.new
       gem_filename    = "engineyard-serverside-#{VERSION}.gem"
@@ -107,8 +183,6 @@ module EY
       remote_gem_file = File.join(Dir.tmpdir, gem_filename)
       gem_binary      = File.join(Gem.default_bindir, 'gem')
 
-      EY::Server.config = config
-
       barrier(*(EY::Server.all.find_all do |server|
         !server.local?            # of course this machine has it
       end.map do |server|
@@ -135,12 +209,14 @@ module EY
 
     private
 
-    def parse_instances(instance_strings)
-      instance_strings.map do |s|
-        tuple = s.split(/,/)
-        {:hostname => tuple[0], :role => tuple[1], :name => tuple[2]}
-      end
+    def assemble_instance_hashes(config)
+      options[:instances].collect { |hostname|
+        { :hostname => hostname,
+          :roles => options[:instance_roles][hostname].to_s.split(','),
+          :name => options[:instance_names][hostname],
+          :user => config.user,
+        }
+      }
     end
-
   end
 end

data/lib/engineyard-serverside/configuration.rb

@@ -84,6 +84,10 @@ module EY
       node['instance_role']
     end
 
+    def current_role
+      current_roles.first
+    end
+
     def copy_exclude
       @copy_exclude ||= Array(configuration.fetch("copy_exclude", []))
     end

data/lib/engineyard-serverside/deploy.rb

@@ -11,6 +11,11 @@ module EY
     def deploy
       debug "Starting deploy at #{Time.now.asctime}"
       update_repository_cache
+      cached_deploy
+    end
+
+    def cached_deploy
+      debug "Deploying app from cached copy at #{Time.now.asctime}"
       require_custom_tasks
       push_code
 
@@ -92,7 +97,7 @@ module EY
     def push_code
       info "~> Pushing code to all servers"
       barrier *(EY::Server.all.map do |server|
-        need_later { server.push_code }
+        need_later { server.sync_directory(config.repository_cache) }
       end)
     end
 
@@ -230,7 +235,7 @@ module EY
         run Escape.shell_command(base_command) do |server, cmd|
           per_instance_args = [
             '--framework-env', c.environment.to_s,
-            '--current-role', server.role.to_s,
+            '--current-roles', server.roles.join(' '),
             '--config', c.to_json,
           ]
           per_instance_args << '--current-name' << server.name.to_s if server.name
@@ -318,16 +323,11 @@ module EY
   end   # DeployBase
 
   class Deploy < DeployBase
-    def self.new(opts={})
+    def self.new(config)
       # include the correct fetch strategy
-      include EY::Strategies.const_get(opts.strategy)::Helpers
+      include EY::Strategies.const_get(config.strategy)::Helpers
       super
     end
 
-    def self.run(opts={})
-      conf = EY::Deploy::Configuration.new(opts)
-      EY::Server.config = conf
-      new(conf).send(opts["default_task"])
-    end
   end
 end

data/lib/engineyard-serverside/deploy_hook.rb

@@ -68,7 +68,7 @@ module EY
 
       private
       def on_roles(desired_roles)
-        yield if desired_roles.include?(current_role.to_s)
+        yield if desired_roles.any? { |role| current_roles.include?(role) }
       end
 
     end

data/lib/engineyard-serverside/server.rb

@@ -2,64 +2,87 @@ require 'open-uri'
 require 'engineyard-serverside/logged_output'
 
 module EY
-  class Server < Struct.new(:hostname, :role, :name)
+  class Server < Struct.new(:hostname, :roles, :name, :user)
     include LoggedOutput
 
-    def initialize(*fields)
-      super
-      self.role = self.role.to_sym
-    end
-
-    def self.config=(config)
-      @@config = config
+    class DuplicateHostname < StandardError
+      def initialize(hostname)
+        super "There is already an EY::Server with hostname '#{hostname}'"
+      end
     end
 
-    def config
-      @@config
+    def initialize(*fields)
+      super
+      self.roles = self.roles.map { |r| r.to_sym } if self.roles
     end
 
     attr_writer :default_task
 
-    def self.from_roles(*roles)
-      roles = roles.flatten.compact
-      return all if !roles || roles.include?(:all) || roles.empty?
+    def self.from_roles(*want_roles)
+      want_roles = want_roles.flatten.compact.map{|r| r.to_sym}
+      return all if !want_roles || want_roles.include?(:all) || want_roles.empty?
 
       all.select do |s|
-        roles.include?(s.role) || roles.include?(s.name)
+        !(s.roles & want_roles).empty?
       end
     end
 
-    def self.from_hash(h)
-      new(h[:hostname], h[:role], h[:name])
+    def role
+      roles.first
+    end
+
+    def self.load_all_from_array(server_hashes)
+      server_hashes.each do |instance_hash|
+        add(instance_hash)
+      end
     end
 
     def self.all
       @all
     end
 
-    def self.all=(server_hashes)
-      @all = server_hashes.map { |s| from_hash(s) }
+    def self.by_hostname(hostname)
+      all.find{|s| s.hostname == hostname}
+    end
+
+    def self.add(server_hash)
+      hostname = server_hash[:hostname]
+      if by_hostname(hostname)
+        raise DuplicateHostname.new(hostname)
+      end
+      server = new(hostname, server_hash[:roles], server_hash[:name], server_hash[:user])
+      @all << server
+      server
     end
 
     def self.current
       all.find {|s| s.local? }
     end
 
+    def self.reset
+      @all = []
+    end
+    reset
+
+    def roles=(roles)
+      super(roles.map{|r| r.to_sym})
+    end
+
     def local?
-      [:app_master, :solo].include?(role)
+      hostname == 'localhost'
     end
 
-    def push_code
+    def sync_directory(directory)
       return if local?
-      run "mkdir -p #{config.repository_cache}"
-      logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{config.repository_cache}/ #{config.user}@#{hostname}:#{config.repository_cache}|)
+      run "mkdir -p #{directory}"
+      logged_system(%|rsync --delete -aq -e "#{ssh_command}" #{directory}/ #{user}@#{hostname}:#{directory}|)
     end
 
     def run(command)
       if local?
         logged_system(command)
       else
-        logged_system(ssh_command + " " + Escape.shell_command(["#{config.user}@#{hostname}", command]))
+        logged_system(ssh_command + " " + Escape.shell_command(["#{user}@#{hostname}", command]))
       end
     end
 

data/lib/engineyard-serverside/version.rb

@@ -1,3 +1,3 @@
 module EY
-  VERSION = '1.2.2'
+  VERSION = '1.3.0'
 end

data/spec/custom_deploy_spec.rb

@@ -53,7 +53,7 @@ describe "the EY::Deploy API" do
     end
 
     before(:each) do
-      @tempdir = `mktemp -d -t custom_deploy_spec`.strip
+      @tempdir = `mktemp -d -t custom_deploy_spec.XXXXX`.strip
       @config = EY::Deploy::Configuration.new('repository_cache' => @tempdir)
       @deploy = TestQuietDeploy.new(@config)
     end

data/spec/deploy_hook_spec.rb

@@ -130,6 +130,8 @@ describe "the deploy-hook API" do
         {:instance_role => 'app'},
         {:instance_role => 'db_master'},
         {:instance_role => 'db_slave'},
+        {:instance_role => 'multi_role,app'},
+        {:instance_role => 'multi,util'},
         {:instance_role => 'util', :name => "alpha"},
         {:instance_role => 'util', :name => "beta"},
         {:instance_role => 'util', :name => "gamma"},
@@ -138,7 +140,7 @@ describe "the deploy-hook API" do
 
     def where_code_runs_with(method, *args)
       scenarios.map do |s|
-        @callback_context.configuration[:current_role] = s[:instance_role]
+        @callback_context.configuration[:current_roles] = s[:instance_role].split(',')
         @callback_context.configuration[:current_name] = s[:name]
 
         if run_hook { send(method, *args) { 'ran!'} } == 'ran!'
@@ -154,17 +156,17 @@ describe "the deploy-hook API" do
     end
 
     it "#on_app_servers runs on app masters, app slaves, and solos" do
-      where_code_runs_with(:on_app_servers).should == %w(solo app_master app)
+      where_code_runs_with(:on_app_servers).should == %w(solo app_master app multi_role,app)
     end
 
     it "#on_app_servers_and_utilities does what it says on the tin" do
       where_code_runs_with(:on_app_servers_and_utilities).should ==
-        %w(solo app_master app util_alpha util_beta util_gamma)
+        %w(solo app_master app multi_role,app multi,util util_alpha util_beta util_gamma)
     end
 
     it "#on_utilities() runs on all utility instances" do
       where_code_runs_with(:on_utilities).should ==
-        %w(util_alpha util_beta util_gamma)
+        %w(multi,util util_alpha util_beta util_gamma)
     end
 
     it "#on_utilities('sometype') runs on only utilities of type 'sometype'" do
@@ -196,4 +198,10 @@ describe "the deploy-hook API" do
       @hook.syntax_error(hook_path).should =~ match
     end
   end
+
+  context "is compatible with older deploy hook scripts" do
+    it "#current_role returns the first role" do
+      run_hook(:current_roles => %w(a b)) { current_role.should == 'a' }
+    end
+  end
 end

data/spec/real_deploy_spec.rb

@@ -105,7 +105,8 @@ describe "deploying an application" do
     @deploy_dir = File.join(Dir.tmpdir, "serverside-deploy-#{Time.now.to_i}-#{$$}")
 
     # set up EY::Server like we're on a solo
-    EY::Server.all = [{:hostname => 'dontcare', :role => 'solo'}]
+    EY::Server.reset
+    EY::Server.add(:hostname => 'localhost', :roles => %w[solo])
 
     # run a deploy
     config = EY::Deploy::Configuration.new({

data/spec/server_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + "/spec_helper"
+
+describe EY::Server do
+  before(:each) do
+    EY::Server.reset
+  end
+
+  context ".all" do
+    it "starts off empty" do
+      EY::Server.all.should be_empty
+    end
+
+    it "is added to with .add" do
+      EY::Server.add(:hostname => 'otherhost', :roles => %w[fire water])
+      EY::Server.all.size.should == 1
+
+      EY::Server.by_hostname('otherhost').should_not be_nil
+    end
+
+    it "rejects duplicates" do
+      EY::Server.add(:hostname => 'otherhost')
+      lambda do
+        EY::Server.add(:hostname => 'otherhost')
+      end.should raise_error(EY::Server::DuplicateHostname)
+    end
+  end
+
+  it "makes sure your roles are symbols at creation time" do
+    EY::Server.add(:hostname => 'otherhost', :roles => ['beerguy'])
+
+    EY::Server.by_hostname('otherhost').roles.should == [:beerguy]
+  end
+
+  it "makes sure your roles are symbols when updated" do
+    EY::Server.add(:hostname => 'otherhost')
+
+    server = EY::Server.by_hostname('otherhost')
+    server.roles = %w[bourbon scotch beer]
+    server.roles.should == [:bourbon, :scotch, :beer]
+  end
+
+  context ".from_roles" do
+    before(:each) do
+      @localhost = EY::Server.add(:hostname => 'localhost', :roles => [:ice, :cold])
+      @host1 = EY::Server.add(:hostname => 'host1', :roles => [:fire, :water])
+      @host2 = EY::Server.add(:hostname => 'host2', :roles => [:ice, :water])
+    end
+
+    it "works with strings or symbols" do
+      EY::Server.from_roles(:fire).should == [@host1]
+      EY::Server.from_roles('fire').should == [@host1]
+    end
+
+    it "finds all servers with the specified role" do
+      EY::Server.from_roles('ice').size.should == 2
+      EY::Server.from_roles('ice').sort do |a, b|
+        a.hostname <=> b.hostname
+      end.should == [@host2, @localhost]
+    end
+
+    it "finds all servers with any of the specified roles" do
+      EY::Server.from_roles(:ice, :water).should == EY::Server.all
+    end
+
+    it "returns everything when asked for :all" do
+      EY::Server.from_roles(:all).should == EY::Server.all
+    end
+  end
+
+  context "#local?" do
+    it "is true only for localhost" do
+      EY::Server.new('localhost').should be_local
+      EY::Server.new('neighborhost').should_not be_local
+    end
+  end
+end

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 2
-  - 2
-  version: 1.2.2
+  - 3
+  - 0
+  version: 1.3.0
 platform: ruby
 authors: 
 - EY Cloud Team
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-31 00:00:00 -07:00
+date: 2010-09-13 00:00:00 -07:00
 default_executable: engineyard-serverside
 dependencies: []
 
@@ -242,6 +242,7 @@ files:
 - spec/git_strategy_spec.rb
 - spec/lockfile_parser_spec.rb
 - spec/real_deploy_spec.rb
+- spec/server_spec.rb
 - spec/spec_helper.rb
 - spec/support/lockfiles/0.9-no-bundler
 - spec/support/lockfiles/0.9-with-bundler
@@ -292,6 +293,7 @@ test_files:
 - spec/git_strategy_spec.rb
 - spec/lockfile_parser_spec.rb
 - spec/real_deploy_spec.rb
+- spec/server_spec.rb
 - spec/spec_helper.rb
 - spec/support/lockfiles/0.9-no-bundler
 - spec/support/lockfiles/0.9-with-bundler