beaker 3.21.1 → 3.22.0

data/lib/beaker/hypervisor/docker.rb

@@ -1,336 +0,0 @@
-module Beaker
-  class Docker < Beaker::Hypervisor
-
-    # Docker hypvervisor initializtion
-    # Env variables supported:
-    # DOCKER_REGISTRY: Docker registry URL
-    # DOCKER_HOST: Remote docker host
-    # DOCKER_BUILDARGS: Docker buildargs map
-    # @param [Host, Array<Host>, String, Symbol] hosts    One or more hosts to act upon,
-    #                            or a role (String or Symbol) that identifies one or more hosts.
-    # @param [Hash{Symbol=>String}] options Options to pass on to the hypervisor
-    def initialize(hosts, options)
-      require 'docker'
-      @options = options
-      @logger = options[:logger]
-      @hosts = hosts
-
-      # increase the http timeouts as provisioning images can be slow
-      default_docker_options = { :write_timeout => 300, :read_timeout => 300 }.merge(::Docker.options || {})
-      # Merge docker options from the entry in hosts file
-      ::Docker.options = default_docker_options.merge(@options[:docker_options] || {})
-      # assert that the docker-api gem can talk to your docker
-      # enpoint.  Will raise if there is a version mismatch
-      begin
-        ::Docker.validate_version!
-      rescue Excon::Errors::SocketError => e
-        raise "Docker instance not connectable.\nError was: #{e}\nCheck your DOCKER_HOST variable has been set\nIf you are on OSX or Windows, you might not have Docker Machine setup correctly: https://docs.docker.com/machine/\n"
-      end
-
-      # Pass on all the logging from docker-api to the beaker logger instance
-      ::Docker.logger = @logger
-
-      # Find out what kind of remote instance we are talking against
-      if ::Docker.version['Version'] =~ /swarm/
-        @docker_type = 'swarm'
-        unless ENV['DOCKER_REGISTRY']
-          raise "Using Swarm with beaker requires a private registry. Please setup the private registry and set the 'DOCKER_REGISTRY' env var"
-        else
-          @registry = ENV['DOCKER_REGISTRY']
-        end
-      else
-        @docker_type = 'docker'
-      end
-
-    end
-
-    def provision
-      @logger.notify "Provisioning docker"
-
-      @hosts.each do |host|
-        @logger.notify "provisioning #{host.name}"
-
-        @logger.debug("Creating image")
-        image = ::Docker::Image.build(dockerfile_for(host), {
-           :rm => true, :buildargs => buildargs_for(host)
-        })
-
-        if @docker_type == 'swarm'
-          image_name = "#{@registry}/beaker/#{image.id}"
-          ret = ::Docker::Image.search(:term => image_name)
-          if ret.first.nil?
-            @logger.debug("Image does not exist on registry. Pushing.")
-            image.tag({:repo => image_name, :force => true})
-            image.push
-          end
-        else
-          image_name = image.id
-        end
-
-        container_opts = {
-          'Image' => image_name,
-          'Hostname' => host.name,
-        }
-        container = find_container(host)
-
-        # If the specified container exists, then use it rather creating a new one
-        if container.nil?
-          unless host['mount_folders'].nil?
-            container_opts['HostConfig'] ||= {}
-            container_opts['HostConfig']['Binds'] = host['mount_folders'].values.map do |mount|
-              a = [ File.expand_path(mount['host_path']), mount['container_path'] ]
-              a << mount['opts'] if mount.has_key?('opts')
-              a.join(':')
-            end
-          end
-
-          if @options[:provision]
-            if host['docker_container_name']
-              container_opts['name'] = host['docker_container_name']
-            end
-
-            @logger.debug("Creating container from image #{image_name}")
-            container = ::Docker::Container.create(container_opts)
-          end
-        end
-
-        if container.nil?
-          raise RuntimeError, 'Cannot continue because no existing container ' +
-                              'could be found and provisioning is disabled.'
-        end
-
-        fix_ssh(container) if @options[:provision] == false
-
-        @logger.debug("Starting container #{container.id}")
-        container.start({"PublishAllPorts" => true, "Privileged" => true})
-
-        # Find out where the ssh port is from the container
-        # When running on swarm DOCKER_HOST points to the swarm manager so we have to get the
-        # IP of the swarm slave via the container data
-        # When we are talking to a normal docker instance DOCKER_HOST can point to a remote docker instance.
-
-        # Talking against a remote docker host which is a normal docker host
-        if @docker_type == 'docker' && ENV['DOCKER_HOST']
-          ip = URI.parse(ENV['DOCKER_HOST']).host
-        else
-          # Swarm or local docker host
-          ip = container.json["NetworkSettings"]["Ports"]["22/tcp"][0]["HostIp"]
-        end
-
-        @logger.info("Using docker server at #{ip}")
-        port = container.json["NetworkSettings"]["Ports"]["22/tcp"][0]["HostPort"]
-
-        forward_ssh_agent = @options[:forward_ssh_agent] || false
-
-        # Update host metadata
-        host['ip']  = ip
-        host['port'] = port
-        host['ssh']  = {
-          :password => root_password,
-          :port => port,
-          :forward_agent => forward_ssh_agent,
-        }
-
-        @logger.debug("node available as  ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no root@#{ip} -p #{port}")
-        host['docker_container'] = container
-        host['docker_image'] = image
-        host['vm_ip'] = container.json["NetworkSettings"]["IPAddress"].to_s
-
-      end
-
-      hack_etc_hosts @hosts, @options
-
-    end
-
-    def cleanup
-      @logger.notify "Cleaning up docker"
-      @hosts.each do |host|
-        if container = host['docker_container']
-          @logger.debug("stop container #{container.id}")
-          begin
-            container.kill
-            sleep 2 # avoid a race condition where the root FS can't unmount
-          rescue Excon::Errors::ClientError => e
-            @logger.warn("stop of container #{container.id} failed: #{e.response.body}")
-          end
-          @logger.debug("delete container #{container.id}")
-          begin
-            container.delete
-          rescue Excon::Errors::ClientError => e
-            @logger.warn("deletion of container #{container.id} failed: #{e.response.body}")
-          end
-        end
-
-        # Do not remove the image if docker_reserve_image is set to true, otherwise remove it
-        if image = (host['docker_preserve_image'] ? nil : host['docker_image'])
-          @logger.debug("delete image #{image.id}")
-          begin
-            image.delete
-          rescue Excon::Errors::ClientError => e
-            @logger.warn("deletion of image #{image.id} failed: #{e.response.body}")
-          rescue ::Docker::Error::DockerError => e
-            @logger.warn("deletion of image #{image.id} caused internal Docker error: #{e.message}")
-          end
-        end
-      end
-    end
-
-    private
-
-    def root_password
-      'root'
-    end
-
-    def buildargs_for(host)
-      docker_buildargs = {}
-      docker_buildargs_env = ENV['DOCKER_BUILDARGS']
-      if docker_buildargs_env != nil
-        docker_buildargs_env.split(/ +|\t+/).each do |arg|
-          key,value=arg.split(/=/)
-          if key
-            docker_buildargs[key]=value
-          else
-            @logger.warn("DOCKER_BUILDARGS environment variable appears invalid, no key found for value #{value}" )
-          end
-        end
-      end
-      if docker_buildargs.empty?
-        buildargs = host['docker_buildargs'] || {}
-      else
-        buildargs = docker_buildargs
-      end
-      @logger.debug("Docker build buildargs: #{buildargs}")
-      JSON.generate(buildargs)
-    end
-
-    def dockerfile_for(host)
-      if host['dockerfile'] then
-        @logger.debug("attempting to load user Dockerfile from #{host['dockerfile']}")
-        if File.exist?(host['dockerfile']) then
-          dockerfile = File.read(host['dockerfile'])
-        else
-          raise "requested Dockerfile #{host['dockerfile']} does not exist"
-        end 
-      else 
-        raise("Docker image undefined!") if (host['image']||= nil).to_s.empty?
-
-        # specify base image
-        dockerfile = <<-EOF
-          FROM #{host['image']}
-          ENV container docker
-        EOF
-
-        # additional options to specify to the sshd
-        # may vary by platform
-        sshd_options = ''
-
-        # add platform-specific actions
-        service_name = "sshd"
-        case host['platform']
-        when /ubuntu/, /debian/
-          service_name = "ssh"
-          dockerfile += <<-EOF
-            RUN apt-get update
-            RUN apt-get install -y openssh-server openssh-client #{Beaker::HostPrebuiltSteps::DEBIAN_PACKAGES.join(' ')}
-          EOF
-          when  /cumulus/
-            dockerfile += <<-EOF
-            RUN apt-get update
-            RUN apt-get install -y openssh-server openssh-client #{Beaker::HostPrebuiltSteps::CUMULUS_PACKAGES.join(' ')}
-          EOF
-        when /fedora-(2[2-9])/
-          dockerfile += <<-EOF
-            RUN dnf clean all
-            RUN dnf install -y sudo openssh-server openssh-clients #{Beaker::HostPrebuiltSteps::UNIX_PACKAGES.join(' ')}
-            RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key
-            RUN ssh-keygen -t dsa -f /etc/ssh/ssh_host_dsa_key
-          EOF
-        when /^el-/, /centos/, /fedora/, /redhat/, /eos/
-          dockerfile += <<-EOF
-            RUN yum clean all
-            RUN yum install -y sudo openssh-server openssh-clients #{Beaker::HostPrebuiltSteps::UNIX_PACKAGES.join(' ')}
-            RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key
-            RUN ssh-keygen -t dsa -f /etc/ssh/ssh_host_dsa_key
-          EOF
-        when /opensuse/, /sles/
-          dockerfile += <<-EOF
-            RUN zypper -n in openssh #{Beaker::HostPrebuiltSteps::SLES_PACKAGES.join(' ')}
-            RUN ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key
-            RUN ssh-keygen -t dsa -f /etc/ssh/ssh_host_dsa_key
-            RUN sed -ri 's/^#?UsePAM .*/UsePAM no/' /etc/ssh/sshd_config
-          EOF
-        else
-          # TODO add more platform steps here
-          raise "platform #{host['platform']} not yet supported on docker"
-        end
-
-        # Make sshd directory, set root password
-        dockerfile += <<-EOF
-          RUN mkdir -p /var/run/sshd
-          RUN echo root:#{root_password} | chpasswd
-        EOF
-
-        # Configure sshd service to allowroot login using password
-        # Also, disable reverse DNS lookups to prevent every. single. ssh
-        # operation taking 30 seconds while the lookup times out.
-        dockerfile += <<-EOF
-          RUN sed -ri 's/^#?PermitRootLogin .*/PermitRootLogin yes/' /etc/ssh/sshd_config
-          RUN sed -ri 's/^#?PasswordAuthentication .*/PasswordAuthentication yes/' /etc/ssh/sshd_config
-          RUN sed -ri 's/^#?UseDNS .*/UseDNS no/' /etc/ssh/sshd_config
-        EOF
-
-
-        # Any extra commands specified for the host
-        dockerfile += (host['docker_image_commands'] || []).map { |command|
-          "RUN #{command}\n"
-        }.join('')
-
-        # Override image entrypoint
-        if host['docker_image_entrypoint']
-          dockerfile += "ENTRYPOINT #{host['docker_image_entrypoint']}\n"
-        end
-
-        # How to start a sshd on port 22.  May be an init for more supervision
-        # Ensure that the ssh server can be restarted (done from set_env) and container keeps running
-        cmd = host['docker_cmd'] || ["sh","-c","service #{service_name} start ; tail -f /dev/null"]
-        dockerfile += <<-EOF
-          EXPOSE 22
-          CMD #{cmd}
-        EOF
-
-      end
-
-      @logger.debug("Dockerfile is #{dockerfile}")
-      return dockerfile
-    end
-
-    # a puppet run may have changed the ssh config which would
-    # keep us out of the container.  This is a best effort to fix it.
-    def fix_ssh(container)
-      @logger.debug("Fixing ssh on container #{container.id}")
-      container.exec(['sed','-ri',
-                      's/^#?PermitRootLogin .*/PermitRootLogin yes/',
-                      '/etc/ssh/sshd_config'])
-      container.exec(['sed','-ri',
-                      's/^#?PasswordAuthentication .*/PasswordAuthentication yes/',
-                      '/etc/ssh/sshd_config'])
-      container.exec(['sed','-ri',
-                      's/^#?UseDNS .*/UseDNS no/',
-                      '/etc/ssh/sshd_config'])
-      container.exec(%w(service ssh restart))
-    end
-
-
-    # return the existing container if we're not provisioning
-    # and docker_container_name is set
-    def find_container(host)
-      return nil if host['docker_container_name'].nil? || @options[:provision]
-      @logger.debug("Looking for an existing container called #{host['docker_container_name']}")
-
-      ::Docker::Container.all.select do |c|
-        c.info['Names'].include? "/#{host['docker_container_name']}"
-      end.first
-    end
-
-  end
-end

