Module: Fezzik

Defined in:
lib/fezzik/dsl.rb,
lib/fezzik/base.rb,
lib/fezzik/role.rb,
lib/fezzik/util.rb,
lib/fezzik/version.rb,
lib/fezzik/host_task.rb,
lib/fezzik/environment.rb

Defined Under Namespace

Modules: DSL, Util Classes: HostTask

Constant Summary collapse

WEAVE_OPTIONS = 
[:num_threads, :serial, :batch_by]
VERSION = 
"0.8.2"

Class Method Summary collapse

Class Method Details

.activated=(value) ⇒ Object 



2
 
# File 'lib/fezzik/base.rb', line 2

def self.activated=(value) @activated = value end

.activated? ⇒ Boolean

Returns:

  • (Boolean) 


3
 
# File 'lib/fezzik/base.rb', line 3

def self.activated?() @activated || false end

.clear(name) ⇒ Object 



28
 
# File 'lib/fezzik/base.rb', line 28

def self.clear(name) @@settings.delete(name) end

.destination(*names, &block) ⇒ Object 



64
65
66
67
68
 
# File 'lib/fezzik/base.rb', line 64

def self.destination(*names, &block)
  @destinations ||= Set.new
  @destinations.merge(names)
  block.call if names.include?(@target_destination)
end

.destinations ⇒ Object 



74
75
76
 
# File 'lib/fezzik/base.rb', line 74

def self.destinations
  @destinations ||= Set.new
end

.env(key, value, options = {}) ⇒ Object 



2
3
4
5
6
7
8
9
 
# File 'lib/fezzik/environment.rb', line 2

def self.env(key, value, options={})
  options = {
    :hosts => Fezzik.get(:domain)
  }.merge(options)
  options[:hosts] = Array(options[:hosts])
  @environments ||= Hash.new { |h, k| h[k] = {} }
  options[:hosts].each { |host| @environments[host][key] = value }
end

.environments ⇒ Object 



11
12
13
 
# File 'lib/fezzik/environment.rb', line 11

def self.environments
  @environments ||= Hash.new { |h, k| h[k] = {} }
end

.get(name) ⇒ Object 



23
24
25
26
 
# File 'lib/fezzik/base.rb', line 23

def self.get(name)
  raise "Fezzik: No such setting: #{name}" unless @@settings.has_key?(name)
  @@settings[name]
end

.host_task(name, options = {}, &block) ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/fezzik/base.rb', line 39

def self.host_task(name, options = {}, &block)
  options = {
    :args => [],
    :deps => [],
    :roles => []
  }.merge(options)
  weave_options = options.dup.keep_if { |k, v| WEAVE_OPTIONS.include? k }
  options.delete_if { |k, v| WEAVE_OPTIONS.include? k }
  options.each { |key, value| options[key] = Array(value) }
  t = HostTask.define_task(name, { options[:args] => options[:deps] }, &block)
  t.roles += options[:roles]
  t.weave_options = t.weave_options.merge(weave_options)
end

.init(options = {}) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
 
# File 'lib/fezzik/base.rb', line 53

def self.init(options={})
  @options = options
  @target_destination = ENV["fezzik_destination"].to_sym rescue nil
  unless options[:tasks].nil?
    $stderr.puts "Loading Fezzik tasks from #{@options[:tasks]}"
    Dir[File.join(File.expand_path(@options[:tasks]), "**", "*.rake")].sort.each do |lib|
      Rake.application.add_import(lib)
    end
  end
end

.remote_task(*args, &block) ⇒ Object 



30
31
32
33
34
35
 
# File 'lib/fezzik/base.rb', line 30

def self.remote_task(*args, &block)
  warn "WARN [Fezzik]: remote_task is deprecated as of 0.8.0, use host_task instead"
  roles = (Hash === args.last && args.last[:roles]) ? args.pop[:roles] : []
  name, args, deps = Rake.application.resolve_args(args)
  host_task(name, { :args => Array(args), :deps => Array(deps), :roles => Array(roles) }, &block)
end

.role(role_name, settings) ⇒ Object 



2
3
4
5
 
# File 'lib/fezzik/role.rb', line 2

def self.role(role_name, settings)
  @roles ||= {}
  @roles[role_name] = settings
end

.roles ⇒ Object 



7
 
# File 'lib/fezzik/role.rb', line 7

def self.roles() @roles ||= {} end

.set(name, value) ⇒ Object 



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/fezzik/base.rb', line 5

def self.set(name, value)
  @@settings ||= {}

  value = Array(value) if name == :domain

  @@settings[name] = value

  if Object.public_instance_methods.include? name.to_sym
    Object.send :alias_method, :"old_#{name}", name
  end

  Object.send :define_method, name do
    warn "WARN [Fezzik]: accessing #{name} at the top-level is deprecated as of 0.8.0," +
         " use Fezzik.get(:#{name}) instead"
    Fezzik.get name
  end
end

.target_destination ⇒ Object 



70
71
72
 
# File 'lib/fezzik/base.rb', line 70

def self.target_destination
  @target_destination ||= nil
end

.with_role(role_name, &block) ⇒ Object 



9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
# File 'lib/fezzik/role.rb', line 9

def self.with_role(role_name, &block)
  return block.call if roles[role_name].nil?

  overridden_settings = {}
  new_settings = []
  roles[role_name].each_key do |name|
    if @@settings.has_key? name
      overridden_settings[name] = Fezzik.get(name)
    else
      new_settings << name
    end
  end
  override_settings(roles[role_name])
  begin
    block.call
  ensure
    override_settings(overridden_settings, new_settings)
  end
end