vagrant-zones 0.0.1

data/lib/vagrant-zones/action/start.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderZone
+    module Action
+      # This is used to start the zone
+      class Start
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_zones::action::import')
+          @app = app
+        end
+
+        def call(env)
+          @machine = env[:machine]
+          @driver  = @machine.provider.driver
+          @driver.check_zone_support(env[:ui])
+          @driver.boot(env[:ui])
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/action/wait_till_boot.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'log4r'
+require 'vagrant-zones/util/timer'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ProviderZone
+    module Action
+      # This is used wait till the zone is booted
+      class WaitTillBoot
+        include Vagrant::Util::Retryable
+
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_zones::action::import')
+          @app = app
+        end
+
+        def terminate(env)
+          return unless env[:machine].state.id != :not_created
+
+          # If we're not supposed to destroy on error then just return
+          return unless env[:destroy_on_error]
+
+          if env[:halt_on_error]
+            halt_env = env.dup
+            halt_env.delete(:interrupted)
+            halt_env[:config_validate] = false
+            env[:action_runner].run(Action.action_halt, halt_env)
+          else
+            destroy_env = env.dup
+            destroy_env.delete(:interrupted)
+            destroy_env[:config_validate] = false
+            destroy_env[:force_confirm_destroy] = true
+            env[:action_runner].run(Action.action_destroy, destroy_env)
+          end
+        end
+
+        def call(env)
+          @machine = env[:machine]
+          @driver  = @machine.provider.driver
+          ui = env[:ui]
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+          env[:metrics]['instance_boot_time'] = Util::Timer.time do
+            next if env[:interrupted]
+
+            breakwait = @driver.waitforboot(ui, env[:metrics], env[:interrupted])
+            ui.info(I18n.t('vagrant_zones.boot_ready') + " in #{env[:metrics]['instance_boot_time']} Seconds") if breakwait
+            break if breakwait
+          end
+          return terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/action/wait_till_up.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'log4r'
+require 'vagrant-zones/util/timer'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+  module ProviderZone
+    module Action
+      # This is used wait till the zone is booted
+      class WaitTillUp
+        include Vagrant::Util::Retryable
+
+        def initialize(app, _env)
+          @logger = Log4r::Logger.new('vagrant_zones::action::import')
+          @app = app
+        end
+
+        def terminate(env)
+          return unless env[:machine].state.id != :not_created
+
+          # If we're not supposed to destroy on error then just return
+          return unless env[:destroy_on_error]
+
+          if env[:halt_on_error]
+            halt_env = env.dup
+            halt_env.delete(:interrupted)
+            halt_env[:config_validate] = false
+            env[:action_runner].run(Action.action_halt, halt_env)
+          else
+            destroy_env = env.dup
+            destroy_env.delete(:interrupted)
+            destroy_env[:config_validate] = false
+            destroy_env[:force_confirm_destroy] = true
+            env[:action_runner].run(Action.action_destroy, destroy_env)
+          end
+        end
+
+        def call(env)
+          @machine = env[:machine]
+          @driver  = @machine.provider.driver
+          ui = env[:ui]
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+          env[:metrics]['instance_ssh_time'] = Util::Timer.time do
+            retryable(on: Errors::TimeoutError, tries: 60) do
+              # If we're interrupted don't worry about waiting
+              next if env[:interrupted]
+
+              loop do
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+              end
+            end
+          end
+          # if interrupted above, just terminate immediately
+          return terminate(env) if env[:interrupted]
+
+          ui.info(I18n.t('vagrant_zones.ssh_ready') + " in #{env[:metrics]['instance_ssh_time']} Seconds")
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/action.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require 'vagrant/action/builder'
+require 'log4r'
+
+module VagrantPlugins
+  module ProviderZone
+    # Run actions against the machine
+    module Action
+      include Vagrant::Action::Builtin
+      @logger = Log4r::Logger.new('vagrant_zones::action')
+
+      # This action is called to bring the box up from nothing.
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env, b2|
+            if env[:result]
+              env[:halt_on_error] = true
+              b2.use action_start
+            elsif !env[:result]
+              b2.use Import
+              b2.use HandleBox
+              b2.use BoxCheckOutdated
+              b2.use Create
+              b2.use Network
+              b2.use Start
+              b2.use WaitTillBoot
+              b2.use Setup
+              b2.use WaitTillUp
+              b2.use Provision
+              b2.use SetHostname
+              b2.use SyncedFolders
+              b2.use SyncedFolderCleanup
+            end
+          end
+        end
+      end
+
+      # Assuming VM is created, just start it. This action is not called directly by any subcommand.
+      def self.action_start
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsState, :running do |env, b1|
+            if env[:result]
+              b1.use Message, I18n.t('vagrant_zones.states.is_running')
+              next
+            end
+            b1.use Call, IsState, :uncleaned do |env2, b2|
+              b2.use Cleanup if env2[:result]
+            end
+            b1.use Start
+            b1.use WaitTillUp
+          end
+        end
+      end
+
+      def self.action_restart
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |_env, b2|
+            b2.use Call, IsState, :stopped do |env2, b3|
+              unless env2[:result]
+                b3.use WaitTillUp
+                b3.use Restart
+              end
+            end
+          end
+        end
+      end
+
+      def self.action_shutdown
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |_env, b2|
+            b2.use Call, IsState, :stopped do |env2, b3|
+              unless env2[:result]
+                b3.use WaitTillUp
+                b3.use Shutdown
+              end
+            end
+          end
+        end
+      end
+
+      # This is the action that is primarily responsible for halting the virtual machine.
+      def self.action_halt
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use NotCreated
+              next
+            end
+            b2.use Halt if env[:result]
+          end
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use SSHExec
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use SSHRun
+        end
+      end
+
+      # This action is called when you try to package an existing virtual machine to an box image.
+      def self.action_package
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Package
+        end
+      end
+
+      # This is the action that is primarily responsible for completely freeing the resources of the underlying virtual machine.
+      def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |_env, b2|
+            b2.use Destroy
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |_env, b2|
+            b2.use Call, IsState, :running do |_env2, b3|
+              b3.use Provision
+            end
+          end
+        end
+      end
+
+      # This is the action implements the reload command It uses the halt and start actions
+      def self.action_reload
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, IsCreated do |env, b2|
+            unless env[:result]
+              b2.use NotCreated
+              next
+            end
+            b2.use action_halt
+            b2.use action_start
+          end
+        end
+      end
+
+      def self.action_create_zfs_snapshots
+        Vagrant::Action::Builder.new.tap do |b|
+          # b.use ConfigValidate # is this per machine?
+          b.use CreateSnapshots
+        end
+      end
+
+      def self.action_delete_zfs_snapshots
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use DeleteSnapshots
+        end
+      end
+
+      def self.action_configure_zfs_snapshots
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigureSnapshots
+        end
+      end
+
+      def self.action_box_outdated
+        Builder.new.tap do |b|
+          b.use Builtin::BoxCheckOutdated
+        end
+      end
+
+      # This is the action that will remove a box given a name (and optionally
+      # a provider). This middleware sequence is built-in to Vagrant. Plugins
+      # can hook into this like any other middleware sequence.
+      def self.action_box_remove
+        Builder.new.tap do |b|
+          b.use Builtin::BoxRemove
+        end
+      end
+
+      action_root = Pathname.new(File.expand_path('action', __dir__))
+      autoload :Import, action_root.join('import')
+      autoload :Create, action_root.join('create')
+      autoload :Network, action_root.join('network')
+      autoload :Setup, action_root.join('setup')
+      autoload :Start, action_root.join('start')
+      autoload :IsCreated, action_root.join('is_created')
+      autoload :NotCreated, action_root.join('not_created')
+      autoload :CreateSnapshots, action_root.join('create_zfs_snapshots')
+      autoload :DeleteSnapshots, action_root.join('delete_zfs_snapshots')
+      autoload :ConfigureSnapshots, action_root.join('configure_zfs_snapshots')
+      autoload :Halt, action_root.join('halt')
+      autoload :Destroy, action_root.join('destroy')
+      autoload :WaitTillBoot, action_root.join('wait_till_boot')
+      autoload :WaitTillUp, action_root.join('wait_till_up')
+      autoload :Restart, action_root.join('restart')
+      autoload :Shutdown, action_root.join('shutdown')
+      autoload :PrepareNFSValidIds, action_root.join('prepare_nfs_valid_ids.rb')
+      autoload :Package, action_root.join('package.rb')
+    end
+  end
+end

