vagrant-local 0.0.1

data/lib/vagrant-local/driver.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'log4r'
+require 'fileutils'
+require 'digest/md5'
+require 'io/console'
+require 'ruby_expect'
+require 'netaddr'
+require 'ipaddr'
+require 'vagrant/util/numeric'
+require 'pty'
+require 'expect'
+require 'vagrant'
+require 'resolv'
+require 'open3'
+require 'vagrant-local/util/timer'
+require 'vagrant-local/util/subprocess'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ProviderLocal
+    # This class does the heavy lifting of the local provider
+    class Driver
+      include Vagrant::Util::Retryable
+      attr_accessor :executor
+
+      def initialize(machine)
+        @logger = Log4r::Logger.new('vagrant_local::driver')
+        @machine = machine
+        @executor = Executor::Exec.new
+        @pfexec = if Process.uid.zero?
+                    ''
+                  elsif system('sudo -v')
+                    'sudo'
+                  else
+                    'pfexec'
+                  end
+      end
+
+      def state(machine)
+        vm_data = YAML.load_file("#{machine.name}.vmstate")
+        return :not_created unless vm_data.is_a?(Array) && !vm_data.empty? && vm_data.first.is_a?(Hash)
+
+        vm_state = vm_data.first['state']
+        case vm_state
+        when 'running'
+          :running
+        when 'installed', 'stopped'
+          :stopped
+        else
+          :not_created
+        end
+      end
+
+      # Execute System commands
+      def execute(...)
+        @executor.execute(...)
+      end
+
+      ## Begin installation
+      def install(_uii)
+        config = @machine.config.vm.provisioners[0].config.extra_vars.to_json
+        command = "#{@pfexec} ansible-playbook ./providers/ansible/install.yml -e '#{config}'"
+        _stdin, stdout, _stderr, wait_thr = Open3.popen3(command)
+        puts stdout.readline until stdout.eof?
+        wait_thr.value
+      end
+
+      ## Run commands over SSH instead of ZLogin
+      def ssh_run_command(uii, command)
+        config = @machine.provider_config
+        ip = get_ip_address
+        user = user(@machine)
+        key = userprivatekeypath(@machine).to_s
+        port = sshport(@machine).to_s
+        port = 22 if sshport(@machine).to_s.nil?
+        execute_return = ''
+        Util::Timer.time do
+          retryable(on: Errors::TimeoutError, tries: 60) do
+            # If we're interrupted don't worry about waiting
+            ssh_string = "#{@pfexec} ssh -o 'StrictHostKeyChecking=no' -p"
+            execute_return = execute(false, %(#{ssh_string} #{port} -i #{key} #{user}@#{ip} "#{command}"))
+            uii.info(I18n.t('vagrant_local.ssh_run_command')) if config.debug
+            uii.info(I18n.t('vagrant_local.ssh_run_command') + command) if config.debug
+            loop do
+              break if @machine.communicate.ready?
+            end
+          end
+        end
+        execute_return
+      end
+
+      ## Boot the Machine
+      def boot(uii)
+        config = @machine.config.vm.provisioners[0].config.extra_vars.to_json
+        command = "#{@pfexec} ansible-playbook ./providers/ansible/boot.yml -e '#{config}'"
+        uii.info(I18n.t('vagrant_local.start'))
+        _stdin, stdout, _stderr, wait_thr = Open3.popen3(command)
+        puts stdout.readline until stdout.eof?
+        wait_thr.value
+      end
+
+      # This ensures the host is ready for provisioning
+      def check_support(uii)
+        uii.info(I18n.t('vagrant_local.preflight_checks'))
+        uii.info(I18n.t('vagrant_local.ansible_playbook_check'))
+        playbook_result = execute(false, "#{@pfexec} which ansible-playbook")
+        raise Errors::AnsiblePlaybookNotDetected if playbook_result.empty?
+
+        uii.info(I18n.t('vagrant_local.ansible_check'))
+        result = execute(false, "#{@pfexec} which ansible")
+        raise Errors::AnsibleNotDetected if result.empty?
+      end
+
+      def get_ip_address
+        vm_data = YAML.load_file("#{@machine.name}.vmstate")
+        return nil unless vm_data.is_a?(Array) && !vm_data.empty? && vm_data.first.is_a?(Hash)
+
+        vm_data.first['public_ip']
+      end
+
+      # This filters the vagrantuser
+      def user(machine)
+        config = machine.provider_config
+        user = config.vagrant_user unless config.vagrant_user.nil?
+        user = 'vagrant' if config.vagrant_user.nil?
+        user
+      end
+
+      # This filters the userprivatekeypath
+      def userprivatekeypath(machine)
+        config = machine.provider_config
+        userkey = config.vagrant_user_private_key_path.to_s
+        if config.vagrant_user_private_key_path.to_s.nil?
+          id_rsa = 'https://raw.githubusercontent.com/hashicorp/vagrant/master/keys/vagrant'
+          file = './id_rsa'
+          command = "#{@pfexec} curl #{id_rsa} -O #{file}"
+          Util::Subprocess.new command do |_stdout, stderr, _thread|
+            uii.rewriting do |uipkp|
+              uipkp.clear_line
+              uipkp.info(I18n.t('vagrant_local.importing_vagrant_key'), new_line: false)
+              uipkp.report_progress(stderr, 100, false)
+            end
+          end
+          uii.clear_line
+          userkey = './id_rsa'
+        end
+        userkey
+      end
+
+      # This filters the sshport
+      def sshport(machine)
+        config = machine.provider_config
+        sshport = '22'
+        sshport = config.sshport.to_s unless config.sshport.to_s.nil? || config.sshport.to_i.zero?
+        # uii.info(I18n.t('vagrant_local.sshport')) if config.debug
+        sshport
+      end
+
+      # This filters the vagrantuserpass
+      def vagrantuserpass(machine)
+        config = machine.provider_config
+        # uii.info(I18n.t('vagrant_local.vagrantuserpass')) if config.debug
+        config.vagrant_user_pass unless config.vagrant_user_pass.to_s.nil?
+      end
+
+      # Halts the instance, first via shutdown command, then a halt.
+      def halt(uii)
+        provider_config = @machine.provider_config
+        config = @machine.config.vm.provisioners[0].config.extra_vars.to_json
+        uii.info(I18n.t('vagrant_local.graceful_shutdown'))
+        begin
+          Timeout.timeout(provider_config.clean_shutdown_time) do
+            command = "#{@pfexec} ansible-playbook ./providers/ansible/halt.yml -e '#{config}'"
+            _stdin, stdout, _stderr, wait_thr = Open3.popen3(command)
+            puts stdout.readline until stdout.eof?
+            wait_thr.value
+          end
+        rescue Timeout::Error
+          uii.info(I18n.t('vagrant_local.graceful_shutdown_failed') + provider_config.clean_shutdown_time.to_s)
+          begin
+            Timeout.timeout(provider_config.clean_shutdown_time) do
+              command = "#{@pfexec} ansible-playbook ./providers/ansible/halt.yml -e '#{config}'"
+              _stdin, stdout, _stderr, wait_thr = Open3.popen3(command)
+              puts stdout.readline until stdout.eof?
+              wait_thr.value
+            end
+          rescue Timeout::Error
+            raise Errors::TimeoutHalt
+          end
+        end
+      end
+
+      # Destroys the instance
+      def destroy(id)
+        config = @machine.config.vm.provisioners[0].config.extra_vars.to_json
+        if state(@machine) == :stopped
+          id.info(I18n.t('vagrant_local.destroy'))
+          command = "#{@pfexec} ansible-playbook ./providers/ansible/destroy.yml -e '#{config}'"
+          _stdin, stdout, _stderr, wait_thr = Open3.popen3(command)
+          puts stdout.readline until stdout.eof?
+          wait_thr.value
+        end
+        id.info(I18n.t('vagrant_local.destroyed'))
+      end
+    end
+  end
+end

data/lib/vagrant-local/errors.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'vagrant'
+
+module VagrantPlugins
+  module ProviderLocal
+    module Errors
+      # Namespace for Vagrant Local Errors
+      class VagrantLocalError < Vagrant::Errors::VagrantError
+        error_namespace('vagrant_local.errors')
+      end
+
+      # System Check Results
+      class SystemVersionIsTooLow < VagrantLocalError
+        error_key(:system_version_too_low)
+      end
+
+      # Compatability Check Tool
+      class MissingCompatCheckTool < VagrantLocalError
+        error_key(:missing_compatability_check_tool)
+      end
+
+      # Missing Bhyve
+      class MissingBhyve < VagrantLocalError
+        error_key(:missing_bhyve)
+      end
+
+      # HasNoRootPrivilege
+      class HasNoRootPrivilege < VagrantLocalError
+        error_key(:has_no_root_privilege)
+      end
+
+      # ExecuteError
+      class ExecuteError < VagrantLocalError
+        error_key(:execute_error)
+      end
+
+      # TimeoutError
+      class TimeoutError < VagrantLocalError
+        error_key(:timeout_error)
+      end
+
+      # VirtualBoxRunningConflictDetected
+      class VirtualBoxRunningConflictDetected < VagrantLocalError
+        error_key(:virtual_box_running_conflict_detected)
+      end
+
+      # AnsibleNotDetected
+      class AnsibleNotDetected < VagrantLocalError
+        error_key(:ansible_not_detected)
+      end
+
+      # AnsiblePlaybookNotDetected
+      class AnsiblePlaybookNotDetected < VagrantLocalError
+        error_key(:ansible_playbook_not_detected)
+      end
+
+      # NotYetImplemented
+      class NotYetImplemented < VagrantLocalError
+        error_key(:not_yet_implemented)
+      end
+
+      # TimeoutHalt
+      class TimeoutHalt < VagrantLocalError
+        error_key(:halt_timeout)
+      end
+
+      # InvalidbhyveBrand
+      class InvalidbhyveBrand < VagrantLocalError
+        error_key(:invalidbhyve_brand)
+      end
+
+      # InvalidLXBrand
+      class InvalidLXBrand < VagrantLocalError
+        error_key(:invalidLX_brand)
+      end
+
+      # ConsoleFailed
+      class ConsoleFailed < VagrantLocalError
+        error_key(:console_failed_exit)
+      end
+    end
+  end
+end

data/lib/vagrant-local/executor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'vagrant/util/busy'
+require 'vagrant/util/subprocess'
+
+module VagrantPlugins
+  module ProviderLocal
+    module Executor
+      # This class is used to execute commands as subprocess.
+      class Exec
+        # When we need the command's exit code we should set parameter
+        # exit_code to true, otherwise this method will return executed
+        # command's stdout
+        def execute(exit_code, *cmd, **_opts, &block)
+          # Append in the options for subprocess
+          cmd << { notify: %i[stdout stderr] }
+
+          cmd.unshift('sh', '-c')
+          interrupted = false
+          # Lambda to change interrupted to true
+          int_callback = -> { interrupted = true }
+          result = ::Vagrant::Util::Busy.busy(int_callback) do
+            ::Vagrant::Util::Subprocess.execute(*cmd, &block)
+          end
+          return result.exit_code if exit_code
+
+          result.stderr.gsub!("\r\n", "\n")
+          result.stdout.gsub!("\r\n", "\n")
+          puts "Command Failed: #{cmd}" if result.exit_code != 0 || interrupted
+          puts "Exit Results: #{result.stderr}" if result.exit_code != 0 || interrupted
+          raise Errors::ExecuteError if result.exit_code != 0 || interrupted
+
+          result.stdout[0..-2]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-local/plugin.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant Local plugin must be run within Vagrant.'
+end
+
+module VagrantPlugins
+  module ProviderLocal
+    # This is a the plugin droping for the vagrant-local vagrant plugin
+    class Plugin < Vagrant.plugin('2')
+      name 'local'
+      description <<-DESC
+        This plugin allows vagrant to manage a host as a VM
+      DESC
+
+      config(:local, :provider) do
+        require_relative 'config'
+        Config
+      end
+      provider(:local, parallel: false) do
+        require_relative 'provider'
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path('locales/en.yml', ProviderLocal.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require 'log4r'
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV['VAGRANT_LOG'].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil unless level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+
+        return unless level
+
+        logger = Log4r::Logger.new('vagrant_local')
+        logger.outputters = Log4r::Outputter.stderr
+        logger.level = level
+        logger
+      end
+
+      # Setup logging and i18n before any autoloading loads other classes
+      # with logging configured as this prevents inheritance of the log level
+      # from the parent logger.
+      setup_logging
+      setup_i18n
+
+      ## This setups the local commands master
+      command('local') do
+        require_relative 'command/local'
+        Command::Local
+      end
+    end
+  end
+end

data/lib/vagrant-local/provider.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'vagrant'
+require 'log4r'
+
+module VagrantPlugins
+  # This is a module to assist in managing a Host
+  module ProviderLocal
+    autoload :Driver, 'vagrant-local/driver'
+    # This is a module to assist in managing a Host
+    class Provider < Vagrant.plugin('2', :provider)
+      def initialize(machine)
+        @logger = Log4r::Logger.new('vagrant::provider::local')
+        @machine = machine
+        super(machine)
+      end
+
+      def driver
+        return @driver if @driver
+
+        @driver = Driver.new(@machine)
+      end
+
+      def ssh_info
+        # We just return nil if were not able to identify the VM's IP and
+        # let Vagrant core deal with it like docker provider does
+        return nil if state.id != :running
+        return nil unless driver.get_ip_address
+
+        passwordauth = 'passwordauth'
+        ssh_info = {
+          host: driver.get_ip_address,
+          port: driver.sshport(@machine).to_s,
+          password: driver.vagrantuserpass(@machine).to_s,
+          username: driver.user(@machine),
+          private_key_path: driver.userprivatekeypath(@machine).to_s,
+          PasswordAuthentication: passwordauth
+        }
+        ssh_info unless ssh_info.nil?
+      end
+
+      # This should return an action callable for the given name.
+      # @param [Symbol] name Name of the action.
+      # @return [Object] A callable action sequence object, whether it
+      #        is a proc, object, etc.
+      def action(name)
+        # Attempt to get the action method from the Action class if it
+        # exists, otherwise return nil to show that we don't support the
+        # given action
+        action_method = "action_#{name}"
+        return Action.send(action_method) if Action.respond_to?(action_method)
+
+        nil
+      end
+
+      # This method is called if the underying machine ID changes. Providers
+      # can use this method to load in new data for the actual backing
+      # machine or to realize that the machine is now gone (the ID can
+      # become `nil`). No parameters are given, since the underlying machine
+      # is simply the machine instance given to this object. And no
+      # return value is necessary.
+      def machine_id_changed
+        nil
+      end
+
+      def state
+        state_id = nil
+        state_id = :not_created unless @machine.id
+        state_id = driver.state(@machine) if @machine.id && !state_id
+        # This is a special pseudo-state so that we don't set the
+        # NOT_CREATED_ID while we're setting up the machine. This avoids
+        # clearing the data dir.
+        state_id = :preparing if @machine.id == 'preparing'
+        # Get the short and long description
+        short = state_id.to_s.tr('_', ' ')
+        # If we're not created, then specify the special ID flag
+        state_id = Vagrant::MachineState::NOT_CREATED_ID if state_id == :not_created
+        # Return the MachineState object
+        Vagrant::MachineState.new(state_id, short, short)
+      end
+    end
+  end
+end

data/lib/vagrant-local/util/subprocess.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'log4r'
+module VagrantPlugins
+  module ProviderLocal
+    module Util
+      # This shiny device polishes bared foos
+      class Subprocess
+        def initialize(cmd, &_block)
+          Open3.popen3(cmd) do |_stdin, stdout, stderr, thread|
+            # read each stream from a new thread
+            { :out => stdout, :err => stderr }.each do |key, stream|
+              Thread.new do
+                until (line = stream.gets).nil?
+                  # yield the block depending on the stream
+                  if key == :out
+                    yield line, nil, thread if block_given?
+                  elsif block_given?
+                    yield nil, line, thread
+                  end
+                end
+              end
+            end
+            thread.join # don't exit until the external process is done
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-local/util/timer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderLocal
+    module Util
+      # This is a utlity to time commands and scripts
+      class Timer
+        # A basic utility method that times the execution of the given
+        # block and returns it.
+        def self.time
+          start_time = Time.now.to_f
+          yield
+          end_time = Time.now.to_f
+          end_time - start_time
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-local/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderLocal
+    VERSION = '0.0.1'
+    NAME = 'vagrant-local'
+  end
+end

data/lib/vagrant-local.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module VagrantPlugins
+  # This is used to configure, manage, create and destroy local where vagrant by itself cannot
+  module ProviderLocal
+    lib_path = Pathname.new(File.expand_path('vagrant-local', __dir__))
+    autoload :Action, lib_path.join('action')
+    autoload :Executor, lib_path.join('executor')
+    autoload :Driver, lib_path.join('driver')
+    autoload :Errors, lib_path.join('errors')
+    # This function returns the path to the source of this plugin
+    # @return [Pathname]
+    def self.source_root
+      @source_root ||= Pathname.new(File.expand_path('..', __dir__))
+    end
+  end
+end
+
+begin
+  require 'vagrant'
+rescue LoadError
+  raise 'The Vagrant vagrant-local plugin must be run within Vagrant.'
+end
+
+raise 'The Vagrant vagrant-local plugin is only compatible with Vagrant 2+.' if Vagrant::VERSION < '2'
+
+require 'vagrant-local/plugin'