vagrant-openstack-provider 0.4.1 → 0.5.0

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

@@ -1,20 +1,30 @@
 require 'log4r'
 
+require 'vagrant-openstack-provider/config_resolver'
+require 'vagrant-openstack-provider/utils'
+
 module VagrantPlugins
   module Openstack
     module Action
       # This action reads the SSH info for the machine and puts it into the
       # `:machine_ssh_info` key in the environment.
       class ReadSSHInfo
-        def initialize(app, _env)
+        def initialize(app, _env, resolver = ConfigResolver.new, utils = Utils.new)
           @app    = app
           @logger = Log4r::Logger.new('vagrant_openstack::action::read_ssh_info')
+          @resolver = resolver
+          @utils = utils
         end
 
         def call(env)
           @logger.info 'Reading SSH info'
-          env[:machine_ssh_info] = read_ssh_info(env)
-
+          server_id = env[:machine].id.to_sym
+          SSHInfoHolder.instance.tap do |holder|
+            holder.synchronize do
+              holder.ssh_info[server_id] = read_ssh_info(env) if holder.ssh_info[server_id].nil?
+              env[:machine_ssh_info] = holder.ssh_info[server_id]
+            end
+          end
           @app.call(env)
         end
 
@@ -22,42 +32,33 @@ module VagrantPlugins
 
         def read_ssh_info(env)
           config = env[:machine].provider_config
+          env[:ui].warn('SSH is disabled in the provider config. The action you are attempting is likely to fail') if config.ssh_disabled
           hash = {
-            host: get_ip_address(env),
-            port: resolve_ssh_port(env),
-            username: resolve_ssh_username(env)
+            host: @utils.get_ip_address(env),
+            port: @resolver.resolve_ssh_port(env),
+            username: @resolver.resolve_ssh_username(env)
           }
           hash[:private_key_path] = "#{env[:machine].data_dir}/#{get_keypair_name(env)}" unless config.keypair_name || config.public_key_path
+          # Should work silently when https://github.com/mitchellh/vagrant/issues/4637 is fixed
+          hash[:log_level] = 'ERROR'
           hash
         end
 
-        def resolve_ssh_port(env)
-          machine_config = env[:machine].config
-          return machine_config.ssh.port if machine_config.ssh.port
-          22
+        def get_keypair_name(env)
+          env[:openstack_client].nova.get_server_details(env, env[:machine].id)['key_name']
         end
+      end
 
-        def resolve_ssh_username(env)
-          config = env[:machine].provider_config
-          machine_config = env[:machine].config
-          return machine_config.ssh.username if machine_config.ssh.username
-          return config.ssh_username if config.ssh_username
-          fail Errors::NoMatchingSshUsername
-        end
+      class SSHInfoHolder < Mutex
+        include Singleton
 
-        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
+        #
+        # Keys are machine ids
+        #
+        attr_accessor :ssh_info
 
-        def get_keypair_name(env)
-          env[:openstack_client].nova.get_server_details(env, env[:machine].id)['key_name']
+        def initialize
+          @ssh_info = {}
         end
       end
     end

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

@@ -12,10 +12,11 @@ module VagrantPlugins
 
         def call(env)
           sync_method = env[:machine].provider_config.sync_method
-          if sync_method == 'rsync'
+          ssh_disabled = env[:machine].provider_config.ssh_disabled
+          if sync_method == 'none' || ssh_disabled
+            NoSyncFolders.new(@app, env, ssh_disabled).call(env)
+          elsif sync_method == 'rsync'
             RsyncFolders.new(@app, env).call(env)
-          elsif sync_method == 'none'
-            NoSyncFolders.new(@app, env).call(env)
           else
             fail Errors::SyncMethodError, sync_method_value: sync_method
           end
@@ -23,13 +24,15 @@ module VagrantPlugins
       end
 
       class NoSyncFolders
-        def initialize(app, _env)
+        def initialize(app, _env, ssh_disabled)
           @app = app
+          @ssh_disabled = ssh_disabled
         end
 
         def call(env)
           @app.call(env)
-          env[:ui].info('Sync folders are disabled')
+          env[:ui].info('Folders will not be synced because provider config ssh_disabled is set to true') if @ssh_disabled
+          env[:ui].info('Sync folders are disabled in the provider configuration') unless @ssh_disabled
         end
       end
 
@@ -60,15 +63,14 @@ module VagrantPlugins
 
             # If on Windows, modify the path to work with cygwin rsync
             if @host_os =~ /mswin|mingw|cygwin/
