PackerFiles 0.0.1

data/lib/PackerFiles/Virtual/KVM.rb

@@ -0,0 +1,119 @@
+# Requires
+require 'Core/Hypervisor'
+require 'Utils/HashSerializer'
+require 'Utils/Size'
+
+module PackerFiles
+
+   module Virtual
+
+      # Abstraction for KVM(QEMU) builder in Packer. Refer to Packer.io
+      # documentation on more details on the various variables for 
+      # QEMU ISO Builder.
+      class KVM < Utils::HashSerializer
+
+	 # Import Size with KVM class as a Mix-in
+	 include Utils::Size
+
+	 # List of attributes that would be converted into Hash Values. The Hash
+	 # values will eventually be converted into JSON values.
+	 hash_variable :iso_checksum
+	 hash_variable :iso_checksum_type
+	 hash_variable :iso_url
+	 hash_variable :ssh_username
+	 hash_variable :accelerator
+	 hash_variable :boot_command, Array
+	 hash_variable :boot_wait
+	 hash_variable :disk_size,    Integer
+	 hash_variable :disk_interface
+	 hash_variable :floppy_files, Array
+	 hash_variable :format
+	 hash_variable :headless
+	 hash_variable :http_directory
+	 hash_variable :http_port_min, Integer
+	 hash_variable :http_port_max, Integer
+	 hash_variable :iso_urls, Array
+	 hash_variable :net_device
+	 hash_variable :output_directory
+	 hash_variable :qemuargs, Array
+	 hash_variable :qemu_binary
+	 hash_variable :shutdown_command
+	 hash_variable :shutdown_timeout
+	 hash_variable :ssh_host_port_min, Integer
+	 hash_variable :ssh_host_port_max, Integer
+	 hash_variable :ssh_key_path
+	 hash_variable :ssh_password
+	 hash_variable :ssh_port, Integer
+	 hash_variable :ssh_wait_timeout
+	 hash_variable :vm_name
+	 hash_variable :type
+	 hash_variable :vnc_port_min
+	 hash_variable :vnc_port_max
+	 hash_variable :name
+
+	 # Constructor. Supports the standard block semantics via yield
+	 def initialize(&block)
+	    self.type = 'qemu'
+	    yield self if block_given?
+	 end
+
+	 # Given an Hypervisor object, convert into a list of qemuargs commands
+	 def Hypervisor(hyper, amd64=true)
+
+	   # Allocate a new array to store values.
+	   value = Array.new
+
+	   # If CPU hot plug is enabled, then current cpu count < max cpu count
+	   count = hyper.cpu_count.to_s 
+	   if (hyper.cpu_hot_plug)
+	      value << ["-smp", "cpus=#{count},maxcpus=255"]
+	   else
+	      value << ["-smp", "cpus=#{count},maxcpus=#{count}"]
+	   end
+	  
+	   # NOTE: CPU Execution Cap is not implemented in KVM
+	   # NOTE: Video RAM Size is not implemented in KVM
+
+	   # RAM Size is always translated into MiB
+	   value << ["-m", MiB(hyper.ram_size).to_s]
+
+	   # Memory Balloon size is ignored by KVM. It is just enabling or
+	   # disabling a feature.
+	   if MiB(hyper.guest_balloon_size) > 0
+	      value << ["-balloon", "none"]
+	   else
+	      value << ["-balloon", "virtio"]
+	   end
+
+	   # ACPI is by default enabled on KVM. We just have to handle the 
+	   # disabled case.
+	   if !hyper.acpi_enabled
+	      value << ["-no-acpi"]
+	   end
+
+	   # We have to use EFI firmware for virtual machines, if it has been
+	   # asked for.
+	   if hyper.use_efi
+	      value << ["-bios", "/usr/share/ovmf/OVMF.fd"]
+	   end
+
+	   # KVM works very differently w.r.t. CPU features. First a base CPU 
+	   # (64 bit or 32 bit) has to be selected and then more features need
+	   # to be added.
+	   cpu_features  =   (amd64)?'qemu64':'qemu32'
+	   cpu_features  +=  ',+pae'   if hyper.pae_enabled 
+	   cpu_features  +=  ',+vmx'   if hyper.hw_virt_enabled
+	   cpu_features  +=  ',+npt'   if hyper.hw_nested_pages
+	   cpu_features  +=  ',+pse36' if hyper.use_large_pages
+	   cpu_features  +=  ',+hypervisor' if hyper.unrestricted_guest_mode
+	   value << ["-cpu", cpu_features]
+
+	   # Set the value for QEMU Args
+	   self.qemuargs = value
+	 end
+
+      end
+
+   end  # Virtual
+
+end # PackerFiles

