veewee 0.3.0.alpha4 → 0.3.0.alpha5

data/lib/veewee/config/vmfusion-ostypes.txt

@@ -0,0 +1 @@
+strings /Applications/VMware Fusion.app/Contents/MacOS/vmware |grep gostable|cut -d '.' -f 4|cut -d ')' -f 1|more 

data/lib/veewee/definition.rb

@@ -1,15 +1,19 @@
 require 'ostruct'
+require 'veewee/provider/core/helper/iso'
 
 module Veewee
   class Definition
 
+    include ::Veewee::Provider::Core::Helper::Iso
+
     attr_accessor :name
     attr_accessor :env
+    attr_accessor :path
 
     attr_accessor :cpu_count,:memory_size,:iso_file
     attr_accessor :disk_size, :disk_format
 
-    attr_accessor :os_typ_id
+    attr_accessor :os_type_id
 
     attr_accessor :boot_wait,:boot_cmd_sequence
 
@@ -24,17 +28,26 @@ module Veewee
 
     attr_accessor :floppy_files
 
-    attr_accessor :path
 
-    attr_accessor :os_type_id,:use_hw_virt_ext,:use_pae,:hostiocache
+    attr_accessor :use_hw_virt_ext,:use_pae,:hostiocache
 
     attr_accessor :iso_dowload_timeout, :iso_src,:iso_md5 ,:iso_download_instructions
 
-    def initialize(name,env)
+    attr_accessor :virtualbox
+    attr_accessor :vmfusion
+    attr_accessor :kvm
+
+    def initialize(name,path,env)
 
       @name=name
       @env=env
 
+      if path.nil? 
+        @path=File.join(env.definition_dir,name)
+      else
+        @path=path
+      end
+
       # Default is 1 CPU + 256 Mem of memory
       @cpu_count='1' ; @memory_size='256';
 
@@ -55,76 +68,119 @@ module Veewee
       #        :boot_wait => "10", :boot_cmd_sequence => [ "boot"],
       #        :kickstart_port => "7122", :kickstart_ip => "127.0.0.1", :kickstart_timeout => 10000,#
       #        :ssh_login_timeout => "10000", :ssh_user => "vagrant", :ssh_password => "vagrant",:ssh_key => "",
+      @ssh_host_port = "2222"; @ssh_guest_port = "22"
       #        :ssh_host_port => "2222", :ssh_guest_port => "22", :sudo_cmd => "echo '%p'|sudo -S sh '%f'",
       #       :shutdown_cmd => "shutdown -h now",
       #        :kickstart_file => nil,
 
-    end
+      @virtualbox={:vm_options => {}}
+      @vmfusion={:vm_options => {}}
+      @kvm={:vm_options => {}}
 
-
-    def method_missing(m, *args, &block)
-      env.logger.info "There's no attribute #{m} defined for builder #{@name}-- ignoring it"
     end
 
+
+    # This function takes a hash of options and injects them into the definition
     def declare(options)
       options.each do |key, value|
         instance_variable_set("@#{key}".to_sym, options[key])
         env.logger.info("definition") { " - #{key} : #{options[key]}" }
       end
-      verify_ostype
 
     end
 
-    # Loading a definition
+    # Class method to loading a definition
     def self.load(name,env)
 
-      dir=env.get_definition_paths[name]
-
-      if dir.nil?
-        env.ui.error "Error loading definition."
-        env.ui.error "could not find the directory of definition #{name}"
-        exit -1
+      # Construct the path to the definition
 
+      path=File.join(env.definition_dir,name)
+      definition=Veewee::Definition.new(name,path,env)
+      env.logger.info "Loading definition directory #{definition.path}"
+      unless definition.exists?
+        raise Veewee::DefinitionNotExist,"Error: Definition #{name} does not seem to exist"
       end
 
-      veewee_definition=Veewee::Definition.new(name,env)
-      veewee_definition.path=dir
+      # We create this longer name to avoid clashes
+      veewee_definition=definition
 
-      definition_file=File.join(dir,"definition.rb")
-      if File.exists?(definition_file)
-        definition_content=File.read(definition_file)
+      if definition.exists?
+        definition_file=File.join(definition.path,"definition.rb")
+        content=File.read(definition_file)
 
