switchtower 0.10.0 → 1.0.0

data/lib/switchtower/actor.rb

@@ -3,6 +3,7 @@ require 'switchtower/command'
 require 'switchtower/transfer'
 require 'switchtower/gateway'
 require 'switchtower/ssh'
+require 'switchtower/utils'
 
 module SwitchTower
 
@@ -29,12 +30,18 @@ module SwitchTower
       attr_accessor :connection_factory
       attr_accessor :command_factory
       attr_accessor :transfer_factory
+      attr_accessor :default_io_proc
     end
 
     self.connection_factory = DefaultConnectionFactory
     self.command_factory = Command
     self.transfer_factory = Transfer
 
+    self.default_io_proc = Proc.new do |ch, stream, out|
+      level = out == :error ? :important : :info
+      ch[:actor].logger.send(level, out, "#{stream} :: #{ch[:host]}")
+    end
+
     # The configuration instance associated with this actor.
     attr_reader :configuration
 
@@ -62,18 +69,22 @@ module SwitchTower
 
     # Represents the definition of a single task.
     class Task #:nodoc:
-      attr_reader :name, :options
+      attr_reader :name, :actor, :options
 
-      def initialize(name, options)
-        @name, @options = name, options
+      def initialize(name, actor, options)
+        @name, @actor, @options = name, actor, options
         @servers = nil
       end
 
       # Returns the list of servers (_not_ connections to servers) that are
       # the target of this task.
-      def servers(configuration)
+      def servers
         unless @servers
-          roles = [*(@options[:roles] || configuration.roles.keys)].map { |name| configuration.roles[name] or raise ArgumentError, "task #{self.name.inspect} references non-existant role #{name.inspect}" }.flatten
+          roles = [*(@options[:roles] || actor.configuration.roles.keys)].
+            map { |name|
+              actor.configuration.roles[name] or
+                raise ArgumentError, "task #{self.name.inspect} references non-existant role #{name.inspect}"
+            }.flatten
           only  = @options[:only] || {}
 
           unless only.empty?
@@ -105,10 +116,10 @@ module SwitchTower
     # Define a new task for this actor. The block will be invoked when this
     # task is called.
     def define_task(name, options={}, &block)
-      @tasks[name] = Task.new(name, options)
+      @tasks[name] = (options[:task_class] || Task).new(name, self, options)
       define_method(name) do
         send "before_#{name}" if respond_to? "before_#{name}"
-        logger.trace "executing task #{name}"
+        logger.debug "executing task #{name}"
         begin
           push_task_call_frame name
           result = instance_eval(&block)
@@ -129,10 +140,7 @@ module SwitchTower
     #
     # If +pretend+ mode is active, this does nothing.
     def run(cmd, options={}, &block)
-      block ||= Proc.new do |ch, stream, out|
-        logger.debug(out, "#{stream} :: #{ch[:host]}")
-      end
-
+      block ||= default_io_proc
       logger.debug "executing #{cmd.strip.inspect}"
 
       execute_on_servers(options) do |servers|
@@ -176,9 +184,7 @@ module SwitchTower
     # the sudo password (if required) is the same as the password for logging
     # in to the server.
     def sudo(command, options={}, &block)
-      block ||= Proc.new do |ch, stream, out|
-        logger.debug(out, "#{stream} :: #{ch[:host]}")
-      end
+      block ||= default_io_proc
 
       # in order to prevent _each host_ from prompting when the password was
       # wrong, let's track which host prompted first and only allow subsequent
@@ -320,11 +326,29 @@ module SwitchTower
       task_call_frames.last.rollback = block
     end
 
-    private
+    # An instance-level reader for the class' #default_io_proc attribute.
+    def default_io_proc
+      self.class.default_io_proc
+    end
 
-      def metaclass
-        class << self; self; end
-      end
+    # Used to force connections to be made to the current task's servers.
+    # Connections are normally made lazily in SwitchTower--you can use this
+    # to force them open before performing some operation that might be
+    # time-sensitive.
+    def connect!(options={})
+      execute_on_servers(options) { }
+    end
+
+    def current_task
+      return nil if task_call_frames.empty?
+      tasks[task_call_frames.last.name]
+    end
+
+    def metaclass
+      class << self; self; end
+    end
+
+    private
 
       def define_method(name, &block)
         metaclass.send(:define_method, name, &block)
@@ -358,8 +382,14 @@ module SwitchTower
       end
 
       def execute_on_servers(options)
