Class: Beaker::GoogleCompute

Inherits:
Hypervisor show all
Defined in:
lib/beaker/hypervisor/google_compute.rb

Overview

Beaker support for the Google Compute Engine.

Constant Summary collapse

SLEEPWAIT = 
5
ZOMBIE =

number of hours before an instance is considered a zombie

3

Constants inherited from Hypervisor

Hypervisor::CHARMAP

Constants included from HostPrebuiltSteps

HostPrebuiltSteps::APT_CFG, HostPrebuiltSteps::ETC_HOSTS_PATH, HostPrebuiltSteps::ETC_HOSTS_PATH_SOLARIS, HostPrebuiltSteps::IPS_PKG_REPO, HostPrebuiltSteps::NTPSERVER, HostPrebuiltSteps::PACKAGES, HostPrebuiltSteps::ROOT_KEYS_SCRIPT, HostPrebuiltSteps::ROOT_KEYS_SYNC_CMD, HostPrebuiltSteps::SLES_PACKAGES, HostPrebuiltSteps::TRIES, HostPrebuiltSteps::UNIX_PACKAGES

Instance Method Summary collapse

Methods inherited from Hypervisor

#configure, create, #generate_host_name, #validate

Methods included from HostPrebuiltSteps

#add_el_extras, #add_master_entry, #apt_get_update, #copy_file_to_remote, #copy_ssh_to_root, #disable_iptables, #disable_se_linux, #enable_root_login, #epel_info_for!, #get_domain_name, #get_ip, #hack_etc_hosts, #proxy_config, #set_etc_hosts, #sync_root_keys, #timesync, #validate_host

Constructor Details

#initialize(google_hosts, options) ⇒ GoogleCompute

Create a new instance of the Google Compute Engine hypervisor object

Parameters:

  • google_hosts (<Host>) —

    The array of google hosts to provision, may ONLY be of platforms /centos-6-.*/ and /debian-7-.*/. We currently only support the Google Compute provided templates.

  • options (Hash{Symbol=>String}) —

    The options hash containing configuration values

Options Hash (options):

  • :gce_project (String) —

    The Google Compute Project name to connect to

  • :gce_keyfile (String) —

    The location of the Google Compute service account keyfile

  • :gce_password (String) —

    The password for the Google Compute service account key

  • :gce_email (String) —

    The email address for the Google Compute service account

  • :gce_machine_type (String) —

    A Google Compute machine type used to create instances, defaults to n1-highmem-2

  • :timeout (Integer) —

    The amount of time to attempt execution before quiting and exiting with failure



21
22
23
24
25
26
27
 
# File 'lib/beaker/hypervisor/google_compute.rb', line 21

def initialize(google_hosts, options)
  @options = options
  @logger = options[:logger]
  @hosts = google_hosts
  @firewall = ''
  @gce_helper = GoogleComputeHelper.new(options)
end

Instance Method Details

#cleanup ⇒ Object

Shutdown and destroy virtual machines in the Google Compute Engine, including their associated disks and firewall rules



86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
# File 'lib/beaker/hypervisor/google_compute.rb', line 86

def cleanup()
  attempts = @options[:timeout].to_i / SLEEPWAIT
  start = Time.now

  @gce_helper.delete_firewall(@firewall, start, attempts) 

  @hosts.each do |host|
    @gce_helper.delete_instance(host['vmhostname'], start, attempts)
    @logger.debug("Deleted Google Compute instance #{host['vmhostname']} for #{host.name}")
    @gce_helper.delete_disk(host['diskname'], start, attempts)
    @logger.debug("Deleted Google Compute disk #{host['diskname']} for #{host.name}")
  end

end

#kill_zombies(max_age = ZOMBIE) ⇒ Object

Shutdown and destroy Google Compute instances (including their associated disks and firewall rules) that have been alive longer than ZOMBIE hours.



103
104
105
106
107
108
109
110
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
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/beaker/hypervisor/google_compute.rb', line 103

def kill_zombies(max_age = ZOMBIE)
  now = start = Time.now
  attempts = @options[:timeout].to_i / SLEEPWAIT

  #get rid of old instances 
  instances = @gce_helper.list_instances(start, attempts)
  if instances
    instances.each do |instance|
      created = Time.parse(instance['creationTimestamp'])
      alive = (now - created ) /60 /60
      if alive >= max_age
        #kill it with fire!
        @logger.debug("Deleting zombie instance #{instance['name']}")
        @gce_helper.delete_instance( instance['name'], start, attempts )
      end
    end
  else 
    @logger.debug("No zombie instances found")
  end
  #get rid of old disks
  disks = @gce_helper.list_disks(start, attempts)
  if disks
    disks.each do |disk|
      created = Time.parse(disk['creationTimestamp'])
      alive = (now - created ) /60 /60
      if alive >= max_age
        #kill it with fire!
        @logger.debug("Deleting zombie disk #{disk['name']}")
        @gce_helper.delete_disk( disk['name'], start, attempts )
      end
    end
  else
    @logger.debug("No zombie disks found")
  end
  #get rid of non-default firewalls
  firewalls = @gce_helper.list_firewalls( start, attempts)

  if firewalls and not firewalls.empty?
    firewalls.each do |firewall|
      @logger.debug("Deleting non-default firewall #{firewall['name']}")
      @gce_helper.delete_firewall( firewall['name'], start, attempts )
    end
  else
    @logger.debug("No zombie firewalls found")
  end

end

#provision ⇒ Object

Create and configure virtual machines in the Google Compute Engine, including their associated disks and firewall rules Currently ONLY supports Google Compute provided templates of CENTOS-6 and DEBIAN-7



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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/beaker/hypervisor/google_compute.rb', line 31

def provision
  try = 1
  attempts = @options[:timeout].to_i / SLEEPWAIT
  start = Time.now

  #get machineType resource, used by all instances
  machineType = @gce_helper.get_machineType(start, attempts)

  #set firewall to open pe ports
  network = @gce_helper.get_network(start, attempts)
  @firewall = generate_host_name
  @gce_helper.create_firewall(@firewall, network, start, attempts)

  @logger.debug("Created Google Compute firewall #{@firewall}")


  @hosts.each do |host|
    img = @gce_helper.get_latest_image(host[:platform], start, attempts)
    host['diskname'] = generate_host_name
    disk = @gce_helper.create_disk(host['diskname'], img, start, attempts)
    @logger.debug("Created Google Compute disk for #{host.name}: #{host['diskname']}")

    #create new host name
    host['vmhostname'] = generate_host_name
    #add a new instance of the image
    instance = @gce_helper.create_instance(host['vmhostname'], img, machineType, disk, start, attempts)
    @logger.debug("Created Google Compute instance for #{host.name}: #{host['vmhostname']}")
    #add metadata to instance
    @gce_helper.setMetadata_on_instance(host['vmhostname'], instance['metadata']['fingerprint'],
                                        [ {:key => :department, :value => @options[:department]}, 
                                          {:key => :project, :value => @options[:project]} ], 
                                        start, attempts)
    @logger.debug("Added tags to Google Compute instance #{host.name}: #{host['vmhostname']}")

    #get ip for this host
    host['ip'] = instance['networkInterfaces'][0]['accessConfigs'][0]['natIP']

    #configure ssh
    default_user = host['user']
    host['user'] = 'google_compute'

    disable_se_linux(host, @options)
    disable_iptables(host, @options)
    copy_ssh_to_root(host, @options)
    (host, @options)
    host['user'] = default_user

    #shut down connection, will reconnect on next exec
    host.close

    @logger.debug("Instance ready: #{host['vmhostname']} for #{host.name}}")
  end
end