vagrant-zone 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f3c18117a8a3b345b488063565bc03e4778ae50dd4e21f09cd5309de2e043a66
+  data.tar.gz: 474569e09d7c50e88021065c28741c2326d6aa0d5fdafe0a6f1aae5cfc394a5f
+SHA512:
+  metadata.gz: feec0720ba256d2f6b05495dee6df5c860336cf4749d7a9467891a3d36f01b7c92989bfa856493ea7012630ec7276899713dec53567e551d907cb886ce3166a4
+  data.tar.gz: 34a58b2d76e8fe2e6cde84ac567edf0fc478af356c0c9f8ed0b140a8b06ef4ebdab4e605e7cb5c1fd938f73ee4d12eb38af40d92a4f915caaa7f8d931394a2b3

data/.gitignore

@@ -0,0 +1,4 @@
+.bundle
+vendor
+bin
+*.lock

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+	gem 'vagrant', :git => "https://github.com/hashicorp/vagrant", :tag => "v2.2.7"
+end
+
+group :plugins do
+  gemspec
+end

data/Vagrantfile

@@ -0,0 +1,55 @@
+Vagrant.configure("2") do |config|
+  config.vm.define :debian do |debian|
+    debian.vm.box        = 'debian.zss'
+    debian.vm.network "public_network",
+      ip: "192.168.122.28", bridge: "e1000g0", auto_config: false, :netmask => "255.255.255.0", gateway: "192.168.122.1"
+
+    debian.vm.provision "shell",
+      inline: "id > /home/vagrant/id"
+
+    debian.vm.provision "ansible_local" do |ansible|
+      ansible.playbook = "playbook.yml"
+      ansible.install  = true
+    end
+
+    debian.vm.provider :zone do |vm|
+      vm.brand      = 'lx'
+      vm.kernel     = '4.10'
+      vm.zonepath   = '/rpool/debian'
+      vm.memory     = '512M'
+    end
+  end
+
+  config.vm.define :centos do |centos|
+    centos.vm.box        = '3dbbdcca-2eab-11e8-b925-23bf77789921'
+    centos.vm.network "public_network",
+      ip: "192.168.122.29", bridge: "e1000g0", auto_config: false, :netmask => "255.255.255.0", gateway: "192.168.122.1"
+  
+    centos.vm.provision "shell",
+      inline: "id > /home/vagrant/id"
+  
+    centos.vm.provision "ansible_local" do |ansible|
+      ansible.playbook = "playbook.yml"
+      ansible.install  = true
+    end
+  
+    centos.vm.provider :zone do |vm|
+      vm.brand      = 'lx'
+      vm.kernel     = '3.10.0'
+      vm.zonepath   = '/rpool/centos'
+      vm.memory     = '512M'
+    end
+  end
+  
+  config.vm.define :example do |example|
+    example.vm.box        = 'example'
+    example.vm.network "public_network",
+      ip: "192.168.122.30", bridge: "e1000g0", auto_config: false, :netmask => "255.255.255.0", gateway: "192.168.122.1"
+
+    example.vm.provider :zone do |vm|
+      vm.brand      = 'lx'
+      vm.zonepath   = '/rpool/example'
+      vm.memory     = '512M'
+    end
+  end
+end

data/lib/vagrant-zone.rb

@@ -0,0 +1,21 @@
+require "pathname"
+
+module VagrantPlugins
+	module ProviderZone
+		lib_path = Pathname.new(File.expand_path("../vagrant-zone", __FILE__))
+
+		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("../../", __FILE__))
+		end
+	end
+end
+
+require "vagrant-zone/plugin"

data/lib/vagrant-zone/action.rb

