Module: Baptize::Registry

Defined in:
lib/baptize/registry.rb

Class Method Summary collapse

Class Method Details

.after(subject_name, other_task = nil, &block) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
 
# File 'lib/baptize/registry.rb', line 42

def self.after(subject_name, other_task=nil, &block)
  @afters ||= {}
  @afters[subject_name] ||= []
  if other_task
    @afters[subject_name] << other_task
  elsif block_given?
    @afters[subject_name] << block
  end
  @afters[subject_name]
end

.apply_policy(role, host, ssh_connection) ⇒ Object 



88
89
90
91
92
93
94
95
 
# File 'lib/baptize/registry.rb', line 88

def self.apply_policy(role, host, ssh_connection)
  execution_scope.set :current_host, host
  execution_scope.set :current_ssh_connection, ssh_connection
  policies[role.to_sym].each do |package_name|
    raise "No package '#{package_name}'" unless packages[package_name]
    packages[package_name].execute
  end
end

.before(subject_name, other_task = nil, &block) ⇒ Object 



31
32
33
34
35
36
37
38
39
40
 
# File 'lib/baptize/registry.rb', line 31

def self.before(subject_name, other_task=nil, &block)
  @befores ||= {}
  @befores[subject_name] ||= []
  if other_task
    @befores[subject_name] << other_task
  elsif block_given?
    @befores[subject_name] << block
  end
  @befores[subject_name]
end

.define_package(package_name, &config_block) ⇒ Object 



65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/baptize/registry.rb', line 65

def self.define_package(package_name, &config_block)
  package = PackageDefinition.new(package_name, self.execution_scope, self)
  packages[package.full_name] = package
  package.instance_eval(&config_block)
  if ENV['SKIP_DEPENDENCIES']
    before package.full_name do
      logger.important "Skipping dependencies for package #{package.name}"
    end
  else
    package.dependencies.each do |task_name|
      before package.full_name, task_name
    end
  end
end

.define_policy(role, package_names) ⇒ Object 



84
85
86
 
# File 'lib/baptize/registry.rb', line 84

def self.define_policy(role, package_names)
  policies[role.to_sym] = package_names.map(&:to_s)
end

.define_server(role, host, options = {}) ⇒ Object 



101
102
103
104
105
106
107
 
# File 'lib/baptize/registry.rb', line 101

def self.define_server(role, host, options = {})
  role = role.to_sym
  servers[host] = options.merge(hostname: host)
  servers[host][:roles] ||= []
  servers[host][:roles] << role unless servers[host][:roles].include?(role)
  servers[host]
end

.execution_scope ⇒ Object 



9
10
11
12
13
14
15
16
17
 
# File 'lib/baptize/registry.rb', line 9

def self.execution_scope
  unless @execution_scope
    @execution_scope = ExecutionScope.new
    plugins.each do |plugin_module|
      (class << @execution_scope ; self ; end).send(:include, plugin_module)
    end
  end
  @execution_scope
end

.for_role(role, options = {}, &block) ⇒ Object 



120
121
122
123
 
# File 'lib/baptize/registry.rb', line 120

def self.for_role(role, options={}, &block)
  subset_copy = Marshal.dump(servers_for_role(role))
  SSHKit::Coordinator.new(Marshal.load(subset_copy)).each(options, &block)
end

.logger ⇒ Object 



19
20
21
 
# File 'lib/baptize/registry.rb', line 19

def self.logger
  @logger ||= ::Logger.new(STDOUT)
end

.packages ⇒ Object 



23
24
25
 
# File 'lib/baptize/registry.rb', line 23

def self.packages
  @packages ||= {}
end

.packages_executed ⇒ Object 



27
28
29
 
# File 'lib/baptize/registry.rb', line 27

def self.packages_executed
  @packages_executed ||= []
end

.plugins ⇒ Object 



5
6
7
 
# File 'lib/baptize/registry.rb', line 5

def self.plugins
  @plugins ||= []
end

.policies ⇒ Object 



80
81
82
 
# File 'lib/baptize/registry.rb', line 80

def self.policies
  @policies ||= {}
end

.resolve_dependency(mixed) ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
 
# File 'lib/baptize/registry.rb', line 53

def self.resolve_dependency(mixed)
  if mixed.kind_of?(String) || mixed.kind_of?(Symbol)
    task = packages[mixed.to_s]
    raise "Didn't find a package by that name: '#{mixed}'" if task.nil?
    task.method(:execute)
  elsif mixed.kind_of? PackageDefinition
    mixed.method(:execute)
  else
    mixed
  end
end

.servers ⇒ Object 



97
98
99
 
# File 'lib/baptize/registry.rb', line 97

def self.servers
  @servers ||= {}
end

.servers_for_role(role) ⇒ Object 



109
110
111
112
113
114
115
116
117
118
 
# File 'lib/baptize/registry.rb', line 109

def self.servers_for_role(role)
  role = role.to_sym
  host_columns = [:password, :hostname, :port, :user, :key, :ssh_options]
  servers.values
  .select do |server|
    server[:roles].include?(role)
  end.map do |server|
    server.select {|k,v| host_columns.include?(k) }
  end
end