-              hostpath = hostpath.sub(/^([A-Za-z]):\//, "/cygdrive/#{Regexp.last_match[1].downcase}/")
+              hostpath = add_cygdrive_prefix_to_path(hostpath)
             end
 
             env[:ui].info(I18n.t('vagrant_openstack.rsync_folder', hostpath: hostpath, guestpath: guestpath))
 
             # Create the guest path
             env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
-            env[:machine].communicate.sudo(
-              "chown -R #{ssh_info[:username]} '#{guestpath}'")
+            env[:machine].communicate.sudo("chown -R #{ssh_info[:username]} '#{guestpath}'")
 
             # Generate rsync include commands
             includes = rsync_includes.each_with_object([]) do |incl, incls|
@@ -77,12 +79,14 @@ module VagrantPlugins
             end
 
             # Rsync over to the guest path using the SSH info. add
-            # .hg/ to exclude list as that isn't covered in
+            # .hg/ and .git/ to exclude list as that isn't covered in
             # --cvs-exclude
             command = [
               'rsync', '--verbose', '--archive', '-z',
               '--cvs-exclude',
               '--exclude', '.hg/',
+              '--exclude', '.git/',
+              '--chmod', 'ugo=rwX',
               *includes,
               '-e', "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no #{ssh_key_options(ssh_info)}",
               hostpath,
@@ -109,6 +113,12 @@ module VagrantPlugins
           # Ensure that `private_key_path` is an Array (for Vagrant < 1.4)
           Array(ssh_info[:private_key_path]).map { |path| "-i '#{path}' " }.join
         end
+
+        def add_cygdrive_prefix_to_path(hostpath)
+          hostpath.downcase.sub(/^([a-z]):\//) do
+            "/cygdrive/#{Regexp.last_match[1]}/"
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,58 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class WaitForServerToBeAccessible
+        def initialize(app, env, resolver = nil, ssh = nil)
+          @logger   = Log4r::Logger.new('vagrant_openstack::action::wait_accessible')
+          @app      = app
+          @ssh      = ssh || Vagrant::Action::Builtin::SSHRun.new(app, env)
+          @resolver = resolver || VagrantPlugins::Openstack::ConfigResolver.new
+        end
+
+        def call(env)
+          waiting_for_server_to_be_reachable(env)
+          @logger.info 'The server is ready'
+          env[:ui].info(I18n.t('vagrant_openstack.ready'))
+          @app.call(env)
+        end
+
+        private
+
+        def waiting_for_server_to_be_reachable(env)
+          return if env[:interrupted]
+          ssh_timeout = env[:machine].provider_config.ssh_timeout
+          return if server_is_reachable?(env, ssh_timeout)
+          env[:ui].error(I18n.t('vagrant_openstack.timeout'))
+          fail Errors::SshUnavailable, host: @resolver.resolve_floating_ip(env), timeout: ssh_timeout
+        end
+
+        def server_is_reachable?(env, timeout)
+          start_time = Time.now
+          current_time = start_time
+          nb_retry = 0
+
+          while (current_time - start_time) <= timeout
+            @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
+
+            env[:ssh_run_command] = 'exit 0'
+            @ssh.call(env)
+            return true if env[:ssh_run_exit_status] == 0
+
+            @logger.debug 'SSH not yet available... new retry in in 1 second'
+            nb_retry += 1
+            sleep 1
+            current_time = Time.now
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -5,18 +5,20 @@ module VagrantPlugins
   module Openstack
     module Action
       class WaitForServerToBeActive
-        def initialize(app, _env)
+        def initialize(app, _env, retry_interval = 3, timeout = 200)
           @app    = app
           @logger = Log4r::Logger.new('vagrant_openstack::action::start_server')
+          @retry_interval = retry_interval
+          @timeout = timeout
         end
 
         def call(env)
           if env[:machine].id
             env[:ui].info(I18n.t('vagrant_openstack.waiting_start'))
             client = env[:openstack_client].nova
-            timeout(200) do
+            timeout(@timeout) do
               while client.get_server_details(env, env[:machine].id)['status'] != 'ACTIVE'
-                sleep 3
+                sleep @retry_interval
                 @logger.info('Waiting for server to be active')
               end
             end

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

@@ -5,18 +5,20 @@ module VagrantPlugins
   module Openstack
     module Action
       class WaitForServerToStop
-        def initialize(app, _env)
+        def initialize(app, _env, retry_interval = 3, timeout = 200)
           @app    = app
           @logger = Log4r::Logger.new('vagrant_openstack::action::stop_server')
+          @retry_interval = retry_interval
+          @timeout = timeout
         end
 
         def call(env)
           if env[:machine].id
             env[:ui].info(I18n.t('vagrant_openstack.waiting_stop'))
             client = env[:openstack_client].nova
-            timeout(200) do
+            timeout(@timeout) do
               while client.get_server_details(env, env[:machine].id)['status'] != 'SHUTOFF'
-                sleep 3
+                sleep @retry_interval
                 @logger.info('Waiting for server to stop')
               end
             end

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

@@ -10,7 +10,7 @@ module VagrantPlugins
 
       # This action is called to destroy the remote machine.
       def self.action_destroy
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -25,7 +25,7 @@ module VagrantPlugins
 
       # This action is called when `vagrant provision` is called.
       def self.action_provision
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -43,7 +43,7 @@ module VagrantPlugins
       # resulting state is expected to be put into the `:machine_ssh_info`
       # key.
       def self.action_read_ssh_info
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use ReadSSHInfo
@@ -54,7 +54,7 @@ module VagrantPlugins
       # resulting state is expected to be put into the `:machine_state_id`
       # key.
       def self.action_read_state
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use ReadState
@@ -62,7 +62,7 @@ module VagrantPlugins
       end
 
       def self.action_ssh
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -76,7 +76,7 @@ module VagrantPlugins
       end
 
       def self.action_ssh_run
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -90,7 +90,7 @@ module VagrantPlugins
       end
 
       def self.action_up
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
 
@@ -100,6 +100,7 @@ module VagrantPlugins
               b2.use Provision
               b2.use SyncFolders
               b2.use CreateServer
+              b2.use WaitForServerToBeAccessible
             when :shutoff
               b2.use StartServer
             when :suspended
@@ -112,7 +113,7 @@ module VagrantPlugins
       end
 
       def self.action_halt
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -128,7 +129,7 @@ module VagrantPlugins
       # This is the action that is primarily responsible for suspending
       # the virtual machine.
       def self.action_suspend
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -146,7 +147,7 @@ module VagrantPlugins
       # This is the action that is primarily responsible for resuming
       # suspended machines.
       def self.action_resume
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -160,7 +161,7 @@ module VagrantPlugins
       end
 
       def self.action_reload
-        Vagrant::Action::Builder.new.tap do |b|
+        new_builder.tap do |b|
           b.use ConfigValidate
           b.use ConnectOpenstack
           b.use Call, ReadState do |env, b2|
@@ -199,6 +200,13 @@ module VagrantPlugins
       autoload :Resume, action_root.join('resume')
       autoload :WaitForServerToStop, action_root.join('wait_stop')
       autoload :WaitForServerToBeActive, action_root.join('wait_active')
+      autoload :WaitForServerToBeAccessible, action_root.join('wait_accessible')
+
+      private
+
+      def self.new_builder
+        Vagrant::Action::Builder.new
+      end
     end
   end
 end

data/lib/vagrant-openstack-provider/client/http_utils.rb

@@ -72,9 +72,10 @@ module VagrantPlugins
         when 401
           fail Errors::AuthenticationRequired
         when 400, 404, 409
-          fail Errors::VagrantOpenstackError, message: JSON.parse(response.to_s)[ERRORS[response.code.to_s]]['message']
+          message = JSON.parse(response.to_s)[ERRORS[response.code.to_s]]['message']
+          fail Errors::VagrantOpenstackError, message: message, code: response.code
         else
-          fail Errors::VagrantOpenstackError, message: response.to_s
+          fail Errors::VagrantOpenstackError, message: response.to_s, code: response.code
         end
       end
 

data/lib/vagrant-openstack-provider/client/neutron.rb

@@ -33,10 +33,20 @@ module VagrantPlugins
       end
 
       def get_private_networks(env)
+        get_networks(env, false)
+      end
+
+      def get_all_networks(env)
+        get_networks(env, true)
+      end
+
+      private
+
+      def get_networks(env, all)
         networks_json = get(env, "#{@session.endpoints[:network]}/networks")
         networks = []
         JSON.parse(networks_json)['networks'].each do |n|
-          networks << Item.new(n['id'], n['name']) if n['tenant_id'].eql? @session.project_id
+          networks << Item.new(n['id'], n['name']) if all || n['tenant_id'].eql?(@session.project_id)
         end
         networks
       end

data/lib/vagrant-openstack-provider/client/nova.rb

@@ -27,7 +27,7 @@ module VagrantPlugins
       def get_all_floating_ips(env)
         ips_json = get(env, "#{@session.endpoints[:compute]}/os-floating-ips",
                        'X-Auth-Token' => @session.token,
-                       :accept => :json) { |res| handle_response(res) }
+                       :accept => :json)
         JSON.parse(ips_json)['floating_ips'].map { |n| FloatingIP.new(n['ip'], n['pool'], n['instance_id']) }
       end
 
@@ -38,7 +38,7 @@ module VagrantPlugins
                         }.to_json,
                         'X-Auth-Token' => @session.token,
                         :accept => :json,
-                        :content_type => :json) { |res| handle_response(res) }
+                        :content_type => :json)
         floating_ip = JSON.parse(ips_json)['floating_ip']
         FloatingIP.new(floating_ip['ip'], floating_ip['pool'], floating_ip['instance_id'])
       end