-        servers = tasks[task_call_frames.last.name].servers(configuration)
-        servers = servers.first if options[:once]
+        task = current_task
+        servers = task.servers
+
+        if servers.empty?
+          raise "The #{task.name} task is only run for servers matching #{task.options.inspect}, but no servers matched"
+        end
+
+        servers = [servers.first] if options[:once]
         logger.trace "servers: #{servers.inspect}"
 
         if !pretend
@@ -376,5 +406,6 @@ module SwitchTower
           super
         end
       end
+
   end
 end

data/lib/switchtower/cli.rb

@@ -86,7 +86,7 @@ module SwitchTower
     #   require 'switchtower/cli'
     #   config = SwitchTower::Configuration.new
     #   config.logger_level = SwitchTower::Logger::TRACE
-    #   config.set :password, Proc.new { SwitchTower::CLI.password_prompt }
+    #   config.set(:password) { SwitchTower::CLI.password_prompt }
     #   config.load "standard", "config/deploy"
     #   config.actor.update_code
     #

data/lib/switchtower/command.rb

@@ -22,8 +22,6 @@ module SwitchTower
     # fails (non-zero return code) on any of the hosts, this will raise a
     # RuntimeError.
     def process!
-      logger.debug "processing command"
-
       since = Time.now
       loop do
         active = 0
@@ -56,6 +54,7 @@ module SwitchTower
         @servers.map do |server|
           @actor.sessions[server].open_channel do |channel|
             channel[:host] = server
+            channel[:actor] = @actor # so callbacks can access the actor instance
             channel.request_pty :want_reply => true
 
             channel.on_success do |ch|

data/lib/switchtower/configuration.rb

@@ -1,6 +1,7 @@
 require 'switchtower/actor'
 require 'switchtower/logger'
 require 'switchtower/scm/subversion'
+require 'switchtower/extensions'
 
 module SwitchTower
   # Represents a specific SwitchTower configuration. A Configuration instance
@@ -29,6 +30,9 @@ module SwitchTower
     # determining the release path.
     attr_reader :now
 
+    # The has of variables currently known by the configuration
+    attr_reader :variables
+
     def initialize(actor_class=Actor) #:nodoc:
       @roles = Hash.new { |h,k| h[k] = [] }
       @actor = actor_class.new(self)
@@ -48,18 +52,28 @@ module SwitchTower
       
       set :ssh_options, Hash.new
 						
-      set :deploy_to,   Proc.new { "/u/apps/#{application}" }
+      set(:deploy_to)   { "/u/apps/#{application}" }
 
       set :version_dir, DEFAULT_VERSION_DIR_NAME
       set :current_dir, DEFAULT_CURRENT_DIR_NAME
       set :shared_dir,  DEFAULT_SHARED_DIR_NAME
       set :scm,         :subversion
 
-      set :revision,    Proc.new { source.latest_revision }
+      set(:revision)    { source.latest_revision }
     end
 
     # Set a variable to the given value.
-    def set(variable, value)
+    def set(variable, value=nil, &block)
+      # if the variable is uppercase, then we add it as a constant to the
+      # actor. This is to allow uppercase "variables" to be set and referenced
+      # in recipes.
+      if variable.to_s[0].between?(?A, ?Z)
+        klass = @actor.metaclass
+        klass.send(:remove_const, variable) if klass.const_defined?(variable)
+        klass.const_set(variable, value)
+      end
+
+      value = block if value.nil? && block_given?
       @variables[variable] = value
     end
 
@@ -103,11 +117,19 @@ module SwitchTower
     #
     #   load(:string => "set :scm, :subversion"):
     #     Load the given string as a configuration specification.
-    def load(*args)
+    #
+    #   load { ... }
+    #     Load the block in the context of the configuration.
+    def load(*args, &block)
       options = args.last.is_a?(Hash) ? args.pop : {}
       args.each { |arg| load options.merge(:file => arg) }
+      return unless args.empty?
+
+      if block
+        raise "loading a block requires 0 parameters" unless args.empty?
+        load(options.merge(:proc => block))
 
-      if options[:file]
+      elsif options[:file]
         file = options[:file]
         unless file[0] == ?/
           load_paths.each do |path|
@@ -122,9 +144,17 @@ module SwitchTower
         end
 
         load :string => File.read(file), :name => options[:name] || file
+
       elsif options[:string]
-        logger.debug "loading configuration #{options[:name] || "<eval>"}"
-        instance_eval options[:string], options[:name] || "<eval>"
+        logger.trace "loading configuration #{options[:name] || "<eval>"}"
+        instance_eval(options[:string], options[:name] || "<eval>")
+
+      elsif options[:proc]
+        logger.trace "loading configuration #{options[:proc].inspect}"
+        instance_eval(&options[:proc])
+
+      else
+        raise ArgumentError, "don't know how to load #{options.inspect}"
       end
     end
 
