vagrant-openstack-provider 0.1.2 → 0.2.0

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

@@ -1,7 +1,8 @@
-require "log4r"
-require "restclient"
-require "json"
-require_relative "../openstack_client"
+require 'log4r'
+require 'restclient'
+require 'json'
+
+require 'vagrant-openstack-provider/client/openstack'
 
 module VagrantPlugins
   module Openstack
@@ -10,17 +11,15 @@ module VagrantPlugins
       # puts the Openstack connection object into the `:openstack_compute` key
       # in the environment.
       class ConnectOpenstack
-        def initialize(app, env)
+        def initialize(app, _env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_openstack::action::connect_openstack")
+          @logger = Log4r::Logger.new('vagrant_openstack::action::connect_openstack')
         end
 
         def call(env)
-          # Get the configs
-          config = env[:machine].provider_config
-          client = OpenstackClient::new()
+          client = VagrantPlugins::Openstack
           env[:openstack_client] = client
-          client.authenticate(env)
+          client.keystone.authenticate(env) if client.session.token.nil?
           @app.call(env)
         end
       end

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

@@ -1,6 +1,6 @@
-require "log4r"
+require 'log4r'
 require 'socket'
-require "timeout"
+require 'timeout'
 
 require 'vagrant/util/retryable'
 
@@ -10,108 +10,137 @@ module VagrantPlugins
       class CreateServer
         include Vagrant::Util::Retryable
 
-        def initialize(app, env)
+        def initialize(app, _env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_openstack::action::create_server")
+          @logger = Log4r::Logger.new('vagrant_openstack::action::create_server')
         end
 
         def call(env)
           config = env[:machine].provider_config
-          client = env[:openstack_client]
+          nova = env[:openstack_client].nova
 
-          # Find the flavor
-          env[:ui].info(I18n.t("vagrant_openstack.finding_flavor"))
-          flavors = client.get_all_flavors(env)
-          flavor = find_matching(flavors, config.flavor)
-          raise Errors::NoMatchingFlavor if !flavor
-
-          # Find the image
-          env[:ui].info(I18n.t("vagrant_openstack.finding_image"))
-          images = client.get_all_images(env)
-          image = find_matching(images, config.image)
-          raise Errors::NoMatchingImage if !image
-
-          # Figure out the name for the server
+          flavor = resolve_flavor(env)
+          image = resolve_image(env)
+          networks = resolve_networks(env)
           server_name = config.server_name || env[:machine].name
 
-          # Output the settings we're going to use to the user
-          env[:ui].info(I18n.t("vagrant_openstack.launching_server"))
-          env[:ui].info(" -- Flavor       : #{flavor.name}")
-          env[:ui].info(" -- FlavorRef    : #{flavor.id}")
-          env[:ui].info(" -- Image        : #{image.name}")
-          env[:ui].info(" -- KeyPair      : #{config.keypair_name}")
-          env[:ui].info(" -- ImageRef     : #{image.id}")
-          env[:ui].info(" -- Disk Config  : #{config.disk_config}") if config.disk_config
-          env[:ui].info(" -- Network      : #{config.network}") if config.network
-          env[:ui].info(" -- Tenant       : #{config.tenant_name}")
-          env[:ui].info(" -- Name         : #{server_name}")
-
-          #TODO(julienvey) add metadata
-          #TODO(julienvey) add availability_zone
-          #TODO(julienvey) add disk_config
-
-          server_id = client.create_server(env, server_name, image.id, flavor.id, config.keypair_name)
-
-          #TODO(julienvey) Find a network if provided
-          #if config.network
-          #  network = find_matching(env[:openstack_network].networks, config.network)
-          #  options[:nics] = [{"net_id" => network.id}] if network
-          #end
+          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
+
+          server_id = nova.create_server(env, server_name, image.id, flavor.id, networks, config.keypair_name)
 
           # 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"))
+          env[:ui].info(I18n.t('vagrant_openstack.waiting_for_build'))
           timeout(200) do
-            while client.get_server_details(env, server_id)['status'] != 'ACTIVE' do
+            while nova.get_server_details(env, server_id)['status'] != 'ACTIVE'
               sleep 3
-              @logger.debug("Waiting for server to be ACTIVE")
+              @logger.debug('Waiting for server to be ACTIVE')
             end
           end
 
           if config.floating_ip
             env[:ui].info("Using floating IP #{config.floating_ip}")
-            client.add_floating_ip(env, server_id, config.floating_ip)
+            nova.add_floating_ip(env, server_id, config.floating_ip)
           end
 
-          if !env[:interrupted]
+          unless env[:interrupted]
             # Clear the line one more time so the progress is removed
             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
-            sleep 240
-            if !port_open?(env, host, 22, ssh_timeout)
-              env[:ui].error(I18n.t("vagrant_openstack.timeout"))
-              raise Errors::SshUnavailable,
-                    :host    => host,
-                    :timeout => ssh_timeout
+            unless port_open?(env, host, 22, ssh_timeout)
+              env[:ui].error(I18n.t('vagrant_openstack.timeout'))
+              fail Errors::SshUnavailable, host: host, timeout: ssh_timeout
             end
 
-            env[:ui].info(I18n.t("vagrant_openstack.ready"))
+            env[:ui].info(I18n.t('vagrant_openstack.ready'))
           end
 
           @app.call(env)
         end
 
-        protected
+        private
+
+        def resolve_flavor(env)
+          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)
+          flavor = find_matching(flavors, config.flavor)
+          fail Errors::NoMatchingFlavor unless flavor
+          flavor
+        end
+
+        def resolve_image(env)
+          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)
+          image = find_matching(images, config.image)
+          fail Errors::NoMatchingImage unless image
+          image
+        end
+
+        def resolve_networks(env)
+          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] }
+
+          networks = []
+          config.networks.each do |network|
+            if private_network_ids.include?(network)
+              networks << network
+              next
+            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]
+            end
+            fail "No matching network with name '#{network}'" if net_id.nil?
+            networks << net_id
+          end
+          networks
+        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"))
+              env[:ui].info(I18n.t('vagrant_openstack.waiting_for_ssh')) if nb_retry % 5 == 0
               TCPSocket.new(ip, port)
               return true
