vagrant-openstack-provider-illuin 0.11.1

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

@@ -0,0 +1,22 @@
+require 'colorize'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class AbstractAction
+        def call(env)
+          execute(env)
+        # rubocop:disable Style/SpecialGlobalVars
+        # rubocop:disable Lint/RescueException
+        rescue Errors::VagrantOpenstackError, SystemExit, Interrupt => e
+          raise e
+        rescue Exception => e
+          puts I18n.t('vagrant_openstack.global_error').red unless e.message && e.message.start_with?('Catched Error:')
+          raise $!, "Catched Error: #{$!}", $!.backtrace
+        end
+        # rubocop:enable Lint/RescueException
+        # rubocop:enable Style/SpecialGlobalVars
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-openstack-provider/client/openstack'
+require 'vagrant-openstack-provider/client/request_logger'
+require 'vagrant-openstack-provider/action/abstract_action'
+require 'vagrant-openstack-provider/catalog/openstack_catalog'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class ConnectOpenstack < AbstractAction
+        include VagrantPlugins::Openstack::HttpUtils::RequestLogger
+        include VagrantPlugins::Openstack::Catalog
+
+        def initialize(app, env, catalog_reader = OpenstackCatalog.new)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::connect_openstack')
+          @catalog_reader = catalog_reader
+          env[:openstack_client] = VagrantPlugins::Openstack
+        end
+
+        def execute(env)
+          client = env[:openstack_client]
+          if client.session.token.nil?
+            catalog = client.keystone.authenticate(env)
+            @catalog_reader.read(env, catalog)
+            override_endpoint_catalog_with_user_config(env)
+            check_configuration(env)
+            log_endpoint_catalog(env)
+          end
+          @app.call(env) unless @app.nil?
+        end
+
+        private
+
+        def override_endpoint_catalog_with_user_config(env)
+          client = env[:openstack_client]
+          config = env[:machine].provider_config
+          endpoints = client.session.endpoints
+          endpoints[:compute] = config.openstack_compute_url unless config.openstack_compute_url.nil?
+          endpoints[:network] = config.openstack_network_url unless config.openstack_network_url.nil?
+          endpoints[:volume]  = config.openstack_volume_url  unless config.openstack_volume_url.nil?
+          endpoints[:image]   = config.openstack_image_url   unless config.openstack_image_url.nil?
+          endpoints.delete_if { |_, value| value.nil? || value.empty? }
+        end
+
+        def check_configuration(env)
+          fail Errors::MissingNovaEndpoint unless env[:openstack_client].session.endpoints.key? :compute
+        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
+  end
+end

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

