Class: Onceover::Beaker

Inherits:
Object
  • Object
show all
Defined in:
lib/onceover/beaker.rb

Class Method Summary collapse

Class Method Details

.deploy_controlrepo_on(host, repo = Onceover::Controlrepo.new()) ⇒ Object

This little method will deploy a Controlrepo object to a host, just using r10k deploy



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/onceover/beaker.rb', line 111

def self.deploy_controlrepo_on(host, repo = Onceover::Controlrepo.new())
  warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"

  require 'beaker-rspec'
  require 'onceover/controlrepo'

  if host.is_a?(Array)
    hosts.each do |single_host|
      deploy_controlrepo_on(single_host)
    end
  end

  # Use a beaker helper to do the install (*nix only)
  install_r10k_on(host)

  # Use beaker to install git
  host.install_package('git')

  # copy the file over to the host (Maybe I should be changing the directory here??)
  scp_to(host, repo.r10k_config_file, '/tmp/r10k.yaml')

  # Do an r10k deploy
  r10k_deploy(host, {
    :puppetfile => true,
    :configfile => '/tmp/r10k.yaml',
    })
end

.facts_to_platform(facts) ⇒ Object

This will take a fact set and return the beaker platform of that machine This is necissary as beaker needs the platform set up correctly to know which commands to run when we do stuff. Personally I would prefer beaker to detect the platform as it would not be that hard, especially once puppet is installed, oh well.



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/onceover/beaker.rb', line 63

def self.facts_to_platform(facts)
  warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"

  if facts.is_a?(Array)
    returnval = []
    facts.each do |fact|
      returnval << self.facts_to_platform(fact)
    end
    return returnval
  end

  begin
    if facts['os']['family'] == 'RedHat'
      platform = 'el'
      version = facts['os']['release']['major']
    end
  rescue
    # Do nothing, this is the easiest way to handle the hash being in different formats
  end

  begin
    if facts['os']['distro']['id'] == 'Ubuntu'
      platform = 'ubuntu'
      version = facts['os']['distro']['release']['major']
    end
  rescue
    # Do nothing, this is the easiest way to handle the hash being in different formats
  end

  begin
    if facts['os']['distro']['id'] == 'Debian'
      platform = 'debian'
      version = facts['os']['distro']['release']['full']
    end
  rescue
    # Do nothing
  end

  if facts['os']['architecture'] =~ /64/
    arch = '64'
  else
    arch = '32'
  end

  "#{platform}-#{version}-#{arch}"
end

.facts_to_vagrant_box(facts) ⇒ Object

WARNING: All of this functionality is deprecated. It will be left around until there is something to replace it, but don’t rely on it



8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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
52
53
54
55
56
57
 
# File 'lib/onceover/beaker.rb', line 8

def self.facts_to_vagrant_box(facts)
  warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"
  # Gets the most similar vagrant box to the facts set provided, will accept a single fact
  # se or an array

  if facts.is_a?(Array)
    returnval = []
    facts.each do |fact|
      returnval << self.facts_to_vagrant_box(fact)
    end
    return returnval
  end

  begin
    if facts['os']['distro']['id'] == 'Ubuntu'
      os = 'ubuntu'
      version = facts['os']['distro']['release']['major']
    end
  rescue
    # Do nothing, this is the easiest way to handle the hash bing in different formats
  end

  begin
    if facts['os']['distro']['id'] == 'Debian'
      os = 'Debian'
      version = facts['os']['distro']['release']['full']
    end
  rescue
    # Do nothing
  end

  begin
    if facts['os']['family'] == "RedHat"
      os = 'centos'
      version = "#{facts['os']['release']['major']}.#{facts['os']['release']['minor']}"
    end
  rescue
    # Do nothing
  end

  return "UNKNOWN" unless os.is_a?(String)

  if facts['os']['architecture'] =~ /64/
    arch = '64'
  else
    arch = '32'
  end

  "puppetlabs/#{os}-#{version}-#{arch}-puppet"
end

.host_create(name, nodes) ⇒ Object 



197
198
199
200
201
202
203
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/onceover/beaker.rb', line 197

def self.host_create(name, nodes)
  warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"

  require 'beaker/network_manager'

  current_opts = {}
  nodes.each do |opt,val|
    if opt == :HOSTS
      val.each do |k,v|
        if k == name
          current_opts[:HOSTS] = {k => v}
        end
      end
    else
      current_opts[opt] = val
    end
  end

  # I copied this code off the internet, basically it allows us
  # to refer to each key as either a string or an object
  current_opts.default_proc = proc do |h, k|
    case k
      when String then sym = k.to_sym; h[sym] if h.key?(sym)
      when Symbol then str = k.to_s; h[str] if h.key?(str)
    end
  end

  @nwm = ::Beaker::NetworkManager.new(current_opts,logger)
  @nwm.provision
  @nwm.proxy_package_manager
  @nwm.validate
  @nwm.configure

  @nwm.instance_variable_get(:@hosts).each do |host|
    host.instance_variable_set(:@nwm,@nwm)
    host.define_singleton_method(:down!) do
      @nwm.cleanup
    end
  end

  raise "The networkmanager created too many machines! Only expecting one" if hosts.count > 1

  @nwm.instance_variable_get(:@hosts)[0]
end

.match_indentation(test, logger) ⇒ Object 



191
192
193
194
195
 
# File 'lib/onceover/beaker.rb', line 191

def self.match_indentation(test,logger)
  warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"

  logger.line_prefix = '  ' * (test.metadata[:scoped_id].split(':').count - 1)
end

.provision_and_test(host, puppet_class, opts = {}, repo = Onceover::Controlrepo.new) ⇒ Object

This actually provisions a node and checks that puppet will be able to run and be idempotent. It hacks the beaker NetworkManager object to do this. The reason is that beaker is designed to run in the following order:

1. Spin up nodes
2. Run all tests
3. Kill all nodes

This is not helpful for us. We want to be able to test all of our classes on all of our nodes, this could be a lot of vms and having them all running at once would be a real kick in the dick for whatever system was running it.



149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
 
# File 'lib/onceover/beaker.rb', line 149

def self.provision_and_test(host,puppet_class,opts = {}, repo = Onceover::Controlrepo.new)
  warn "[DEPRECATION] #{__method__} is deprecated due to the removal of Beaker"

  opts = {:runs_before_idempotency => 1}.merge(opts)
  opts = {:check_idempotency => true}.merge(opts)
  opts = {:deploy_controlrepo => true}.merge(opts)


  raise "Hosts must be a single host object, not an array" if host.is_a?(Array)
  raise "Class must be a single Class [String], not an array" unless puppet_class.is_a?(String)

  # Create our own NWM object that we are going to interact with
  # Note here that 'options', 'logger' and are exposed within the rspec tests
  # if this is run outside of that context it will fail
  network_manager = ::Beaker::NetworkManager.new(options,logger)

  # Hack the network manager to smash our host in there without provisioning
  network_manager.instance_variable_set(:@hosts,[host])

  # Now that we have a working network manager object, we can provision, but only if
  # we need to, ahhh smart...
  unless host.up?
    network_manager.provision
    network_manager.proxy_package_manager
    network_manager.validate
    network_manager.configure
  end

  # Actually run the tests
  manifest = "include #{puppet_class}"

  opts[:runs_before_idempotency].times do
    apply_manifest_on(host, manifest, {:catch_failures => true})
  end

  if opts[:check_idempotency]
    apply_manifest_on(host, manifest, {:catch_changes => true})
  end

  network_manager.cleanup
end