-            rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+            rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ETIMEDOUT
+              nb_retry += 1
               sleep 1
             end
             current_time = Time.now
           end
-          return false
+          false
         end
 
         # This method finds a matching _thing_ in a collection of

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

@@ -1,20 +1,19 @@
-require "log4r"
+require 'log4r'
 
 module VagrantPlugins
   module Openstack
     module Action
       # This deletes the running server, if there is one.
       class DeleteServer
-        def initialize(app, env)
+        def initialize(app, _env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_openstack::action::delete_server")
+          @logger = Log4r::Logger.new('vagrant_openstack::action::delete_server')
         end
 
         def call(env)
           if env[:machine].id
-            env[:ui].info(I18n.t("vagrant_openstack.deleting_server"))
-            client = env[:openstack_client]
-            client.delete_server(env, env[:machine].id)
+            env[:ui].info(I18n.t('vagrant_openstack.deleting_server'))
+            env[:openstack_client].nova.delete_server(env, env[:machine].id)
             env[:machine].id = nil
           end
 

data/lib/vagrant-openstack-provider/action/{is_created.rb → message.rb}

@@ -1,13 +1,14 @@
 module VagrantPlugins
   module Openstack
     module Action
-      class IsCreated
-        def initialize(app, env)
+      class Message
+        def initialize(app, _env, message)
           @app = app
+          @message = message
         end
 
         def call(env)
-          env[:result] = env[:machine].state.id != :not_created
+          env[:ui].info(@message)
           @app.call(env)
         end
       end

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

@@ -1,4 +1,4 @@
-require "log4r"
+require 'log4r'
 
 module VagrantPlugins
   module Openstack
@@ -6,9 +6,9 @@ module VagrantPlugins
       # 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)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_openstack::action::read_ssh_info")
+          @logger = Log4r::Logger.new('vagrant_openstack::action::read_ssh_info')
         end
 
         def call(env)
@@ -18,32 +18,12 @@ module VagrantPlugins
         end
 
         def read_ssh_info(env)
-          client = env[:openstack_client]
-          machine = env[:machine]
           config = env[:machine].provider_config
-          @logger.debug(config)
-          return nil if machine.id.nil?
-          begin
-            details = client.get_server_details(env, machine.id)
-          rescue Exception => e
-            # The machine can't be found
-            @logger.error(e)
-            @logger.info("Machine couldn't be found, assuming it got destroyed.")
-            machine.id = nil
-            return nil
-          end
-
-          for addr in details['addresses']['private']
-            if addr['OS-EXT-IPS:type'] == 'floating'
-              host = addr['addr']
-            end
-          end
-
-          return {
+          {
             # Usually there should only be one public IP
-            :host => host,
-            :port => 22,
-            :username => config.ssh_username
+            host: config.floating_ip,
+            port: 22,
+            username: config.ssh_username
           }
         end
       end

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

@@ -1,4 +1,4 @@
-require "log4r"
+require 'log4r'
 
 module VagrantPlugins
   module Openstack
@@ -6,33 +6,31 @@ module VagrantPlugins
       # This action reads the state of the machine and puts it in the
       # `:machine_state_id` key in the environment.
       class ReadState
-        def initialize(app, env)
+        def initialize(app, _env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_openstack::action::read_state")
+          @logger = Log4r::Logger.new('vagrant_openstack::action::read_state')
         end
 
         def call(env)
           env[:machine_state_id] = read_state(env)
-
           @app.call(env)
         end
 
         def read_state(env)
           machine = env[:machine]
-          client = env[:openstack_client]
           return :not_created if machine.id.nil?
 
           # Find the machine
-          server = client.get_server_details(env, machine.id)
-          if server.nil? || server['status'] == "DELETED"
+          server = env[:openstack_client].nova.get_server_details(env, machine.id)
+          if server.nil? || server['status'] == 'DELETED'
             # The machine can't be found
-            @logger.info("Machine not found or deleted, assuming it got destroyed.")
+            @logger.info('Machine not found or deleted, assuming it got destroyed.')
             machine.id = nil
             return :not_created
           end
 
           # Return the state
-          return server['status'].downcase.to_sym
+          server['status'].downcase.to_sym
         end
       end
     end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module Openstack
+    module Action
+      class Resume
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info I18n.t('vagrant.actions.vm.resume.resuming')
+            env[:openstack_client].nova.resume_server(env, env[:machine].id)
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class StartServer
+        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.starting_server'))
+            env[:openstack_client].nova.start_server(env, env[:machine].id)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'log4r'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class StopServer
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::stop_server')
+        end
+
+        def call(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t('vagrant_openstack.stopping_server'))
+            env[:openstack_client].nova.stop_server(env, env[:machine].id)
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end