vagrant-smartos-zones 0.0.1.pre.21

data/lib/vagrant/smartos/zones/commands/zones.rb

@@ -0,0 +1,136 @@
+require 'vagrant'
+require 'vagrant/smartos/zones/errors'
+require 'vagrant/smartos/zones/models/zone'
+require 'vagrant/smartos/zones/util/snapshots'
+require 'vagrant/smartos/zones/util/zone_info'
+require_relative 'multi_command'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Command
+        class Zones < Vagrant.plugin('2', :command)
+          include MultiCommand
+
+          COMMANDS = %w(create destroy list show snapshot start stop).freeze
+
+          OPTION_PARSER = OptionParser.new do |o|
+            o.banner = 'Usage: vagrant zones [command] [name]'
+            o.separator ''
+            o.separator 'Commands:'
+            o.separator '  list                                 show status of zones'
+            o.separator '  create [name]                        create or update zone with alias [name]'
+            o.separator '  destroy [name]                       delete zone with alias [name]'
+            o.separator '  show [name]                          show info on zone with alias [name]'
+            o.separator '  snapshot [action] [name] [snapshot]  snapshot the ZFS filesystem for [name]'
+            o.separator '                                       actions: list, create, delete, rollback'
+            o.separator '  start [name]                         start zone with alias [name]'
+            o.separator '  stop [name]                          stop zone with alias [name]'
+            o.separator ''
+            o.separator 'Options:'
+            o.separator ''
+          end
+
+          def self.synopsis
+            'View and interact with SmartOS zones'
+          end
+
+          def execute
+            process_subcommand
+          end
+
+          def create(name)
+            zones.create(name).tap do |zone|
+              return unless zone
+              @env.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.create',
+                                  name: zone.name, state: zone.state,
+                                  uuid: zone.uuid, brand: zone.brand,
+                                  image: zone.image),
+                           prefix: false)
+            end
+          end
+
+          def destroy(name)
+            with_zone(name) do |zone|
+              zone.destroy
+              @env.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.destroyed',
+                                  name: zone.name, state: zone.state,
+                                  uuid: zone.uuid, brand: zone.brand,
+                                  image: zone.image))
+            end
+          end
+
+          def list(*_args)
+            with_target_vms('default') do |machine|
+              zones = Models::Zone.all(machine).map do |zone|
+                [zone.name.to_s.ljust(25), zone.state.to_s.ljust(10), zone.uuid].join(' ')
+              end
+              @env.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.list',
+                                  zones: zones.join("\n")), prefix: false)
+            end
+          end
+
+          def show(name)
+            with_zone(name) do |zone|
+              @env.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.show',
+                                  name: zone.name, state: zone.state,
+                                  uuid: zone.uuid, brand: zone.brand,
+                                  image: zone.image),
+                           prefix: false)
+            end
+          end
+
+          def snapshot(action = nil, name = nil, snapshot = nil)
+            fail_options! unless action && name
+            with_target_vms('default') do |machine|
+              Util::Snapshots.new(machine, name).run(action, snapshot)
+            end
+          end
+
+          def start(name)
+            with_zone(name) do |zone|
+              zone.start
+              @env.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.start',
+                                  name: zone.name, state: zone.state,
+                                  uuid: zone.uuid, brand: zone.brand,
+                                  image: zone.image))
+            end
+          end
+
+          def stop(name)
+            with_zone(name) do |zone|
+              zone.stop
+              @env.ui.info(I18n.t('vagrant.smartos.zones.commands.zones.stop',
+                                  name: zone.name, state: zone.state,
+                                  uuid: zone.uuid, brand: zone.brand,
+                                  image: zone.image))
+            end
+          end
+
+          private
+
+          def zones
+            zones = nil
+            with_target_vms('default') { |machine| zones = Util::ZoneInfo.new(machine) }
+            zones
+          end
+
+          def ui
+            @env.ui
+          end
+
+          def with_zone(name)
+            with_target_vms('default', single_target: true) do |machine|
+              Models::Zone.find(machine, name).tap do |zone|
+                yield zone
+              end
+            end
+          rescue ZoneNotFound
+            ui.warn(I18n.t('vagrant.smartos.zones.warning.zone_not_found',
+                           name: name), prefix: false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/communicator/smartos.rb

@@ -0,0 +1,87 @@
+require 'vagrant/smartos/zones/util/global_zone/connection'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Communicator
+        class Smartos < Vagrant.plugin('2').manager.communicators[:ssh]
+          def initialize(machine)
+            @machine = machine
+            super
+          end
+
+          # rubocop:disable Metrics/MethodLength
+          def gz_execute(command, opts = {}, &block)
+            opts = {
+              error_check: true,
+              error_class: Vagrant::Errors::VagrantError,
+              error_key:   :ssh_bad_exit_status,
+              good_exit:   0,
+              command:     command,
+              shell:       nil,
+              sudo:        false
+            }.merge(opts)
+
+            opts[:good_exit] = Array(opts[:good_exit])
+
+            # Connect via SSH and execute the command in the shell.
+            stdout = ''
+            stderr = ''
+            global_zone_connector.connect
+
+            begin
+              generic_ssh_info = @connection_ssh_info
+              @connection_ssh_info = global_zone_connector.ssh_info
+
+              exit_status = global_zone_connector.with_connection do |connection|
+                shell_opts = {
+                  sudo: opts[:sudo],
+                  shell: opts[:shell]
+                }
+
+                shell_execute(connection, command, **shell_opts) do |type, data|
+                  if type == :stdout
+                    stdout += data
+                  elsif type == :stderr
+                    stderr += data
+                  end
+
+                  block.call(type, data) if block
+                end
+              end
+            ensure
+              @connection_ssh_info = generic_ssh_info
+            end
+
+            # Check for any errors
+            if opts[:error_check] && !opts[:good_exit].include?(exit_status)
+              # The error classes expect the translation key to be _key,
+              # but that makes for an ugly configuration parameter, so we
+              # set it here from `error_key`
+              error_opts = opts.merge(
+                _key: opts[:error_key],
+                stdout: stdout,
+                stderr: stderr
+              )
+              raise opts[:error_class], error_opts
+            end
+
+            # Return the exit status
+            exit_status
+          end
+
+          def gz_test(command, opts = nil)
+            opts = { error_check: false }.merge(opts || {})
+            gz_execute(command, opts) == 0
+          end
+
+          private
+
+          def global_zone_connector
+            @global_zone_connector ||= Vagrant::Smartos::Zones::Util::GlobalZone::Connection.new(@machine, @logger)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/config/global_zone.rb

@@ -0,0 +1,26 @@
+require 'vagrant'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Config
+        class GlobalZone < Vagrant.plugin('2', :config)
+          attr_accessor :platform_image, :platform_image_url, :ssh_port, :forwarded_ssh_port
+
+          def initialize
+            @platform_image = UNSET_VALUE
+            @platform_image_url = UNSET_VALUE
+            @ssh_port = UNSET_VALUE
+            @forwarded_ssh_port = UNSET_VALUE
+          end
+
+          def finalize!
+            @platform_image = 'latest' if @platform_image == UNSET_VALUE
+            @ssh_port = 2222 if @ssh_port == UNSET_VALUE
+            @forwarded_ssh_port = 22_022 if @forwarded_ssh_port == UNSET_VALUE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/config/zone.rb

@@ -0,0 +1,33 @@
+require 'vagrant'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Config
+        class Zone < Vagrant.plugin('2', :config)
+          attr_accessor :brand, :disk_size, :image, :kernel_version, :memory, :name
+          attr_reader :synced_folders
+
+          def initialize
+            @brand = UNSET_VALUE
+            @disk_size = UNSET_VALUE
+            @image = UNSET_VALUE
+            @kernel_version = UNSET_VALUE
+            @memory = UNSET_VALUE
+            @name = UNSET_VALUE
+            @synced_folders = []
+          end
+
+          def synced_folder(*args)
+            @synced_folders << args
+          end
+
+          def finalize!
+            @brand = 'joyent' if @brand == UNSET_VALUE
+            @kernel_version = '3.16' if @kernel_version == UNSET_VALUE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/errors.rb

@@ -0,0 +1,9 @@
+module Vagrant
+  module Smartos
+    module Zones
+      class Error < StandardError; end
+      class SnapshotNotFound < Error; end
+      class ZoneNotFound < Error; end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/guest.rb

@@ -0,0 +1,25 @@
+require 'vagrant'
+
+module Vagrant
+  module Smartos
+    module Zones
+      class Guest < Vagrant.plugin('2', :guest)
+        TEST_COMMAND = "grep 'SmartOS [0-9]\\{8\\}T[0-9]\\{6\\}Z' /etc/release"
+
+        def detect?(machine)
+          @machine = machine
+          ssh_test || gz_test
+        end
+
+        def ssh_test
+          @machine.communicate.test(TEST_COMMAND)
+        end
+
+        def gz_test
+          return false unless @machine.communicate.respond_to?(:gz_test)
+          @machine.communicate.gz_test(TEST_COMMAND)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/hooks.rb

@@ -0,0 +1,41 @@
+# rubocop:disable all
+module Vagrant
+  module Smartos
+    module Zones
+      class Plugin < Vagrant.plugin("2")
+        manage_zones = lambda do |hook|
+          require_relative 'action'
+          hook.before(::VagrantPlugins::ProviderVirtualBox::Action::PrepareForwardedPortCollisionParams, Vagrant::Smartos::Zones::Action.forward_gz_ports)
+          hook.after(::VagrantPlugins::ProviderVirtualBox::Action::SaneDefaults, Vagrant::Smartos::Zones::Action.virtualbox_platform_iso)
+          hook.before(::VagrantPlugins::ProviderVirtualBox::Action::Network, Vagrant::Smartos::Zones::Action.create_gz_vnic)
+
+          hook.before(Vagrant::Smartos::Zones::Action::CreateGZVnic, Vagrant::Smartos::Zones::Action.install_zone_gate)
+          hook.before(Vagrant::Smartos::Zones::Action::ZoneGate::Install, Vagrant::Smartos::Zones::Action.zone_create)
+          hook.before(Vagrant::Smartos::Zones::Action::Zone::Create, Vagrant::Smartos::Zones::Action.configure_zone_synced_folders)
+          hook.before(Vagrant::Smartos::Zones::Action::Zone::Create, Vagrant::Smartos::Zones::Action.zone_start)
+
+          # Currently if this runs before a zone is created, other capabilities (such as creating zone users)
+          # fail with the error that the machine is not ready for guest communication.
+          hook.before(Vagrant::Smartos::Zones::Action::Zone::Create, Vagrant::Smartos::Zones::Action.enable_zone_gate)
+          hook.after(Vagrant::Smartos::Zones::Action::ConfigureZoneSyncedFolders, Vagrant::Action::Builtin::SyncedFolders)
+        end
+
+        zone_start = lambda do |hook|
+          require_relative 'action'
+          hook.before(::Vagrant::Action::Builtin::WaitForCommunicator, Vagrant::Smartos::Zones::Action.zone_start)
+        end
+
+        zone_stop = lambda do |hook|
+          require_relative 'action'
+          hook.before(::Vagrant::Action::Builtin::GracefulHalt, Vagrant::Smartos::Zones::Action.zone_stop)
+        end
+
+        action_hook('smartos-zones-up', :machine_action_up, &manage_zones)
+        action_hook('smartos-zones-reload', :machine_action_reload, &manage_zones)
+        action_hook('smartos-zones-provision', :machine_action_provision, &manage_zones)
+        action_hook('smartos-zones-halt', :machine_action_halt, &zone_stop)
+        action_hook('smartos-zones-resume', :machine_action_resume, &zone_start)
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/models/dataset.rb

@@ -0,0 +1,27 @@
+require 'vagrant/smartos/zones/models/snapshot'
+require 'vagrant/smartos/zones/util/global_zone/helper'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Models
+        class Dataset
+          include Util::GlobalZone::Helper
+
+          def self.create(name, zone)
+            Models::Snapshot.around(zone) do
+              zone.zlogin('\'find /var/log -type f -exec truncate --size 0 {} \;\'')
+              zone.zlogin('sm-prepare-image -y')
+              zone.stop
+              Models::Snapshot.around(zone) do |snapshot|
+                cmd = 'pfexec /usr/bin/bash -l -c "/usr/sbin/zfs send %s | /usr/bin/bzip2 > /zones/%s.zfs.bz2"'
+                with_gz(zone.machine, cmd % [snapshot.path, name])
+              end
+            end
+            zone.start
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/models/snapshot.rb

@@ -0,0 +1,71 @@
+require 'vagrant/smartos/zones/errors'
+require 'vagrant/smartos/zones/util/global_zone/helper'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Models
+        class Snapshot
+          include Util::GlobalZone::Helper
+
+          attr_accessor :machine, :zone, :name, :created_at, :space_used
+
+          def self.around(zone, &block)
+            snapshot_name = "before_#{Time.now.to_i}"
+            snapshot = create(snapshot_name, zone)
+            if block.arity.eql?(1)
+              block.call snapshot
+            else
+              block.call
+            end
+            snapshot.rollback
+            snapshot.destroy
+          end
+
+          def self.all(zone)
+            snapshots = []
+            cmd = "pfexec zfs list -t snapshot -H -r -o name,creation,used zones/#{zone.uuid}"
+            with_gz(zone.machine, cmd) do |output|
+              break if output.include?('no datasets available')
+              snapshots += output.split("\n").map { |l| from_line(l, zone) }
+            end
+            snapshots
+          end
+
+          def self.create(name, zone)
+            cmd = "pfexec zfs snapshot zones/#{zone.uuid}@#{name}"
+            with_gz(zone.machine, cmd)
+            find(name, zone)
+          end
+
+          def self.find(name, zone)
+            all(zone).find { |snapshot| snapshot.name == name } || raise(SnapshotNotFound)
+          end
+
+          def self.from_line(l, zone)
+            name, created_at, used = l.split("\t")
+            new.tap do |s|
+              s.machine = zone.machine
+              s.zone = zone
+              s.name = name.split('@').last
+              s.created_at = created_at
+              s.space_used = used
+            end
+          end
+
+          def path
+            "zones/#{zone.uuid}@#{name}"
+          end
+
+          def destroy
+            with_gz("pfexec zfs destroy #{path}")
+          end
+
+          def rollback
+            with_gz("pfexec zfs rollback -r #{path}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/models/zone.rb

@@ -0,0 +1,80 @@
+require 'vagrant/smartos/zones/errors'
+require 'vagrant/smartos/zones/util/global_zone/helper'
+
+module Vagrant
+  module Smartos
+    module Zones
+      module Models
+        class Zone
+          include Util::GlobalZone::Helper
+
+          attr_accessor :machine, :name, :state, :uuid, :brand, :image
+
+          def self.all(machine)
+            zones = []
+            with_gz(machine, 'pfexec vmadm lookup -j') do |output|
+              hashes = JSON.parse(output)
+              zones += hashes.map { |h| from_hash(h, machine) }
+            end
+            zones
+          end
+
+          def self.find(machine, name)
+            zone_hash = {}
+            finder = "pfexec vmadm lookup -j -o uuid,alias,state,image_uuid,brand alias=#{name}"
+            with_gz(machine, finder) do |output|
+              hash = JSON.parse(output).first
+              raise ZoneNotFound unless hash
+              zone_hash.merge!(hash)
+            end
+            from_hash(zone_hash, machine)
+          end
+
+          def self.from_hash(zone, machine = nil)
+            new.tap do |z|
+              z.machine = machine
+              z.name = zone['alias']
+              z.uuid = zone['uuid']
+              z.brand = zone['brand']
+              z.state = zone['state']
+              z.image = zone['image_uuid']
+            end
+          end
+
+          def running?
+            state == 'running'
+          end
+
+          def lx_brand?
+            brand == 'lx'
+          end
+
+          def test(cmd)
+            command = "pfexec zlogin #{uuid} #{cmd}"
+            machine.communicate.gz_test(command)
+          end
+
+          def zlogin(cmd, options = {})
+            command = "pfexec zlogin #{uuid} #{cmd}"
+            with_gz(command, options) do |output|
+              yield output if block_given?
+            end
+          end
+
+          def destroy
+            with_gz("pfexec vmadm delete #{uuid}")
+            self.state = 'deleted'
+          end
+
+          def start
+            with_gz("pfexec vmadm start #{uuid}")
+          end
+
+          def stop
+            with_gz("pfexec vmadm stop #{uuid}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/models/zone_group.rb

@@ -0,0 +1,11 @@
+module Vagrant
+  module Smartos
+    module Zones
+      module Models
+        class ZoneGroup
+          attr_accessor :name, :gid
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/models/zone_user.rb

@@ -0,0 +1,11 @@
+module Vagrant
+  module Smartos
+    module Zones
+      module Models
+        class ZoneUser
+          attr_accessor :name, :uid
+        end
+      end
+    end
+  end
+end

data/lib/vagrant/smartos/zones/plugin.rb

@@ -0,0 +1,118 @@
+require 'vagrant'
+
+module Vagrant
+  module Smartos
+    module Zones
+      class Plugin < Vagrant.plugin('2')
+        name 'smartos-zones'
+
+        description 'SmartOS zone support'
+
+        communicator('smartos') do
+          require_relative 'communicator/smartos'
+          Communicator::Smartos
+        end
+
+        config 'global_zone' do
+          load_il8n
+          require_relative 'config/global_zone'
+          Config::GlobalZone
+        end
+
+        config 'zone' do
+          require_relative 'config/zone'
+          Config::Zone
+        end
+
+        command 'dataset' do
+          require_relative 'commands/dataset'
+          Command::Dataset
+        end
+
+        command 'global-zone' do
+          require_relative 'commands/global_zone'
+          Command::GlobalZone
+        end
+
+        command 'smartos' do
+          require_relative 'commands/smartos'
+          Command::Smartos
+        end
+
+        command 'zones' do
+          require_relative 'commands/zones'
+          Command::Zones
+        end
+
+        command 'zlogin' do
+          require_relative 'commands/zlogin'
+          Command::Zlogin
+        end
+
+        guest 'global_zone', 'smartos' do
+          require_relative 'guest'
+          Guest
+        end
+
+        guest_capability 'global_zone', 'create_gz_vnic' do
+          require_relative 'cap/create_gz_vnic'
+          Cap::CreateGZVnic
+        end
+
+        guest_capability 'global_zone', 'imgadm_import' do
+          require_relative 'cap/imgadm_import'
+          Cap::ImgadmImport
+        end
+
+        guest_capability 'global_zone', 'zone_gate_enable' do
+          require_relative 'cap/zone_gate/enable'
+          Cap::ZoneGate::Enable
+        end
+
+        guest_capability 'global_zone', 'zone_gate_install' do
+          require_relative 'cap/zone_gate/install'
+          Cap::ZoneGate::Install
+        end
+
+        guest_capability 'global_zone', 'zone__create' do
+          require_relative 'cap/zone/create'
+          Cap::Zone::Create
+        end
+
+        guest_capability 'global_zone', 'zone__start' do
+          require_relative 'cap/zone/start'
+          Cap::Zone::Start
+        end
+
+        guest_capability 'global_zone', 'zone__stop' do
+          require_relative 'cap/zone/stop'
+          Cap::Zone::Stop
+        end
+
+        host_capability 'bsd', 'platform_image_install' do
+          require_relative 'cap/platform_image/install'
+          Cap::PlatformImage::Install
+        end
+
+        host_capability 'bsd', 'platform_image_latest' do
+          require_relative 'cap/platform_image/latest'
+          Cap::PlatformImage::Latest
+        end
+
+        host_capability 'bsd', 'platform_image_list' do
+          require_relative 'cap/platform_image/list'
+          Cap::PlatformImage::List
+        end
+
+        class << self
+          def load_il8n
+            I18n.load_path << File.expand_path('../../locales/en.yml', __FILE__)
+            I18n.reload!
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative 'hooks'