Class: SwitchTower::Actor

Inherits:
Object
  • Object
show all
Defined in:
lib/switchtower/actor.rb

Overview

An Actor is the entity that actually does the work of determining which servers should be the target of a particular task, and of executing the task on each of them in parallel. An Actor is never instantiated directly–rather, you create a new Configuration instance, and access the new actor via Configuration#actor.

Defined Under Namespace

Classes: DefaultConnectionFactory, Task, TaskCallFrame

Class Attribute Summary collapse

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(config) ⇒ Actor

:nodoc:



93
94
95
96
97
98
99
 
# File 'lib/switchtower/actor.rb', line 93

def initialize(config) #:nodoc:
  @configuration = config
  @tasks = {}
  @task_call_frames = []
  @sessions = {}
  @factory = self.class.connection_factory.new(configuration)
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(sym, *args, &block) ⇒ Object (private) 



342
343
344
345
346
347
348
 
# File 'lib/switchtower/actor.rb', line 342

def method_missing(sym, *args, &block)
  if @configuration.respond_to?(sym)
    @configuration.send(sym, *args, &block)
  else
    super
  end
end

Class Attribute Details

.command_factory ⇒ Object

Returns the value of attribute command_factory.



29
30
31
 
# File 'lib/switchtower/actor.rb', line 29

def command_factory
  @command_factory
end

.connection_factory ⇒ Object

Returns the value of attribute connection_factory.



28
29
30
 
# File 'lib/switchtower/actor.rb', line 28

def connection_factory
  @connection_factory
end

Instance Attribute Details

#configuration ⇒ Object (readonly)

The configuration instance associated with this actor.



36
37
38
 
# File 'lib/switchtower/actor.rb', line 36

def configuration
  @configuration
end

#sessions ⇒ Object (readonly)

A hash of the SSH sessions that are currently open and available. Because sessions are constructed lazily, this will only contain connections to those servers that have been the targets of one or more executed tasks.



46
47
48
 
# File 'lib/switchtower/actor.rb', line 46

def sessions
  @sessions
end

#task_call_frames ⇒ Object (readonly)

The call stack of the tasks. The currently executing task may inspect this to see who its caller was. The current task is always the last element of this stack.



51
52
53
 
# File 'lib/switchtower/actor.rb', line 51

def task_call_frames
  @task_call_frames
end

#task_call_history ⇒ Object (readonly)

The history of executed tasks. This will be an array of all tasks that have been executed, in the order in which they were called.



55
56
57
 
# File 'lib/switchtower/actor.rb', line 55

def task_call_history
  @task_call_history
end

#tasks ⇒ Object (readonly)

A hash of the tasks known to this actor, keyed by name. The values are instances of Actor::Task.



40
41
42
 
# File 'lib/switchtower/actor.rb', line 40

def tasks
  @tasks
end

Instance Method Details

#current_release ⇒ Object

Returns the most recent deployed release



258
259
260
 
# File 'lib/switchtower/actor.rb', line 258

def current_release
  release_path(releases.last)
end

#define_task(name, options = {}, &block) ⇒ Object

Define a new task for this actor. The block will be invoked when this task is called.



103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/switchtower/actor.rb', line 103

def define_task(name, options={}, &block)
  @tasks[name] = Task.new(name, options)
  define_method(name) do
    send "before_#{name}" if respond_to? "before_#{name}"
    logger.trace "executing task #{name}"
    begin
      push_task_call_frame name
      result = instance_eval &block
    ensure
      pop_task_call_frame
    end
    send "after_#{name}" if respond_to? "after_#{name}"
    result
  end
end

#delete(path, options = {}) ⇒ Object

Deletes the given file from all servers targetted by the current task. If :recursive => true is specified, it may be used to remove directories.



152
153
154
155
 
# File 'lib/switchtower/actor.rb', line 152

def delete(path, options={})
  cmd = "rm -%sf #{path}" % (options[:recursive] ? "r" : "")
  run(cmd, options)
end

#on_rollback(&block) ⇒ Object

Specifies an on_rollback hook for the currently executing task. If this or any subsequent task then fails, and a transaction is active, this hook will be executed.



301
302
303
 
# File 'lib/switchtower/actor.rb', line 301

def on_rollback(&block)
  task_call_frames.last.rollback = block
end

#previous_release ⇒ Object

Returns the release immediately before the currently deployed one



263
264
265
 
# File 'lib/switchtower/actor.rb', line 263

def previous_release
  release_path(releases[-2])
end

#put(data, path, options = {}) ⇒ Object

Store the given data at the given location on all servers targetted by the current task. If :mode is specified it is used to set the mode on the file.



160
161
162
163
164
165
166
167
168
169
 
# File 'lib/switchtower/actor.rb', line 160

