Module: Baptize::Registry

Defined in:
lib/baptize/registry.rb

Class Method Summary collapse

Class Method Details

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



46
47
48
49
50
51
52
53
54
55
 
# File 'lib/baptize/registry.rb', line 46

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, options = {}) ⇒ Object 



92
93
94
95
96
97
98
99
100
101
 
# File 'lib/baptize/registry.rb', line 92

def self.apply_policy(role, options={})
  ssh_for_role role do |host, ssh_for_role|
    policies[role.to_sym].each do |package_name|
      if options[:package].nil? || package_name.to_sym == options[:package].to_sym
        raise "No package '#{package_name}'" unless packages[package_name]
        packages[package_name].execute(force: options[:force])
      end
    end
  end
end

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



35
36
37
38
39
40
41
42
43
44
 
# File 'lib/baptize/registry.rb', line 35

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 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/baptize/registry.rb', line 69

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 



88
89
90
 
# File 'lib/baptize/registry.rb', line 88

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

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



107
108
109
110
111
112
113
 
# File 'lib/baptize/registry.rb', line 107

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 



126
127
128
129
 
# File 'lib/baptize/registry.rb', line 126

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

.has_package?(package_name) ⇒ Boolean

Returns:

  • (Boolean) 


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

def self.has_package?(package_name)
  !! @packages[package_name]
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 



31
32
33
 
# File 'lib/baptize/registry.rb', line 31

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 



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

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

.resolve_dependency(mixed) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/baptize/registry.rb', line 57

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 



103
104
105
 
# File 'lib/baptize/registry.rb', line 103

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

.servers_for_role(role) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
 
# File 'lib/baptize/registry.rb', line 115

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

.ssh_for_role(role, &block) ⇒ Object 



131
132
133
134
135
136
137
138
 
# File 'lib/baptize/registry.rb', line 131

def self.ssh_for_role(role, &block)
  registry = self
  for_role role, in: :parallel do |host|
    registry.execution_scope.set :current_host, host
    registry.execution_scope.set :current_ssh_connection, self
    block.call
  end
end