Class: Rye::Set

Inherits:
Object
  • Object
show all
Defined in:
lib/rye/set.rb,
lib/rye/dsl.rb

Overview

Rye::Set

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(name = 'default', opts = {}) ⇒ Set

  • name The name of the set of machines

  • opts a hash of optional arguments

The opts hash is used as defaults for all for all Rye::Box objects. All args supported by Rye::Box are available here with the addition of:

  • :parallel => run the commands in parallel? true or false (default).



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/rye/set.rb', line 25

def initialize(name='default', opts={})
  @name = name
  @boxes = []

  # These opts are use by Rye::Box and also passed to Net::SSH
  @opts = {
    :parallel => false,
    :user => Rye.sysinfo.user,
    :safe => true,
    :port => 22,
    :keys => [],
    :password => nil,
    :proxy => nil,
    :debug => nil,
    :error => STDERR,
  }.merge(opts)

  @parallel = @opts.delete(:parallel) # Rye::Box doesn't have :parallel

  @safe = @opts[:safe]
  @debug = @opts[:debug]
  @error = @opts[:error]

  @opts[:keys] = [@opts[:keys]].flatten.compact

  add_keys(@opts[:keys])
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(meth, *args, &block) ⇒ Object

Catches calls to Rye::Box commands. If meth is the name of an instance method defined in Rye::Cmd then we call it against all the boxes in @boxes. Otherwise this method raises a Rye::CommandNotFound exception. It will also raise a Rye::NoBoxes exception if this set has no boxes defined.

Returns a Rye::Rap object containing the responses from each Rye::Box.

Raises:



142
143
144
145
146
147
148
149
150
 
# File 'lib/rye/set.rb', line 142

def method_missing(meth, *args, &block)
  # Ruby 1.8 populates Module.instance_methods with Strings. 1.9 uses Symbols.
  meth = (Rye.sysinfo.ruby[1] == 8) ? meth.to_s : meth.to_sym
  raise Rye::NoBoxes if @boxes.empty?
  if @safe
    raise Rye::CommandNotFound, meth.to_s unless Rye::Box.instance_methods.member?(meth)
  end
  run_command(meth, *args, &block)
end

Instance Attribute Details

#boxes ⇒ Object (readonly)

Returns the value of attribute boxes.



10
11
12
 
# File 'lib/rye/set.rb', line 10

def boxes
  @boxes
end

#name ⇒ Object (readonly)

Returns the value of attribute name.



9
10
11
 
# File 'lib/rye/set.rb', line 9

def name
  @name
end

#opts ⇒ Object (readonly)

Returns the value of attribute opts.



11
12
13
 
# File 'lib/rye/set.rb', line 11

def opts
  @opts
end

#parallel ⇒ Object

Run commands in parallel? A Boolean value. Default: false.



14
15
16
 
# File 'lib/rye/set.rb', line 14

def parallel
  @parallel
end

Instance Method Details

#[](key = nil) ⇒ Object

See Rye::Box.[]



120
121
122
123
 
# File 'lib/rye/set.rb', line 120

def [](key=nil)
  run_command(:cd, key)
  self
end

#add_box(*boxes) ⇒ Object Also known as: add_boxes

  • boxes one or more boxes. Rye::Box objects will be added directly

to the set. Hostnames will be used to create new instances of Rye::Box and those will be added to the list.



60
61
62
63
64
65
66
67
68
 
# File 'lib/rye/set.rb', line 60

def add_box(*boxes)
  boxes = boxes.flatten.compact
  @boxes += boxes.collect do |box|
    box = Rye::Box.new(box, @opts) if box.is_a?(String)
    box.add_keys(@keys)
    box
  end
  self
end

#add_keys(*additional_keys) ⇒ Object Also known as: add_key

Add one or more private keys to each box. Also stores key paths in the set so when new boxes are added they will get the same keys,

  • additional_keys is a list of file paths to private keys

Returns the instance of Rye::Set



75
76
77
78
79
80
81
82
83
84
 
# File 'lib/rye/set.rb', line 75

def add_keys(*additional_keys)
  additional_keys = additional_keys.flatten.compact
  @opts[:keys] ||= []
  @opts[:keys] += additional_keys
  @opts[:keys].uniq!
  @boxes.each do |box|
    box.add_keys *additional_keys
  end
  self
end

#cd(key = nil) ⇒ Object

alias :cd :‘[]’ # fix for jruby



125
126
127
128
 
# File 'lib/rye/set.rb', line 125

def cd(key=nil)
  run_command(:cd, key)
  self
end

#empty? ⇒ Boolean

Are there any boxes in this set?

Returns:

  • (Boolean) 


131
132
133
 
# File 'lib/rye/set.rb', line 131

def empty?
  @boxes.nil? || @boxes.empty?
end

#inspect ⇒ Object 



114
115
116
117
 
# File 'lib/rye/set.rb', line 114

def inspect
  a = [self.class.to_s, @name, @parallel, @opts.inspect, @boxes.inspect]
  %q{#<%s:%s parallel=%s opts=%s boxes=%s>} % a
end

#keys ⇒ Object

See Rye.keys



106
107
108
 
# File 'lib/rye/set.rb', line 106

def keys
  Rye.keys
end

#remove_keys(*keys) ⇒ Object Also known as: remove_key 



87
88
89
90
91
92
93
94
 
# File 'lib/rye/set.rb', line 87

def remove_keys(*keys)
  @opts[:keys] ||= []
  @opts[:keys] -= keys.flatten.compact
  @boxes.each do |box|
    box.remove_keys keys.flatten.compact
  end
  self
end

#root? ⇒ Boolean

Returns:

  • (Boolean) 


55
 
# File 'lib/rye/set.rb', line 55

def root?; user.to_s == "root" end

#run(cmd) ⇒ Object 



5
6
7
 
# File 'lib/rye/dsl.rb', line 5

def run cmd
  instance_eval &@@command[cmd]
end

#setenv(n, v) ⇒ Object Also known as: setenvironment_variable

Add an environment variable. n and v are the name and value. Returns the instance of Rye::Set



99
100
101
102
 
# File 'lib/rye/set.rb', line 99

def setenv(n, v)
  run_command(:setenv, n, v)
  self
end

#to_s ⇒ Object 



110
111
112
 
# File 'lib/rye/set.rb', line 110

def to_s
  "%s:%s" % [self.class.to_s, @name]
end

#user ⇒ Object 



54
 
# File 'lib/rye/set.rb', line 54

def user; (@opts || {})[:user]; end