@@ -60,14 +60,9 @@ module VagrantPlugins
           s['key_name'] = options[:keypair]
           s['availability_zone'] = options[:availability_zone] unless options[:availability_zone].nil?
           s['security_groups'] = options[:security_groups] unless options[:security_groups].nil?
-          s['user_data'] = options[:user_data] unless options[:user_data].nil?
+          s['user_data'] = Base64.encode64(options[:user_data]) unless options[:user_data].nil?
           s['metadata'] = options[:metadata] unless options[:metadata].nil?
-          unless options[:networks].nil? || options[:networks].empty?
-            s['networks'] = []
-            options[:networks].each do |uuid|
-              s['networks'] << { uuid: uuid }
-            end
-          end
+          s['networks'] = options[:networks] unless options[:networks].nil? || options[:networks].empty?
         end
         object = { server: server }
         object[:scheduler_hints] = options[:scheduler_hints] unless options[:scheduler_hints].nil?
@@ -76,36 +71,49 @@ module VagrantPlugins
       end
 
       def delete_server(env, server_id)
-        delete(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
+        instance_exists do
+          delete(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
+        end
       end
 
       def suspend_server(env, server_id)
-        change_server_state(env, server_id, :suspend)
+        instance_exists do
+          change_server_state(env, server_id, :suspend)
+        end
       end
 
       def resume_server(env, server_id)
-        # TODO(julienvey) check status before (if pause->unpause, if suspend->resume...)
-        change_server_state(env, server_id, :resume)
+        instance_exists do
+          change_server_state(env, server_id, :resume)
+        end
       end
 
       def stop_server(env, server_id)
-        change_server_state(env, server_id, :stop)
+        instance_exists do
+          change_server_state(env, server_id, :stop)
+        end
       end
 
       def start_server(env, server_id)
-        change_server_state(env, server_id, :start)
+        instance_exists do
+          change_server_state(env, server_id, :start)
+        end
       end
 
       def get_server_details(env, server_id)
-        server_details = get(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
-        JSON.parse(server_details)['server']
+        instance_exists do
+          server_details = get(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
+          JSON.parse(server_details)['server']
+        end
       end
 
       def add_floating_ip(env, server_id, floating_ip)
-        check_floating_ip(env, floating_ip)
+        instance_exists do
+          check_floating_ip(env, floating_ip)
 
-        post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
-             { addFloatingIp: { address: floating_ip } }.to_json)
+          post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
+               { addFloatingIp: { address: floating_ip } }.to_json)
+        end
       end
 
       def import_keypair(env, public_key)
@@ -128,8 +136,10 @@ module VagrantPlugins
       end
 
       def delete_keypair_if_vagrant(env, server_id)
-        keyname = get_server_details(env, server_id)['key_name']
-        delete(env, "#{@session.endpoints[:compute]}/os-keypairs/#{keyname}") if keyname.start_with?('vagrant-generated-')
+        instance_exists do
+          keyname = get_server_details(env, server_id)['key_name']
+          delete(env, "#{@session.endpoints[:compute]}/os-keypairs/#{keyname}") if keyname.start_with?('vagrant-generated-')
+        end
       end
 
       def get_floating_ip_pools(env)
@@ -143,14 +153,16 @@ module VagrantPlugins
       end
 
       def attach_volume(env, server_id, volume_id, device = nil)
-        attachment = post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/os-volume_attachments",
-                          {
-                            volumeAttachment: {
-                              volumeId: volume_id,
-                              device: device
-                            }
-                          }.to_json)
-        JSON.parse(attachment)['volumeAttachment']
+        instance_exists do
+          attachment = post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/os-volume_attachments",
+                            {
+                              volumeAttachment: {
+                                volumeId: volume_id,
+                                device: device
+                              }
+                            }.to_json)
+          JSON.parse(attachment)['volumeAttachment']
+        end
       end
 
       private
@@ -163,6 +175,13 @@ module VagrantPlugins
             stop: 'os-stop'
           }
 
+      def instance_exists
+        return yield
+      rescue Errors::VagrantOpenstackError => e
+        raise Errors::InstanceNotFound if e.extra_data[:code] == 404
+        raise e
+      end
+
       def change_server_state(env, server_id, new_state)
         post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
              { :"#{VM_STATES[new_state.to_sym]}" => nil }.to_json)