-        definition_content.gsub!("Veewee::Session.declare","veewee_definition.declare")
-        definition_content.gsub!("Veewee::Definition.declare","veewee_definition.declare")
+        content.gsub!("Veewee::Session.declare","veewee_definition.declare")
+        content.gsub!("Veewee::Definition.declare","veewee_definition.declare")
 
-        env.logger.info(definition_content)
+        env.logger.info(content)
 
         begin
           cwd=FileUtils.pwd
-          FileUtils.cd(dir)
-          self.instance_eval(definition_content)
-          env.logger.info("Setting definition path for definition #{name} to #{File.dirname(definition_file)}")
+          env.logger.info("Entering path #{definition.path}")
+          FileUtils.cd(definition.path)
+          self.instance_eval(content)
+          env.logger.info("Returning to  path #{cwd}")
           FileUtils.cd(cwd)
         rescue NameError => ex
-          env.ui.error("NameError reading definition from file #{definition_file} #{ex}")
+          raise Veewee::DefinitionError,"NameError reading definition from file #{definition_file} #{ex}"
         rescue Exception => ex
-          env.ui.error("Error in the definition from file #{definition_file}\n#{ex}")
-          exit -1
+          raise Veewee::DefinitionError,"Error in the definition from file #{definition_file}\n#{ex}"
         end
       else
-        env.logger.info "#{definition_file} not found"
+        env.logger.fatal("#{definition_file} not found")
+        raise Veewee::DefinitionNotExist,"#{definition_file} not found"
+      end
+
+      if definition.valid?
+        return definition
+      else
+        env.logger.fatal("Invalid Definition")
+        raise Veewee::DefinitionError,"Invalid Definition"
       end
-      veewee_definition
     end
 
-    def verify_ostype
+    def exists?
+      filename=File.join(path,"definition.rb")
+      unless File.exists?(filename)
+        return false
+      end
+
+      return true
+    end
+
+    def valid?
+      # Check if the definition exists?
+      unless exists?
+        return false
+      end
+
+      # Check ostype to be valid
+      unless ostype_valid?
+        return false
+      end
 
-      unless env.config.ostypes.has_key?(@os_type_id)
-        raise "The ostype: #{@os_type_id} is not available"
+      # Postinstall files require a valid user and password
+      unless self.postinstall_files.nil?
+        if self.ssh_user.nil? || self.ssh_password.nil?
+          return false
+        end
       end
 
+      return true
     end
 
+    private
+    def ostype_valid?
+      unless env.ostypes.has_key?(@os_type_id)
+        env.ui.info("The ostype: #{@os_type_id} is not available")
+        return false
+      else
+        return true
+      end
+    end
+
+    def method_missing(m, *args, &block)
+      env.logger.info "There's no attribute #{m} defined for definition #{@name}-- ignoring it"
+    end
 
   end #End Class
 end #End Module

data/lib/veewee/definitions.rb

