veewee-atlassian 0.3.11

data/lib/veewee/definitions.rb

@@ -0,0 +1,172 @@
+require 'grit'
+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']}")
+
+      git_template = false
+      # Check if the template is a git repo
+      if template_name.start_with?("git://")
+        git_template = true
+      end
+
+      # Check if template exists
+      template = env.templates[template_name]
+      if template.nil? and ! git_template
+        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.info("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
+      if (git_template)
+        begin
+          env.logger.info("Starting git clone #{template_name} #{dst_dir}")
+          g = Grit::Git.new(dst_dir)
+          g.clone({ :timeout => false }, template_name, dst_dir)
+        rescue Exception => ex
+          err = "git clone #{template_name} #{dst_dir} failed: #{ex}"
+          env.logger.fatal(err)
+          raise Veewee::DefinitionError, err
+        end
+      else
+        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}' succesful")
+        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
+      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

@@ -0,0 +1,213 @@
+require 'veewee/config'
+require 'veewee/definitions'
+require 'veewee/templates'
+require 'veewee/providers'
+
+require 'logger'
+
+module Veewee
+
+  # Represents a single Veewee environment. A "Veewee environment" is
+  # defined as basically a folder with a "Veeweefile". This class allows
+  # access to the VMs, CLI, etc. all in the scope of this environment
+  class Environment
+
+    # The `cwd` that this environment represents
+    attr_accessor :cwd
+
+    # The valid name for a Veeweefile for this environment
+    attr_accessor :veewee_filename
+
+    attr_accessor :loglevel
+
+    # This initializes a new Veewee Environment
+    # settings argument is a hash with the following options
+    # - :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
+    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
+
+    # 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 = 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_dir => File.join(cwd, "definitions"),
+        :template_path => [File.expand_path(File.join(File.dirname(__FILE__), "..", "..", 'templates')), "templates"],
+        :iso_dir => File.join(cwd, "iso"),
+        :validation_dir => File.join(File.expand_path(File.join(File.dirname(__FILE__), "..", "..")), "validation"),
+        :tmp_dir => File.join(cwd, "tmp")
+      }
+
+      options = defaults.merge(options)
+      veeweefile_config = defaults.keys.inject({}) do |memo, obj|
+        if config.env.methods.include?(obj) && !config.env.send(obj).nil?
+          memo.merge({ obj => config.env.send(obj) })
+        else
+          memo
+        end
+      end
+      options = options.merge(veeweefile_config)
+
+      # We need to set this variable before the first call to the logger object
+      if options.has_key?("debug")
+        if options["debug"] == true
+          ENV['VEEWEE_LOG'] = "STDOUT"
+        end
+      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
+
+      # Definitions
+      @definitions = Veewee::Definitions.new(self)
+      @templates = Veewee::Templates.new(self)
+      @providers = Veewee::Providers.new(self, options)
+
+      # Read ostypes
+      yamlfile = File.join(File.dirname(__FILE__), "config", "ostypes.yml")
+      logger.info "Reading ostype yamlfile #{yamlfile}"
+      @ostypes = YAML.load_file(yamlfile)
+
+      return self
+    end
+
+    #---------------------------------------------------------------
+    # Config Methods
+    #---------------------------------------------------------------
+
+    # The configuration object represented by this environment. This
+    # will trigger the environment to load if it hasn't loaded yet (see
+    # {#load!}).
+    #
+    # @return [Config::Top]
+    def config
+      load! if !loaded?
+      @config
+    end
+
+    # Returns the {UI} for the environment, which is responsible
+    # for talking with the outside world.
+    #
+    # @return [UI]
+    def ui
+      @ui ||= UI.new(self)
+    end
+
+    #---------------------------------------------------------------
+    # Load Methods
+    #---------------------------------------------------------------
+
+    # Returns a boolean representing if the environment has been
+    # loaded or not.
+    #
+    # @return [Bool]
+    def loaded?
+      !!@loaded
+    end
+
+    # Loads this entire environment, setting up the instance variables
+    # such as `vm`, `config`, etc. on this environment. The order this
+    # method calls its other methods is very particular.
+    def load!
+      if !loaded?
+        @loaded = true
+
+        logger.info("environment") { "Loading configuration..." }
+        load_config!
+
+        self
+      end
+    end
+
+    def load_config!
+      @config = Config.new({ :env => self }).load_veewee_config()
+
+      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
+
+    def resource
+      "veewee"
+    end
+
+    # 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
+      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
+    end
+
+  end #Class
+end #Module

