PackerFiles 0.0.1

data/lib/PackerFiles/Provision/Provisioners.rb

@@ -0,0 +1,87 @@
+# Requires
+require_relative 'Copy'
+require_relative 'InlineScript'
+require_relative 'ExternalScript'
+require_relative 'ChefSolo'
+
+# Top level class for managing Provisioners in a OS Spec file
+module PackerFiles
+   class Provisioners 
+
+      # Documentation for this class 
+      def self.doc_file
+         PackerFiles.DirPath('Provision/example/Provisioners.txt').first
+      end
+
+      # List of registered provisioners
+      attr_accessor :list
+
+      # Constructor just yields self for further initialization
+      def initialize(&block)
+	 @list = []
+         yield self if block_given?   
+      end
+
+      # Enable File Copy Provisioner to be called multiple times
+      # with order preservation.
+      def Copy(&block)
+	 @list.push(Provision::Copy.new(&block))
+      end
+
+      # Enable Inline Script Provisioner to be called multiple times
+      # with order preservation.
+      def InlineScript(&block)
+	 @list.push(Provision::InlineScript.new(&block))
+      end
+
+      # Enable External Script Provisioner to be called multiple times
+      # with order preservation.
+      def ExternalScript(&block)
+	 @list.push(Provision::ExternalScript.new(&block))
+      end
+
+      # Enable Chef Solo Provisioner to be called multiple times
+      # with order preservation.
+      def ChefSolo(&block)
+	 @list.push(Provision::ChefSolo.new(&block))
+      end
+
+      # Convert self into Packer JSON format.
+      def convert(gen, os)
+	 @list.unshift(EnableRootLoginScript(os))
+	 @list.push(DisableRootLoginScript(os))
+         @list.compact.each do |prov|
+	    prov.os = os
+	    hash    = prov.to_hash(os)
+	    gen.provisioners.push(hash) if !hash.nil?
+         end
+      end
+
+      # Create a inline script command to enable root logins
+      private
+      def EnableRootLoginScript(os)
+	cmd    = os.run_command_as_root
+        enable = os.enable_root_for_user
+	if !cmd.nil? && !enable.nil?
+	   return Provision::InlineScript.new do |script|
+	      script.execute_command = cmd
+	      script.inline          = enable
+	   end
+	end
+      end
+
+      # Create a inline script command to disable root logins
+      private
+      def DisableRootLoginScript(os)
+	cmd     = os.run_command_as_root
+        disable = os.disable_root_for_user
+	if !cmd.nil? && !disable.nil?
+	   return Provision::InlineScript.new do |script|
+	      script.execute_command = cmd
+	      script.inline          = disable
+	   end
+	end
+      end
+ 
+   end
+end

data/lib/PackerFiles/Provision/example/Provisioners.txt

@@ -0,0 +1,21 @@
+
+# Define Provisioners for this OS
+<% if @obj.nil? -%>
+#os.<%= @name -%> do |prov|
+<% else -%>
+os.<%= @name -%> do  |prov|
+<% end -%>
+
+  # The Copy provisioner is used for Copying files.
+  # Multiple files or folders can be copied by using the same
+  # construct many times.
+  # prov.Copy do |cp|
+  #    cp.source      = 'source'
+  #    cp.destination = 'destination'
+  # end
+
+<% if @obj.nil? -%>
+#end
+<% else -%>
+end
+<% end -%>

data/lib/PackerFiles/Utils/AutoZone.rb