@@ -0,0 +1,184 @@
+require 'log4r'
+require 'socket'
+require 'timeout'
+require 'sshkey'
+
+require 'vagrant-openstack-provider/config_resolver'
+require 'vagrant-openstack-provider/utils'
+require 'vagrant-openstack-provider/action/abstract_action'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class CreateServer < AbstractAction
+        include Vagrant::Util::Retryable
+
+        def initialize(app, _env, resolver = ConfigResolver.new, utils = Utils.new)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::create_server')
+          @resolver = resolver
+          @utils = utils
+        end
+
+        def execute(env)
+          @logger.info 'Start create server action'
+
+          config = env[:machine].provider_config
+
+          fail Errors::MissingBootOption if config.image.nil? && config.volume_boot.nil?
+          fail Errors::ConflictBootOption unless config.image.nil? || config.volume_boot.nil?
+
+          options = {
+            flavor: @resolver.resolve_flavor(env),
+            image: @resolver.resolve_image(env),
+            volume_boot: @resolver.resolve_volume_boot(env),
+            networks: @resolver.resolve_networks(env),
+            volumes: @resolver.resolve_volumes(env),
+            keypair_name: @resolver.resolve_keypair(env),
+            availability_zone: env[:machine].provider_config.availability_zone,
+            scheduler_hints: env[:machine].provider_config.scheduler_hints,
+            security_groups: @resolver.resolve_security_groups(env),
+            user_data: env[:machine].provider_config.user_data,
+            metadata: env[:machine].provider_config.metadata
+          }
+
+          server_id = create_server(env, options)
+
+          # Store the ID right away so we can track it
+          env[:machine].id = server_id
+
+          waiting_for_server_to_be_built(env, server_id)
+          assign_floating_ip(env, server_id)
+          waiting_for_floating_ip_to_be_assigned(env, server_id)
+          attach_volumes(env, server_id, options[:volumes]) unless options[:volumes].empty?
+
+          @app.call(env)
+        end
+
+        private
+
+        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}")
+          unless options[:image].nil?
+            env[:ui].info(" -- Image           : #{options[:image].name}")
+            env[:ui].info(" -- ImageRef        : #{options[:image].id}")
+          end
+          env[:ui].info(" -- Boot volume     : #{options[:volume_boot][:id]} (#{options[:volume_boot][:device]})") unless options[:volume_boot].nil?
+          env[:ui].info(" -- KeyPair         : #{options[:keypair_name]}") unless options[:keypair_name].nil?
+
+          unless options[:networks].empty?
+            formated_networks = ' -- '
+            if options[:networks].size == 1
+              formated_networks << 'Network         : '
+            else
+              formated_networks << 'Networks        : '
+            end
+            formated_networks << options[:networks].map do |n|
+              if n.key? :fixed_ip
+                "#{n[:uuid]} (#{n[:fixed_ip]})"
+              else
+                n[:uuid]
+              end
+            end.join(', ')
+            env[:ui].info(formated_networks)
+          end
+
+          unless options[:volumes].empty?
+            options[:volumes].each do |volume|
+              device = volume[:device]
+              device = :auto if device.nil?
+              env[:ui].info(" -- Volume attached : #{volume[:id]} => #{device}")
+            end
+          end
+
+          log = "Launching server '#{server_name}' in project '#{config.tenant_name}' "
+          log << "with flavor '#{options[:flavor].name}' (#{options[:flavor].id}), "
+          unless options[:image].nil?
+            log << "image '#{options[:image].name}' (#{options[:image].id}) "
+          end
+          unless options[:keypair_name].nil?
+            log << "and keypair '#{options[:keypair_name]}'"
+          end
+
+          @logger.info(log)
+
+          image_ref = options[:image].id unless options[:image].nil?
+
+          create_opts = {
+            name: server_name,
+            image_ref: image_ref,
+            volume_boot: options[:volume_boot],
+            flavor_ref: options[:flavor].id,
+            keypair: options[:keypair_name],
+            availability_zone: options[:availability_zone],
+            networks: options[:networks],
+            scheduler_hints: options[:scheduler_hints],
+            security_groups: options[:security_groups],
+            user_data: options[:user_data],
+            metadata: options[:metadata]
+          }
+
+          nova.create_server(env, create_opts)
+        end
+
+        def waiting_for_server_to_be_built(env, server_id, retry_interval = 3)
+          @logger.info "Waiting for the server with id #{server_id} to be built..."
+          env[:ui].info(I18n.t('vagrant_openstack.waiting_for_build'))
+          config = env[:machine].provider_config
+          Timeout.timeout(config.server_create_timeout, Errors::Timeout) do
+            server_status = 'WAITING'
+            until server_status == 'ACTIVE'
+              @logger.debug('Waiting for server to be ACTIVE')
+              server_status = env[:openstack_client].nova.get_server_details(env, server_id)['status']
+              fail Errors::ServerStatusError, server: server_id if server_status == 'ERROR'
+              sleep retry_interval
+            end
+          end
+        end
+
+        def assign_floating_ip(env, server_id)
+          floating_ip = @resolver.resolve_floating_ip(env)
+          return 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))
+          env[:openstack_client].nova.add_floating_ip(env, server_id, floating_ip)
+        rescue Errors::UnableToResolveFloatingIP
+          @logger.info 'Vagrant was unable to resolve FloatingIP, continue assuming it is not necessary'
+        end
+
+        def waiting_for_floating_ip_to_be_assigned(env, server_id, retry_interval = 3)
+          floating_ip = @resolver.resolve_floating_ip(env)
+          return if !floating_ip || floating_ip.empty?
+          @logger.info "Waiting for floating IP #{floating_ip} to be assigned"
+          env[:ui].info(I18n.t('vagrant_openstack.waiting_for_floating_ip', floating_ip: floating_ip))
+          config = env[:machine].provider_config
+          Timeout.timeout(config.floating_ip_assign_timeout, Errors::Timeout) do
+            until env[:openstack_client].nova.check_assigned_floating_ip(env, server_id, floating_ip)
+              sleep retry_interval
+            end
+            return
+          end
+        rescue Errors::UnableToResolveFloatingIP
+          @logger.info 'Vagrant was unable to resolve FloatingIP, not waiting for assignment'
+        end
+
+        def attach_volumes(env, server_id, volumes)
+          @logger.info("Attaching volumes #{volumes} to server #{server_id}")
+          volumes.each do |volume|
+            @logger.debug("Attaching volumes #{volume}")
+            env[:openstack_client].nova.attach_volume(env, server_id, volume[:id], volume[:device])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'log4r'
+require 'socket'
+require 'timeout'
+require 'sshkey'
+require 'yaml'
+
+require 'vagrant-openstack-provider/config_resolver'
+require 'vagrant-openstack-provider/utils'
+require 'vagrant-openstack-provider/action/abstract_action'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class CreateStack < AbstractAction
+        @@is_created = false
+
+        def initialize(app, _env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::create_stack')
+        end
+
+        def execute(env)
+          if @@is_created
+            @app.call(env)
+            return
+          end
+
+          @logger.info 'Start create stacks action'
+
+          config = env[:machine].provider_config
+
+          heat = env[:openstack_client].heat
+
+          config.stacks.each do |stack|
+            env[:ui].info(I18n.t('vagrant_openstack.create_stack'))
+            env[:ui].info(" -- Stack Name : #{stack[:name]}")
+            env[:ui].info(" -- Template   : #{stack[:template]}")
+
+            create_opts = {
+              name: stack[:name],
+              template: YAML.load_file(stack[:template])
+            }
+
+            stack_id = heat.create_stack(env, create_opts)
+
+            file_path = "#{env[:machine].data_dir}/stack_#{stack[:name]}_id"
+            File.write(file_path, stack_id)
+
+            waiting_for_stack_to_be_created(env, stack[:name], stack_id)
+          end unless config.stacks.nil?
+
+          @@is_created = true
+          @app.call(env)
+        end
+
+        private
+
+        def waiting_for_stack_to_be_created(env, stack_name, stack_id, retry_interval = 3)
+          @logger.info "Waiting for the stack with id #{stack_id} to be built..."
+          env[:ui].info(I18n.t('vagrant_openstack.waiting_for_stack'))
+          config = env[:machine].provider_config
+          Timeout.timeout(config.stack_create_timeout, Errors::Timeout) do
+            stack_status = 'CREATE_IN_PROGRESS'
+            until stack_status == 'CREATE_COMPLETE'
+              @logger.debug('Waiting for stack to be CREATED')
+              stack_status = env[:openstack_client].heat.get_stack_details(env, stack_name, stack_id)['stack_status']
+              fail Errors::StackStatusError, stack: stack_id if stack_status == 'CREATE_FAILED'
+              sleep retry_interval
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'log4r'
+
+require 'vagrant-openstack-provider/action/abstract_action'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      # This deletes the running server, if there is one.
+      class DeleteServer < AbstractAction
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::delete_server')
+        end
+
+        def execute(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)
+
+            waiting_for_instance_to_be_deleted(env, env[:machine].id)
+
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def waiting_for_instance_to_be_deleted(env, instance_id, retry_interval = 3)
+          @logger.info "Waiting for the instance with id #{instance_id} to be deleted..."
+          env[:ui].info(I18n.t('vagrant_openstack.waiting_deleted'))
+          config = env[:machine].provider_config
+          Timeout.timeout(config.server_delete_timeout, Errors::Timeout) do
+            delete_ok = false
+            until delete_ok
+              begin
+                @logger.debug('Waiting for instance to be DELETED')
+                server_status = env[:openstack_client].nova.get_server_details(env, instance_id)['status']
+                fail Errors::ServerStatusError, server: instance_id if server_status == 'ERROR'
+                break if server_status == 'DELETED'
+                sleep retry_interval
+              rescue Errors::InstanceNotFound
+                delete_ok = true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'log4r'
+require 'socket'
+require 'timeout'
+require 'sshkey'
+require 'yaml'
+
+require 'vagrant-openstack-provider/config_resolver'
+require 'vagrant-openstack-provider/utils'
+require 'vagrant-openstack-provider/action/abstract_action'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module Openstack
+    module Action
+      class DeleteStack < AbstractAction
+        def initialize(app, _env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::delete_stack')
+        end
+
+        def execute(env)
+          @logger.info 'Start delete stacks action'
+
+          heat = env[:openstack_client].heat
+
+          list_stack_files(env).each do |stack|
+            env[:ui].info(I18n.t('vagrant_openstack.delete_stack'))
+            env[:ui].info(" -- Stack Name : #{stack[:name]}")
+            env[:ui].info(" -- Stack ID   : #{stack[:id]}")
+
+            heat.delete_stack(env, stack[:name], stack[:id])
+
+            waiting_for_stack_to_be_deleted(env, stack[:name], stack[:id])
+          end
+
+          # This will remove all files in the .vagrant instance directory
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+
+        private
+
+        def list_stack_files(env)
+          stack_files = []
+          Dir.glob("#{env[:machine].data_dir}/stack_*_id") do |stack_file|
+            file_name = stack_file.split('/')[-1]
+            stack_files << {
+              name: file_name[6, (file_name.length) - 9],
+              id: File.read("#{stack_file}")
+            }
+          end
+          stack_files
+        end
+
+        def waiting_for_stack_to_be_deleted(env, stack_name, stack_id, retry_interval = 3)
+          @logger.info "Waiting for the stack with id #{stack_id} to be deleted..."
+          env[:ui].info(I18n.t('vagrant_openstack.waiting_for_stack_deleted'))
+          config = env[:machine].provider_config
+          Timeout.timeout(config.stack_delete_timeout, Errors::Timeout) do
+            stack_status = 'DELETE_IN_PROGRESS'
+            until stack_status == 'DELETE_COMPLETE'
+              @logger.debug('Waiting for stack to be DELETED')
+              stack_status = env[:openstack_client].heat.get_stack_details(env, stack_name, stack_id)['stack_status']
+              fail Errors::StackStatusError, stack: stack_id if stack_status == 'DELETE_FAILED'
+              sleep retry_interval
+            end
+          end
+        end
+      end
+    end
+  end
+end