data/lib/PackerFiles/Virtual/KVMConverter.rb

@@ -0,0 +1,79 @@
+# Requires
+require 'Virtual/KVM'
+require 'Utils/Generator'
+
+# Converts a given OS into a KVM builder
+module PackerFiles
+  module Virtual
+    class KVMConverter
+
+      # Hash Value
+      attr_reader :value 
+
+      # Constructor
+      def initialize(os, gen)
+	@value = convert(os, gen).to_hash
+      end
+
+      # Convert OS object into a hash
+      def convert(os, gen)
+        KVM.new do |kvm|
+        
+           # Fill in output directory
+           rel  = os.CDImage.release
+           arch = os.CDImage.arch
+	   name = os.name.gsub('::', '-')
+	   kvm.output_directory = "output-#{name}-#{rel}-#{arch}-#{kvm.type}"
+	   kvm.name = "#{name}-#{rel}-#{arch}-#{kvm.type}"
+
+	   # Fill in image details, Some amount of url handling
+	   # is really required to handle various corner cases. 
+	   # thus making the code a bit harder to understand
+	   kvm.iso_checksum_type = os.CDImage.check_sum_type
+	   kvm.iso_checksum      = os.CDImage.check_sum
+	
+	   # The code below creates a user variable called mirror
+	   # whose base value is the URL fragment w/o the file-name.
+           url                     = URI::parse(os.CDImage.iso_url)
+	   file                    = File.basename(url.path)
+	   url.path                = File.dirname(url.path)
+	   gen.variables['mirror'] = url.to_s
+	   kvm.iso_url             = "{{user `mirror`}}/#{file}"
+
+	   # Fill in SSH specifics
+	   kvm.ssh_username     = os.User.login
+	   kvm.ssh_password     = os.User.password
+	   kvm.ssh_wait_timeout = '10000s'
+
+	   # Fill in other specifics
+	   kvm.disk_size       = os.Disk.size
+	   kvm.http_directory  = File.basename(os.http_dir)
+
+	   # Fill in boot command and boot_wait command
+	   gen.variables['host']        = ''
+	   gen.variables['port']        = ''
+	   user_var_name                = name + "-#{kvm.type}-boot-wait"
+	   gen.variables[user_var_name] = "10s"
+	   kvm.boot_command            = os.boot_command
+	   kvm.boot_wait               = "{{user `#{user_var_name}`}}"
+
+	   # Fill in shutdown command
+	   kvm.shutdown_command = os.shutdown_command
+
+	   # If the guest OS type contains 64 bit OS, then we need to enable
+           # a 64 bit CPU.
+	   if os.guest_os_type.match("64")
+	      kvm.Hypervisor(os.Hypervisors.KVM, true)
+	   else
+	      kvm.Hypervisor(os.Hypervisors.KVM, false)
+	   end
+
+	   # Merge with Custom attributes
+	   kvm.merge_hs(os.Hypervisors.KVM.custom)
+        end
+
+      end
+
+    end
+ end
+end

data/lib/PackerFiles/Virtual/VMWare.rb

