vagrant-conoha 0.1.0

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

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

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

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

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

@@ -0,0 +1,129 @@
+require 'log4r'
+require 'rbconfig'
+require 'vagrant/util/subprocess'
+
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class SyncFolders < AbstractAction
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def execute(env)
+          sync_method = env[:machine].provider_config.sync_method
+          if sync_method == 'none'
+            NoSyncFolders.new(@app, env).call(env)
+          elsif sync_method == 'rsync'
+            RsyncFolders.new(@app, env).call(env)
+          else
+            fail Errors::SyncMethodError, sync_method_value: sync_method
+          end
+        end
+      end
+
+      class NoSyncFolders
+        def initialize(app, _env)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+          env[:ui].info(I18n.t('vagrant_openstack.disabled_sync_folders'))
+        end
+      end
+
+      # This middleware uses `rsync` to sync the folders over to the
+      # remote instance.
+      class RsyncFolders
+        def initialize(app, _env)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::sync_folders')
+          @host_os = RbConfig::CONFIG['host_os']
+        end
+
+        def call(env)
+          @app.call(env)
+
+          if env[:machine].provider_config.ssh_disabled
+            env[:ui].info(I18n.t('vagrant_openstack.ssh_disabled_sync_folders'))
+            return
+          end
+
+          ssh_info = env[:machine].ssh_info
+
+          config          = env[:machine].provider_config
+          rsync_includes  = config.rsync_includes.to_a
+
+          env[:machine].config.vm.synced_folders.each do |_, data|
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            # If on Windows, modify the path to work with cygwin rsync
+            if @host_os =~ /mswin|mingw|cygwin/
+              hostpath = add_cygdrive_prefix_to_path(hostpath)
+            end
+
+            env[:ui].info(I18n.t('vagrant_openstack.rsync_folder', hostpath: hostpath, guestpath: guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo("chown -R #{ssh_info[:username]} '#{guestpath}'")
+
+            # Generate rsync include commands
+            includes = rsync_includes.each_with_object([]) do |incl, incls|
+              incls << '--include'
+              incls << incl
+            end
+
+            # Rsync over to the guest path using the SSH info. add
+            # .hg/ and .git/ to exclude list as that isn't covered in
+            # --cvs-exclude
+            command = [
+              'rsync', '--verbose', '--archive', '-z',
+              '--cvs-exclude',
+              '--exclude', '.hg/',
+              '--exclude', '.git/',
+              '--chmod', 'ugo=rwX',
+              *includes,
+              '-e', "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no #{ssh_key_options(ssh_info)}",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+            command.compact!
+
+            # during rsync, ignore files specified in list of files containing exclude patterns
+            # ex: rsync_ignore_files = ['.hgignore', '.gitignore']
+            ignore_files = []
+            ignore_files = env[:machine].provider_config.rsync_ignore_files unless env[:machine].provider_config.rsync_ignore_files.nil?
+            ignore_files.each do |ignore_file|
+              abs_ignore_file = env[:root_path].to_s + '/' + ignore_file
+              command += ['--exclude-from', abs_ignore_file] if File.exist?(abs_ignore_file)
+            end
+            r = Vagrant::Util::Subprocess.execute(*command)
+            next if r.exit_code == 0
+            fail Errors::RsyncError, guestpath: guestpath, hostpath: hostpath, stderr: r.stderr
+          end
+        end
+
+        private
+
+        def ssh_key_options(ssh_info)
+          # Ensure that `private_key_path` is an Array (for Vagrant < 1.4)
+          Array(ssh_info[:private_key_path]).map { |path| "-i '#{path}' " }.join
+        end
+
+        def add_cygdrive_prefix_to_path(hostpath)
+          hostpath.downcase.sub(/^([a-z]):\//) do
+            "/cygdrive/#{Regexp.last_match[1]}/"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'log4r'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class WaitForServerToBeAccessible < AbstractAction
+        def initialize(app, env, resolver = nil, ssh = nil)
+          @logger   = Log4r::Logger.new('vagrant_openstack::action::wait_accessible')
+          @app      = app
+          @ssh      = ssh || Vagrant::Action::Builtin::SSHRun.new(app, env)
+          @resolver = resolver || VagrantPlugins::ConoHa::ConfigResolver.new
+        end
+
+        def execute(env)
+          waiting_for_server_to_be_reachable(env)
+          @logger.info 'The server is ready'
+          env[:ui].info(I18n.t('vagrant_openstack.ready'))
+          @app.call(env)
+        end
+
+        private
+
+        def waiting_for_server_to_be_reachable(env)
+          return if env[:interrupted]
+          ssh_timeout = env[:machine].provider_config.ssh_timeout
+          return if server_is_reachable?(env, ssh_timeout)
+          env[:ui].error(I18n.t('vagrant_openstack.timeout'))
+          fail Errors::SshUnavailable, host: @resolver.resolve_floating_ip(env), timeout: ssh_timeout
+        end
+
+        def server_is_reachable?(env, timeout)
+          start_time = Time.now
+          current_time = start_time
+          nb_retry = 0
+
+          while (current_time - start_time) <= timeout
+            @logger.debug "Checking if SSH port is open... Attempt number #{nb_retry}"
+            if nb_retry % 5 == 0
+              @logger.info 'Waiting for SSH to become available...'
+              env[:ui].info(I18n.t('vagrant_openstack.waiting_for_ssh'))
+            end
+
+            env[:ssh_run_command] = 'exit 0'
+            env[:ssh_opts] = {
+              extra_args: ['-o', 'BatchMode=yes']
+            }
+            @ssh.call(env)
+            return true if env[:ssh_run_exit_status] == 0
+
+            @logger.debug 'SSH not yet available... new retry in in 1 second'
+            nb_retry += 1
+            sleep 1
+            current_time = Time.now
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'log4r'
+require 'timeout'
+
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class WaitForServerToBeActive < AbstractAction
+        def initialize(app, _env, retry_interval = 3)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::start_server')
+          @retry_interval = retry_interval
+        end
+
+        def execute(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t('vagrant_openstack.waiting_start'))
+            client = env[:openstack_client].nova
+            config = env[:machine].provider_config
+            timeout(config.server_active_timeout, Errors::Timeout) do
+              while client.get_server_details(env, env[:machine].id)['status'] != 'ACTIVE'
+                sleep @retry_interval
+                @logger.info('Waiting for server to be active')
+              end
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'log4r'
+require 'timeout'
+
+require 'vagrant-conoha/action/abstract_action'
+
+module VagrantPlugins
+  module ConoHa
+    module Action
+      class WaitForServerToStop < AbstractAction
+        def initialize(app, _env, retry_interval = 3)
+          @app    = app
+          @logger = Log4r::Logger.new('vagrant_openstack::action::stop_server')
+          @retry_interval = retry_interval
+        end
+
+        def execute(env)
+          if env[:machine].id
+            env[:ui].info(I18n.t('vagrant_openstack.waiting_stop'))
+            client = env[:openstack_client].nova
+            config = env[:machine].provider_config
+            timeout(config.server_stop_timeout, Errors::Timeout) do
+              while client.get_server_details(env, env[:machine].id)['status'] != 'SHUTOFF'
+                sleep @retry_interval
+                @logger.info('Waiting for server to stop')
+              end
+            end
+          end
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/catalog/openstack_catalog.rb

@@ -0,0 +1,67 @@
+module VagrantPlugins
+  module ConoHa
+    module Catalog
+      class OpenstackCatalog
+        def initialize
+          @logger = Log4r::Logger.new('vagrant_openstack::action::openstack_reader')
+        end
+
+        def read(env, catalog)
+          config = env[:machine].provider_config
+          client = env[:openstack_client]
+          endpoints = client.session.endpoints
+          endpoint_type = config.endpoint_type
+          @logger.info(I18n.t('vagrant_openstack.client.looking_for_available_endpoints'))
+          @logger.info("Selecting endpoints matching region '#{config.region}'") unless config.region.nil?
+
+          catalog.each do |service|
+            se = service['endpoints']
+            if config.region.nil?
+              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][endpoint_type]}"
+              end
+              url = se[0][endpoint_type].strip
+            else
+              se.each do |endpoint|
+                url = endpoint[endpoint_type].strip if endpoint['region'].eql? config.region
+              end
+            end
+            endpoints[service['type'].to_sym] = url unless url.nil? || url.empty?
+          end
+
+          endpoints[:network] = choose_api_version('Neutron', 'openstack_network_url', 'v2') do
+            client.neutron.get_api_version_list(env, :network)
+          end if config.openstack_network_url.nil? && !endpoints[:network].nil?
+
+          endpoints[:image] = choose_api_version('Glance', 'openstack_image_url', nil, false) do
+            client.glance.get_api_version_list(env)
+          end if config.openstack_image_url.nil? && !endpoints[:image].nil?
+        end
+
+        private
+
+        def choose_api_version(service_name, url_property, version_prefix = nil, fail_if_not_found = true)
+          versions = yield
+
+          return versions.first['links'].first['href'] if version_prefix.nil?
+
+          if versions.size == 1
+            return versions.first['links'].first['href'] if versions.first['id'].start_with?(version_prefix)
+            fail Errors::NoMatchingApiVersion, api_name: service_name, url_property: url_property, version_list: version_list if fail_if_not_found
+          end
+
+          version_list = ''
+          versions.each do |version|
+            return version['links'].first['href'] if version['id'].start_with?(version_prefix)
+            links = version['links'].map { |l| l['href'] }
+            version_list << "#{version['id'].ljust(6)} #{version['status'].ljust(10)} #{links}\n"
+          end
+
+          fail Errors::NoMatchingApiVersion, api_name: service_name, url_property: url_property, version_list: version_list if fail_if_not_found
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/client/cinder.rb

@@ -0,0 +1,39 @@
+require 'log4r'
+require 'json'
+
+require 'vagrant-conoha/client/http_utils'
+require 'vagrant-conoha/client/domain'
+
+module VagrantPlugins
+  module ConoHa
+    class CinderClient
+      include Singleton
+      include VagrantPlugins::ConoHa::HttpUtils
+      include VagrantPlugins::ConoHa::Domain
+
+      def initialize
+        @logger = Log4r::Logger.new('vagrant_openstack::cinder')
+        @session = VagrantPlugins::ConoHa.session
+      end
+
+      def get_all_volumes(env)
+        volumes_json = get(env, "#{@session.endpoints[:volumev2]}/volumes/detail")
+        JSON.parse(volumes_json)['volumes'].map do |volume|
+          name = volume['display_name']
+          name = volume['name'] if name.nil? # To be compatible with cinder api v1 and v2
+          case volume['attachments'].size
+          when 0
+            @logger.debug "No attachment found for volume #{volume['id']}"
+          else
+            attachment = volume['attachments'][0]
+            server_id = attachment['server_id']
+            device = attachment['device']
+            @logger.warn "Found #{attachment.size} attachments for volume #{volume['id']} : " if attachment.size > 1
+            @logger.debug "Attachment found for volume #{volume['id']} : #{attachment.to_json}"
+          end
+          Volume.new(volume['id'], name, volume['size'], volume['status'], volume['bootable'], server_id, device)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-conoha/client/domain.rb

@@ -0,0 +1,159 @@
+require 'log4r'
+require 'json'
+
+module VagrantPlugins
+  module ConoHa
+    module Domain
+      class Item
+        attr_accessor :id, :name
+        def initialize(id, name)
+          @id = id
+          @name = name
+        end
+
+        def ==(other)
+          other.class == self.class && other.state == state
+        end
+
+        def state
+          [@id, @name]
+        end
+      end
+
+      class Image < Item
+        attr_accessor :visibility
+        attr_accessor :size
+        attr_accessor :min_ram
+        attr_accessor :min_disk
+
+        def initialize(id, name, visibility = nil, size = nil, min_ram = nil, min_disk = nil)
+          @visibility = visibility
+          @size = size
+          @min_ram = min_ram
+          @min_disk = min_disk
+          super(id, name)
+        end
+
+        protected
+
+        def state
+          [@id, @name, @visibility, @size, @min_ram, @min_disk]
+        end
+      end
+
+      class Flavor < Item
+        #
+        # The number of vCPU
+        #
+        attr_accessor :vcpus
+
+        #
+        # The amount of RAM in Megaoctet
+        #
+        attr_accessor :ram
+
+        #
+        # The size of root disk in Gigaoctet
+        #
+        attr_accessor :disk
+
+        def initialize(id, name, vcpus, ram, disk)
+          @vcpus = vcpus
+          @ram  = ram
+          @disk = disk
+          super(id, name)
+        end
+
+        protected
+
+        def state
+          [@id, @name, @vcpus, @ram, @disk]
+        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
+
+      class Volume < Item
+        #
+        # Size in Gigaoctet
+        #
+        attr_accessor :size
+
+        #
+        # Status (e.g. 'Available', 'In-use')
+        #
+        attr_accessor :status
+
+        #
+        # Whether volume is bootable or not
+        #
+        attr_accessor :bootable
+
+        #
+        # instance id volume is attached to
+        #
+        attr_accessor :instance_id
+
+        #
+        # device (e.g. /dev/sdb) if attached
+        #
+        attr_accessor :device
+
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(id, name, size, status, bootable, instance_id, device)
+          @size = size
+          @status = status
+          @bootable = bootable
+          @instance_id = instance_id
+          @device = device
+          super(id, name)
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        def to_s
+          {
+            id: @id,
+            name: @name,
+            size: @size,
+            status: @status,
+            bootable: @bootable,
+            instance_id: @instance_id,
+            device: @device
+          }.to_json
+        end
+
+        protected
+
+        def state
+          [@id, @name, @size, @status, @bootable, @instance_id, @device]
+        end
+      end
+
+      class Subnet < Item
+        attr_accessor :cidr
+        attr_accessor :enable_dhcp
+        attr_accessor :network_id
+
+        def initialize(id, name, cidr, enable_dhcp, network_id)
+          @cidr = cidr
+          @enable_dhcp = enable_dhcp
+          @network_id = network_id
+          super(id, name)
+        end
+
+        protected
+
+        def state
+          [@id, @name, @cidr, @enable_dhcp, @network_id]
+        end
+      end
+    end
+  end
+end