vagrant-openstack-provider 0.2.0 → 0.3.0

data/lib/vagrant-openstack-provider/action.rb

@@ -95,10 +95,15 @@ module VagrantPlugins
           b.use ConnectOpenstack
 
           b.use Call, ReadState do |env, b2|
-            if env[:machine_state_id] == :not_created
+            case env[:machine_state_id]
+            when :not_created
               b2.use Provision
               b2.use SyncFolders
               b2.use CreateServer
+            when :shutoff
+              b2.use StartServer
+            when :suspended
+              b2.use Resume
             else
               b2.use Message, I18n.t('vagrant_openstack.already_created')
             end
@@ -159,8 +164,17 @@ module VagrantPlugins
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
-            if env[:machine_state_id] == :not_created
+            case env[:machine_state_id]
+            when :not_created
               b2.use Message, I18n.t('vagrant_openstack.not_created')
+            when :suspended
+              b2.use Resume
+              b2.use WaitForServerToBeActive
+              b2.use StopServer
+              b2.use WaitForServerToStop
+              b2.use StartServer
+            when :shutoff
+              b2.use StartServer
             else
               b2.use StopServer
               b2.use WaitForServerToStop
@@ -184,6 +198,7 @@ module VagrantPlugins
       autoload :Suspend, action_root.join('suspend')
       autoload :Resume, action_root.join('resume')
       autoload :WaitForServerToStop, action_root.join('wait_stop')
+      autoload :WaitForServerToBeActive, action_root.join('wait_active')
     end
   end
 end

data/lib/vagrant-openstack-provider/action/connect_openstack.rb

@@ -3,24 +3,76 @@ require 'restclient'
 require 'json'
 
 require 'vagrant-openstack-provider/client/openstack'
+require 'vagrant-openstack-provider/client/request_logger'
 
 module VagrantPlugins
   module Openstack
     module Action
-      # This action connects to Openstack, verifies credentials work, and
-      # puts the Openstack connection object into the `:openstack_compute` key
-      # in the environment.
       class ConnectOpenstack
-        def initialize(app, _env)
+        include VagrantPlugins::Openstack::HttpUtils::RequestLogger
+
+        def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new('vagrant_openstack::action::connect_openstack')
+          env[:openstack_client] = VagrantPlugins::Openstack
         end
 
         def call(env)
-          client = VagrantPlugins::Openstack
-          env[:openstack_client] = client
-          client.keystone.authenticate(env) if client.session.token.nil?
-          @app.call(env)
+          client = env[:openstack_client]
+          if client.session.token.nil?
+            catalog = client.keystone.authenticate(env)
+            read_endpoint_catalog(env, catalog)
+            override_endpoint_catalog_with_user_config(env)
+            log_endpoint_catalog(env)
+          end
+          @app.call(env) unless @app.nil?
+        end
+
+        private
+
+        def read_endpoint_catalog(env, catalog)
+          config = env[:machine].provider_config
+          client = env[:openstack_client]
+          @logger.info(I18n.t('vagrant_openstack.client.looking_for_available_endpoints'))
+
+          catalog.each do |service|
+            se = service['endpoints']
+            if se.size > 1
+              env[:ui].warn I18n.t('vagrant_openstack.client.multiple_endpoint', size: se.size, type: service['type'])
+              env[:ui].warn "  => #{service['endpoints'][0]['publicURL']}"
+            end
+            url = se[0]['publicURL'].strip
+            client.session.endpoints[service['type'].to_sym] = url unless url.empty?
+          end
+
+          read_network_api_version(env) if config.openstack_network_url.nil?
+        end
+
+        def read_network_api_version(env)
+          client = env[:openstack_client]
+          versions = client.neutron.get_api_version_list(env)
+          if versions.size > 1
+            version_list = ''
+            versions.each do |version|
+              links = version['links'].map { |l| l['href'] }
+              version_list << "#{version['id'].ljust(6)} #{version['status'].ljust(10)} #{links}\n"
+            end
+            fail Errors::MultipleApiVersion, api_name: 'Neutron', url_property: 'openstack_network_url', version_list: version_list
+          end
+          client.session.endpoints[:network] = versions.first['links'].first['href']
+        end
+
+        def override_endpoint_catalog_with_user_config(env)
+          client = env[:openstack_client]
+          config = env[:machine].provider_config
+          client.session.endpoints[:compute] = config.openstack_compute_url unless config.openstack_compute_url.nil?
+          client.session.endpoints[:network] = config.openstack_network_url unless config.openstack_network_url.nil?
+        end
+
+        def log_endpoint_catalog(env)
+          env[:openstack_client].session.endpoints.each do |key, value|
+            @logger.info(" -- #{key.to_s.ljust 15}: #{value}")
+          end
         end
       end
     end