@@ -0,0 +1,108 @@
+# Requires
+require 'Core/Hypervisor'
+require 'Utils/HashSerializer'
+require 'Utils/Size'
+
+module PackerFiles
+
+   module Virtual
+
+      # Abstraction for VMWare builder in Packer. Refer to Packer.io
+      # documentation on more details on the various variables for 
+      # VMWare ISO Builder.
+      class VMWare < Utils::HashSerializer
+
+	 # Import Size with VirtualBox class as a Mix-in
+	 include Utils::Size
+
+	 # List of attributes that would be converted into Hash Values. The Hash
+	 # values will eventually be converted into JSON values.
+	 hash_variable :iso_checksum
+	 hash_variable :iso_checksum_type
+	 hash_variable :iso_url
+	 hash_variable :ssh_username
+	 hash_variable :boot_command, Array
+	 hash_variable :boot_wait
+	 hash_variable :disk_size,    Integer
+	 hash_variable :disk_type_id
+	 hash_variable :floppy_files, Array
+	 hash_variable :fusion_app_path
+	 hash_variable :guest_os_type
+	 hash_variable :headless
+	 hash_variable :http_directory
+	 hash_variable :http_port_min, Integer
+	 hash_variable :http_port_max, Integer
+	 hash_variable :iso_urls, Array
+	 hash_variable :output_directory
+	 hash_variable :remote_cache_datastore
+	 hash_variable :remote_cache_directory
+	 hash_variable :remote_datastore
+	 hash_variable :remote_host
+	 hash_variable :remote_password
+	 hash_variable :remote_type
+	 hash_variable :remote_username
+	 hash_variable :shutdown_command
+	 hash_variable :shutdown_timeout
+	 hash_variable :ssh_host
+	 hash_variable :ssh_key_path
+	 hash_variable :ssh_password
+	 hash_variable :ssh_port, Integer
+	 hash_variable :ssh_wait_timeout
+	 hash_variable :tools_upload_flavor
+	 hash_variable :tools_upload_path
+	 hash_variable :vm_name
+	 hash_variable :vmdk_name
+	 hash_variable :vmx_data, Hash
+	 hash_variable :vmx_data_post, Hash
+	 hash_variable :vmx_template_path
+	 hash_variable :vnc_port_min, Integer
+	 hash_variable :vnc_port_max, Integer
+	 hash_variable :type
+	 hash_variable :name
+
+	 # Constructor. Supports the standard block semantics via yield
+	 def initialize(&block)
+	    self.type = 'vmware-iso'
+	    yield self if block_given?
+	 end
+
+	 # Given an Hypervisor object, convert into a list of VMX commands
+	 # and set vmx_data accordingly
+	 def Hypervisor(hyper)
+	   value = Hash.new
+	   value['numvcpus']      = hyper.cpu_count.to_s
+	   value['vcpu.hotadd']   = true_false(hyper.cpu_hot_plug)
+	   value['memsize']       = MiB(hyper.ram_size).to_s
+	   value['mem.hotadd']    = 'TRUE'
+	   value['svga.vramsize'] = Bytes(MiB(hyper.video_ram_size)).to_s
+	   value['acpi.present']  = true_false(hyper.acpi_enabled)
+	   value['paevm']         = true_false(hyper.pae_enabled)
+	   value['vhv.enable']    = true_false(hyper.hw_virt_enabled)
+	   value['monitor_control.disable_mmu_largepages'] = true_false(!hyper.use_large_pages)
+	   value['mks.enable3d']  = true_false(hyper.video_3d_acceleration)
+	   value['firmware']      = 'efi' if (hyper.use_efi)
+	   value['sched.mem.maxmemctl'] = MiB(hyper.guest_balloon_size)
+
+	   # CPU Speed limit is done by converting any value into MHZ
+	   value['sched.cpu.max']   = MiB(hyper.cpu_speed)
+	   value['sched.cpu.units'] = 'mhz'
+	   
+	   #NOTE: CPU Execution Cap is not supported in VMX File settings. 
+	   #NOTE: Extended Page Table [Nested Paging] is enabled because of VHV.
+	   #NOTE: Unrestricted  Guest Mode is enabled because of VHV.
+	   self.vmx_data = value
+	 end
+
+	# Convert a boolean to a TRUE/FALSE string
+	private
+	def true_false(value)
+	   return "TRUE"  if (value)
+	   return "FALSE" if (!value)
+	end
+
+
+      end
+
+   end  # Virtual
+
+end # PackerFiles

data/lib/PackerFiles/Virtual/VMWareConverter.rb