data/lib/veewee/error.rb

@@ -0,0 +1,38 @@
+module Veewee
+  class Error < StandardError
+    attr_reader :orginal
+
+    def initialize(msg, original = $!)
+      super(msg)
+      @original = original
+    end
+
+  end
+
+  class DefinitionError < Error
+  end
+
+  class DefinitionNotExist < DefinitionError
+  end
+
+  class TemplateError < Error
+  end
+
+  class SshError < Error
+  end
+
+  class WinrmError < Error
+  end
+end
+
+#Usage (from the exceptional ruby book)
+#begin
+#   begin
+#     raise "Error A"
+#   rescue => error
+#     raise MyError, "Error B"
+#   end
+#rescue => error 
+#   env.ui.info "Current failure: #{error.inspect}"
+#   env.ui.info "Original failure: #{error.original.inspect}"
+#end

data/lib/veewee/provider/core/box.rb

@@ -0,0 +1,104 @@
+require 'veewee/provider/core/helper/tcp'
+require 'veewee/provider/core/helper/ssh'
+require 'veewee/provider/core/helper/web'
+require 'veewee/provider/core/helper/shell'
+require 'veewee/provider/core/helper/iso'
+require 'veewee/provider/core/helper/comm'
+
+require 'veewee/provider/core/box/build'
+require 'veewee/provider/core/box/scp'
+require 'veewee/provider/core/box/copy'
+require 'veewee/provider/core/box/exec'
+require 'veewee/provider/core/box/poweroff'
+require 'veewee/provider/core/box/halt'
+require 'veewee/provider/core/box/sudo'
+require 'veewee/provider/core/box/ssh'
+require 'veewee/provider/core/box/issh'
+
+
+require 'veewee/provider/core/box/floppy'
+require 'veewee/provider/core/box/validate_tags'
+
+module Veewee
+  module Provider
+    module Core
+      class  Box
+        attr_accessor :definition
+        attr_accessor :env
+        attr_accessor :name
+        attr_accessor :provider
+
+        include ::Veewee::Provider::Core::Helper::Tcp
+        include ::Veewee::Provider::Core::Helper::Web
+        include ::Veewee::Provider::Core::Helper::Shell
+        include ::Veewee::Provider::Core::Helper::Ssh
+        include ::Veewee::Provider::Core::Helper::Comm
+        include ::Veewee::Provider::Core::Helper::Iso
+
+        include ::Veewee::Provider::Core::BoxCommand
+
+        def ui
+          return @_ui if defined?(@_ui)
+          @_ui = @env.ui.dup
+          @_ui.resource = @name
+          @_ui
+        end
+
+        def initialize(name,env)
+          @env=env
+          @name=name
+          self.set_definition(name)
+        end
+
+        def gem_available?(gemname)
+          env.logger.info "Checking for gem #{gemname}"
+          available=false
+          begin
+            available=true unless Gem::Specification::find_by_name("#{gemname}").nil?
+          rescue Gem::LoadError
+            env.logger.info "Error loading gem #{gemname}"
+            available=false
+          rescue
+            env.logger.info "Falling back to old syntax for #{gemname}"
+            available=Gem.available?("#{gemname}")
+            env.logger.info "Old syntax #{gemname}.available? #{available}"
+          end
+          return available
+        end
+
+        def set_definition(definition_name)
+          @definition=env.definitions[definition_name]
+
+          unless @definition.nil?
+            # We check for windows as em-winrm is not available on ruby1.9
+            is_windows =  @definition.os_type_id.start_with?('Windows')
+
+            # On windows systems
+            if is_windows
+              # Check if winrm is available
+              if gem_available?('em-winrm')
+                require 'veewee/provider/core/box/winrm'
+                require 'veewee/provider/core/helper/winrm'
+                require 'veewee/provider/core/box/wincp'
+
+                self.class.send(:include, ::Veewee::Provider::Core::Helper::Winrm)
+              else
+                raise Veewee::Error, "\nTo build a windows basebox you need to install the gem 'em-winrm' first"
+              end
+            end
+          else
+            raise Veewee::Error, "definition '#{definition_name}' does not exist. Are you sure you are in the top directory?"
+          end
+
+          return self
+        end
+
+        def reload
+          @raw=nil
+        end
+
+
+      end #End Class
+    end # End Module
+  end # End Module
+end # End Module