@@ -0,0 +1,96 @@
+# Requires
+require 'rubygems'
+require 'open-uri'
+require 'json'
+
+module PackerFiles
+
+  module Utils
+
+     # AutoZone handles the automatic detection of a time zone via
+     # web based GEO Lookups.
+     class AutoZone
+
+	 # URL for maxmind timezone specifier
+	 @@url = 'https://raw.githubusercontent.com/maxmind/geoip-api-c/master/timezone/timezone.txt'
+
+	 # List of URLs for Geo-IP lookup
+	 @@geo = [
+	    'http://www.telize.com/geoip',
+	    'http://freegeoip.net/json'
+	 ]
+
+	 # JSON object cache to prevent multiple internet lookups.
+	 @@cache = nil
+
+	 # Return back the Cached JSON
+	 def self.Cache
+	    @@cache
+	 end
+
+	 # Return the JSON from the web services, to do what ever.
+	 def JSON
+	  
+	   # Return the cache if it is populated already
+	   return @@cache if !@@cache.nil?
+
+	   # Cache Miss! Let us get it from Internet.
+	   @@geo.each do |url|
+	      begin
+		contents = open(url) {|f| f.read }
+		@@cache  = JSON.parse(contents)
+		break
+	      rescue
+		next
+	      end
+	   end
+	   return @@cache
+	 end
+
+	 # Sugar coated country code
+	 def country_code
+	    return self.JSON['country_code']
+	 end
+
+	 # Sugar coated country_area code
+	 def country_area_code
+	    json  = self.JSON
+	    return json['country_code'], json['area_code']
+	 end
+
+	 # Sugar coated perfect time zone look-up
+	 def time_zone
+       
+	    # Get the RAW JSON
+	    json  = self.JSON
+
+	    # If it already contains a timezone, good enough and move on.
+	    return json['timezone'] if json.has_key?('timezone')
+
+	    # If not need more lookups with max-mind DB. Cache it for further
+	    # use. 
+	    country = json['country_code']
+	    area    = json['area_code']
+	    open(@@url) {|f|
+	     f.each_line do |line|
+	       arr = line.split("\t")
+	       # Return the Time Zone if there is an exact match of country and area
+	       if (arr[0] == country && arr[1] == area)
+		  @@cache['timezone'] = arr[2]
+		  break
+	       # Return the Time Zone if there is an exact match of country and if 
+	       # area cannot be determined reliably.
+	       elsif (arr[0] == country && (arr[1].empty? || area.empty?))
+		  @@cache['timezone'] = arr[2]
+		  break
+	       end
+	     end 
+	   }
+	   return @@cache['timezone']
+	 end
+
+     end # AutoZone
+
+  end # Utils
+
+end # PackerFiles

data/lib/PackerFiles/Utils/FastestURL.rb

@@ -0,0 +1,73 @@
+# Requires
+require 'open-uri'
+require 'benchmark'
+require 'uri'
+
+module PackerFiles
+  
+   module Utils
+
+      # Given a list of URL, returns the fastest URL (to access) among them. 
+      # This is done by launching several threads in parallel and estimating
+      # the time taken to access the contents of these URLs.
+      class FastestURL
+
+	 # Error URL 
+	 @@error = 25000
+     
+	 # Creates a new object of type FastestURL. slow_limit is used for 
+	 # signalling the response time (in seconds) of a web URL to be 
+	 # categorized as slow. Trials specifies the # of attempts the web
+	 # URLs must be opened and closed.  
+	 def initialize(slow_limit = 0.5 , trials = 1)
+	    @limit  = slow_limit
+	    @trials = trials
+	 end 
+
+	 # Returns URLs sorted in terms of best access times from a list of 
+	 # input URLs.
+	 def best_urls(url_list)
+	    threads = url_list.map  { |h| Thread.new {speed_trials(h) }}
+	    speeds  = threads.map   { |t| t.join; t.value }
+	    hash    = Hash.new
+	    url_list.each_with_index do |url, index|
+	       hash[url] = speeds.at(index) if speeds.at(index) != @@error
+	    end
+	    hash.sort_by {|url, speed| speed} 
+	 end
+
+	 # Compute the latency of a web url, multiple times via independent
+	 # trials. This is called in thread context only.
+	 private
+	 def speed_trials(url)
+	   total = 0.0
+	   @trials.times do
+	     speed = estimate_speed(url)
+	     if speed >= @limit
+	       return @@error
+	     else
+	       total += speed
+	     end
+	   end
+	   return (total / @trials)
+	 end
+	 
+	 # This function is called in thread context only. It computes
+	 # the  time it takes for the various mirrors to return the index
+	 # as a proxy for measuring it's speed.
+	 private
+	 def estimate_speed(url)
+	    Benchmark.realtime do
+	      begin
+		open(url) {|f| f.read}
+	      rescue Exception => e
+		return @@error
+	      end
+	    end
+	 end
+
+      end # FastestURL
+
+   end # Utils
+ 
+end # PackerFiles

data/lib/PackerFiles/Utils/Generator.rb

@@ -0,0 +1,34 @@
+# Requires
+require 'Utils/HashSerializer'
+require 'json'
+
+module PackerFiles
+   module Utils
+
+      # Generates the top level JSON file for Packer to operate upon.
+      class Generator < HashSerializer
+
+	# List of Hash Serializers
+	hash_variable :variables,    Hash
+	hash_variable :builders,     Array 
+	hash_variable :provisioners, Array
+    
+	# Constructor
+	def initialize
+	   self.builders     = Array.new
+	   self.variables    = Hash.new
+	   self.provisioners = Array.new
+	end 
+
+	# Create the JSON file in the given directory
+	def create_json(filename)
+	   hash    = self.to_hash
+	   content = JSON.pretty_generate(hash) + "\n"
+	   File.write(filename, content)
+	end
+
+      end # Generator
+
+   end # Utils
+
+end # PackerFiles

data/lib/PackerFiles/Utils/HashSerializer.rb