@@ -0,0 +1,78 @@
+# Requires
+require 'Virtual/VMWare'
+require 'Utils/Generator'
+
+# Converts a given OS into a VMWare builder
+module PackerFiles
+  module Virtual
+    class VMWareConverter
+
+      # Hash Value
+      attr_reader :value 
+
+      # Constructor
+      def initialize(os, gen)
+	@value = convert(os, gen).to_hash
+      end
+
+      # Convert OS object into a hash
+      def convert(os, gen)
+        VMWare.new do |vmware|
+
+           # Fill in output directory and builder name
+           rel  = os.CDImage.release
+           arch = os.CDImage.arch
+	   name = os.name.gsub('::', '-')
+	   vmware.output_directory = "output-#{name}-#{rel}-#{arch}-#{vmware.type}"
+	   vmware.name = "#{name}-#{rel}-#{arch}-#{vmware.type}"
+       
+	   # Fill in image details, Some amount of url handling
+	   # is really required to handle various corner cases. 
+	   # thus making the code a bit harder to understand
+	   vmware.iso_checksum_type = os.CDImage.check_sum_type
+	   vmware.iso_checksum      = os.CDImage.check_sum
+	
+	   # The code below creates a user variable called mirror
+	   # whose base value is the URL fragment w/o the file-name.
+           url                     = URI::parse(os.CDImage.iso_url)
+	   file                    = File.basename(url.path)
+	   url.path                = File.dirname(url.path)
+	   gen.variables['mirror'] = url.to_s
+	   vmware.iso_url            = "{{user `mirror`}}/#{file}"
+
+	   # Fill in SSH specifics
+	   vmware.ssh_username     = os.User.login
+	   vmware.ssh_password     = os.User.password
+	   vmware.ssh_wait_timeout = '10000s'
+
+	   # Fill in other specifics
+	   vmware.disk_size       = os.Disk.size
+	   vmware.http_directory  = File.basename(os.http_dir)
+	   vmware.guest_os_type   = os.vmware_guest_os_type
+
+	   # Fill in boot command and boot_wait timeout
+	   gen.variables['host']        = ''
+	   gen.variables['port']        = ''
+	   user_var_name                = name + "-#{vmware.type}-boot-wait"
+	   gen.variables[user_var_name] = "10s"
+	   vmware.boot_command            = os.boot_command
+	   vmware.boot_wait               = "{{user `#{user_var_name}`}}"
+
+	   # Fill in shutdown command
+	   vmware.shutdown_command = os.shutdown_command
+
+           # Generate vmx commands    
+	   vmware.Hypervisor(os.Hypervisors.VMWare)
+
+	   # Tools flavor
+	   vmware.tools_upload_flavor = os.vmware_guest_os_flavor
+
+	   # Merge with Custom values
+	   vmware.merge_hs(os.Hypervisors.VMWare.custom)
+        end
+
+      end
+
+    end
+ end
+end

data/lib/PackerFiles/Virtual/VirtualBox.rb