@@ -164,6 +194,18 @@ module SwitchTower
       actor.define_task(name, options, &block)
     end
 
+    # Require another file. This is identical to the standard require method,
+    # with the exception that it sets the reciever as the "current" configuration
+    # so that third-party task bundles can include themselves relative to
+    # that configuration.
+    def require(*args) #:nodoc:
+      original, SwitchTower.configuration = SwitchTower.configuration, self
+      super
+    ensure
+      # restore the original, so that require's can be nested
+      SwitchTower.configuration = original
+    end
+
     # Return the path into which releases should be deployed.
     def releases_path
       File.join(deploy_to, version_dir)

data/lib/switchtower/extensions.rb

@@ -0,0 +1,38 @@
+require 'switchtower/actor'
+
+module SwitchTower
+  class ExtensionProxy
+    def initialize(actor, mod)
+      @actor = actor
+      extend(mod)
+    end
+
+    def method_missing(sym, *args, &block)
+      @actor.send(sym, *args, &block)
+    end
+  end
+
+  EXTENSIONS = {}
+
+  def self.plugin(name, mod)
+    return false if EXTENSIONS.has_key?(name)
+
+    SwitchTower::Actor.class_eval <<-STR, __FILE__, __LINE__+1
+      def #{name}
+        @__#{name}_proxy ||= SwitchTower::ExtensionProxy.new(self, SwitchTower::EXTENSIONS[#{name.inspect}])
+      end
+    STR
+
+    EXTENSIONS[name] = mod
+    return true
+  end
+
+  def self.remove_plugin(name)
+    if EXTENSIONS.delete(name)
+      SwitchTower::Actor.send(:remove_method, name)
+      return true
+    end
+
+    return false
+  end
+end

data/lib/switchtower/gateway.rb

@@ -25,11 +25,14 @@ module SwitchTower
     # The Net::SSH session representing the gateway connection.
     attr_reader :session
 
+    MAX_PORT = 65535
+    MIN_PORT = 1024
+
     def initialize(server, config) #:nodoc:
       @config = config
       @pending_forward_requests = {}
       @mutex = Mutex.new
-      @next_port = 31310
+      @next_port = MAX_PORT
       @terminate_thread = false
 
       waiter = ConditionVariable.new
@@ -79,6 +82,13 @@ module SwitchTower
 
     private
 
+      def next_port
+        port = @next_port
+        @next_port -= 1
+        @next_port = MAX_PORT if @next_port < MIN_PORT
+        port
+      end
+
       def process_next_pending_connection_request
         @mutex.synchronize do
           key = @pending_forward_requests.keys.detect { |k| ConditionVariable === @pending_forward_requests[k] } or return
@@ -86,14 +96,16 @@ module SwitchTower
 
           @config.logger.trace "establishing connection to #{key} via gateway"
 
-          port = @next_port
-          @next_port += 1
+          port = next_port
 
           begin
             @session.forward.local(port, key, 22)
             @pending_forward_requests[key] = SSH.connect('127.0.0.1', @config,
               port)
             @config.logger.trace "connection to #{key} via gateway established"
+          rescue Errno::EADDRINUSE
+            port = next_port
+            retry
           rescue Object
             @pending_forward_requests[key] = nil
             raise

data/lib/switchtower/generators/rails/deployment/templates/switchtower.rake

@@ -10,7 +10,11 @@ def switchtower_invoke(*actions)
     # no rubygems to load, so we fail silently
   end
 
-  require 'switchtower/cli'
+  options = actions.last.is_a?(Hash) ? actions.pop : {}
+
+  args = %w[-r config/deploy]
+  verbose = options[:verbose] || "-vvvvv"
+  args << verbose
 
   args = %w[-vvvvv -r config/<%= recipe_file %>]
   args.concat(actions.map { |act| ["-a", act.to_s] }.flatten)
@@ -34,7 +38,7 @@ end
 
 desc "Enumerate all available deployment tasks"
 task :show_deploy_tasks do
-  switchtower_invoke :show_tasks
+  switchtower_invoke :show_tasks, :verbose => ""
 end
 
 desc "Execute a specific action using switchtower"

data/lib/switchtower/logger.rb

@@ -6,6 +6,8 @@ module SwitchTower
     INFO      = 1
     DEBUG     = 2
     TRACE     = 3