data/lib/vagrant-openstack-provider/action/create_server.rb

@@ -1,6 +1,7 @@
 require 'log4r'
 require 'socket'
 require 'timeout'
+require 'sshkey'
 
 require 'vagrant/util/retryable'
 
@@ -16,47 +17,29 @@ module VagrantPlugins
         end
 
         def call(env)
-          config = env[:machine].provider_config
-          nova = env[:openstack_client].nova
-
-          flavor = resolve_flavor(env)
-          image = resolve_image(env)
-          networks = resolve_networks(env)
-          server_name = config.server_name || env[:machine].name
+          @logger.info 'Start create server action'
 
-          env[:ui].info(I18n.t('vagrant_openstack.launching_server'))
-          env[:ui].info(" -- Tenant         : #{config.tenant_name}")
-          env[:ui].info(" -- Name           : #{server_name}")
-          env[:ui].info(" -- Flavor         : #{flavor.name}")
-          env[:ui].info(" -- FlavorRef      : #{flavor.id}")
-          env[:ui].info(" -- Image          : #{image.name}")
-          env[:ui].info(" -- ImageRef       : #{image.id}")
-          env[:ui].info(" -- KeyPair        : #{config.keypair_name}")
-          unless networks.empty?
-            if networks.size == 1
-              env[:ui].info(" -- Network        : #{config.networks[0]}")
-            else
-              env[:ui].info(" -- Networks       : #{config.networks}")
-            end
-          end
+          nova = env[:openstack_client].nova
 
-          server_id = nova.create_server(env, server_name, image.id, flavor.id, networks, config.keypair_name)
+          options = {
+            flavor: resolve_flavor(env),
+            image: resolve_image(env),
+            networks: resolve_networks(env),
+            keypair_name: resolve_keypair(env),
+            availability_zone: env[:machine].provider_config.availability_zone
+          }
+          server_id = create_server(env, options)
 
           # Store the ID right away so we can track it
           env[:machine].id = server_id
 
-          # Wait for the server to finish building
-          env[:ui].info(I18n.t('vagrant_openstack.waiting_for_build'))
-          timeout(200) do
-            while nova.get_server_details(env, server_id)['status'] != 'ACTIVE'
-              sleep 3
-              @logger.debug('Waiting for server to be ACTIVE')
-            end
-          end
+          waiting_for_server_to_be_build(env, server_id)
 
-          if config.floating_ip
-            env[:ui].info("Using floating IP #{config.floating_ip}")
-            nova.add_floating_ip(env, server_id, config.floating_ip)
+          floating_ip = resolve_floating_ip(env)
+          if floating_ip && !floating_ip.empty?
+            @logger.info "Using floating IP #{floating_ip}"
+            env[:ui].info(I18n.t('vagrant_openstack.using_floating_ip', floating_ip: floating_ip))
+            nova.add_floating_ip(env, server_id, floating_ip)
           end
 
           unless env[:interrupted]
@@ -64,13 +47,13 @@ module VagrantPlugins
             env[:ui].clear_line
 
             # Wait for SSH to become available
-            host = env[:machine].provider_config.floating_ip
             ssh_timeout = env[:machine].provider_config.ssh_timeout
-            unless port_open?(env, host, 22, ssh_timeout)
+            unless port_open?(env, floating_ip, 22, ssh_timeout)
               env[:ui].error(I18n.t('vagrant_openstack.timeout'))
-              fail Errors::SshUnavailable, host: host, timeout: ssh_timeout
+              fail Errors::SshUnavailable, host: floating_ip, timeout: ssh_timeout
             end
 
+            @logger.info 'The server is ready'
             env[:ui].info(I18n.t('vagrant_openstack.ready'))
           end
 
@@ -79,33 +62,81 @@ module VagrantPlugins
 
         private
 