@@ -0,0 +1,110 @@
+# Requires
+
+module PackerFiles
+
+  module Utils
+
+     # The Hash serializer is a meta-class that allows tracking of objects 
+     # that needs to be converted into Hash objects, w/o having to hand-write
+     # lot of code.
+     class HashSerializer
+
+       # The Meta-class Idiom. All functions within this block are meta-class 
+       # functions that cannot be invoked on the object, but can be invoked 
+       # on the class.
+       class << self
+
+	 # Specify that a list of methods are tracked for serialization.
+	 # Name is the attribute name, Type is the object type that it 
+	 # belongs to. Method is the name of the conversion function that 
+	 # returns the value of the object serialized for JSON.
+	 def hash_variable(name, type = String, method = nil, nil_emit=false)
+	    @attrs ||= []
+	    @attrs +=  [Hash["name",     name,   "type",     type, 
+			     "method",   method, "nil_emit", nil_emit]
+		       ]
+	    self.class_eval do
+      
+	      # Read accessor
+	      define_method(name) do
+		instance_variable_get("@#{name}")
+	      end
+
+	      # Write accessor
+	      define_method("#{name}=") do |value|
+		 if value.is_a? type
+		   instance_variable_set("@#{name}", value)
+		 else
+		   raise ArgumentError.new("Invalid Type")
+		 end
+	      end
+
+	      # Converter function. We need to first get the
+	      # variable and then call a function on it by binding
+	      # first. (See Module::instance_method example in Ruby man page) 
+	      define_method("to_hash_value_#{name}") do
+		var = instance_variable_get("@#{name}")
+		if (method.nil? || var.nil?)
+		  var
+		else
+		  self.method(method).call
+		end
+	      end
+
+	    end
+	 end
+
+	 # Return the attributes that are tracked so that it can be
+	 # used for serialization. 
+	 def hash_attributes
+	   @attrs
+	 end
+
+       end
+
+       # Merge a hash serializer object with the current object.
+       def merge_hs(other)
+
+          # Do nothing if the other is not a Hash Serializer
+	  return unless other.kind_of?(HashSerializer)
+
+	  # Get the attributes set in other and if the same attribute
+	  # is not set in self, then replace it. Otherwise ignore
+	  other.class.hash_attributes.each do |attr|
+	     name         = attr['name']
+	     other_value  = other.method(name).call
+	     self_value   = self.method(name).call
+	     if !other_value.nil? && self_value.nil?
+	        self.method("#{name}=").call(other_value)
+	     end
+	  end
+       end
+
+       # Hash Converter which iterates through all the tracked objects
+       # and outputs the hash. This function is *NOT* a meta-class function
+       # but instead operates on the object level.
+       def to_hash(*args)
+	
+	  # Return value 
+	  hash = Hash.new
+
+	  # Get all classes in the class hierarchy until HashSerializer
+	  index = self.class.ancestors.index(HashSerializer)
+	  cl_list  = self.class.ancestors.slice(0, index)
+	  cl_list.each do |klass|
+	     next if !klass.respond_to?(:hash_attributes)
+	     klass.hash_attributes.each do |attr|
+	       name       = attr['name']
+	       nil_emit   = attr['nil_emit']
+	       value      = method("to_hash_value_#{name}").call
+	       hash[name] = value if (!value.nil? || (value.nil? && nil_emit))
+	     end
+	  end
+	  return hash
+       end
+
+     end # HashSerializer
+
+  end # Utils
+
+end # PackerFiles

data/lib/PackerFiles/Utils/Size.rb

@@ -0,0 +1,44 @@
+
+module PackerFiles
+
+   module Utils
+
+      # Contains utility functions to manage size conversions
+      module Size
+
+         # Array of regular expressions to match size and their 
+         # corresponding lambda functions to return size in number. It is 
+         # easy to understand the constants if we remember that Packer always
+         # accepts size in MiB [Power of 2].
+	 @@regex = {
+	   /([0-9]+)GiB/ =>  lambda {|n| 1024 * n},
+	   /([0-9]+)GB/  =>  lambda {|n| (953.67 * n).round},
+	   /([0-9]+)MB/  =>  lambda {|n| (0.95367 * n).round},
+	   /([0-9]+)MiB/ =>  lambda {|n| n},
+	   /([0-9]+)TiB/ =>  lambda {|n| 1048576 * n},
+	   /([0-9]+)TB/  =>  lambda {|n| (909486.46 * n).round},
+	   /([0-9]+)GHz/ =>  lambda {|n| 1024 * n},
+	   /([0-9]+)MHz/ =>  lambda {|n| n}
+	 }
+
+         # Convert a text 'size' into a units of MiB. This is done
+         # calling the appropriate lambda function, whenever the 
+         # regex is matched.
+         def MiB(size)
+            @@regex.each_pair do |r, l|
+               if m = r.match(size)
+                  return l.call(m[1].to_i)
+               end
+            end
+         end
+   
+         # Convert MiB Size into Bytes
+         def Bytes(size)
+            size * 1024 * 1024
+         end
+
+      end # Size
+
+   end # Utils
+
+end # PackerFiles