@@ -0,0 +1,156 @@
+require 'veewee/definition'
+require 'veewee/templates'
+require 'veewee/template'
+
+module Veewee
+  class Definitions
+
+    attr_accessor :env
+
+    def initialize(env)
+      @env=env
+      return self
+    end
+
+    def [](name)
+      begin
+        definition=Veewee::Definition.load(name,env)
+        return definition
+      rescue Veewee::DefinitionNotExist
+        return nil
+      end
+    end
+
+    # Fetch all definitions
+    def each(&block)
+      definitions=Hash.new
+
+      env.logger.debug("[Definition] Searching #{env.definition_dir} for definitions:")
+      subdirs=Dir.glob("#{env.definition_dir}/*")
+
+      subdirs.each do |sub|
+        name=File.basename(sub)
+        env.logger.debug("[Definition] possible definition '#{name}' found")
+        begin
+          definitions[name]=Veewee::Definition.load(name,env)
+        rescue Veewee::DefinitionError => ex
+          env.logger.debug("[Definition] failed to load definition from directory '#{name}' #{ex}")
+        end
+      end
+
+      if definitions.length==0
+        env.logger.debug("[Definition] no definitions found") 
+      end
+
+      definitions.each(&block)
+    end
+
+    # This function 'defines'/'clones'/'instantiates a template:
+    # It copies from a template dir with template_name
+    #           to a new definition dir with definition_name
+    #
+    # Options are : :force => true to overwrite an existing definition
+    #
+    # Returns definition object
+
+
+    def define(definition_name,template_name,options = {})
+
+      # Default is not to overwrite
+      options = {'force' => false}.merge(options)
+
+      env.logger.debug("Forceflag : #{options['force']}")
+
+      # Check if template exists
+      template=env.templates[template_name]
+      if template.nil?
+        env.logger.fatal("Template '#{template_name}' does not exist")
+        raise Veewee::TemplateError, "Template '#{template_name}' does not exist"
+      else
+        env.logger.debug("Template '#{template_name}' exists")
+      end
+
+      create_definition_dir_if_needed
+
+      # Check if definition does not exist
+      definition=env.definitions[definition_name]
+      unless definition.nil?
+        env.logger.debug("Definition '#{definition_name}' exists")
+        if options['force']==true
+          self.undefine(definition_name,options)
+        else
+           raise Veewee::DefinitionError,"Definition #{definition_name} already exists and no force option was given"
+        end
+      end
+
+      env.logger.debug("Creating definition #{definition_name} in directory '#{env.definition_dir}' ")
+      dst_dir="#{File.join(env.definition_dir,definition_name)}"
+      FileUtils.mkdir(dst_dir)
+      env.logger.debug("Definition Directory '#{File.join(env.definition_dir,definition_name)}' succesfuly created")
+
+      # Start copying/cloning the directory of the template to the definition directory
+      begin
+        env.logger.debug("Starting copy '#{template.path}' to '#{dst_dir}'")
+        FileUtils.cp_r(template.path+"/.",dst_dir)
+        env.logger.debug("Copy '#{template.path}' to '#{dst_dir}' succesfull")
+      rescue Exception => ex
+        env.logger.fatal("Copy '#{template.path}' to #{dst_dir}' failed: #{ex}")
+        raise Veewee::Error , "Copy '#{template.path}' to #{dst_dir}' failed: #{ex}"
+      end
+
+      definition=env.definitions[definition_name]
+      return definition
+    end
+
+
+    # This function undefines/removes the definition by removing the directoy with definition_name
+    # under env.definition_dir
+    def undefine(definition_name,options = {})
+      definition=env.definitions[definition_name]
+      unless definition.nil?
+
+        #TODO: Needs to be more defensive!!
+        env.logger.debug("[Undefine] About to remove '#{definition.path} for '#{definition_name}'")
+        begin
+          if File.exists?(File.join(definition.path,"definition.rb"))
+            FileUtils.rm_rf(definition.path)
+          else
+            env.logger.fatal("Aborting delete: The directory definition.path does not contain a definition.rb file")
+            raise Veewee::DefinitionError,"Aborting delete: The directory definition.path does not contain a definition.rb file"
+          end
+        rescue Exception => ex
+          env.logger.fatal("Removing '#{definition.path} for '#{definition_name}' failed: #{ex}")
+          raise Veewee::Error, "Removing '#{definition.path }for '#{definition_name}' failed: #{ex}"
+        end
+        env.logger.debug("Removing '#{definition.path} for '#{definition_name}' succesful")
+      else
+        raise Veewee::DefinitionError,"Definition '#{definition_name}' does not exist"
+      end
+    end
+
+    def create_definition_dir_if_needed
+      # Check if definition_dir already exists
+      unless File.exists?(env.definition_dir)
+        env.logger.debug("Creating definition base directory '#{env.definition_dir}' ")
+        FileUtils.mkdir(env.definition_dir)
+        env.logger.debug("Definition base directory '#{env.definition_dir}' succesfuly created")
+      end
+
+      if File.writable?(env.definition_dir)
+        env.logger.debug("DefinitionDir '#{env.definition_dir}' is writable")
+        if File.exists?("#{env.definition_dir}")
+          env.logger.debug("DefinitionDir '#{env.definition_dir}' already exists")
+        else
+          env.logger.debug("DefinitionDir '#{env.definition_dir}' does not exist, creating it")
+          FileUtils.mkdir(definition_dir)
+          env.logger.debug("DefinitionDir '#{env.definition_dir}' succesfuly created")
+        end
+      else
+        env.logger.fatal("DefinitionDir '#{definition_dir}' is not writable")
+        raise Veewee::Error, "DefinitionDir '#{definition_dir}' is not writable"
+      end
+    end
+
+
+  end
+end

data/lib/veewee/environment.rb

@@ -1,4 +1,7 @@
 require 'veewee/config'
+require 'veewee/definitions'
+require 'veewee/templates'
+require 'veewee/providers'
 
 require 'logger'
 