@@ -0,0 +1,98 @@
+# Requires
+require 'Core/Hypervisor'
+require 'Utils/HashSerializer'
+require 'Utils/Size'
+
+module PackerFiles
+
+   module Virtual
+
+       # Abstraction for VirtualBox builder in Packer. Refer to Packer.io
+       # documentation on more details on the various variables for 
+       # VirtualBox ISO Builder.
+       class VirtualBox < Utils::HashSerializer
+
+	  # Import Size with VirtualBox class as a Mix-in
+	  include Utils::Size
+
+	  # List of attributes that would be converted into Hash Values. The Hash
+	  # values will eventually be converted into JSON values.
+	  hash_variable :iso_checksum
+	  hash_variable :iso_checksum_type
+	  hash_variable :iso_url
+	  hash_variable :ssh_username
+	  hash_variable :boot_command, Array
+	  hash_variable :boot_wait
+	  hash_variable :disk_size,    Integer
+	  hash_variable :export_opts, Array
+	  hash_variable :floppy_files, Array
+	  hash_variable :format
+	  hash_variable :guest_additions_mode
+	  hash_variable :guest_additions_path
+	  hash_variable :guest_additions_sha256
+	  hash_variable :guest_additions_url
+	  hash_variable :guest_os_type
+	  hash_variable :hard_drive_interface
+	  hash_variable :headless
+	  hash_variable :http_directory
+	  hash_variable :http_port_min, Integer
+	  hash_variable :http_port_max, Integer
+	  hash_variable :iso_interface
+	  hash_variable :iso_urls, Array
+	  hash_variable :output_directory
+	  hash_variable :shutdown_command
+	  hash_variable :shutdown_timeout
+	  hash_variable :ssh_host_port_min, Integer
+	  hash_variable :ssh_host_port_max, Integer
+	  hash_variable :ssh_key_path
+	  hash_variable :ssh_password
+	  hash_variable :ssh_port, Integer
+	  hash_variable :ssh_wait_timeout
+	  hash_variable :vboxmanage, Array
+	  hash_variable :vboxmanage_post, Array
+	  hash_variable :virtualbox_version_file
+	  hash_variable :vm_name
+	  hash_variable :type
+	  hash_variable :name
+
+	  # Constructor. Supports the standard block semantics via yield
+	  def initialize(&block)
+	     self.type = 'virtualbox-iso'
+	     yield self if block_given?
+	  end
+
+	  # Given an Hypervisor object, convert into a list of VBoxmanage commands
+	  # and set vboxmanage attribute accordingly.
+	  def Hypervisor(hyper)
+	    value = Array.new
+	    std   = ["modifyvm", "{{.Name}}"]
+	    value << std + ["--cpus",               hyper.cpu_count.to_s]
+	    value << std + ["--cpuhotplug",         on_off(hyper.cpu_hot_plug)]
+	    value << std + ["--cpuexecutioncap",    hyper.cpu_execution_cap.to_s]
+	    value << std + ["--memory",             MiB(hyper.ram_size).to_s]
+	    value << std + ["--vram",               MiB(hyper.video_ram_size).to_s]
+	    value << std + ["--acpi",               on_off(hyper.acpi_enabled)]
+	    value << std + ["--pae",                on_off(hyper.pae_enabled)]
+	    value << std + ["--hwvirtex",           on_off(hyper.hw_virt_enabled)]
+	    value << std + ["--nestedpaging",       on_off(hyper.hw_virt_enabled)]
+	    value << std + ["--vtxvpid",            on_off(hyper.hw_virt_enabled)]
+	    value << std + ["--largepages",         on_off(hyper.use_large_pages)]
+	    value << std + ["--vtxux",              on_off(hyper.unrestricted_guest_mode)]
+	    value << std + ["--accelerate3d",       on_off(hyper.video_3d_acceleration)]
+	    value << std + ["--firmware","efi"]     if (hyper.use_efi)
+	    value << std + ["--guestmemoryballoon", MiB(hyper.guest_balloon_size).to_s]
+	    self.vboxmanage = value
+	  end
+
+	 # Convert a boolean to a on/off string
+	 private
+	 def on_off(value)
+	    return "on"  if (value)
+	    return "off" if (!value)
+	 end
+
+       end # VirtualBox
+
+   end  # Virtual
+
+end # PackerFiles

data/lib/PackerFiles/Virtual/VirtualBoxConverter.rb