+    
+    MAX_LEVEL = 3
 
     def initialize(options={})
       output = options[:output] || STDERR
@@ -27,12 +29,13 @@ module SwitchTower
 
     def log(level, message, line_prefix=nil)
       if level <= self.level
-        if line_prefix
-          message.split(/\r?\n/).each do |line|
-            @device.print "[#{line_prefix}] #{line.strip}\n"
+        indent = "%*s" % [MAX_LEVEL, "*" * (MAX_LEVEL - level)]
+        message.split(/\r?\n/).each do |line|
+          if line_prefix
+            @device.print "#{indent} [#{line_prefix}] #{line.strip}\n"
+          else
+            @device.puts "#{indent} #{line.strip}\n"
           end
-        else
-          @device.puts message.strip
         end
       end
     end

data/lib/switchtower/recipes/standard.rb

@@ -11,10 +11,15 @@
 
 set :rake, "rake"
 
+set :rails_env, :production
+
 set :migrate_target, :current
 set :migrate_env, ""
 
-set :restart_via, :sudo
+set :use_sudo, true
+set(:run_method) { use_sudo ? :sudo : :run }
+
+set :spinner_user, :app
 
 desc "Enumerate and describe every available task."
 task :show_tasks do
@@ -98,12 +103,12 @@ task :symlink, :roles => [:app, :db, :web] do
 end
 
 desc <<-DESC
-Restart the FCGI processes on the app server. This uses the :restart_via
-variable to determine whether to use sudo or not. By default, :restart_via is
-set to :sudo, but you can set it to :run if you are in a shared environment.
+Restart the FCGI processes on the app server. This uses the :use_sudo
+variable to determine whether to use sudo or not. By default, :use_sudo is
+set to true, but you can set it to false if you are in a shared environment.
 DESC
 task :restart, :roles => :app do
-  send(restart_via, "#{current_path}/script/process/reaper")
+  send(run_method, "#{current_path}/script/process/reaper")
 end
 
 desc <<-DESC
@@ -126,7 +131,7 @@ task :migrate, :roles => :db, :only => { :primary => true } do
   end
 
   run "cd #{directory} && " +
-      "#{rake} RAILS_ENV=production #{migrate_env} migrate"
+      "#{rake} RAILS_ENV=#{rails_env} #{migrate_env} migrate"
 end
 
 desc <<-DESC
@@ -189,7 +194,8 @@ end
 desc <<-DESC
 Removes unused releases from the releases directory. By default, the last 5
 releases are retained, but this can be configured with the 'keep_releases'
-variable.
+variable. This will use sudo to do the delete by default, but you can specify
+that run should be used by setting the :use_sudo variable to false.
 DESC
 task :cleanup do
   count = (self[:keep_releases] || 5).to_i
@@ -197,9 +203,42 @@ task :cleanup do
     logger.important "no old releases to clean up"
   else
     logger.info "keeping #{count} of #{releases.length} deployed releases"
-    keepers = (releases - releases.last(count)).map { |release|
+    directories = (releases - releases.last(count)).map { |release|
       File.join(releases_path, release) }.join(" ")
 
-    sudo "rm -rf #{keepers}"
+    send(run_method, "rm -rf #{directories}")
   end
-end
+end
+
+desc <<-DESC
+Start the spinner daemon for the application (requires script/spin). This will
+use sudo to start the spinner by default, unless :use_sudo is false. If using
+sudo, you can specify the user that the spinner ought to run as by setting the
+:spinner_user variable (defaults to :app).
+DESC
+task :spinner, :roles => :app do
+  user = (use_sudo && spinner_user) ? "-u #{spinner_user} " : ""
+  send(run_method, "#{user}#{current_path}/script/spin")
+end
+
+desc <<-DESC
+Used only for deploying when the spinner isn't running. It invokes deploy,
+and when it finishes it then invokes the spinner task (to start the spinner).
+DESC
+task :cold_deploy do
+  deploy
+  spinner
+end
+
+desc <<-DESC
+A simple task for performing one-off commands that may not require a full task
+to be written for them. Simply specify the command to execute via the COMMAND
+environment variable. To execute the command only on certain roles, specify
+the ROLES environment variable as a comma-delimited list of role names. Lastly,
+if you want to execute the command via sudo, specify a non-empty value for the
+SUDO environment variable.
+DESC
+task :invoke, :roles => SwitchTower.str2roles(ENV["ROLES"] || "") do
+  method = ENV["SUDO"] ? :sudo : :run
+  send(method, ENV["COMMAND"])
+end