+        # 1. if floating_ip is set, use it
+        # 2. if floating_ip_pool is set
+        #    GET v2/{{tenant_id}}/os-floating-ips
+        #    If any IP with the same pool is available, use it
+        #    Else Allocate a new IP from the pool
+        #       Manage error case
+        # 3. GET v2/{{tenant_id}}/os-floating-ips
+        #    If any IP is available, use it
+        #    Else fail
+        def resolve_floating_ip(env)
+          config = env[:machine].provider_config
+          nova = env[:openstack_client].nova
+          return config.floating_ip if config.floating_ip
+          floating_ips = nova.get_all_floating_ips(env)
+          if config.floating_ip_pool
+            floating_ips.each do |single|
+              return single.ip if single.pool == config.floating_ip_pool && single.instance_id.nil?
+            end
+            return nova.allocate_floating_ip(env, config.floating_ip_pool).ip
+          else
+            floating_ips.each do |ip|
+              return ip.ip if ip.instance_id.nil?
+            end
+          end
+          fail Errors::UnableToResolveFloatingIP
+        end
+
+        def resolve_keypair(env)
+          config = env[:machine].provider_config
+          nova = env[:openstack_client].nova
+          return config.keypair_name if config.keypair_name
+          return nova.import_keypair_from_file(env, config.public_key_path) if config.public_key_path
+          generate_keypair(env)
+        end
+
+        def generate_keypair(env)
+          key = SSHKey.generate
+          nova = env[:openstack_client].nova
+          generated_keyname = nova.import_keypair(env, key.ssh_public_key)
+          File.write("#{env[:machine].data_dir}/#{generated_keyname}", key.private_key)
+          generated_keyname
+        end
+
         def resolve_flavor(env)
+          @logger.info 'Resolving flavor'
           config = env[:machine].provider_config
           nova = env[:openstack_client].nova
           env[:ui].info(I18n.t('vagrant_openstack.finding_flavor'))
           flavors = nova.get_all_flavors(env)
+          @logger.info "Finding flavor matching name '#{config.flavor}'"
           flavor = find_matching(flavors, config.flavor)
           fail Errors::NoMatchingFlavor unless flavor
           flavor
         end
 
         def resolve_image(env)
+          @logger.info 'Resolving image'
           config = env[:machine].provider_config
           nova = env[:openstack_client].nova
           env[:ui].info(I18n.t('vagrant_openstack.finding_image'))
           images = nova.get_all_images(env)
+          @logger.info "Finding image matching name '#{config.image}'"
           image = find_matching(images, config.image)
           fail Errors::NoMatchingImage unless image
           image
         end
 
         def resolve_networks(env)
+          @logger.info 'Resolving network(s)'
           config = env[:machine].provider_config
           return [] if config.networks.nil? || config.networks.empty?
           env[:ui].info(I18n.t('vagrant_openstack.finding_networks'))
 
           private_networks = env[:openstack_client].neutron.get_private_networks(env)
-          private_network_ids = private_networks.map { |n| n[:id] }
+          private_network_ids = private_networks.map { |n| n.id }
 
           networks = []
           config.networks.each do |network|
@@ -115,9 +146,9 @@ module VagrantPlugins
             end
             net_id = nil
             private_networks.each do |n| # Bad algorithm complexity, but here we don't care...
-              next unless n[:name].eql? network
-              fail "Multiple networks with name '#{n[:name]}'" unless net_id.nil?
-              net_id = n[:id]
+              next unless n.name.eql? network
+              fail "Multiple networks with name '#{n.id}'" unless net_id.nil?
+              net_id = n.id
             end
             fail "No matching network with name '#{network}'" if net_id.nil?
             networks << net_id
@@ -125,16 +156,73 @@ module VagrantPlugins
           networks
         end
 
