kameleon-builder 2.1.3 → 2.2.0

data/.env

@@ -13,11 +13,7 @@ QEMU_MONITOR_PORT=11023
 
 
 function kameleon {
-    sudo -E BUNDLE_GEMFILE=$ROOT_PROJECT/Gemfile bundle exec kameleon $@
-}
-
-function runtest {
-    sudo -E BUNDLE_GEMFILE=$ROOT_PROJECT/Gemfile bundle exec rake $@
+    BUNDLE_GEMFILE=$ROOT_PROJECT/Gemfile bundle exec kameleon $@
 }
 
 function devrun_chroot_clean() {
@@ -88,7 +84,7 @@ function devrun_qemu() {
 function devrun_build() {
     KAMELEON_WORKDIR=${KAMELEON_WORKDIR:-"/tmp/kameleon/"}
     RECIPE_DEV_NAME=${RECIPE_DEV_NAME:-"mymachine"}
-    TEMPLATE=${1:-"debian7"}
+    TEMPLATE=${1:-"chroot/debian7"}
     mkdir -p $KAMELEON_WORKDIR && cd $KAMELEON_WORKDIR
     cmd="kameleon new $RECIPE_DEV_NAME $TEMPLATE  \
          && kameleon build $RECIPE_DEV_NAME.yaml"

data/CHANGELOG.rst

@@ -1,9 +1,81 @@
 Kameleon CHANGELOG
 ==================
 
+version 2.2.0
+-------------
+
+Released on July 20th 2014
+
+- [proxy cache] Added ``proxy_cache`` recipe option to context_in/out to enable
+  persistant cache for every context
+- [proxy cache] Added ``--cache-path`` CLI option to set different cache directory
+- [proxy cache] Shared cache directory between recipes by default
+- [proxy cache] No more internal cache for debootstrap
+- [proxy_cache] Polipo does not use default config file anymore
+- [proxy_cache] Recipe is now stored in cache at the end
+- [package] Removed diffy from dependencies
+- [package] Removed log4r-color from dependencies
+- [core] Rewrote checkpoint mechanism. (allow to run multiple commands)
+- [core] Added ``--script`` CLI option to enable non-interactive mode
+- [core] Added ``reload_context`` command that reloads the context from the recipe
+- [core] From now on, Kameleon tries to clean all contexts without blocking the shell
+- [core] Improved cleaning contexts upon interruption
+- [core] If microstep is marked as ``redo`` or ``skip`` (on checkpoint), the ID will be independent from other steps
+- [template] Grouped templates by virtualization tools
+- [template] Removed extlinux timeout for debian
+- [template] Configured apt to install recommended packages by default
+- [template] Added architecture type in templates description
+- [template] Forced killing qemu with sigterm signal
+- [template] Removed ssh ControlPath option
+- [template] Used parted tool in script mode
+- [template] Added a timeout during startup and shutdown VMs
+- [template] Restored eth0 as default interface in Fedora (net.ifnames=0 biosdevname=0)
+- [template] Ensured that the checkpoint was disabled at the beginning of the recipe
+- [template] Make sure that qemu is stopped at the end
+- [template] Replaced netcat by socat
+- [template] Removed duplicated ubuntu repository (restricted)
+- [template] Used a debian-jessie iso to bootstrap the out_context with a minimal linux system
+- [template] Hide default kameleon state files
+- [template] Enabled debug mode with ``KAMELEON_DEBUG=1`` environment variable
+- [template] Added ``download_file`` alias that uses curl/wget or python to download files
+- [template] Enabled kvm only if available
+- [template] Do not run qemu with nohup (Use ``-daemonize`` instead)
+- [template] Improved context_out/in log readability
+- [template] Removed fedora-rawhide templates
+- [template] Added new templates :
+
+  - qemu/archlinux-desktop-i686
+  - qemu/archlinux-i686
+  - qemu/centos6.5-x86_64
+  - qemu/centos7-x86_64
+  - qemu/debian8-amd64
+  - vagrant/debian7-amd64
+  - virtualbox/archlinux-desktop-i686
+  - virtualbox/archlinux-desktop-x86_64
+  - virtualbox/archlinux-i686
+  - virtualbox/archlinux-x86_64
+  - virtualbox/centos6.5-i386
+  - virtualbox/centos6.5-x86_64
+  - virtualbox/centos7-x86_64
+  - virtualbox/debian7-amd64
+  - virtualbox/debian7-desktop-amd64
+  - virtualbox/debian7-i386
+  - virtualbox/debian7-kameleon-amd64
+  - virtualbox/debian7-oar-amd64
+  - virtualbox/debian8-amd64
+  - virtualbox/debian8-i386
+  - virtualbox/fedora20-x86_64
+  - virtualbox/ubuntu-12.04-amd64
+  - virtualbox/ubuntu-12.04-desktop-amd64
+  - virtualbox/ubuntu-14.04-amd64
+  - virtualbox/ubuntu-14.04-desktop-amd64
+
+
 version 2.1.3
 -------------
 
+Released on June 16th 2014
+
  - [core] Loading dependent gems based on the users ruby version
  - [core] Getting back compatibility with ruby 1.8.7
  - [core] Don't fail if context is not ready
@@ -14,7 +86,7 @@ version 2.1.3
 version 2.1.0
 -------------
 
-Released on May 12th 2014
+Released on June 12th 2014
 
 - [core] Fixed psych yaml parsing (#1)
 - [core] Changed option ``--no-no-color`` to ``--color``
@@ -95,3 +167,4 @@ version 2.0.0
 Released on February 17th 2014
 
 Initial public release of kameleon 2
+

data/Gemfile

@@ -1,4 +1,22 @@
-source 'https://rubygems.org'
+source "https://rubygems.org"
+
+gem "syck", :platforms => [:ruby_20,  :ruby_21]
+
+group :development do
+  gem "pry"
+  gem "rake"
+  platforms :ruby_19, :ruby_20 do
+    gem "pry-debugger"
+    gem "pry-stack_explorer"
+  end
+end
+
+group :test do
+  gem "coveralls", ">= 0.5.7", :require => false
+  gem "rspec", ">= 3"
+  gem "rspec-mocks", ">= 3"
+  gem "rubocop", ">= 0.19", :platforms => [:ruby_19, :ruby_20, :ruby_21]
+  gem "simplecov", :require => false
+end
 
-# Specify your gem's dependencies in kameleon.gemspec
 gemspec

data/README.rst

@@ -11,23 +11,36 @@ you can probably do a lot more than that.
 Installation
 ------------
 
+Gem package
+-----------
+
 To install the latest release from `RubyGems`_:
 
 .. _RubyGems: https://rubygems.org/gems/kameleon-builder
 
 ::
 
-    gem install kameleon-builder --pre
-
-Or from source:
+    gem install kameleon-builder
 
-::
+Or from source::
 
-    git clone https://github.com/oar-team/kameleon.git
-    cd kameleon
+    git clone https://github.com/oar-team/kameleon.git && cd kameleon
     gem build kameleon-builder.gemspec
-    gem install kameleon-builder-<version>.gem
+    gem install kameleon-builder-*.gem
+
+On debian based distribution be sure to install the ``ruby-dev`` package first
+
 
+Dist packages
+-------------
+
+These packages contain Kameleon and all its dependencies (Ruby, polipo and all
+gems with their native extensions already compiled). These packages are made
+with `omnibus project`_.
+
+.. _`omnibus project`: https://github.com/opscode/omnibus-ruby
+
+Please download the package in the following `page <http://kameleon.imag.fr/installation.html#dist-packages>`_
 
 -----
 Usage
@@ -44,19 +57,19 @@ Just type
 ::
 
     Commands:
-      kameleon build [RECIPE_NAME]                        # Builds the appliance from the recipe
-      kameleon checkpoints [RECIPE_NAME]                  # Lists all availables checkpoints
-      kameleon clear [RECIPE_NAME]                        # Cleaning out context and removing all checkpoints
-      kameleon help [COMMAND]                             # Describe available commands or one specific command
-      kameleon new [RECIPE_NAME] -t, --template=TEMPLATE  # Creates a new recipe
-      kameleon templates                                  # Lists all defined templates
-      kameleon version                                    # Prints the Kameleon's version information
+      kameleon build [RECIPE_PATH]                # Builds the appliance from the given recipe
+      kameleon checkpoints [RECIPE_PATH]          # Lists all availables checkpoints
+      kameleon clean [RECIPE_PATH]                # Cleaning 'out' and 'local' contexts and removing all checkpoints
+      kameleon help [COMMAND]                     # Describe available commands or one specific command
+      kameleon import [TEMPLATE_NAME]             # Imports the given template
+      kameleon new [RECIPE_NAME] [TEMPLATE_NAME]  # Creates a new recipe
+      kameleon templates                          # Lists all defined templates
+      kameleon version                            # Prints the Kameleon's version information
 
     Options:
-          [--no-color]             # Disable colorization in output
-          [--debug]                # Enable debug output
-      -w, [--workspace=WORKSPACE]  # Change the kameleon current work directory. (The folder containing your
-                                   # recipes folder). Default : ./
+      [--color], [--no-color]  # Enable colorization in output
+                               # Default: true
+      [--debug], [--no-debug]  # Enable debug output
 
 First, you should select a template. To see the available templates use:
 
@@ -64,13 +77,11 @@ First, you should select a template. To see the available templates use:
 
     kameleon templates
 
-Then, create a new recipe from the template you've just choose. This will
-create a `recipes` folder in the current directory. (use `-w` option to set a
-different workspace).
+Then, create a new recipe from the template you've just choose.
 
 ::
 
-    kameleon new my_test_recipe -t template_name
+    kameleon new my_test_recipe template_name
 
 Then build your new recipe with the build command:
 
@@ -78,18 +89,17 @@ Then build your new recipe with the build command:
 
     kameleon build my_test_recipe
 
-A `builds` directory was created and contains your new image!
+A ``builds`` directory will be created and will contain your new image!
 
 To go further, it is highly recommended you start with the `Getting Started`_ guide.
 
 
-.. _Getting Started: http://kameleon.readthedocs.org/en/latest/getting_started.html
+.. _Getting Started: http://kameleon.imag.fr/getting_started.html
 
 ------------
 Contributing
 ------------
 
-
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)

data/Thorfile

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require "bundler"
+require "thor/rake_compat"
+
+class Default < Thor
+  include Thor::RakeCompat
+  Bundler::GemHelper.install_tasks
+
+  desc "build", "Build kameleon-#{Kameleon::VERSION}.gem into the pkg directory"
+  def build
+    Rake::Task["build"].execute
+  end
+
+  desc "install", "Build and install kameleon-#{Kameleon::VERSION}.gem into system gems"
+  def install
+    Rake::Task["install"].execute
+  end
+
+  desc "release", "Create tag #{Kameleon::VERSION} and build and push kameleon-#{Kameleon::VERSION}.gem to Rubygems"
+  def release
+    Rake::Task["release"].execute
+  end
+
+  desc "spec", "Run RSpec code examples"
+  def spec
+    exec "rspec spec"
+  end
+end

data/contrib/kameleon_bashrc.sh

@@ -136,3 +136,64 @@ else
     alias ls='ls -G'
 fi
 fi
+
+function __download {
+    echo "Downloading: $1..."
+    if which curl >/dev/null; then
+        curl -# -L --retry 999 --retry-max-time 0 "$1" -o "$2" 2>&1
+    else
+        fail "curl is missing, trying with wget..."
+        if which wget >/dev/null; then
+            wget --progress=bar:force "$1" -O "$2" 2>&1
+        else
+            fail "wget is missing, trying with python..."
+            if which python >/dev/null; then
+                python -c "
+import sys
+import time
+if sys.version_info >= (3,):
+    import urllib.request as urllib
+else:
+    import urllib
+
+
+def reporthook(count, block_size, total_size):
+    global start_time
+    if count == 0:
+        start_time = time.time()
+        return
+    duration = time.time() - start_time
+    progress_size = float(count * block_size)
+    if duration != 0:
+        if total_size == -1:
+            total_size = block_size
+            percent = 'Unknown size, '
+        else:
+            percent = '%.0f%%, ' % float(count * block_size * 100 / total_size)
+        speed = int(progress_size / (1024 * duration))
+        sys.stdout.write('\r%s%.2f MB, %d KB/s, %d seconds passed'
+                         % (percent, progress_size / (1024 * 1024), speed, duration))
+        sys.stdout.flush()
+
+urllib.urlretrieve('$1', '$2', reporthook=reporthook)
+print('\n')
+"
+            true
+            else
+                fail "Cannot download $1"
+            fi
+        fi
+    fi
+}
+
+function __find_linux_boot_device() {
+    local PDEVICE=`stat -c %04D /boot`
+    for file in $(find /dev -type b 2>/dev/null) ; do
+        local CURRENT_DEVICE=$(stat -c "%02t%02T" $file)
+        if [ $CURRENT_DEVICE = $PDEVICE ]; then
+            ROOTDEVICE="$file"
+            break;
+        fi
+    done
+    echo "$ROOTDEVICE"
+}

data/contrib/polipo_env.sh

@@ -1,2 +1,3 @@
-export http_proxy=http://10.0.2.2:<%= @cache.polipo_port %>
-export ftp_proxy=http://10.0.2.2:<%= @cache.polipo_port %>
+export http_proxy=http://<%= @proxy_cache %>:<%= @cache.polipo_port %>
+export ftp_proxy=http://<%= @proxy_cache %>:<%= @cache.polipo_port %>
+export https_proxy=https://<%= @proxy_cache %>:<%= @cache.polipo_port %>

data/kameleon-builder.gemspec

@@ -20,25 +20,18 @@ Gem::Specification.new do |s|
   s.license       = "GPL-2"
 
   s.files         = `git ls-files`.split($/)
+  s.files.reject! { |file| file.start_with?("docs/") }
+  s.files.reject! { |file| file.start_with?("omnibus/") }
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
   s.test_files    = s.files.grep(%r{^(tests|s|features)/})
   s.require_paths = ["lib"]
 
-  s.add_dependency 'childprocess', '~> 0.5'
+  s.add_dependency 'childprocess', '~> 0.3'
   s.add_dependency 'thor', '~> 0.15'
   s.add_dependency 'table_print', '~> 1.5'
-  s.add_dependency 'log4r-color', '~> 1.2'
-  s.add_dependency 'diffy', '~> 3.0'
   # Syck is also a dependency for Ruby 2 environments.
   # It is installed at install-time if necessary,
   # via ext/mkrf_conf.rb
-
-  s.add_development_dependency 'pry', '~> 0.9'
-  s.add_development_dependency 'pry-debugger', '~> 0.2'
-  s.add_development_dependency 'rake', '~> 10.1'
-  s.add_development_dependency 'minitest', '~> 4.7'
-  s.add_development_dependency 'coveralls', '~> 0.7'
-
   # To allow installing the Syck gem when Ruby version is >2.0.0
   s.extensions = ["ext/mkrf_conf.rb"]
 end

data/lib/kameleon.rb

@@ -6,25 +6,18 @@ require 'tempfile'
 require 'pp'
 require 'thor'
 require 'childprocess'
-require 'log4r-color'
-require 'log4r-color/configurator'
 require 'pathname'
 require 'table_print'
-require 'diffy'
 
 module Kameleon
-  # add a PROGRESS and NOTICE level
-  Log4r::Configurator.custom_levels(:DEBUG, :INFO, :NOTICE,
-                                    :PROGRESS, :WARN, :ERROR,
-                                    :FATAL)
-
   class << self
-    attr_writer :logger
     attr_writer :env
+    attr_writer :ui
     attr_writer :source_root
     attr_writer :templates_path
     attr_writer :templates_names
     attr_writer :templates_files
+    attr_writer :log_on_progress
 
     # The source root is the path to the root directory of the kameleon gem.
     def source_root
@@ -55,14 +48,17 @@ module Kameleon
       @templates_names
     end
 
-    def logger
-      @logger ||= Log4r::Logger.new("kameleon::[kameleon]")
-    end
-
     def env
       @env ||= Environment.new
     end
 
+    def ui
+      @ui ||= UI::Shell.new
+    end
+
+    def log_on_progress
+      @log_on_progress ||= false
+    end
   end
 end
 
@@ -73,4 +69,4 @@ require 'kameleon/error'
 require 'kameleon/cli'
 require 'kameleon/environment'
 require 'kameleon/version'
-require 'kameleon/logger'
+require 'kameleon/ui'

data/lib/kameleon/cli.rb

@@ -4,43 +4,37 @@ require 'kameleon/utils'
 
 module Kameleon
   class CLI < Thor
-
+    include Thor::Actions
 
     class_option :color, :type => :boolean, :default => true,
                  :desc => "Enable colorization in output"
     class_option :debug, :type => :boolean, :default => false,
                  :desc => "Enable debug output"
+    class_option :script, :type => :boolean, :default => false,
+                 :desc => "never prompts for user intervention",
+                 :aliases => "-s"
     map %w(-h --help) => :help
 
-    no_commands do
-      def logger
-        @logger ||= Log4r::Logger.new("kameleon::[kameleon]")
-      end
-    end
-
-    method_option :force,:type => :boolean,
-                  :default => false, :aliases => "-f",
-                  :desc => "Overwrite all existing files"
     desc "import [TEMPLATE_NAME]", "Imports the given template"
     def import(template_name)
       templates_path = Kameleon.env.templates_path
       template_path = File.join(templates_path, template_name) + '.yaml'
       begin
-        template_recipe = RecipeTemplate.new(template_path, :strict => false)
+        tpl = RecipeTemplate.new(template_path)
       rescue
         raise TemplateNotFound, "Template '#{template_name}' not found. " \
                                 "To see all templates, run the command "\
                                 "`kameleon templates`"
       else
-        logger.notice("Importing template '#{template_name}'...")
-        template_recipe.copy_template(options[:force])
-        logger.notice("done")
+        files2copy = tpl.base_recipes_files + tpl.files
+        files2copy.each do |path|
+          relative_path = path.relative_path_from(Kameleon.env.templates_path)
+          dst = File.join(Kameleon.env.workspace, relative_path)
+          copy_file(path, dst)
+        end
       end
     end
 
-    method_option :force,:type => :boolean,
-                  :default => false, :aliases => "-f",
-                  :desc => "Overwrite all existing files"
     desc "new [RECIPE_NAME] [TEMPLATE_NAME]", "Creates a new recipe"
     def new(recipe_name, template_name)
       if recipe_name == template_name
@@ -49,31 +43,47 @@ module Kameleon
       templates_path = Kameleon.env.templates_path
       template_path = File.join(templates_path, template_name) + '.yaml'
       begin
-        template_recipe = RecipeTemplate.new(template_path, :strict => false)
+        tpl = RecipeTemplate.new(template_path)
       rescue
         raise TemplateNotFound, "Template '#{template_name}' not found. " \
                                 "To see all templates, run the command "\
                                 "`kameleon templates`"
       else
-        logger.notice("Cloning template '#{template_name}'...")
-        template_recipe.copy_template(options[:force])
-        logger.notice("Creating extended recipe from template '#{template_name}'...")
-        template_recipe.copy_extended_recipe(recipe_name, options[:force])
-        logger.notice("done")
+        files2copy = tpl.base_recipes_files + tpl.files
+        files2copy.each do |path|
+          relative_path = path.relative_path_from(Kameleon.env.templates_path)
+          dst = File.join(Kameleon.env.workspace, relative_path)
+          copy_file(path, dst)
+        end
+        Dir::mktmpdir do |tmp_dir|
+          recipe_path = File.join(tmp_dir, recipe_name + '.yaml')
+          ## copying recipe
+          File.open(recipe_path, 'w+') do |file|
+            extend_erb_tpl = File.join(Kameleon.env.templates_path, "extend.erb")
+            erb = ERB.new(File.open(extend_erb_tpl, 'rb') { |f| f.read })
+            result = erb.result(binding)
+            file.write(result)
+          end
+          recipe_dst = File.join(Kameleon.env.workspace, recipe_name + '.yaml')
+          copy_file(recipe_path, Pathname.new(recipe_dst))
+        end
       end
     end
 
     desc "templates", "Lists all defined templates"
     def templates
-      Log4r::Outputter['console'].level = Log4r::ERROR unless Kameleon.env.debug
       puts "The following templates are available in " \
                  "#{ Kameleon.templates_path }:"
       templates_hash = []
-      Kameleon.templates_files.each do |f|
+      templates_path = File.join(Kameleon.env.templates_path, "/")
+      all_yaml_files = Dir["#{templates_path}**/*.yaml"]
+      steps_files = Dir["#{templates_path}steps/**/*.yaml"]
+      templates_files = all_yaml_files - steps_files
+      templates_files.each do |f|
         begin
-        recipe = RecipeTemplate.new(f, :strict => false)
+        recipe = RecipeTemplate.new(f)
         templates_hash.push({
-          "name" => recipe.name,
+          "name" => f.gsub(templates_path, "").chomp(".yaml"),
           "description" => recipe.metainfo['description'],
         })
         rescue => e
@@ -81,12 +91,15 @@ module Kameleon
         end
       end
       templates_hash = templates_hash.sort_by{ |k| k["name"] }
-      tp templates_hash, {"name" => {:width => 30}}, { "description" => {:width => 60}}
+      name_width = templates_hash.map { |k| k['name'].size }.max
+      desc_width = Kameleon.ui.shell.terminal_width - name_width - 3
+      tp(templates_hash,
+        {"name" => {:width => name_width}},
+        { "description" => {:width => desc_width}})
     end
 
     desc "version", "Prints the Kameleon's version information"
     def version
-      Log4r::Outputter['console'].level = Log4r::OFF unless Kameleon.env.debug
       puts "Kameleon version #{Kameleon::VERSION}"
     end
     map %w(-v --version) => :version
@@ -103,11 +116,14 @@ module Kameleon
                   :desc => "Using specific checkpoint to build the image. " \
                            "Default value is the last checkpoint."
     method_option :checkpoint, :type => :boolean ,
-                  :default => true,
-                  :desc => "Do not use checkpoints"
+                  :default => false,
+                  :desc => "Enable checkpoint"
     method_option :cache, :type => :boolean,
                   :default => false,
                   :desc => "Generate a persistent cache for the appliance."
+    method_option :cache_path, :type => :string ,
+                  :default => nil,
+                  :desc => "Set the cache directory path"
     method_option :from_cache, :type => :string ,
                   :default => nil,
                   :desc => "Using a persistent cache tar file to build the image."
@@ -115,19 +131,24 @@ module Kameleon
                   :default => nil,
                   :desc => "Full path of the proxy binary to use for the persistent cache."
 
-    def build(recipe_path)
+    def build(recipe_path=nil)
+      if recipe_path.nil? && !options[:from_cache].nil?
+        Kameleon.ui.info("Using the cached recipe")
+        @cache = Kameleon::Persistent_cache.instance
+        @cache.cache_path = options[:from_cache]
+        recipe_path =  @cache.get_recipe
+      end
+      raise BuildError, "A recipe file or a persistent cache archive " \
+                        "is required to run this command." if recipe_path.nil?
       clean(recipe_path) if options[:clean]
       engine = Kameleon::Engine.new(Recipe.new(recipe_path), options)
-      logger.notice("Starting build recipe '#{recipe_path}'")
+      Kameleon.ui.info("Starting build recipe '#{recipe_path}'")
       start_time = Time.now.to_i
       engine.build
       total_time = Time.now.to_i - start_time
-      logger.notice("")
-      logger.notice("Build recipe '#{recipe_path}' is completed !")
-      logger.notice("Build total duration : #{total_time} secs")
-      logger.notice("Build directory : #{engine.cwd}")
-      logger.notice("Build recipe file : #{engine.build_recipe_path}")
-      logger.notice("Log file : #{Kameleon.env.log_file}")
+      Kameleon.ui.info("")
+      Kameleon.ui.info("Successfully built '#{recipe_path}'")
+      Kameleon.ui.info("Total duration : #{total_time} secs")
     end
 
     desc "checkpoints [RECIPE_PATH]", "Lists all availables checkpoints"
@@ -135,25 +156,27 @@ module Kameleon
                   :default => nil, :aliases => "-b",
                   :desc => "Set the build directory path"
     def checkpoints(recipe_path)
-      Log4r::Outputter['console'].level = Log4r::ERROR unless Kameleon.env.debug
+      Kameleon.ui.level = "error"
       engine = Kameleon::Engine.new(Recipe.new(recipe_path), options)
       engine.pretty_checkpoints_list
     end
 
-    desc "clean [RECIPE_PATH]", "Cleaning 'out' and 'local' contexts and removing all checkpoints"
+    desc "clean [RECIPE_PATH]", "Cleaning all contexts and removing the checkpoints"
     method_option :build_path, :type => :string ,
                   :default => nil, :aliases => "-b",
                   :desc => "Set the build directory path"
     def clean(recipe_path)
-      Log4r::Outputter['console'].level = Log4r::INFO
-      engine = Kameleon::Engine.new(Recipe.new(recipe_path), options)
-      engine.clear
+      opts = Hash.new.merge options
+      opts[:lazyload] = false
+      opts[:fail_silently] = true
+      engine = Kameleon::Engine.new(Recipe.new(recipe_path), opts)
+      engine.clean(:with_checkpoint => true)
     end
     map %w(clear) => :clean
 
     desc "commands", "Lists all available commands", :hide => true
     def commands
-      puts CLI.all_commands.keys - ["commands", "completions"]
+      Kameleon.ui.info CLI.all_commands.keys - ["commands", "completions"]
     end
 
     desc "source_root", "Prints the kameleon directory path", :hide => true
@@ -161,70 +184,34 @@ module Kameleon
       puts Kameleon.source_root
     end
 
-    # Hack Thor to init Kameleon env soon
-    def self.init(base_config)
-      env_options = Hash.new
-      env_options.merge! base_config[:shell].base.options.clone
-      # configure logger
-      env_options["debug"] = true if ENV["KAMELEON_LOG"] == "debug"
-      ENV["KAMELEON_LOG"] = "debug" if env_options["debug"]
-      if ENV["KAMELEON_LOG"] && ENV["KAMELEON_LOG"] != ""
-        level_name = ENV["KAMELEON_LOG"]
-      else
-        level_name = "info"
-      end
-      # Require Log4r and define the levels we'll be using
-      require 'log4r-color/config'
-      Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
-
-      begin
-        level = Log4r.const_get(level_name.upcase)
-      rescue NameError
-        level = Log4r.const_get("INFO")
-        $stderr << "Invalid KAMELEON_LOG level is set: #{level_name}.\n" \
-                   "Please use one of the standard log levels: debug," \
-                   " info, warn, or error\n"
-        raise KameleonError
+    def initialize(*args)
+      super
+      self.options ||= {}
+      Kameleon.env = Kameleon::Environment.new(self.options)
+      if !$stdout.tty? or !options["color"]
+        Thor::Base.shell = Thor::Shell::Basic
       end
-      format = ConsoleFormatter.new
-      # format = Log4r::PatternFormatter.new(:pattern => '%11c: %M')
-      if !$stdout.tty? or !env_options["color"]
-        console_output = Log4r::StdoutOutputter.new('console',
-                                                    :formatter => format)
-        Diffy::Diff.default_format = :text
-      else
-        console_output = Log4r::ColorOutputter.new 'console', {
-          :colors => { :debug  => :light_black,
-                       :info   => :green,
-                       :progress_info => :green,
-                       :notice => :light_blue,
-                       :progress_notice => :light_blue,
-                       :warn   => :yellow,
-                       :error  => :red,
-                       :progress_error => :red,
-                       :fatal  => :red,
-                     },
-          :formatter => format,
-        }
-        Diffy::Diff.default_format = :color
+      Kameleon.ui = Kameleon::UI::Shell.new(self.options)
+      Kameleon.ui.level = "debug" if self.options["debug"]
+      opts = args[1]
+      cmd_name = args[2][:current_command].name
+      if opts.include? "--help"
+        CLI.command_help(Kameleon.ui.shell, cmd_name)
+        raise Kameleon::Exit
       end
-      logger = Log4r::Logger.new('kameleon')
-      logger.level = level
-      logger.outputters << console_output
-      format_file = FileFormatter.new
-      Kameleon.logger.debug("`kameleon` invoked: #{ARGV.inspect}")
-      Kameleon.env = Kameleon::Environment.new(env_options)
-      filelog = Log4r::FileOutputter.new('logfile',
-                                         :trunc=>false,
-                                         :filename => Kameleon.env.log_file.to_s,
-                                         :formatter => format_file)
-      logger.outputters << filelog
-      logger = nil
     end
 
-    def self.start(given_args=ARGV, config={})
-        config[:shell] ||= Thor::Base.shell.new
-        dispatch(nil, given_args.dup, nil, config) { init(config) }
+    def self.start(*)
+      super
+    rescue Exception => e
+      Kameleon.ui = Kameleon::UI::Shell.new
+      raise e
+    end
+
+    def self.source_root
+      Kameleon.source_root
     end
+
   end
+
 end