def put(data, path, options={})
  # Poor-man's SFTP... just run a cat on the remote end, and send data
  # to it.

  cmd = "cat > #{path}"
  cmd << " && chmod #{options[:mode].to_s(8)} #{path}" if options[:mode]
  run(cmd, options.merge(:data => data + "\n\4")) do |ch, stream, out|
    logger.important out, "#{stream} :: #{ch[:host]}" if out == :err
  end
end

#releases ⇒ Object

Inspects the remote servers to determine the list of all released versions of the software. Releases are sorted with the most recent release last.



244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/switchtower/actor.rb', line 244

def releases
  unless @releases
    buffer = ""
    run "ls -x1 #{releases_path}", :once => true do |ch, str, out|
      buffer << out if str == :out
      raise "could not determine releases #{out.inspect}" if str == :err
    end
    @releases = buffer.split.sort
  end

  @releases
end

#render(*args) ⇒ Object

Renders an ERb template and returns the result. This is useful for dynamically building documents to store on the remote servers.

Usage:

render("something", :foo => "hello")
  look for "something.rhtml" in the current directory, or in the
  switchtower/recipes/templates directory, and render it with
  foo defined as a local variable with the value "hello".

render(:file => "something", :foo => "hello")
  same as above

render(:template => "<%= foo %> world", :foo => "hello")
  treat the given string as an ERb template and render it with
  the given hash of local variables active.

Raises:

  • (ArgumentError) 


204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/switchtower/actor.rb', line 204

def render(*args)
  options = args.last.is_a?(Hash) ? args.pop : {}
  options[:file] = args.shift if args.first.is_a?(String)
  raise ArgumentError, "too many parameters" unless args.empty?

  case
    when options[:file]
      file = options.delete :file
      unless file[0] == ?/
        dirs = [".",
          File.join(File.dirname(__FILE__), "recipes", "templates")]
        dirs.each do |dir|
          if File.file?(File.join(dir, file))
            file = File.join(dir, file)
            break
          elsif File.file?(File.join(dir, file + ".rhtml"))
            file = File.join(dir, file + ".rhtml")
            break
          end
        end
      end

      render options.merge(:template => File.read(file))

    when options[:template]
      erb = ERB.new(options[:template])
      b = Proc.new { binding }.call
      options.each do |key, value|
        next if key == :template
        eval "#{key} = options[:#{key}]", b
      end
      erb.result(b)

    else
      raise ArgumentError, "no file or template given for rendering"
  end
end

#run(cmd, options = {}, &block) ⇒ Object

Execute the given command on all servers that are the target of the current task. If a block is given, it is invoked for all output generated by the command, and should accept three parameters: the SSH channel (which may be used to send data back to the remote process), the stream identifier (:err for stderr, and :out for stdout), and the data that was received.

If pretend mode is active, this does nothing.



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/switchtower/actor.rb', line 127

def run(cmd, options={}, &block)
  block ||= Proc.new do |ch, stream, out|
    logger.debug(out, "#{stream} :: #{ch[:host]}")
  end

  logger.debug "executing #{cmd.strip.inspect}"

  # get the currently executing task and determine which servers it uses
  servers = tasks[task_call_frames.last.name].servers(configuration)
  servers = servers.first if options[:once]
  logger.trace "servers: #{servers.inspect}"

  if !pretend
    # establish connections to those servers, as necessary
    establish_connections(servers)

    # execute the command on each server in parallel
    command = self.class.command_factory.new(servers, cmd, block, options, self)
    command.process! # raises an exception if command fails on any server
  end
end

#sudo(command, options = {}, &block) ⇒ Object

Like #run, but executes the command via sudo. This assumes that the sudo password (if required) is the same as the password for logging in to the server.



174
175
176
177
178
179
180
181
182
183
184
185
186
 
# File 'lib/switchtower/actor.rb', line 174

def sudo(command, options={}, &block)
  block ||= Proc.new do |ch, stream, out|
    logger.debug(out, "#{stream} :: #{ch[:host]}")
  end

  run "sudo #{command}", options do |ch, stream, out|
    if out =~ /^Password:/
      ch.send_data "#{password}\n"
    else
      block.call(ch, stream, out)
    end
  end
end

#transaction ⇒ Object

Invoke a set of tasks in a transaction. If any task fails (raises an exception), all tasks executed within the transaction are inspected to see if they have an associated on_rollback hook, and if so, that hook is called.



271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
 
# File 'lib/switchtower/actor.rb', line 271

def transaction
  if task_call_history
    yield
  else
    logger.info "transaction: start"
    begin
      @task_call_history = []
      yield
      logger.info "transaction: commit"
    rescue Object => e
      current = task_call_history.last
      logger.important "transaction: rollback", current ? current.name : "transaction start"
      task_call_history.reverse.each do |task|
        begin
          logger.debug "rolling back", task.name
          task.rollback.call if task.rollback
        rescue Object => e
          logger.info "exception while rolling back: #{e.class}, #{e.message}", task.name
        end
      end
      raise
    ensure
      @task_call_history = nil
    end
  end
end