vagrant-openstack-provider 0.2.0 → 0.3.0

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

@@ -4,10 +4,12 @@ module VagrantPlugins
       class Resume
         def initialize(app, _env)
           @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::resume_server')
         end
 
         def call(env)
           if env[:machine].id
+            @logger.info "Resuming suspended VM #{env[:machine].id}..."
             env[:ui].info I18n.t('vagrant.actions.vm.resume.resuming')
             env[:openstack_client].nova.resume_server(env, env[:machine].id)
           end

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

@@ -11,6 +11,7 @@ module VagrantPlugins
 
         def call(env)
           if env[:machine].id
+            @logger.info "Stopping server #{env[:machine].id}..."
             env[:ui].info(I18n.t('vagrant_openstack.stopping_server'))
             env[:openstack_client].nova.stop_server(env, env[:machine].id)
           end

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

@@ -4,10 +4,12 @@ module VagrantPlugins
       class Suspend
         def initialize(app, _env)
           @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::suspend_server')
         end
 
         def call(env)
           if env[:machine].id
+            @logger.info "Saving VM #{env[:machine].id} state and suspending execution..."
             env[:ui].info I18n.t('vagrant.actions.vm.suspend.suspending')
             env[:openstack_client].nova.suspend_server(env, env[:machine].id)
           end

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

@@ -97,8 +97,9 @@ module VagrantPlugins
               command += ['--exclude-from', abs_ignore_file] if File.exist?(abs_ignore_file)
             end
 
-            next if Vagrant::Util::Subprocess.execute(*command).exit_code == 0
-            ail Errors::RsyncError, guestpath: guestpath, hostpath: hostpath, stderr: r.stderr
+            r = Vagrant::Util::Subprocess.execute(*command)
+            next if r.exit_code == 0
+            fail Errors::RsyncError, guestpath: guestpath, hostpath: hostpath, stderr: r.stderr
           end
         end
 

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

@@ -0,0 +1,29 @@
+require 'log4r'
+require 'timeout'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class WaitForServerToBeActive
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::start_server')
+        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
+              while client.get_server_details(env, env[:machine].id)['status'] != 'ACTIVE'
+                sleep 3
+                @logger.info('Waiting for server to be active')
+              end
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ module VagrantPlugins
             timeout(200) do
               while client.get_server_details(env, env[:machine].id)['status'] != 'SHUTOFF'
                 sleep 3
-                @logger.debug('Waiting for server to stop')
+                @logger.info('Waiting for server to stop')
               end
             end
           end

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