+        def create_server(env, options)
+          config = env[:machine].provider_config
+          nova = env[:openstack_client].nova
+          server_name = config.server_name || env[:machine].name
+
+          env[:ui].info(I18n.t('vagrant_openstack.launching_server'))
+          env[:ui].info(" -- Tenant         : #{config.tenant_name}")
+          env[:ui].info(" -- Name           : #{server_name}")
+          env[:ui].info(" -- Flavor         : #{options[:flavor].name}")
+          env[:ui].info(" -- FlavorRef      : #{options[:flavor].id}")
+          env[:ui].info(" -- Image          : #{options[:image].name}")
+          env[:ui].info(" -- ImageRef       : #{options[:image].id}")
+          env[:ui].info(" -- KeyPair        : #{options[:keypair_name]}")
+          unless options[:networks].empty?
+            if options[:networks].size == 1
+              env[:ui].info(" -- Network        : #{options[:networks][0]}")
+            else
+              env[:ui].info(" -- Networks       : #{options[:networks]}")
+            end
+          end
+
+          log = "Lauching server '#{server_name}' in project '#{config.tenant_name}' "
+          log << "with flavor '#{options[:flavor].name}' (#{options[:flavor].id}), "
+          log << "image '#{options[:image].name}' (#{options[:image].id}) "
+          log << "and keypair '#{options[:keypair_name]}'"
+
+          @logger.info(log)
+
+          create_opts = {
+            name: server_name,
+            image_ref: options[:image].id,
+            flavor_ref: options[:flavor].id,
+            keypair: options[:keypair_name],
+            availability_zone: options[:availability_zone],
+            networks: options[:networks]
+          }
+
+          nova.create_server(env, create_opts)
+        end
+
+        def waiting_for_server_to_be_build(env, server_id)
+          @logger.info 'Waiting for the server to be built...'
+          env[:ui].info(I18n.t('vagrant_openstack.waiting_for_build'))
+          nova = env[:openstack_client].nova
+          timeout(200) do
+            while nova.get_server_details(env, server_id)['status'] != 'ACTIVE'
+              sleep 3
+              @logger.debug('Waiting for server to be ACTIVE')
+            end
+          end
+        end
+
         def port_open?(env, ip, port, timeout)
           start_time = Time.now
           current_time = start_time
           nb_retry = 0
           while (current_time - start_time) <= timeout
             begin
-              env[:ui].info(I18n.t('vagrant_openstack.waiting_for_ssh')) if nb_retry % 5 == 0
+              @logger.debug "Checking if SSH port is open... Attempt number #{nb_retry}"
+              if nb_retry % 5 == 0
+                @logger.info 'Waiting for SSH to become available...'
+                env[:ui].info(I18n.t('vagrant_openstack.waiting_for_ssh'))
+              end
               TCPSocket.new(ip, port)
               return true
             rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT
+              @logger.debug 'SSH port is not open... new retry in in 1 second'
               nb_retry += 1
               sleep 1
             end
@@ -153,7 +241,7 @@ module VagrantPlugins
             return single if single.name == name
             return single if name.is_a?(Regexp) && name =~ single.name
           end
-
+          @logger.error "Flavor '#{name}' not found"
           nil
         end
       end

data/lib/vagrant-openstack-provider/action/delete_server.rb

@@ -12,8 +12,10 @@ module VagrantPlugins
 
         def call(env)
           if env[:machine].id
+            @logger.info "Deleting server #{env[:machine].id}..."
             env[:ui].info(I18n.t('vagrant_openstack.deleting_server'))
             env[:openstack_client].nova.delete_server(env, env[:machine].id)
+            env[:openstack_client].nova.delete_keypair_if_vagrant(env, env[:machine].id)
             env[:machine].id = nil
           end
 

data/lib/vagrant-openstack-provider/action/read_ssh_info.rb

@@ -12,19 +12,38 @@ module VagrantPlugins
         end
 
         def call(env)
+          @logger.info 'Reading SSH info'
           env[:machine_ssh_info] = read_ssh_info(env)
 
           @app.call(env)
         end
 
+        private
+
         def read_ssh_info(env)
           config = env[:machine].provider_config
-          {
-            # Usually there should only be one public IP
-            host: config.floating_ip,
+          hash = {
+            host: get_ip_address(env),
             port: 22,
             username: config.ssh_username
           }
+          hash[:private_key_path] = "#{env[:machine].data_dir}/#{get_keypair_name(env)}" unless config.keypair_name || config.public_key_path
+          hash
+        end
+
+        def get_ip_address(env)
+          return env[:machine].provider_config.floating_ip unless env[:machine].provider_config.floating_ip.nil?
+          details = env[:openstack_client].nova.get_server_details(env, env[:machine].id)
+          details['addresses'].each do |network|
+            network[1].each do |network_detail|
+              return network_detail['addr'] if network_detail['OS-EXT-IPS:type'] == 'floating'
+            end
+          end
+          fail Errors::UnableToResolveIP
+        end
+
+        def get_keypair_name(env)
+          env[:openstack_client].nova.get_server_details(env, env[:machine].id)['key_name']
         end
       end
     end