vagrant-conoha 0.1.0

data/lib/vagrant-conoha.rb

@@ -0,0 +1,29 @@
+require 'pathname'
+
+require 'vagrant-conoha/plugin'
+require 'vagrant-conoha/logging'
+
+module VagrantPlugins
+  module ConoHa
+    lib_path = Pathname.new(File.expand_path('../vagrant-conoha', __FILE__))
+    autoload :Errors, lib_path.join('errors')
+
+    # This initializes the i18n load path so that the plugin-specific
+    # translations work.
+    def self.init_i18n
+      I18n.load_path << File.expand_path('locales/en.yml', source_root)
+      I18n.reload!
+    end
+
+    def self.init_logging
+      Logging.init
+    end
+
+    # This returns the path to the source of this plugin.
+    #
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('../../', __FILE__))
+    end
+  end
+end

data/lib/vagrant-conoha/action.rb

@@ -0,0 +1,227 @@
+require 'pathname'
+
+require 'vagrant/action/builder'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+
+      # This action is called to destroy the remote machine.
+      def self.action_destroy
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            if env[:machine_state_id] == :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            else
+              b2.use DeleteServer
+              b2.use DeleteStack
+            end
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            if env[:machine_state_id] == :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            else
+              b2.use ProvisionWrapper
+              b2.use SyncFolders
+            end
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use ReadSSHInfo
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use ReadState
+        end
+      end
+
+      def self.action_ssh
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            if env[:machine_state_id] == :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            else
+              b2.use SSHExec
+            end
+          end
+        end
+      end
+
+      def self.action_ssh_run
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            if env[:machine_state_id] == :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            else
+              b2.use SSHRun
+            end
+          end
+        end
+      end
+
+      def self.action_up
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+
+          b.use Call, ReadState do |env, b2|
+            case env[:machine_state_id]
+            when :not_created
+              ssh_disabled = env[:machine].provider_config.ssh_disabled
+              b2.use ProvisionWrapper unless ssh_disabled
+              b2.use SyncFolders
+              b2.use CreateStack
+              b2.use CreateServer
+              b2.use Message, I18n.t('vagrant_openstack.ssh_disabled_provisioning') if ssh_disabled
+              b2.use WaitForServerToBeAccessible unless ssh_disabled
+            when :shutoff
+              b2.use StartServer
+            when :suspended
+              b2.use Resume
+            else
+              b2.use Message, I18n.t('vagrant_openstack.already_created')
+            end
+          end
+        end
+      end
+
+      def self.action_halt
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            if env[:machine_state_id] == :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            else
+              b2.use StopServer
+            end
+          end
+        end
+      end
+
+      # This is the action that is primarily responsible for suspending
+      # the virtual machine.
+      # Vm cannot be suspended when the machine_state_id is not "active" (typically a task is ongoing)
+      def self.action_suspend
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            case env[:machine_state_id]
+            when :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            when :suspended
+              b2.use Message, I18n.t('vagrant_openstack.already_suspended')
+            when :active
+              b2.use Suspend
+            else
+              b2.use Message, I18n.t('vagrant_openstack.ongoing_task')
+            end
+          end
+        end
+      end
+
+      # This is the action that is primarily responsible for resuming
+      # suspended machines.
+      # Vm cannot be resumed when the machine_state_id is not suspended.
+      def self.action_resume
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            case env[:machine_state_id]
+            when :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            when :suspended
+              b2.use Resume
+            else
+              b2.use Message, I18n.t('vagrant_openstack.not_suspended')
+            end
+          end
+        end
+      end
+
+      def self.action_reload
+        new_builder.tap do |b|
+          b.use ConfigValidate
+          b.use ConnectOpenstack
+          b.use Call, ReadState do |env, b2|
+            case env[:machine_state_id]
+            when :not_created
+              b2.use Message, I18n.t('vagrant_openstack.not_created')
+            when :suspended
+              b2.use Resume
+              b2.use WaitForServerToBeActive
+              b2.use StopServer
+              b2.use WaitForServerToStop
+              b2.use StartServer
+            when :shutoff
+              b2.use StartServer
+            else
+              b2.use StopServer
+              b2.use WaitForServerToStop
+              b2.use StartServer
+            end
+          end
+        end
+      end
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path('../action', __FILE__))
+      autoload :Message, action_root.join('message')
+      autoload :ConnectOpenstack, action_root.join('connect_openstack')
+      autoload :CreateServer, action_root.join('create_server')
+      autoload :CreateStack, action_root.join('create_stack')
+      autoload :DeleteStack, action_root.join('delete_stack')
+      autoload :DeleteServer, action_root.join('delete_server')
+      autoload :StopServer, action_root.join('stop_server')
+      autoload :StartServer, action_root.join('start_server')
+      autoload :ReadSSHInfo, action_root.join('read_ssh_info')
+      autoload :ReadState, action_root.join('read_state')
+      autoload :SyncFolders, action_root.join('sync_folders')
+      autoload :Suspend, action_root.join('suspend')
+      autoload :Resume, action_root.join('resume')
+      autoload :ProvisionWrapper, action_root.join('provision')
+      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-conoha/action/abstract_action.rb

@@ -0,0 +1,22 @@
+require 'colorize'
+
+module VagrantPlugins
+  module ConoHa
+    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-conoha/action/connect_openstack.rb

@@ -0,0 +1,60 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/openstack'
+require 'vagrant-conoha/client/request_logger'
+require 'vagrant-conoha/action/abstract_action'
+require 'vagrant-conoha/catalog/openstack_catalog'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class ConnectOpenstack < AbstractAction
+        include VagrantPlugins::ConoHa::HttpUtils::RequestLogger
+        include VagrantPlugins::ConoHa::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::ConoHa
+        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-conoha/action/create_server.rb

@@ -0,0 +1,154 @@
+require 'log4r'
+require 'socket'
+require 'timeout'
+require 'sshkey'
+
+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 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)
+          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[: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 = "Lauching 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
+          log << "and keypair '#{options[:keypair_name]}'"
+
+          @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(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 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