@@ -0,0 +1,147 @@
+require "vagrant/action/builder"
+require 'log4r'
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			# Include the built-in modules so we can use them as top-level things.
+			include Vagrant::Action::Builtin
+			@logger = Log4r::Logger.new('vagrant_zone::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|
+						re = env[:result]
+						m = env[:machine].state.id
+
+						if !env[:result]
+							b2.use Import
+							b2.use Create
+							b2.use Network
+							b2.use Start
+							b2.use Setup
+							#b2.use PrepareNFSValidIds
+							#b2.use SyncedFolderCleanup
+							#b2.use SyncedFolders
+							b2.use WaitTillUp
+							b2.use Provision
+						else
+							env[:halt_on_error] = true
+							b2.use action_start
+						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_zone.states.is_running')
+							next
+						end
+						b1.use Call, IsState, :uncleaned do |env1, b2|
+							if env1[:result]
+								b2.use Cleanup
+							end
+						end
+
+						b1.use Start
+						b1.use Setup
+					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
+
+						if env[:result]
+							# VM is running, halt it
+							b2.use Halt
+						end
+					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 |env, 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
+
+			action_root = Pathname.new(File.expand_path('../action', __FILE__))
+			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 :Halt, action_root.join('halt')
+			autoload :Destroy, action_root.join('destroy')
+			autoload :WaitTillUp, action_root.join('wait_till_up')
+			autoload :PrepareNFSValidIds, action_root.join('prepare_nfs_valid_ids.rb')
+			autoload :Package, action_root.join('package.rb')
+		end
+	end
+end

data/lib/vagrant-zone/action/create.rb

@@ -0,0 +1,26 @@
+require "log4r"
+require "securerandom"
+require "digest/md5"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Create
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					@machine.id = SecureRandom.uuid
+					@driver.zonecfg(@machine, env[:ui])
+					@driver.install(@machine, env[:ui])
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/destroy.rb

@@ -0,0 +1,24 @@
+require "log4r"
+require "securerandom"
+require "digest/md5"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Destroy
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					@driver.destroy(@machine, env[:ui])
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/halt.rb

@@ -0,0 +1,22 @@
+require "log4r"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Halt
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					@driver.halt(@machine, env[:ui])
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/import.rb

@@ -0,0 +1,65 @@
+require "log4r"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Import
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@joyent_images_url = 'https://images.joyent.com/images/'
+					@app = app
+				end
+
+				def validate_uuid_format(uuid)
+					uuid_regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+					return true if uuid_regex.match?(uuid.to_s.downcase)
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					image    = @machine.config.vm.box
+					curdir   = Dir.pwd
+					datadir  = @machine.data_dir
+					@logger.info("DATADIR #{datadir}")
+					# If image ends on '.zss' it's a local ZFS snapshot which
+					# should be used
+					if image[-4, 4] == '.zss'
+						if File.exist?(curdir + '/' + image)
+							FileUtils.cp(curdir + '/' + image, datadir.to_s + '/' + image)
+						elsif not File.exist?(datadir.to_s + '/' + image)
+							raise Vagrant::Errors::BoxNotFound
+						end
+					## If image looks like an UUID, download the ZFS snapshot from
+					## Joyent images server
+					elsif validate_uuid_format(image)
+						raise Vagrant::Errors::BoxNotFound if not check(image)
+						download(image, datadir.to_s + '/' + image)
+					## If it's a regular name (everything else), try to find it
+					## on Vagrant Cloud
+					else
+						# Support zss format only for now
+						box_format = env[:machine].box.metadata['format']
+						if box_format.nil?
+							raise Errors::NoBoxFormatSet
+						elsif box_format != 'zss'
+							raise Errors::WrongBoxFormatSet
+						end
+
+						box_image_file = env[:machine].box.directory.join('box.zss').to_s
+						FileUtils.cp(env[:machine].box.directory.join('box.zss').to_s, datadir.to_s + '/' + image)
+					end
+					@app.call(env)
+				end
+				
+				def check(uuid)
+					`curl --output /dev/null --silent -r 0-0 --fail #{@joyent_images_url}/#{uuid}`
+					return $?.success?
+				end
+				def download(uuid, dest)
+					`curl --output #{dest} --silent #{@joyent_images_url}/#{uuid}/file`
+					return $?.success?
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/is_created.rb

@@ -0,0 +1,22 @@
+require 'log4r'
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			# This can be used with "Call" built-in to check if the machine
+			# is created and branch in the middleware.
+			class IsCreated
+				def initialize(app, _env)
+					@app = app
+					@logger = Log4r::Logger.new('vagrant_zone::action')
+				end
+
+				def call(env)
+					m = env[:machine].state.id
+					env[:result] = env[:machine].state.id != :not_created
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/network.rb

@@ -0,0 +1,24 @@
+require "log4r"
+require "securerandom"
+require "digest/md5"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Network
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					@driver.create_vnic(@machine, env[:ui])
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/not_created.rb

@@ -0,0 +1,18 @@
+require 'log4r'
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class NotCreated
+				def initialize(app, _env)
+					@app = app
+				end
+
+				def call(env)
+					env[:ui].info(I18n.t('vagrant_zone.states.not_created'))
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/package.rb

@@ -0,0 +1,108 @@
+require "log4r"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Package
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+					env['package.output'] ||= 'package.box'
+				end
+
+
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					boxname = env['package.output']
+					raise "#{boxname}: Already exists" if File.exist?(boxname)
+
+					tmp_dir = Dir.pwd + '/_tmp_package'
+					tmp_img = tmp_dir + '/box.zss'
+					Dir.mkdir(tmp_dir) unless File.exists?(tmp_dir)
+
+					zonepath = @machine.provider_config.zonepath.sub!(/^\//, '')
+					brand  = @machine.provider_config.brand
+					kernel = @machine.provider_config.kernel
+
+					snapshot_create(zonepath)
+					snapshot_send(zonepath, tmp_img)
+					snapshot_delete(zonepath)
+
+					extra = ''
+					@tmp_include = tmp_dir + '/_include'
+					if env['package.include']
+						extra = './_include'
+						Dir.mkdir(@tmp_include)
+						env['package.include'].each do |f|
+							env[:ui].info("Including user file: #{f}")
+							FileUtils.cp(f, @tmp_include)
+						end
+					end
+					if env['package.vagrantfile']
+						extra = './_include'
+						Dir.mkdir(@tmp_include) unless File.directory?(@tmp_include)
+						env[:ui].info('Including user Vagrantfile')
+						FileUtils.cp(env['package.vagrantfile'], @tmp_include + '/Vagrantfile')
+					end
+
+					File.write(tmp_dir + '/metadata.json', metadata_content(brand, kernel))
+					File.write(tmp_dir + '/Vagrantfile', vagrantfile_content(brand, kernel, zonepath))
+
+					Dir.chdir(tmp_dir)
+					assemble_box(boxname, extra)
+
+					FileUtils.mv(tmp_dir + '/' + boxname, '../' + boxname)
+					FileUtils.rm_rf(tmp_dir)
+
+					env[:ui].info('Box created')
+					env[:ui].info('You can now add the box:')
+					env[:ui].info("vagrant box add #{boxname} --name any_comfortable_name")
+
+					@app.call(env)
+				end
+
+				def snapshot_create(zonepath)
+					`pfexec zfs snapshot -r #{zonepath}@vagrant_boxing`
+				end
+				def snapshot_delete(zonepath)
+					`pfexec zfs destroy #{zonepath}@vagrant_boxing`
+				end
+				def snapshot_send(zonepath, destination)
+					`pfexec zfs send #{zonepath}@vagrant_boxing > #{destination}`
+				end
+
+				def metadata_content(brand, kernel)
+					<<-EOF
+					{
+						"provider": "zone",
+						"format": "zss",
+						"brand": "#{brand}",
+						"kernel": "#{kernel}"
+					}
+					EOF
+				end
+
+				def vagrantfile_content(brand, kernel, zonepath)
+					<<-EOF
+					Vagrant.configure("2") do |config|
+						config.vm.provider :zone do |zone|
+							zone.brand = "#{brand}"
+							zone.kernel = "#{kernel}"
+							zone.zonepath = "#{zonepath}"
+						end
+					end
+					user_vagrantfile = File.expand_path('../_include/Vagrantfile', __FILE__)
+					load user_vagrantfile if File.exists?(user_vagrantfile)
+					EOF
+				end
+
+				def assemble_box(boxname, extra)
+					`tar cvzf "#{boxname}" ./metadata.json ./Vagrantfile ./box.zss #{extra}`
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/prepare_nfs_valid_ids.rb

@@ -0,0 +1,22 @@
+require "log4r"
+require "securerandom"
+require "digest/md5"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class PrepareNFSValidIds
+
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::prepare_nfs_valid_ids")
+					@app = app
+				end
+
+				def call(env)
+					env[:nfs_valid_ids] = [env[:machine].id]
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/action/setup.rb

@@ -0,0 +1,24 @@
+require "log4r"
+require "securerandom"
+require "digest/md5"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Setup
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					@driver.setup(@machine, env[:ui])
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,22 @@
+require "log4r"
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class Start
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					@driver.boot(@machine, env[:ui])
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,42 @@
+require "log4r"
+require 'vagrant-zone/util/timer'
+require 'vagrant/util/retryable'
+
+module VagrantPlugins
+	module ProviderZone
+		module Action
+			class WaitTillUp
+				include Vagrant::Util::Retryable
+
+				def initialize(app, env)
+					@logger = Log4r::Logger.new("vagrant_zone::action::import")
+					@app = app
+				end
+
+				def call(env)
+					@machine = env[:machine]
+					@driver  = @machine.provider.driver
+
+					# 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]
+					@logger.info("Time for SSH ready: #{env[:metrics]['instance_ssh_time']}")
+
+					@app.call(env)
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/config.rb

@@ -0,0 +1,22 @@
+require "vagrant"
+
+module VagrantPlugins
+	module ProviderZone
+		class Config < Vagrant.plugin('2', :config)
+			attr_accessor :brand
+			attr_accessor :autoboot
+			attr_accessor :kernel
+			attr_accessor :zonepath
+			attr_accessor :memory
+
+			def initialize
+				# pkgsrc, lx, bhyve, kvm, illumos
+				@brand    = UNSET_VALUE
+				@autoboot = false
+				@kernel   = UNSET_VALUE
+				@zonepath = UNSET_VALUE
+				@memory   = UNSET_VALUE
+			end
+		end
+	end
+end

data/lib/vagrant-zone/driver.rb

@@ -0,0 +1,170 @@
+require "log4r"
+require "fileutils"
+require "digest/md5"
+require "io/console"
+require "ruby_expect"
+require 'netaddr'
+
+module VagrantPlugins
+	module ProviderZone
+		class Driver
+			attr_accessor :executor
+
+			def initialize(machine)
+				@logger = Log4r::Logger.new("vagrant_zone::driver")
+				@machine = machine
+				@executor = Executor::Exec.new
+
+				if Process.uid == 0
+					@pfexec = ''
+				else
+					sudo = system('sudo -v')
+					if sudo
+						@pfexec = 'sudo'
+					else
+						@pfexec = 'pfexec'
+					end
+				end
+			end
+
+			def state(machine)
+				uuid = machine.id
+				name = machine.name
+				vm_state = execute(false, "#{@pfexec} zoneadm -z #{name} list -p | awk -F: '{ print $3 }'")
+				if vm_state == 'running'
+					:running
+				elsif vm_state == 'configured'
+					:preparing
+				elsif vm_state == 'installed'
+					:stopped
+				else
+					:not_created
+				end
+			end
+
+			def execute(*cmd, **opts, &block)
+				@executor.execute(*cmd, **opts, &block)
+			end
+
+			def get_ip_address(machine)
+				name = @machine.name
+				ip   = execute(false, "#{@pfexec} zonecfg -z #{name} info net | sed -n 's|property: (name=ips,value=\"\\(.*\\)/.*\")|\\1|p'")
+				return nil if ip.length == 0
+				return ip.gsub /\t/, ''
+			end
+
+			def install(machine, ui)
+				box  = @machine.data_dir.to_s + '/' + @machine.config.vm.box
+				name = @machine.name
+				execute(false, "#{@pfexec} zoneadm -z #{name} install -s #{box}")
+			end
+
+			def boot(machine, ui)
+				name = @machine.name
+				execute(false, "#{@pfexec} zoneadm -z #{name} boot")
+			end
+
+			def create_vnic(machine, ui)
+				machine.config.vm.networks.each do |_type, opts|
+					if _type.to_s == "public_network"
+						link = opts[:bridge]
+						mac  = 'auto'
+						if !opts[:mac].nil?
+							mac  = opts[:mac]
+						end
+						execute(false, "#{@pfexec} dladm create-vnic -l #{link} -m #{mac} #{machine.name}0")
+					end
+				end
+			end
+
+			def zonecfg(machine, ui)
+				config = machine.provider_config
+				machine.config.vm.networks.each do |_type, opts|
+					if _type.to_s == "public_network"
+						@ip        = opts[:ip].to_s
+						@network   = NetAddr.parse_net(opts[:ip].to_s + '/' + opts[:netmask].to_s)
+						@defrouter = opts[:gateway]
+					end
+				end
+
+				allowed_address  = @ip + @network.netmask.to_s
+				lofs_current_dir = Dir.pwd
+
+				data = %{
+					create
+					set zonepath=#{config.zonepath}
+					set brand=#{config.brand}
+					set autoboot=false
+					add net
+						set physical=#{machine.name}0
+						set global-nic=auto
+						add property (name=gateway,value="#{@defrouter.to_s}")
+						add property (name=ips,value="#{allowed_address}")
+						add property (name=primary,value="true")
+					end
+					add attr
+						set name=kernel-version
+						set type=string
+						set value=#{config.kernel}
+					end
+					add capped-memory
+						set physical=#{config.memory}
+						set swap=#{config.memory}
+						set locked=#{config.memory}
+					end
+					add fs
+						set dir=/vagrant
+						set special=#{lofs_current_dir}
+						set type=lofs
+					end
+					set max-lwps=2000
+					exit
+				}
+				File.open('zone_config', 'w') do |f|
+					f.puts data
+				end
+				execute(false, "cat zone_config | #{@pfexec} zonecfg -z #{machine.name}")
+			end
+
+			def setup(machine, ui)
+				zlogin(machine, %('echo nameserver 1.1.1.1 >> /etc/resolv.conf'))
+				if not user_exists?(machine)
+					zlogin(machine, "useradd -m -s /bin/bash -U vagrant")
+				end
+				zlogin(machine, %('echo "vagrant ALL=(ALL:ALL) NOPASSWD:ALL" > /etc/sudoers.d/vagrant'))
+				zlogin(machine, "mkdir -p /home/vagrant/.ssh")
+				zlogin(machine, %('echo "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA6NF8iallvQVp22WDkTkyrtvp9eWW6A8YVr+kz4TjGYe7gHzIw+niNltGEFHzD8+v1I2YJ6oXevct1YeS0o9HZyN1Q9qgCgzUFtdOKLv6IedplqoPkcmF0aYet2PkEDo3MlTBckFXPITAMzF8dJSIFo9D8HfdOV0IAdx4O7PtixWKn5y2hMNG0zQPyUecp4pzC6kivAIhyfHilFR61RGL+GPXQ2MWZWFYbAGjyiYJnAmCP3NOTd0jMZEnDkbUvxhMmBYSdETk1rRgm+R4LOzFUGaHqHDLKLX+FIPKcF96hrucXzcWyLbIbEgE98OHlnVYCzRdK8jlqm8tehUc9c9WhQ== vagrant insecure public key" > /home/vagrant/.ssh/authorized_keys'))
+				zlogin(machine, "chown -R vagrant:vagrant /home/vagrant/.ssh")
+				zlogin(machine, "chmod 600 /home/vagrant/.ssh/authorized_keys")
+			end
+
+			def zlogin(machine, cmd)
+				name = @machine.name
+				execute(false, "#{@pfexec} zlogin #{name} #{cmd}")
+			end
+
+			def user_exists?(machine, user = 'vagrant')
+				name = @machine.name
+				ret  = execute(true, "#{@pfexec} zlogin #{name} id -u #{user}")
+				if ret == 0
+					return true
+				end
+				return false
+			end
+
+			def halt(machine, ui)
+				name = @machine.name
+				execute(false, "#{@pfexec} zoneadm -z #{name} halt")
+			end
+
+			def destroy(machine, id)
+				name = @machine.name
+				execute(false, "#{@pfexec} zoneadm -z #{name} halt")
+				execute(false, "#{@pfexec} zoneadm -z #{name} uninstall -F")
+				execute(false, "#{@pfexec} zonecfg -z #{name} delete -F")
+				execute(false, "#{@pfexec} dladm delete-vnic #{name}0")
+
+			end
+		end
+	end
+end

data/lib/vagrant-zone/errors.rb

@@ -0,0 +1,27 @@
+require "vagrant"
+
+module VagrantPlugins
+	module ProviderZone
+		module Errors
+			class VagrantZoneError < Vagrant::Errors::VagrantError
+				error_namespace('vagrant_zone.errors')
+			end
+
+			class SystemVersionIsTooLow < VagrantZoneError
+				error_key(:system_version_too_low)
+			end
+
+			class HasNoRootPrivilege < VagrantZoneError
+				error_key(:has_no_root_privilege)
+			end
+
+			class ExecuteError < VagrantZoneError
+				error_key(:execute_error)
+			end
+
+			class TimeoutError < VagrantZoneError
+				error_key(:timeout_error)
+			end
+		end
+	end
+end

data/lib/vagrant-zone/executor.rb

@@ -0,0 +1,38 @@
+require "vagrant/util/busy"
+require "vagrant/util/subprocess"
+
+module VagrantPlugins
+	module ProviderZone
+		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: [: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")
+
+					if result.exit_code != 0 || interrupted
+						raise Errors::ExecuteError
+					end
+
+					result.stdout[0..-2]
+				end
+			end
+		end
+	end
+end

data/lib/vagrant-zone/plugin.rb

@@ -0,0 +1,68 @@
+begin
+	require "vagrant"
+rescue LoadError
+	raise "The Vagrant Zone plugin must be run within Vagrant."
+end
+
+module VagrantPlugins
+	module ProviderZone
+		class Plugin < Vagrant.plugin('2')
+			name "zone"
+			description <<-DESC
+			This plugin allows vagrant to manage lx-branded zones or native zones on
+			OmniOSce or any other illumos based distribution
+			DESC
+
+			config(:zone, :provider) do
+				require_relative "config"
+				Config
+			end
+
+			provider(:zone) do
+				require_relative "provider"
+				Provider
+			end
+
+			# This initializes the internationalization strings.
+			def self.setup_i18n
+				I18n.load_path << File.expand_path('locales/en.yml', ProviderZone.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 if !level.is_a?(Integer)
+
+				# Set the logging level on all "vagrant" namespaced
+				# logs as long as we have a valid level.
+				if level
+					logger = Log4r::Logger.new('vagrant_zone')
+					logger.outputters = Log4r::Outputter.stderr
+					logger.level = level
+					logger = nil
+				end
+			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
+		end
+	end
+end

data/lib/vagrant-zone/provider.rb

@@ -0,0 +1,93 @@
+require "vagrant"
+require "log4r"
+
+module VagrantPlugins
+	module ProviderZone
+		autoload :Driver, 'vagrant-zone/driver'
+
+		class Provider < Vagrant.plugin('2', :provider)
+			def initialize(machine)
+				@logger = Log4r::Logger.new("vagrant::provider::zone")
+				@machine = machine
+			end
+
+			def driver
+				return @driver if @driver
+				@driver = Driver.new(@machine)
+			end
+
+			# This should return a hash of information that explains how to SSH
+			# into the machine. If the machine is not at a point where SSH is 
+			# even possiable, then 'nil' should be returned
+			#
+			# The general structure of this returned hash should be the
+			# following:
+			#
+			#			   {
+			#			    host: "1.2.3.4",
+			#			    port: "22",
+			#			    username: "vagrant",
+			#			    private_key_path: "/path/to/my/key"
+			#			   }
+			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
+				ip = driver.get_ip_address(@machine)
+				return nil if !ip
+				ssh_info = {
+					host: ip,
+					port: 22,
+				}
+			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)
+				# Attrmpt 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
+			end
+
+			def state
+				id = @machine.id
+				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
+				if state_id == :not_created
+					state_id = Vagrant::MachineState::NOT_CREATED_ID
+				end
+
+				# Return the MachineState object
+				Vagrant::MachineState.new(state_id, short, short)
+			end
+
+		end
+	end
+end

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

@@ -0,0 +1,17 @@
+module VagrantPlugins
+  module ProviderZone
+    module Util
+      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-zone/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+	module ProviderZone
+		VERSION = "0.0.1"
+	end
+end

data/locales/en.yml

@@ -0,0 +1,12 @@
+en:
+  vagrant_zone:
+    states:
+      not_created: |-
+        Your instance of this box haven't been created.
+      is_running: |-
+        Your instance has already be booted.
+    errors:
+      execute_error: |-
+        Failed when execute commands.
+      timeout_error: |-
+        Timeout exceeded.

data/playbook.yml

@@ -0,0 +1,9 @@
+---
+- name: First Playbook
+  hosts: all
+  gather_facts: yes
+  tasks:
+    - name: Display the config
+      debug:
+        msg: "The hostname is {{ ansible_hostname }} and the OS is {{ ansible_version }}"
+

data/vagrant-zone.gemspec

@@ -0,0 +1,24 @@
+require File.expand_path('../lib/vagrant-zone/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "vagrant-zone"
+  spec.version       = VagrantPlugins::ProviderZone::VERSION
+  spec.authors       = ["Thomas Merkel"]
+  spec.email         = ["thomas.merkel@skylime.net"]
+
+  spec.summary       = %q{Vagrant provider plugin to support zones}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/skylime/vagrant-zone"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_runtime_dependency "ruby_expect"
+  spec.add_runtime_dependency "netaddr"
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-zone
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Thomas Merkel
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby_expect
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: netaddr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Vagrant provider plugin to support zones
+email:
+- thomas.merkel@skylime.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Vagrantfile
+- lib/vagrant-zone.rb
+- lib/vagrant-zone/action.rb
+- lib/vagrant-zone/action/create.rb
+- lib/vagrant-zone/action/destroy.rb
+- lib/vagrant-zone/action/halt.rb
+- lib/vagrant-zone/action/import.rb
+- lib/vagrant-zone/action/is_created.rb
+- lib/vagrant-zone/action/network.rb
+- lib/vagrant-zone/action/not_created.rb
+- lib/vagrant-zone/action/package.rb
+- lib/vagrant-zone/action/prepare_nfs_valid_ids.rb
+- lib/vagrant-zone/action/setup.rb
+- lib/vagrant-zone/action/start.rb
+- lib/vagrant-zone/action/wait_till_up.rb
+- lib/vagrant-zone/config.rb
+- lib/vagrant-zone/driver.rb
+- lib/vagrant-zone/errors.rb
+- lib/vagrant-zone/executor.rb
+- lib/vagrant-zone/plugin.rb
+- lib/vagrant-zone/provider.rb
+- lib/vagrant-zone/util/timer.rb
+- lib/vagrant-zone/version.rb
+- locales/en.yml
+- playbook.yml
+- vagrant-zone.gemspec
+homepage: https://github.com/skylime/vagrant-zone
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Vagrant provider plugin to support zones
+test_files: []