data/lib/vagrant-zones/command/configure_snapshots.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderZone
+    module Command
+      # This is used to configure snapshots for the zone
+      class ConfigureSnapshots < Vagrant.plugin('2', :command)
+        def execute
+          options = {}
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant zone zfssnapshot list [options]'
+            o.on('--dataset DATASETPATH/ALL', 'Specify path to enable snapshots on, defaults to ALL') do |p|
+              options[:dataset] = p
+            end
+            frequencymsg = 'Set a policy with one of the available optional frequencies'
+            o.on('--set_frequency <hourly/daily/weekly/monthly/all>', frequencymsg) do |p|
+              options[:set_frequency] = p
+            end
+            frequency_rtnmsg = 'Number of snapshots to take for the frequency policy'
+            o.on('--set_frequency_rtn <#>/defaults ', frequency_rtnmsg) do |p|
+              options[:set_frequency_rtn] = p
+            end
+            deletemsg = 'Delete frequency policy'
+            o.on('--delete  <hourly/daily/weekly/monthly/all>', deletemsg) do |p|
+              options[:delete] = p
+            end
+            listmsg = 'Show Cron Policies'
+            o.on('--list  <hourly/daily/weekly/monthly/all>', listmsg) do |p|
+              options[:list] = p
+            end
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          unless argv.length <= 4
+            @env.ui.info(opts.help)
+            return
+          end
+
+          with_target_vms(argv, provider: :zone) do |machine|
+            driver = machine.provider.driver
+            driver.zfs(@env.ui, 'cron', options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/command/console.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderZone
+    module Command
+      # This is used to start a console to the zone via WebVNC, VNC or Serial/Telnet
+      class Console < Vagrant.plugin('2', :command)
+        def initialize(argv, env)
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:vnc) do
+            require File.expand_path('vnc_console', __dir__)
+            VNCConsole
+          end
+          @subcommands.register(:zlogin) do
+            require File.expand_path('zlogin_console', __dir__)
+            ZloginConsole
+          end
+          @subcommands.register(:webvnc) do
+            require File.expand_path('webvnc_console', __dir__)
+            WebVNCConsole
+          end
+          super(argv, env)
+        end
+
+        def execute
+          if @main_args.include?('-h') || @main_args.include?('--help')
+            # Print the help for all the vagrant-zones commands.
+            return help
+          end
+
+          with_target_vms(@main_args, provider: :zone) do |machine|
+            @sub_command = machine.provider_config.console.to_sym unless machine.provider_config.console.nil? || @sub_command
+            command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+            @logger.debug("Invoking command class: #{command_class} #{machine.provider_config.console.to_sym}")
+            return help if !command_class || !@sub_command
+
+            # Initialize and execute the command class
+            command_class.new(@sub_args, @env).execute
+          end
+        end
+
+        def help
+          opts = OptionParser.new do |subopts|
+            subopts.banner = 'Usage: vagrant zone console <subcommand> [<args>]'
+            subopts.separator ''
+            subopts.separator 'Available subcommands:'
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, _value| keys << key.to_s }
+            keys.sort.each do |key|
+              subopts.separator "     #{key}"
+            end
+            subopts.separator 'For help on any individual subcommand run `vagrant zone console <subcommand> -h`'
+          end
+          @env.ui.info(opts.help, :prefix => false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/command/create_snapshots.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderZone
+    module Command
+      # This is used to create zfs snapshots the zone
+      class CreateSnapshots < Vagrant.plugin('2', :command)
+        def execute
+          options = {}
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant zone zfssnapshot list [options]'
+            o.on('--dataset SNAPSHOTPATH', 'Specify snapshot path') do |p|
+              options[:dataset] = p
+            end
+            o.on('--snapshot_name @SNAPSHOTNAME', 'Specify snapshot name') do |p|
+              options[:snapshot_name] = p
+            end
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          unless argv.length <= 4
+            @env.ui.info(opts.help)
+            return
+          end
+
+          options[:dataset] = 'all' if options[:dataset].nil?
+
+          if options[:snapshot_name].nil?
+            t = Time.new
+            dash = '-'
+            colon = ':'
+            datetime = t.year.to_s + dash + t.month.to_s + dash + t.day.to_s + dash + t.hour.to_s + colon + t.min.to_s + colon + t.sec.to_s
+            options[:snapshot_name] = datetime
+          end
+
+          with_target_vms(argv, provider: :zone) do |machine|
+            driver = machine.provider.driver
+            driver.zfs(@env.ui, 'create', options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/command/delete_snapshots.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderZone
+    module Command
+      # This is used to delete zfs snapshots the zone
+      class DeleteSnapshots < Vagrant.plugin('2', :command)
+        def execute
+          options = {}
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant zone zfssnapshot list [options]'
+            o.on('--dataset DATASETPATH', 'Specify snapshot path') do |p|
+              options[:dataset] = p
+            end
+            o.on('--snapshot_name @SNAPSHOTNAME', 'Specify snapshot name') do |p|
+              options[:snapshot_name] = p
+            end
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          unless argv.length <= 4
+            @env.ui.info(opts.help)
+            return
+          end
+
+          options[:dataset] = 'all' if options[:dataset].nil?
+          options[:snapshot_name] = 'all' if options[:snapshot_name].nil?
+          with_target_vms(argv, provider: :zone) do |machine|
+            driver = machine.provider.driver
+            driver.zfs(@env.ui, 'destroy', options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/command/guest_power_controls.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderZone
+    module Command
+      # This is used to manage the power controls for the zone
+      class GuestPowerControls < Vagrant.plugin('2', :command)
+        def initialize(argv, env)
+          @main_args, @sub_command, @sub_args = split_main_and_subcommand(argv)
+
+          @subcommands = Vagrant::Registry.new
+          @subcommands.register(:restart) do
+            require File.expand_path('restart_guest', __dir__)
+            RestartGuest
+          end
+          @subcommands.register(:shutdown) do
+            require File.expand_path('shutdown_guest', __dir__)
+            ShutdownGuest
+          end
+          super(argv, env)
+        end
+
+        def execute
+          if @main_args.include?('-h') || @main_args.include?('--help')
+            # Print the help for all the vagrant-zones commands.
+            return help
+          end
+
+          command_class = @subcommands.get(@sub_command.to_sym) if @sub_command
+          return help if !command_class || !@sub_command
+
+          @logger.debug("Invoking command class: #{command_class} #{@sub_args.inspect}")
+
+          # Initialize and execute the command class
+          command_class.new(@sub_args, @env).execute
+        end
+
+        def help
+          opts = OptionParser.new do |subopts|
+            subopts.banner = 'Usage: vagrant zone control <subcommand> [<args>]'
+            subopts.separator ''
+            subopts.separator 'Available subcommands:'
+            # Add the available subcommands as separators in order to print them
+            # out as well.
+            keys = []
+            @subcommands.each { |key, _value| keys << key.to_s }
+            keys.sort.each do |key|
+              subopts.separator "     #{key}"
+            end
+            subopts.separator ''
+            subopts.separator 'For help on any individual subcommand run `vagrant zone control <subcommand> -h`'
+          end
+          @env.ui.info(opts.help, :prefix => false)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/command/list_snapshots.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderZone
+    module Command
+      # This is used to list snapshots for the zone
+      class ListSnapshots < Vagrant.plugin('2', :command)
+        def execute
+          options = {}
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant zone zfssnapshot list [options]'
+            o.on('--dataset SNAPSHOTPATH', 'Specify snapshot path') do |p|
+              options[:dataset] = p
+            end
+            o.on('--snapshot_name @SNAPSHOTNAME', 'Specify snapshot name') do |p|
+              options[:snapshot_name] = p
+            end
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          unless argv.length <= 2
+            @env.ui.info(opts.help)
+            return
+          end
+
+          if options[:snapshot_name].nil?
+            t = Time.new
+            dash = '-'
+            colon = ':'
+            datetime = t.year.to_s + dash + t.month.to_s + dash + t.day.to_s + dash + t.hour.to_s + colon + t.min.to_s + colon + t.sec.to_s
+            options[:snapshot_name] = datetime
+          end
+
+          with_target_vms(argv, provider: :zone) do |machine|
+            driver = machine.provider.driver
+            driver.zfs(@env.ui, 'list', options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-zones/command/restart_guest.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module VagrantPlugins
+  module ProviderZone
+    module Command
+      # This is used to restart the guest from inside the guest
+      class RestartGuest < Vagrant.plugin('2', :command)
+        def execute
+          opts = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant zone control restart [options]'
+          end
+
+          argv = parse_options(opts)
+          return unless argv
+
+          unless argv.empty?
+            @env.ui.info(opts.help)
+            return
+          end
+
+          ## Wait for VM up
+          with_target_vms(argv, provider: :zone) do |machine|
+            machine.action('restart')
+          end
+        end
+      end
+    end
+  end
+end