vagrant-conoha 0.1.0

data/lib/vagrant-conoha/action/create_stack.rb

@@ -0,0 +1,68 @@
+require 'log4r'
+require 'socket'
+require 'timeout'
+require 'sshkey'
+require 'yaml'
+
+require 'vagrant-conoha/config_resolver'
+require 'vagrant-conoha/utils'
+require 'vagrant-conoha/action/abstract_action'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class CreateStack < AbstractAction
+        def initialize(app, _env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::create_stack')
+        end
+
+        def execute(env)
+          @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?
+
+          @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(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-conoha/action/delete_server.rb

@@ -0,0 +1,53 @@
+require 'log4r'
+
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    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(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-conoha/action/delete_stack.rb

@@ -0,0 +1,73 @@
+require 'log4r'
+require 'socket'
+require 'timeout'
+require 'sshkey'
+require 'yaml'
+
+require 'vagrant-conoha/config_resolver'
+require 'vagrant-conoha/utils'
+require 'vagrant-conoha/action/abstract_action'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ConoHa
+    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(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

data/lib/vagrant-conoha/action/message.rb

@@ -0,0 +1,19 @@
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class Message < AbstractAction
+        def initialize(app, _env, message)
+          @app = app
+          @message = message
+        end
+
+        def execute(env)
+          env[:ui].info(@message)
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/action/provision.rb

@@ -0,0 +1,60 @@
+require 'log4r'
+
+require 'vagrant/action/builder'
+
+require 'vagrant-conoha/action/abstract_action'
+require 'vagrant-conoha/action/read_ssh_info'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      include Vagrant::Action::Builtin
+
+      class ProvisionWrapper < AbstractAction
+        def initialize(app, env)
+          @app    = app
+          @env    = env
+          @logger = Log4r::Logger.new('vagrant_openstack::action::provision_wrapper')
+        end
+
+        def execute(env)
+          @logger.info 'Run provisioning'
+          InternalProvisionWrapper.new(@app, @env).call(@env)
+          @app.call(env)
+        end
+      end
+
+      class InternalProvisionWrapper < Vagrant::Action::Builtin::Provision
+        def initialize(app, env)
+          @logger = Log4r::Logger.new('vagrant_openstack::action::internal_provision_wrapper')
+          super app, env
+        end
+
+        def run_provisioner(env)
+          if env[:provisioner].class == VagrantPlugins::Shell::Provisioner
+            handle_shell_meta_args(env)
+          end
+          env[:provisioner].provision
+        end
+
+        private
+
+        def handle_shell_meta_args(env)
+          config = env[:provisioner].config
+          args = config.args.nil? ? [] : [config.args].flatten
+          config.args = []
+          @logger.info "Shell provisioner args: #{args}"
+          args.each do |arg|
+            if '@@ssh_ip@@'.eql? arg
+              ssh_info = VagrantPlugins::ConoHa::Action.get_ssh_info(env)
+              @logger.info "Replace meta-arg #{arg} by value #{ssh_info[:host]}"
+              config.args << ssh_info[:host]
+            else
+              config.args << arg
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/action/read_ssh_info.rb

@@ -0,0 +1,72 @@
+require 'log4r'
+
+require 'vagrant-conoha/config_resolver'
+require 'vagrant-conoha/utils'
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    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 < AbstractAction
+        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 execute(env)
+          @logger.info 'Reading SSH info'
+          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
+
+        private
+
+        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: @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 get_keypair_name(env)
+          env[:openstack_client].nova.get_server_details(env, env[:machine].id)['key_name']
+        end
+      end
+
+      class SSHInfoHolder < Mutex
+        include Singleton
+
+        #
+        # Keys are machine ids
+        #
+        attr_accessor :ssh_info
+
+        def initialize
+          @ssh_info = {}
+        end
+      end
+
+      def self.get_ssh_info(env)
+        SSHInfoHolder.instance.ssh_info[env[:machine].id.to_sym]
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/action/read_state.rb

@@ -0,0 +1,43 @@
+require 'log4r'
+
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      # This action reads the state of the machine and puts it in the
+      # `:machine_state_id` key in the environment.
+      class ReadState < AbstractAction
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::read_state')
+        end
+
+        def execute(env)
+          env[:machine_state_id] = read_state(env)
+          @app.call(env)
+        end
+
+        def read_state(env)
+          machine = env[:machine]
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          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.')
+            machine.id = nil
+            return :not_created
+          end
+
+          if !server['OS-EXT-STS:task_state'].nil?
+            server['OS-EXT-STS:task_state'].downcase.to_sym
+          else
+            server['status'].downcase.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/action/resume.rb

@@ -0,0 +1,24 @@
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class Resume < AbstractAction
+        def initialize(app, _env)
+          @app = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::resume_server')
+        end
+
+        def execute(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
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/action/start_server.rb

@@ -0,0 +1,24 @@
+require 'log4r'
+
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class StartServer < AbstractAction
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::start_server')
+        end
+
+        def execute(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