data/lib/beaker/hypervisor/openstack.rb

@@ -1,363 +0,0 @@
-module Beaker
-  #Beaker support for OpenStack
-  #This code is EXPERIMENTAL!
-  #Please file any issues/concerns at https://github.com/puppetlabs/beaker/issues
-  class OpenStack < Beaker::Hypervisor
-
-    SLEEPWAIT = 5
-
-    #Create a new instance of the OpenStack hypervisor object
-    #@param [<Host>] openstack_hosts The array of OpenStack hosts to provision
-    #@param [Hash{Symbol=>String}] options The options hash containing configuration values
-    #@option options [String] :openstack_api_key The key to access the OpenStack instance with (required)
-    #@option options [String] :openstack_username The username to access the OpenStack instance with (required)
-    #@option options [String] :openstack_auth_url The URL to access the OpenStack instance with (required)
-    #@option options [String] :openstack_tenant The tenant to access the OpenStack instance with (required)
-    #@option options [String] :openstack_region The region that each OpenStack instance should be provisioned on (optional)
-    #@option options [String] :openstack_network The network that each OpenStack instance should be contacted through (required)
-    #@option options [String] :openstack_keyname The name of an existing key pair that should be auto-loaded onto each
-    #@option options [Hash] :security_group An array of security groups to associate with the instance
-    #                                            OpenStack instance (optional)
-    #@option options [String] :jenkins_build_url Added as metadata to each OpenStack instance
-    #@option options [String] :department Added as metadata to each OpenStack instance
-    #@option options [String] :project Added as metadata to each OpenStack instance
-    #@option options [Integer] :timeout The amount of time to attempt execution before quiting and exiting with failure
-    def initialize(openstack_hosts, options)
-      require 'fog'
-      @options = options
-      @logger = options[:logger]
-      @hosts = openstack_hosts
-      @vms = []
-
-      raise 'You must specify an Openstack API key (:openstack_api_key) for OpenStack instances!' unless @options[:openstack_api_key]
-      raise 'You must specify an Openstack username (:openstack_username) for OpenStack instances!' unless @options[:openstack_username]
-      raise 'You must specify an Openstack auth URL (:openstack_auth_url) for OpenStack instances!' unless @options[:openstack_auth_url]
-      raise 'You must specify an Openstack tenant (:openstack_tenant) for OpenStack instances!' unless @options[:openstack_tenant]
-      raise 'You must specify an Openstack network (:openstack_network) for OpenStack instances!' unless @options[:openstack_network]
-
-      # Common keystone authentication credentials
-      @credentials = {
-        :provider           => :openstack,
-        :openstack_auth_url => @options[:openstack_auth_url],
-        :openstack_api_key  => @options[:openstack_api_key],
-        :openstack_username => @options[:openstack_username],
-        :openstack_tenant   => @options[:openstack_tenant],
-        :openstack_region   => @options[:openstack_region],
-      }
-
-      # Keystone version 3 requires users and projects to be scoped
-      if @credentials[:openstack_auth_url].include?('/v3/')
-        @credentials[:openstack_user_domain]    = @options[:openstack_user_domain] || 'Default'
-        @credentials[:openstack_project_domain] = @options[:openstack_project_domain] || 'Default'
-      end
-
-      @compute_client ||= Fog::Compute.new(@credentials)
-
-      if not @compute_client
-        raise "Unable to create OpenStack Compute instance (api key: #{@options[:openstack_api_key]}, username: #{@options[:openstack_username]}, auth_url: #{@options[:openstack_auth_url]}, tenant: #{@options[:openstack_tenant]})"
-      end
-
-      @network_client ||= Fog::Network.new(@credentials)
-
-      if not @network_client
-        raise "Unable to create OpenStack Network instance (api_key: #{@options[:openstack_api_key]}, username: #{@options[:openstack_username]}, auth_url: #{@options[:openstack_auth_url]}, tenant: #{@options[:openstack_tenant]})"
-      end
-
-      # Validate openstack_volume_support setting value, reset to boolean if passed via ENV value string
-      @options[:openstack_volume_support] = true  if @options[:openstack_volume_support].to_s.match(/\btrue\b/i)
-      @options[:openstack_volume_support] = false if @options[:openstack_volume_support].to_s.match(/\bfalse\b/i)
-      [true,false].include? @options[:openstack_volume_support] or raise "Invalid openstack_volume_support setting, current: @options[:openstack_volume_support]"
-
-    end
-
-    #Provided a flavor name return the OpenStack id for that flavor
-    #@param [String] f The flavor name
-    #@return [String] Openstack id for provided flavor name
-    def flavor f
-      @logger.debug "OpenStack: Looking up flavor '#{f}'"
-      @compute_client.flavors.find { |x| x.name == f } || raise("Couldn't find flavor: #{f}")
-    end
-
-    #Provided an image name return the OpenStack id for that image
-    #@param [String] i The image name
-    #@return [String] Openstack id for provided image name
-    def image i
-      @logger.debug "OpenStack: Looking up image '#{i}'"
-      @compute_client.images.find { |x| x.name == i } || raise("Couldn't find image: #{i}")
-    end
-
-    #Provided a network name return the OpenStack id for that network
-    #@param [String] n The network name
-    #@return [String] Openstack id for provided network name
-    def network n
-      @logger.debug "OpenStack: Looking up network '#{n}'"
-      @network_client.networks.find { |x| x.name == n } || raise("Couldn't find network: #{n}")
-    end
-
-    #Provided an array of security groups return that array if all
-    #security groups are present
-    #@param [Array] sgs The array of security group names
-    #@return [Array] The array of security group names
-    def security_groups sgs
-      for sg in sgs
-        @logger.debug "Openstack: Looking up security group '#{sg}'"
-        @compute_client.security_groups.find { |x| x.name == sg } || raise("Couldn't find security group: #{sg}")
-        sgs
-      end
-    end
-
-    # Create a volume client on request
-    # @return [Fog::OpenStack::Volume] OpenStack volume client
-    def volume_client_create
-      @volume_client ||= Fog::Volume.new(@credentials)
-      unless @volume_client
-        raise "Unable to create OpenStack Volume instance"\
-          " (api_key: #{@options[:openstack_api_key]},"\
-        " username: #{@options[:openstack_username]},"\
-        " auth_url: #{@options[:openstack_auth_url]},"\
-        " tenant: #{@options[:openstack_tenant]})"
-      end
-    end
-
-    # Get a hash of volumes from the host
-    def get_volumes host
-      return host['volumes'] if host['volumes']
-      {}
-    end
-
-    # Get the API version
-    def get_volume_api_version
-      case @volume_client
-      when Fog::Volume::OpenStack::V1
-        1
-      else
-        -1
-      end
-    end
-
-    # Create and attach dynamic volumes
-    #
-    # Creates an array of volumes and attaches them to the current host.
-    # The host bus type is determined by the image type, so by default
-    # devices appear as /dev/vdb, /dev/vdc etc.  Setting the glance
-    # properties hw_disk_bus=scsi, hw_scsi_model=virtio-scsi will present
-    # them as /dev/sdb, /dev/sdc (or 2:0:0:1, 2:0:0:2 in SCSI addresses)
-    #
-    # @param host [Hash] thet current host defined in the nodeset
-    # @param vm [Fog::Compute::OpenStack::Server] the server to attach to
-    def provision_storage host, vm
-      volumes = get_volumes(host)
-      if !volumes.empty?
-        # Lazily create the volume client if needed
-        volume_client_create
-        volumes.keys.each_with_index do |volume, index|
-          @logger.debug "Creating volume #{volume} for OpenStack host #{host.name}"
-
-          # The node defintion file defines volume sizes in MB (due to precedent
-          # with the vagrant virtualbox implementation) however OpenStack requires
-          # this translating into GB
-          openstack_size = volumes[volume]['size'].to_i / 1000
-
-          # Set up the volume creation arguments
-          args = {
-            :size        => openstack_size,
-            :description => "Beaker volume: host=#{host.name} volume=#{volume}",
-          }
-
-          # Between version 1 and subsequent versions the API was updated to
-          # rename 'display_name' to just 'name' for better consistency
-          if get_volume_api_version == 1
-            args[:display_name] = volume
-          else
-            args[:name] = volume
-          end
-
-          # Create the volume and wait for it to become available
-          vol = @volume_client.volumes.create(**args)
-          vol.wait_for { ready? }
-
-          # Fog needs a device name to attach as, so invent one.  The guest
-          # doesn't pay any attention to this
-          device = "/dev/vd#{('b'.ord + index).chr}"
-          vm.attach_volume(vol.id, device)
-        end
-      end
-    end
-
-    # Detach and delete guest volumes
-    # @param vm [Fog::Compute::OpenStack::Server] the server to detach from
-    def cleanup_storage vm
-      vm.volumes.each do |vol|
-        @logger.debug "Deleting volume #{vol.name} for OpenStack host #{vm.name}"
-        vm.detach_volume(vol.id)
-        vol.wait_for { ready? }
-        vol.destroy
-      end
-    end
-
-    # Get a floating IP address to associate with the instance, try
-    # to allocate a new one from the specified pool if none are available
-    def get_ip
-      begin
-        @logger.debug "Creating IP"
-        ip = @compute_client.addresses.create
-      rescue Fog::Compute::OpenStack::NotFound
-        # If there are no more floating IP addresses, allocate a
-        # new one and try again. 
-        @compute_client.allocate_address(@options[:floating_ip_pool])
-        ip = @compute_client.addresses.find { |ip| ip.instance_id.nil? }
-      end
-      raise 'Could not find or allocate an address' if not ip
-      ip
-    end
-
-    #Create new instances in OpenStack
-    def provision
-      @logger.notify "Provisioning OpenStack"
-
-      @hosts.each do |host|
-        ip = get_ip
-        hostname = ip.ip.gsub('.','-')
-        host[:vmhostname] = hostname + '.rfc1918.puppetlabs.net'
-        create_or_associate_keypair(host, hostname)
-        @logger.debug "Provisioning #{host.name} (#{host[:vmhostname]})"
-        options = {
-          :flavor_ref => flavor(host[:flavor]).id,
-          :image_ref  => image(host[:image]).id,
-          :nics       => [ {'net_id' => network(@options[:openstack_network]).id } ],
-          :name       => host[:vmhostname],
-          :hostname   => host[:vmhostname],
-          :user_data  => host[:user_data] || "#cloud-config\nmanage_etc_hosts: true\n",
-          :key_name   => host[:keyname],
-        }
-        options[:security_groups] = security_groups(@options[:security_group]) unless @options[:security_group].nil?
-        vm = @compute_client.servers.create(options)
-
-        #wait for the new instance to start up
-        try = 1
-        attempts = @options[:timeout].to_i / SLEEPWAIT
-
-        while try <= attempts
-          begin
-            vm.wait_for(5) { ready? }
-            break
-          rescue Fog::Errors::TimeoutError => e
-            if try >= attempts
-              @logger.debug "Failed to connect to new OpenStack instance #{host.name} (#{host[:vmhostname]})"
-              raise e
-            end
-            @logger.debug "Timeout connecting to instance #{host.name} (#{host[:vmhostname]}), trying again..."
-          end
-          sleep SLEEPWAIT
-          try += 1
-        end
-
-        # Associate a public IP to the server
-        ip.server = vm
-        host[:ip] = ip.ip
-
-        @logger.debug "OpenStack host #{host.name} (#{host[:vmhostname]}) assigned ip: #{host[:ip]}"
-
-        #set metadata
-        vm.metadata.update({:jenkins_build_url => @options[:jenkins_build_url].to_s,
-                            :department        => @options[:department].to_s,
-                            :project           => @options[:project].to_s })
-        @vms << vm
-
-        # Wait for the host to accept ssh logins
-        host.wait_for_port(22)
-
-        #enable root if user is not root
-        enable_root(host)
-
-        provision_storage(host, vm) if @options[:openstack_volume_support]
-        @logger.notify "OpenStack Volume Support Disabled, can't provision volumes" if not @options[:openstack_volume_support]
-      end
-
-      hack_etc_hosts @hosts, @options
-
-    end
-
-    #Destroy any OpenStack instances
-    def cleanup
-      @logger.notify "Cleaning up OpenStack"
-      @vms.each do |vm|
-        cleanup_storage(vm) if @options[:openstack_volume_support]
-        @logger.debug "Release floating IPs for OpenStack host #{vm.name}"
-        floating_ips = vm.all_addresses # fetch and release its floating IPs
-        floating_ips.each do |address|
-          @compute_client.disassociate_address(vm.id, address['ip'])
-          @compute_client.release_address(address['id'])
-        end
-        @logger.debug "Destroying OpenStack host #{vm.name}"
-        vm.destroy
-        if @options[:openstack_keyname].nil?
-          @logger.debug "Deleting random keypair"
-          @compute_client.delete_key_pair vm.key_name
-        end
-      end
-    end
-
-    # Enables root access for a host when username is not root
-    # This method ripped from the aws_sdk implementation and is probably wrong
-    # because it iterates on a collection when there's no guarantee the collection
-    # has all been brought up in openstack yet and will thus explode
-    # @return [void]
-    # @api private
-    def enable_root_on_hosts
-      @hosts.each do |host|
-        enable_root(host)
-      end
-    end
-
-    # enable root on a single host (the current one presumably) but only
-    # if the username isn't 'root'
-    def enable_root(host)
-      if host['user'] != 'root'
-        copy_ssh_to_root(host, @options)
-        enable_root_login(host, @options)
-        host['user'] = 'root'
-        host.close
-      end
-    end
-
-    #Get key_name from options or generate a new rsa key and add it to
-    #OpenStack keypairs
-    #
-    #@param [Host] host The OpenStack host to provision
-    #@api private
-    def create_or_associate_keypair(host, keyname)
-      if @options[:openstack_keyname]
-        @logger.debug "Adding optional key_name #{@options[:openstack_keyname]} to #{host.name} (#{host[:vmhostname]})"
-        keyname = @options[:openstack_keyname]
-      else
-        @logger.debug "Generate a new rsa key"
-
-        # There is apparently an error that can occur when generating RSA keys, probably
-        # due to some timing issue, probably similar to the issue described here:
-        # https://github.com/negativecode/vines/issues/34
-        # In order to mitigate this error, we will simply try again up to three times, and
-        # then fail if we continue to error out.
-        begin
-          retries ||= 0
-          key = OpenSSL::PKey::RSA.new 2048
-        rescue OpenSSL::PKey::RSAError => e
-          retries += 1
-          if retries > 2
-            @logger.notify "error generating RSA key #{retries} times, exiting"
-            raise e
-          end
-          retry
-        end
-
-        type = key.ssh_type
-        data = [ key.to_blob ].pack('m0')
-        @logger.debug "Creating Openstack keypair '#{keyname}' for public key '#{type} #{data}'"
-        @compute_client.create_key_pair keyname, "#{type} #{data}"
-        host['ssh'][:key_data] = [ key.to_pem ]
-      end
-
-      host[:keyname] = keyname
-    end
-  end
-end