@@ -0,0 +1,75 @@
+# Requires
+require 'Virtual/VirtualBox'
+require 'Utils/Generator'
+
+# Converts a given OS into a VirtualBox builder
+module PackerFiles
+  module Virtual
+    class VirtualBoxConverter
+
+      # Hash Value
+      attr_reader :value 
+
+      # Constructor
+      def initialize(os, gen)
+	@value = convert(os, gen).to_hash
+      end
+
+      # Convert OS object into a hash
+      def convert(os, gen)
+        VirtualBox.new do |vbox|
+
+           # Fill in output directory and builder name
+           rel  = os.CDImage.release
+           arch = os.CDImage.arch
+	   name = os.name.gsub('::', '-')
+	   vbox.output_directory = "output-#{name}-#{rel}-#{arch}-#{vbox.type}"
+	   vbox.name = "#{name}-#{rel}-#{arch}-#{vbox.type}"
+       
+	   # Fill in image details, Some amount of url handling
+	   # is really required to handle various corner cases. 
+	   # thus making the code a bit harder to understand
+	   vbox.iso_checksum_type = os.CDImage.check_sum_type
+	   vbox.iso_checksum      = os.CDImage.check_sum
+	
+	   # The code below creates a user variable called mirror
+	   # whose base value is the URL fragment w/o the file-name.
+           url                     = URI::parse(os.CDImage.iso_url)
+	   file                    = File.basename(url.path)
+	   url.path                = File.dirname(url.path)
+	   gen.variables['mirror'] = url.to_s
+	   vbox.iso_url            = "{{user `mirror`}}/#{file}"
+
+	   # Fill in SSH specifics
+	   vbox.ssh_username     = os.User.login
+	   vbox.ssh_password     = os.User.password
+	   vbox.ssh_wait_timeout = '10000s'
+
+	   # Fill in other specifics
+	   vbox.disk_size       = os.Disk.size
+	   vbox.http_directory  = File.basename(os.http_dir)
+	   vbox.guest_os_type   = os.guest_os_type
+
+	   # Fill in boot command and boot_wait timeout
+	   gen.variables['host']        = ''
+	   gen.variables['port']        = ''
+	   user_var_name                = name + "-#{vbox.type}-boot-wait"
+	   gen.variables[user_var_name] = "10s"
+	   vbox.boot_command            = os.boot_command
+	   vbox.boot_wait               = "{{user `#{user_var_name}`}}"
+
+	   # Fill in shutdown command
+	   vbox.shutdown_command = os.shutdown_command
+
+           # Generate VBoxManage commands    
+	   vbox.Hypervisor(os.Hypervisors.VirtualBox)
+
+	   # Finally do a Merge with custom
+	   vbox.merge_hs(os.Hypervisors.VirtualBox.custom)
+        end
+
+      end
+
+    end
+ end
+end

data/lib/PackerFiles/Virtual/example/Hypervisors.txt

@@ -0,0 +1,23 @@
+
+# Define Hypervisors for this OS
+<% if @obj.nil? -%>
+#os.<%= @name -%> do |hypervisors|
+<% else -%>
+os.<%= @name -%> do  |hypervisors|
+<% end -%>
+
+<% 
+content = []
+%w[VirtualBox VMWare KVM].each do |func|
+   file = @mod.const_get('PackerFiles::Core::Hypervisor').doc_file
+   doc  = @mod.evaluate_erb(file, {'name' => func})
+   content += doc.split("\n").map {|line| '   ' + line  }
+end
+-%>
+<%= content.join("\n") -%>
+
+<% if @obj.nil? -%>
+#end
+<% else -%>
+end
+<% end -%>

data/lib/PackerFiles/version.rb

@@ -0,0 +1,3 @@
+module PackerFiles
+  VERSION = "0.0.1"
+end

data/lib/PackerFiles.rb

@@ -0,0 +1,44 @@
+# Requires
+require 'rubygems'
+require 'erubis'
+
+# Utility functions for the module
+module PackerFiles
+
+  # Name of the gem of this module. This is useful elsewhere, but primarily
+  # to avoid multiple definitions of gem name everywhere.
+  @@gem = 'PackerFiles'
+
+  # Accessor for the Gem name
+  def self.GemName
+    @@gem
+  end
+
+  # Accessor for Gem Spec
+  def self.GemSpec
+    Gem::Specification.find_by_name(self.GemName)
+  end
+
+  # Given a Path, return it's absolute path within the context of the Gem
+  def self.DirPath(file_name)
+     self.GemSpec.matches_for_glob(file_name)
+  end
+
+  # Evaluate a given ERB file in a given OS folder with the object
+  # hash. The hash contains object bindings in the form of {var, obj}
+  # where {var} is present in the erb file.
+  def self.evaluate_erb(filename, hash)
+     return Erubis::Eruby.new(File.read(filename)).evaluate(hash)
+  end
+
+  # Top level function that is called by the DSL to generate all the
+  # required PackerFiles
+  def self.Generate(os_name, version = nil, &block)
+     require 'Finder'
+     finder = Finder.new
+     obj    = finder.class_name(os_name, version).new(&block)
+     obj.Generate
+  end
+
+
+end