@@ -19,16 +22,16 @@ module Veewee
 
     # This initializes a new Veewee Environment
     # settings argument is a hash with the following options
-    # - :definition_path  : paths to look for definitions
-    # - :definition_dir   : where new definition will be created
+    # - :definition_dir   : where definitions are located
     # - :template_path    : paths that contains the template definitions that come with the veewee gem, defaults to the path relative to the gemfiles
     # - :iso_dir         : directory to look for iso files, defaults to $environment_dir/iso
     # - :validation_dir  : directory that contains a list of validation tests, that can be run after building a box
     # - :tmp_dir         : directory that will be used for creating temporary files, needs to be rewritable, default to $environment_dir/tmp
-
-    attr_accessor :template_path,:definition_path, :definition_dir
-
-    attr_accessor :iso_dir,:tmp_dir
+    attr_accessor :template_path
+    attr_accessor :definition_dir
+    attr_accessor :iso_dir
+    attr_accessor :validation_dir
+    attr_accessor :tmp_dir
 
     # The {UI} Object to communicate with the outside world
     attr_writer :ui
@@ -36,15 +39,28 @@ module Veewee
     # The configuration as loaded
     attr_accessor :config
 
+    # Hash element of all definitions available
+    attr_accessor :definitions
+
+    # Hash element of all templates available
+    attr_accessor :templates
+
+    # Hash element of all templates available
+    attr_accessor :providers
+
+    # Hash elelement of all OStypes
+    attr_reader :ostypes
+
     def initialize(options={})
 