data/lib/PackerFiles/Utils/TypeAccessor.rb

@@ -0,0 +1,71 @@
+# Requires
+require_relative "../Core/Exceptions"
+
+module PackerFiles
+
+   module Utils
+
+      # Exception class used to indicate that a required type accessor is
+      # missing.
+      class MissingAccessor < Core::Error
+	 def initialize(accessor_name, class_name)
+	    self.message = "Missing #{accessor_name} Section for #{class_name}"
+	 end
+      end
+
+      # The Type accessor class is used as a meta-class for any class.
+      class TypeAccessor
+      
+       # The Meta-class Idiom. All functions within this block are meta-class 
+       # functions that cannot be invoked on the object, but can be invoked 
+       # on the class.
+       class << self
+
+	 # Custom accessor to create accessors from type name. It is also
+	 # Possible to set the name of the accessor. By default it is the 
+	 # name of the type.
+	 def type_accessor(type, name     = type.name.gsub(/.*::/, ''), 
+				 optional = false)
+
+	    # Save the type and name in a array hash, which will be used later.
+	    @types ||= Hash.new
+	    @types[name] = [type, optional]
+
+	    # Doing a class_eval creates a new method of "name"
+	    class_eval do
+     
+	      # Read/Write accessor which accepts blocks for initialization.
+	      define_method("#{name}") do |arg = nil, &block|
+		if (self.class.proc_from(&block).nil?)
+		   instance_variable_get("@#{name}")
+		else
+		   obj = type.new(&block)
+		   instance_variable_set("@#{name}", obj)
+		end
+	      end # define_method
+	    end # class_eval
+
+	 end
+
+	 # Return the Hash that is used to track registered type accessors
+	 def type_accessors
+	   @types
+	 end
+	 
+	 # Given a block, convert it into a proc. if no block is given
+	 # then it is a nil object that is returned
+	 def proc_from(&block)
+	   if block_given?
+	      Proc.new
+	   else
+	      nil
+	   end
+	 end
+
+       end # class << self
+
+      end # TypeAccessor
+
+   end # Utils
+
+end # PackerFiles

data/lib/PackerFiles/Virtual/Hypervisors.rb

@@ -0,0 +1,72 @@
+# Requires
+require 'Utils/TypeAccessor'
+require 'Core/Hypervisor'
+
+module PackerFiles
+
+   module Virtual
+
+      # Internal List of Hypervisors that are supported. All of them Just override
+      # the Custom Object call.
+      class I_VirtualBox < Core::Hypervisor
+         def Custom(&block)
+	    @custom = VirtualBox.new(&block)
+         end
+      end
+
+      class I_VMWare < Core::Hypervisor
+         def Custom(&block)
+	    @custom = VMWare.new(&block)
+         end
+      end
+
+      class I_KVM < Core::Hypervisor
+         def Custom(&block)
+	    @custom = KVM.new(&block)
+         end
+      end
+
+      # Top level class for managing hypervisors in a OS Spec file
+      class Hypervisors  < Utils::TypeAccessor
+
+	 # Documentation for this class 
+	 def self.doc_file
+	    PackerFiles.DirPath('Virtual/example/Hypervisors.txt').first
+	 end
+
+	 # Specify accessors for various supported Hypervisors
+	 type_accessor I_VirtualBox, :VirtualBox
+	 type_accessor I_VMWare,     :VMWare
+	 type_accessor I_KVM,        :KVM
+
+	 # Constructor just yields self for further initialization
+	 def initialize(&block)
+	    yield self if block_given?   
+	 end
+
+	 # Given a generator and a OS class derived from builder, convert
+	 # it into hashes suitable for packer json file generation
+	 def convert(gen, builder)
+
+	   # Convert parameters into hash for registered Hypervisors
+	   if !self.VirtualBox.nil?
+	      hash = builder.vbox_converter_hook(gen)
+	      gen.builders.push(hash) if !hash.nil?
+	   end
+	   if !self.VMWare.nil?
+	      hash = builder.vmware_converter_hook(gen)
+	      gen.builders.push(hash) if !hash.nil?
+	   end
+	   if !self.KVM.nil?
+	      hash = builder.kvm_converter_hook(gen)
+	      gen.builders.push(hash) if !hash.nil?
+	   end
+
+	 end
+
+      end # Hypervisors
+
+   end  # Virtual
+
+end # PackerFiles
+