@@ -0,0 +1,26 @@
+require 'log4r'
+require 'restclient'
+require 'json'
+
+module VagrantPlugins
+  module Openstack
+    module Domain
+      class Item
+        attr_accessor :id, :name
+        def initialize(id, name)
+          @id = id
+          @name = name
+        end
+      end
+
+      class FloatingIP
+        attr_accessor :ip, :pool, :instance_id
+        def initialize(ip, pool, instance_id)
+          @ip = ip
+          @pool = pool
+          @instance_id = instance_id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+require 'log4r'
+require 'restclient'
+require 'json'
+
+require 'vagrant-openstack-provider/client/keystone'
+require 'vagrant-openstack-provider/client/request_logger'
+
+module VagrantPlugins
+  module Openstack
+    module HttpUtils
+      include VagrantPlugins::Openstack::HttpUtils::RequestLogger
+
+      def get(env, url, headers = {})
+        calling_method = caller[0][/`.*'/][1..-2]
+        @logger.debug("#{calling_method} - start")
+
+        headers.merge!('X-Auth-Token' => @session.token, :accept => :json)
+
+        log_request(:GET, url, headers)
+
+        authenticated(env) do
+          RestClient.get(url, headers) { |res| handle_response(res) }.tap do
+            @logger.debug("#{calling_method} - end")
+          end
+        end
+      end
+
+      def post(env, url, body = nil, headers = {})
+        calling_method = caller[0][/`.*'/][1..-2]
+        @logger.debug("#{calling_method} - start")
+
+        headers.merge!('X-Auth-Token' => @session.token, :accept => :json, :content_type => :json)
+
+        log_request(:POST, url, body, headers)
+
+        authenticated(env) do
+          RestClient.post(url, body, headers) { |res| handle_response(res) }.tap do
+            @logger.debug("#{calling_method} - end")
+          end
+        end
+      end
+
+      def delete(env, url, headers = {})
+        calling_method = caller[0][/`.*'/][1..-2]
+        @logger.debug("#{calling_method} - start")
+
+        headers.merge!('X-Auth-Token' => @session.token, :accept => :json, :content_type => :json)
+
+        log_request(:DELETE, url, headers)
+
+        authenticated(env) do
+          RestClient.delete(url, headers) { |res| handle_response(res) }.tap do
+            @logger.debug("#{calling_method} - end")
+          end
+        end
+      end
+
+      private
+
+      ERRORS =
+          {
+            '400' => 'badRequest',
+            '404' => 'itemNotFound',
+            '409' => 'conflictingRequest'
+          }
+
+      def handle_response(response)
+        log_response(response)
+        case response.code
+        when 200, 201, 202, 204
+          response
+        when 401
+          fail Errors::AuthenticationRequired
+        when 400, 404, 409
+          fail Errors::VagrantOpenstackError, message: JSON.parse(response.to_s)[ERRORS[response.code.to_s]]['message']
+        else
+          fail Errors::VagrantOpenstackError, message: response.to_s
+        end
+      end
+
+      def authenticated(env)
+        nb_retry = 0
+        begin
+          return yield
+        rescue Errors::AuthenticationRequired => e
+          nb_retry += 1
+          env[:ui].warn(e)
+          env[:ui].warn(I18n.t('vagrant_openstack.trying_authentication'))
+          env[:openstack_client].keystone.authenticate(env)
+          retry if nb_retry < 3
+          raise e
+        end
+      end
+    end
+  end
+end

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

@@ -2,10 +2,13 @@ require 'log4r'
 require 'restclient'
 require 'json'
 
+require 'vagrant-openstack-provider/client/request_logger'
+
 module VagrantPlugins
   module Openstack
     class KeystoneClient
       include Singleton
+      include VagrantPlugins::Openstack::HttpUtils::RequestLogger
 
       def initialize
         @logger = Log4r::Logger.new('vagrant_openstack::keystone')
@@ -13,63 +16,49 @@ module VagrantPlugins
       end
 
       def authenticate(env)
-        @logger.debug('Authenticating on Keystone')
+        @logger.info('Authenticating on Keystone')
         config = env[:machine].provider_config
-        env[:ui].info(I18n.t('vagrant_openstack.client.authentication', project: config.tenant_name, user: config.username))
+        @logger.info(I18n.t('vagrant_openstack.client.authentication', project: config.tenant_name, user: config.username))
 
-        authentication = RestClient.post(
-            config.openstack_auth_url,
-            {
-              auth:
+        post_body =
+          {
+            auth:
               {
                 tenantName: config.tenant_name,
                 passwordCredentials:
                   {
                     username: config.username,
-                    password: config.password
+                    password: '****'
                   }
               }
-            }.to_json,
-            content_type: :json,
-            accept: :json)
-
-        access = JSON.parse(authentication)['access']
-
-        read_endpoint_catalog(env, access['serviceCatalog'])
-        override_endpoint_catalog_with_user_config(env)
-        print_endpoint_catalog(env)
-
-        response_token = access['token']
-        @session.token = response_token['id']
-        @session.project_id = response_token['tenant']['id']
-      end
+          }
 
-      private
+        log_request(:POST, config.openstack_auth_url, post_body.to_json)
 
-      def read_endpoint_catalog(env, catalog)
-        env[:ui].info(I18n.t('vagrant_openstack.client.looking_for_available_endpoints'))
+        post_body[:auth][:passwordCredentials][:password] = config.password
 
-        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']}"
+        authentication = RestClient.post(config.openstack_auth_url, post_body.to_json,
+                                         content_type: :json,
+                                         accept: :json) do |response|
+          log_response(response)
+          case response.code
+          when 200
+            response
+          when 401
+            fail Errors::AuthenticationFailed
+          when 404
+            fail Errors::BadAuthenticationEndpoint
+          else
+            fail Errors::VagrantOpenstackError, message: response.to_s
           end
-          url = se[0]['publicURL'].strip
-          @session.endpoints[service['type'].to_sym] = url unless url.empty?
         end
-      end
 
-      def override_endpoint_catalog_with_user_config(env)
-        config = env[:machine].provider_config
-        @session.endpoints[:compute] = config.openstack_compute_url unless config.openstack_compute_url.nil?
-        @session.endpoints[:network] = config.openstack_network_url unless config.openstack_network_url.nil?
-      end
+        access = JSON.parse(authentication)['access']
+        response_token = access['token']
+        @session.token = response_token['id']
+        @session.project_id = response_token['tenant']['id']
 
-      def print_endpoint_catalog(env)
-        @session.endpoints.each do |key, value|
-          env[:ui].info(" -- #{key.to_s.ljust 15}: #{value}")
-        end
+        access['serviceCatalog']
       end
     end
   end

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

@@ -2,30 +2,43 @@ require 'log4r'
 require 'restclient'
 require 'json'
 
-require 'vagrant-openstack-provider/client/utils'
+require 'vagrant-openstack-provider/client/http_utils'
+require 'vagrant-openstack-provider/client/domain'
 
 module VagrantPlugins
   module Openstack
     class NeutronClient
       include Singleton
-      include VagrantPlugins::Openstack::Utils
+      include VagrantPlugins::Openstack::HttpUtils
+      include VagrantPlugins::Openstack::Domain
 
       def initialize
         @logger = Log4r::Logger.new('vagrant_openstack::neutron')
         @session = VagrantPlugins::Openstack.session
       end
 
-      def get_private_networks(env)
-        authenticated(env) do
-          networks_json = RestClient.get("#{@session.endpoints[:network]}/networks",
-                                         'X-Auth-Token' => @session.token,
-                                         :accept => :json) { |res| handle_response(res) }
-          networks = []
-          JSON.parse(networks_json)['networks'].each do |n|
-            networks << { id: n['id'], name: n['name'] } if n['tenant_id'].eql? @session.project_id
+      def get_api_version_list(_env)
+        json = RestClient.get(@session.endpoints[:network], 'X-Auth-Token' => @session.token, :accept => :json) do |response|
+          log_response(response)
+          case response.code
+          when 200, 300
+            response
+          when 401
+            fail Errors::AuthenticationFailed
+          else
+            fail Errors::VagrantOpenstackError, message: response.to_s
           end
-          networks
         end
+        JSON.parse(json)['versions']
+      end
+
+      def get_private_networks(env)
+        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
+        end
+        networks
       end
     end
   end

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

@@ -2,13 +2,15 @@ require 'log4r'
 require 'restclient'
 require 'json'
 
-require 'vagrant-openstack-provider/client/utils'
+require 'vagrant-openstack-provider/client/http_utils'
+require 'vagrant-openstack-provider/client/domain'
 
 module VagrantPlugins
   module Openstack
     class NovaClient
       include Singleton
-      include VagrantPlugins::Openstack::Utils
+      include VagrantPlugins::Openstack::HttpUtils
+      include VagrantPlugins::Openstack::Domain
 
       def initialize
         @logger = Log4r::Logger.new('vagrant_openstack::nova')
@@ -16,135 +18,136 @@ module VagrantPlugins
       end
 
       def get_all_flavors(env)
-        authenticated(env) do
-          flavors_json = RestClient.get("#{@session.endpoints[:compute]}/flavors",
-                                        'X-Auth-Token' => @session.token,
-                                        :accept => :json) { |res| handle_response(res) }
+        flavors_json = get(env, "#{@session.endpoints[:compute]}/flavors")
+        JSON.parse(flavors_json)['flavors'].map { |fl| Item.new(fl['id'], fl['name']) }
+      end
 
-          return JSON.parse(flavors_json)['flavors'].map { |fl| Item.new(fl['id'], fl['name']) }
-        end
+      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) }
+        JSON.parse(ips_json)['floating_ips'].map { |n| FloatingIP.new(n['ip'], n['pool'], n['instance_id']) }
       end
 
-      def get_all_images(env)
-        authenticated(env) do
-          images_json = RestClient.get(
-            "#{@session.endpoints[:compute]}/images",
-            'X-Auth-Token' => @session.token, :accept => :json) { |res| handle_response(res) }
+      def allocate_floating_ip(env, pool)
+        ips_json = post(env, "#{@session.endpoints[:compute]}/os-floating-ips",
+                        {
+                          pool: pool
+                        }.to_json,
+                        'X-Auth-Token' => @session.token,
+                        :accept => :json,
+                        :content_type => :json) { |res| handle_response(res) }
+        floating_ip = JSON.parse(ips_json)['floating_ip']
+        FloatingIP.new(floating_ip['ip'], floating_ip['pool'], floating_ip['instance_id'])
+      end
 
-          JSON.parse(images_json)['images'].map { |im| Item.new(im['id'], im['name']) }
-        end
+      def get_all_images(env)
+        images_json = get(env, "#{@session.endpoints[:compute]}/images")
+        JSON.parse(images_json)['images'].map { |fl| Item.new(fl['id'], fl['name']) }
       end
 
-      def create_server(env, name, image_ref, flavor_ref, networks, keypair)
-        authenticated(env) do
-          server = {}.tap do |s|
-            s['name'] = name
-            s['imageRef'] = image_ref
-            s['flavorRef'] = flavor_ref
-            s['key_name'] = keypair
-            unless networks.nil? || networks.empty?
-              s['networks'] = []
-              networks.each do |uuid|
-                s['networks'] << { uuid: uuid }
-              end
+      def create_server(env, options)
+        server = {}.tap do |s|
+          s['name'] = options[:name]
+          s['imageRef'] = options[:image_ref]
+          s['flavorRef'] = options[:flavor_ref]
+          s['key_name'] = options[:keypair]
+          s['availability_zone'] = options[:availability_zone] unless options[:availability_zone].nil?
+          unless options[:networks].nil? || options[:networks].empty?
+            s['networks'] = []
+            options[:networks].each do |uuid|
+              s['networks'] << { uuid: uuid }
             end
           end
-
-          server = RestClient.post(
-            "#{@session.endpoints[:compute]}/servers", { server: server }.to_json,
-            'X-Auth-Token' => @session.token,
-            :accept => :json,
-            :content_type => :json) { |res| handle_response(res) }
-
-          JSON.parse(server)['server']['id']
         end
+        server = post(env, "#{@session.endpoints[:compute]}/servers", { server: server }.to_json)
+        JSON.parse(server)['server']['id']
       end
 
       def delete_server(env, server_id)
-        authenticated(env) do
-          RestClient.delete(
-            "#{@session.endpoints[:compute]}/servers/#{server_id}",
-            'X-Auth-Token' => @session.token,
-            :accept => :json) { |res| handle_response(res) }
-        end
+        delete(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
       end
 
       def suspend_server(env, server_id)
-        authenticated(env) do
-          RestClient.post(
-            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "suspend": null }',
-            'X-Auth-Token' => @session.token,
-            :accept => :json,
-            :content_type => :json) { |res| handle_response(res) }
-        end
+        change_server_state(env, server_id, :suspend)
       end
 
       def resume_server(env, server_id)
         # TODO(julienvey) check status before (if pause->unpause, if suspend->resume...)
-        authenticated(env) do
-          RestClient.post(
-            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "resume": null }',
-            'X-Auth-Token' => @session.token,
-            :accept => :json,
-            :content_type => :json) { |res| handle_response(res) }
-        end
+        change_server_state(env, server_id, :resume)
       end
 
       def stop_server(env, server_id)
-        authenticated(env) do
-          RestClient.post(
-            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "os-stop": null }',
-            'X-Auth-Token' => @session.token,
-            :accept => :json,
-            :content_type => :json) { |res| handle_response(res) }
-        end
+        change_server_state(env, server_id, :stop)
       end
 
       def start_server(env, server_id)
-        authenticated(env) do
-          RestClient.post(
-            "#{@session.endpoints[:compute]}/servers/#{server_id}/action", '{ "os-start": null }',
-            'X-Auth-Token' => @session.token,
-            :accept => :json,
-            :content_type => :json) { |res| handle_response(res) }
-        end
+        change_server_state(env, server_id, :start)
       end
 
       def get_server_details(env, server_id)
-        authenticated(env) do
-          server_details = RestClient.get(
-            "#{@session.endpoints[:compute]}/servers/#{server_id}",
-            'X-Auth-Token' => @session.token,
-            :accept => :json) { |res| handle_response(res) }
-
-          return JSON.parse(server_details)['server']
-        end
+        server_details = get(env, "#{@session.endpoints[:compute]}/servers/#{server_id}")
+        JSON.parse(server_details)['server']
       end
 
       def add_floating_ip(env, server_id, floating_ip)
-        authenticated(env) do
-          check_floating_ip(env, floating_ip)
-          RestClient.post(
-            "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
-            {
-              addFloatingIp:
-              {
-                address: floating_ip
-              }
-            }.to_json,
-            'X-Auth-Token' => @session.token,
-            :accept => :json,
-            :content_type => :json) { |res| handle_response(res) }
-        end
+        check_floating_ip(env, floating_ip)
+
+        post(env, "#{@session.endpoints[:compute]}/servers/#{server_id}/action",
+             { addFloatingIp: { address: floating_ip } }.to_json)
+      end
+
+      def import_keypair(env, public_key)
+        keyname = "vagrant-generated-#{Kernel.rand(36**8).to_s(36)}"
+
+        key_details = post(env, "#{@session.endpoints[:compute]}/os-keypairs",
+                           { keypair:
+                             {
+                               name: keyname,
+                               public_key: public_key
+                             }
+                           }.to_json)
+        JSON.parse(key_details)['keypair']['name']
+      end
+
+      def import_keypair_from_file(env, public_key_path)
+        fail "File specified in public_key_path #{public_key_path} doesn't exist" unless File.exist?(public_key_path)
+        file = File.open(public_key_path)
+        import_keypair(env, file.read)
+      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-')
+      end
+
+      def get_floating_ip_pools(env)
+        floating_ips = get(env, "#{@session.endpoints[:compute]}/os-floating-ip-pools")
+        JSON.parse(floating_ips)['floating_ip_pools']
+      end
+
+      def get_floating_ips(env)
+        floating_ips = get(env, "#{@session.endpoints[:compute]}/os-floating-ips")
+        JSON.parse(floating_ips)['floating_ips']
       end
 
       private
 
-      def check_floating_ip(_env, floating_ip)
-        ip_details = RestClient.get(
-          "#{@session.endpoints[:compute]}/os-floating-ips",
-          'X-Auth-Token' => @session.token,
-          :accept => :json) { |res| handle_response(res) }
+      VM_STATES =
+          {
+            suspend: 'suspend',
+            resume: 'resume',
+            start: 'os-start',
+            stop: 'os-stop'
+          }
+
+      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)
+      end
+
+      def check_floating_ip(env, floating_ip)
+        ip_details = get(env, "#{@session.endpoints[:compute]}/os-floating-ips")
 
         JSON.parse(ip_details)['floating_ips'].each do |ip|
           next unless ip['ip'] == floating_ip
@@ -154,13 +157,5 @@ module VagrantPlugins
         fail "Floating IP #{floating_ip} not available for this tenant"
       end
     end
-
-    class Item
-      attr_accessor :id, :name
-      def initialize(id, name)
-        @id = id
-        @name = name
-      end
-    end
   end
 end