-      cwd= options.has_key?(:cwd) ? options[:cwd] : Dir.pwd
+      cwd = ENV['VEEWEE_DIR'] || Dir.pwd
+      # If a cwd was provided as option it overrules the default
+      cwd = options[:cwd] if options.has_key?(:cwd)
 
       defaults={
         :cwd => cwd,
         :veewee_filename => "Veeweefile",
         :loglevel => :info,
-        :definition_path => [File.join(cwd,"definitions")],
         :definition_dir => File.join(cwd,"definitions"),
         :template_path => [File.expand_path(File.join(File.dirname(__FILE__),"..","..",'templates')),"templates"],
         :iso_dir => File.join(cwd,"iso"),
@@ -57,209 +73,29 @@ module Veewee
       # We need to set this variable before the first call to the logger object
       if options.has_key?("debug")
         ENV['VEEWEE_LOG']="STDOUT"
-        ui.info "Debugging enabled"
       end
 
-
       logger.info("environment") { "Environment initialized (#{self})" }
 
       # Injecting all variables of the options and assign the variables
       options.each do |key, value|
         instance_variable_set("@#{key}".to_sym, options[key])
         logger.info("environment") { " - #{key} : #{options[key]}" }
-
-      end
-
-      return self
-    end
-
-
-    #---------------------------------------------------------------
-    # Retrieval Methods
-    #---------------------------------------------------------------
-
-    # Traverses path to see which exist or not
-    # and checks if a definition.rb is available
-    def valid_paths(paths)
-      valid_paths=paths.collect { |path|
-        if File.exists?(path) && File.directory?(path)
-          logger.info "Definition path #{path} exists"
-          File.expand_path(path)
-        else
-          logger.info "Definition path #{path} does not exist, skipping"
-          nil
-        end
-      }
-      return valid_paths.compact
-    end
-
-    # This function retrieves all the templates given the @template_dir in the current Environment object
-    # A valid template has to contain the file definition.rb
-    # The name of the template is the name of the parent directory of the definition.rb file
-    #
-    # returns a hash of 'template name' => 'path'
-    def get_template_paths
-
-      templates=Hash.new
-
-      valid_paths(template_path).each do |template_dir|
-
-      logger.debug("[Template] Searching #{template_dir} for templates")
-
-      subdirs=Dir.glob("#{template_dir}/*")
-      subdirs.each do |sub|
-        if File.directory?("#{sub}")
-          definition=Dir.glob("#{sub}/definition.rb")
-          if definition.length!=0
-            name=sub.sub(/#{template_dir}\//,'')
-              logger.debug("[Template] template '#{name}' found")
-            templates[name]=File.join(template_dir,name)
-          end
-        end
       end
-    end
 
-      return templates
-    end
+      # Definitions
+      @definitions=Veewee::Definitions.new(self)
+      @templates=Veewee::Templates.new(self)
+      @providers=Veewee::Providers.new(self)
 
-    def list_ostypes
-      @ui.info "The following are possible os_types you can use in your definition.rb files"
+      # Read ostypes
+      yamlfile=File.join(File.dirname(__FILE__),"config","ostypes.yml")
+      logger.info "Reading ostype yamlfile #{yamlfile}"
+      @ostypes=YAML.load_file(yamlfile)
 
-      config.ostypes.each { |key,value|
-        @ui.info "#{key}"
-      }
+      return self
     end
 
-     # This function returns a hash of names of all the definitions that are in the @definition_dir,
-     # given the @definition_dir in the current Environment object
-     # The name of the definition is the name of a sub-directory in the @definition_dir
-     def get_definition_paths
-
-       definitions=Hash.new
-
-       valid_paths(definition_path).each do |definition_dir|
-
-       logger.debug("[Definition] Searching #{definition_dir} for definitions:")
-
-       subdirs=Dir.glob("#{definition_dir}/*")
-       subdirs.each do |sub|
-         name=File.basename(sub)
-         logger.debug("[Definition] definition '#{name}' found")
-         definitions[name]=File.join(definition_dir,name)
-       end
-      end
-       logger.debug("[Definition] no definitions found") if definitions.length==0
-
-       return definitions
-     end
-
-     # Based on the definition_dir set in the current Environment object
-      # it will load the definition based on the name
-      #
-      # returns a Veewee::Definition
-      def get_definition(name)
-        definition=Veewee::Definition.load(name,self)
-        return definition
-      end
-
-     # This function 'defines'/'clones'/'instantiates a template
-      # by copying the template directory to a directory with the definitionname under the @defintion_dir
-      # Options are : :force => true to overwrite an existing definition
-      #
-      # Returns nothing
-      def define(definition_name,template_name,define_options = {})
-        # Default is not to overwrite
-        define_options = {'force' => false}.merge(define_options)
-
-        logger.debug("Forceflag : #{define_options['force']}")
-
-        # Check if template exists
-        template_exists=get_template_paths.has_key?(template_name)
-        template_dir=get_template_paths[template_name]
-
-        unless template_exists
-          logger.fatal("Template '#{template_name}' does not exist")
-          exit -1
-        else
-          logger.debug("Template '#{template_name}' exists")
-        end
-
-        # Check if definition exists
-        definition_exists=get_definition_paths.has_key?(definition_name)
-        definition_dir=get_definition_paths[definition_name]
-
-        if definition_exists
-          logger.debug("Definition '#{definition_name}' already exists")
-
-          if !define_options['force']
-            logger.fatal("No force was specified, bailing out")
-            exit -1
-          else
-            logger.debug("Force option specified, cleaning existing directory")
-            undefine(definition_name)
-          end
-
-        else
-          logger.debug("Definition '#{definition_name}' does not yet exist")
-        end
-
-        unless File.exists?(@definition_dir)
-          logger.debug("Creating definition base directory '#{@definition_dir}' ")
-          FileUtils.mkdir(@definition_dir)
-          logger.debug("Definition base directory '#{@definition_dir}' succesfuly created")
-        end
-
-        if File.writable?(@definition_dir)
-          logger.debug("DefinitionDir '#{@definition_dir}' is writable")
-          if File.exists?("#{@definition_dir}")
-            logger.debug("DefinitionDir '#{@definition_dir}' already exists")
-          else
-            logger.debug("DefinitionDir '#{@definition_dir}' does not exist, creating it")
-            FileUtils.mkdir(definition_dir)
-            logger.debug("DefinitionDir '#{@definition_dir}' succesfuly created")
-          end
-          logger.debug("Creating definition #{definition_name} in directory '#{@definition_dir}' ")
-          FileUtils.mkdir(File.join(@definition_dir,definition_name))
-          logger.debug("Definition Directory '#{File.join(@definition_dir,definition_name)}' succesfuly created")
-
-        else
-          logger.fatal("DefinitionDir '#{definition_dir}' is not writable")
-          exit -1
-        end
-
-        # Start copying/cloning the directory of the template to the definition directory
-        begin
-          logger.debug("Starting copy '#{template_dir}' to '#{File.join(@definition_dir,definition_name)}'")
-          FileUtils.cp_r(template_dir+"/.","#{File.join(@definition_dir,definition_name)}")
-          logger.debug("Copy '#{template_dir}' to '#{File.join(@definition_dir,definition_name)}' succesfull")
-        rescue Exception => ex
-          logger.fatal("Copy '#{template_dir}' to #{File.join(@definition_dir,definition_name)}' failed: #{ex}")
-          exit -1
-        end
-      end
-
-
-      # This function undefines/removes the definition by removing the directoy with definition_name
-      # under @definition_dir
-      def undefine(definition_name,undefine_options = {})
-        definition_dir=get_definition_paths[definition_name]
-        unless definition_dir.nil?
-          #TODO: Needs to be more defensive!!
-          logger.debug("[Undefine] About to remove '#{definition_dir} for '#{definition_name}'")
-          begin
-            FileUtils.rm_rf(definition_dir)
-          rescue Exception => ex
-            logger.fatal("Removing '#{definition_dir} for '#{definition_name}' failed")
-            exit -1
-          end
-          logger.debug("Removing '#{definition_dir} for '#{definition_name}' succesful")
-        else
-          logger.fatal("Definition '#{definition_name}' does not exist")
-          exit -1
-        end
-      end
-
-
     #---------------------------------------------------------------
     # Config Methods
     #---------------------------------------------------------------
@@ -309,59 +145,59 @@ module Veewee
     end
 
     def load_config!
-        @config=Config.new({:env => self}).load_veewee_config()
+      @config=Config.new({:env => self}).load_veewee_config()
 
-        return self
+      return self
     end
 
-      # Reloads the configuration of this environment.
-      def reload_config!
-        @config = nil
-        load_config!
-        self
-      end
-
-      # Makes a call to the CLI with the given arguments as if they
-      # came from the real command line (sometimes they do!). An example:
-      #
-      #     env.cli("package", "--veeweefile", "Veeweefie")
-      #
-      def cli(*args)
-        CLI.start(args.flatten, :env => self)
-      end
+    # Reloads the configuration of this environment.
+    def reload_config!
+      @config = nil
+      load_config!
+      self
+    end
 
-      def resource
-        "veewee"
-      end
+    # Makes a call to the CLI with the given arguments as if they
+    # came from the real command line (sometimes they do!). An example:
+    #
+    #     env.cli("package", "--veeweefile", "Veeweefie")
+    #
+    def cli(*args)
+      CLI.start(args.flatten, :env => self)
+    end
 
-      # Accesses the logger for Vagrant. This logger is a _detailed_
-      # logger which should be used to log internals only. For outward
-      # facing information, use {#ui}.
-      #
-      # @return [Logger]
-      def logger
-        return @logger if @logger
+    def resource
+      "veewee"
+    end
 
-        # Figure out where the output should go to.
+    # Accesses the logger for Veewee. This logger is a _detailed_
+    # logger which should be used to log internals only. For outward
+    # facing information, use {#ui}.
+    #
+    # @return [Logger]
+    def logger
+      return @logger if @logger
+
+      # Figure out where the output should go to.
+      output = nil
+      if ENV["VEEWEE_LOG"] == "STDOUT"
+        output = STDOUT
+      elsif ENV["VEEWEE_LOG"] == "NULL"
         output = nil
-        if ENV["VEEWEE_LOG"] == "STDOUT"
-          output = STDOUT
-        elsif ENV["VEEWEE_LOG"] == "NULL"
-          output = nil
-        elsif ENV["VEEWEE_LOG"]
-          output = ENV["VEEWEE_LOG"]
-        else
-          output = nil #log_path.join("#{Time.now.to_i}.log")
-        end
-
-        # Create the logger and custom formatter
-        @logger = ::Logger.new(output)
-        @logger.formatter = Proc.new do |severity, datetime, progname, msg|
-          "#{datetime} - #{progname} - [#{resource}] #{msg}\n"
-        end
-
-        @logger
+      elsif ENV["VEEWEE_LOG"]
+        output = ENV["VEEWEE_LOG"]
+      else
+        output = nil #log_path.join("#{Time.now.to_i}.log")
       end
 
-    end #Class
-  end #Module
+      # Create the logger and custom formatter
+      @logger = ::Logger.new(output)
+      @logger.formatter = Proc.new do |severity, datetime, progname, msg|
+        "#{datetime} - #{progname} - [#{resource}] #{msg}\n"
+      end
+
+      @logger
+    end
+
+  end #Class
+end #Module