kameleon-builder 2.1.3 → 2.2.0

data/lib/kameleon/environment.rb

@@ -7,30 +7,35 @@ module Kameleon
     attr_accessor :workspace
     attr_accessor :templates_path
     attr_accessor :build_path
-    attr_accessor :log_file
+    attr_accessor :cache_path
     attr_accessor :debug
 
+    def script?
+      @script
+    end
 
     def initialize(options = {})
-      @logger = Log4r::Logger.new("kameleon::[kameleon]")
       # symbolify commandline options
       options = options.inject({}) {|result,(key,value)| result.update({key.to_sym => value})}
       workspace = File.expand_path(Dir.pwd)
       build_path = File.expand_path(options[:build_path] || File.join(workspace, "build"))
+      cache_path = File.expand_path(options[:cache_path] || File.join(build_path, "cache"))
       defaults = {
         :workspace => Pathname.new(workspace),
         :templates_path => Kameleon.templates_path,
         :templates_names => Kameleon.templates_names,
         :build_path => Pathname.new(build_path),
-        :log_file => Pathname.new(File.join(workspace, "kameleon.log"))
+        :cache_path => Pathname.new(cache_path),
+        :script => options[:script],
       }
       options = defaults.merge(options)
-      @logger.debug("Environment initialized (#{self})")
+      Kameleon.ui.debug("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.debug("  @#{key} : #{options[key]}")
+        Kameleon.ui.debug("  @#{key} : #{options[key]}")
       end
+      @debug = true if ENV['KAMELEON_DEBUG']
     end
   end
 end

data/lib/kameleon/error.rb

@@ -1,4 +1,3 @@
-require 'thor/error'
 
 module Kameleon
   class Error < ::StandardError
@@ -14,6 +13,7 @@ module Kameleon
     end
   end
 
+  class Exit < Error; status_code(0) ; end
   class KameleonError < Error; status_code(1) ; end
   class ExecError < Error; status_code(2) ; end
   class InternalError < Error; status_code(3) ; end
@@ -23,35 +23,4 @@ module Kameleon
   class BuildError < Error; status_code(7) ; end
   class AbortError < Error; status_code(8) ; end
   class TemplateNotFound < Error; status_code(9) ; end
-
-  def self.with_friendly_errors
-    yield
-  rescue Kameleon::Error => e
-    e.message.split( /\r?\n/ ).each {|m| Kameleon.logger.fatal m }
-    exit e.status_code
-  rescue Thor::UndefinedTaskError => e
-    $stderr << "#{e.message}\n"
-    e.backtrace.each {|m| Kameleon.logger.debug m }
-    exit 15
-  rescue Thor::Error => e
-    $stderr << "#{e.message}\n"
-    e.backtrace.each {|m| Kameleon.logger.debug m }
-    exit 15
-  rescue SystemExit, Interrupt => e
-    Kameleon.logger.fatal("Quitting...")
-    exit 1
-  rescue Errno::ENOENT => e
-    $stderr << "#{e.message}\n"
-    e.backtrace.each {|m| Kameleon.logger.debug m }
-    exit 16
-  rescue Exception => e
-    if ENV["KAMELEON_LOG"] != "debug"
-      $stderr << "Unfortunately, a fatal error has occurred : "\
-                 "#{e.message}.\nUse --debug option for more details\n"
-    else
-      Kameleon.logger.debug "Error : #{e}"
-      e.backtrace.each {|m| puts "==> #{m}" }
-    end
-    exit 666
-  end
 end

data/lib/kameleon/persistent_cache.rb

@@ -1,7 +1,6 @@
 require 'childprocess'
 require 'singleton'
 require 'socket'
-
 module Kameleon
   #This ruby class will control the execution of Polipo web proxy
   class Persistent_cache
@@ -12,11 +11,15 @@ module Kameleon
     attr_reader :polipo_port
     attr_writer :activated
     attr_reader :cwd
-    attr_reader :polipo_path
+    attr_writer :polipo_path
     attr_reader :name
+    attr_writer :cache_path
+    attr_accessor :mode
+    attr_accessor :name
+    attr_accessor :recipe_files # have to check those.
+    attr_accessor :recipe_path
 
     def initialize()
-      @logger = Log4r::Logger.new("kameleon::[kameleon]")
       ## we must configure Polipo to be execute for the in and out context
       ## we have to start polipo in the out context for debootstrap step
 
@@ -28,18 +31,28 @@ module Kameleon
       @polipo_port = find_unused_port
 
       @polipo_cmd_options = {:diskCacheRoot => "",
-                            :idleTime => "5",
-                            :chunkHighMark => "425165824",
-                            :proxyPort => @polipo_port,
-                            :relaxTransparency =>"true"
+                             :idleTime => "1",
+                             :chunkHighMark => "425165824",
+                             :proxyPort => @polipo_port,
+                             :relaxTransparency =>"true",
+                             :daemonise => false,
+                             :logFile => File.join(Kameleon.env.build_path, 'polipo.log')
                             }
 
       @activated = false
 
-      @cache_dir = ""
+      @mode = nil #It could be build or from
+      @cache_dir = Kameleon.env.cache_path
       @polipo_path = nil
       @cwd = ""
-
+      #structure {:cmd => "cmd", :stdout_filename => "file_name"}
+      @cmd_cached = []
+      @cache_path = ""
+      @current_cmd_id = nil
+      @current_step_dir = nil
+      @recipe_file = nil
+      @steps_files = []
+      @cached_recipe_dir = nil
     end
 
     def find_unused_port
@@ -49,7 +62,7 @@ module Kameleon
       ports.each do |p|
         begin
           port = p
-          tmp = TCPServer.new('localhost',port)
+          tmp = TCPServer.new('localhost', port)
         rescue
           port =0
         end
@@ -61,12 +74,11 @@ module Kameleon
 
     def check_polipo_binary
 
-
       @polipo_path ||= which("polipo")
 
       if @polipo_path.nil? then
-        @logger.error("Polipo binary not found, make sure it is in your current PATH")
-        @logger.error("or use the option --proxy-path")
+        Kameleon.ui.error("Polipo binary not found, make sure it is in your current PATH")
+        Kameleon.ui.error("or use the option --proxy-path")
         raise BuildError, "Failed to use persistent cache"
       end
     end
@@ -75,54 +87,131 @@ module Kameleon
       @activated
     end
 
-
     def cwd=(dir)
       @cwd = dir
-      @cache_dir = @cwd + "/cache/"
     end
 
     def create_cache_directory(step_name)
-      @logger.notice("Creating cache directory #{step_name} for Polipo")
-      directory_name = @cache_dir + "/#{step_name}"
+      Kameleon.ui.debug("Creating  cache directory #{step_name} for Polipo")
+      directory_name = File.join(@cache_dir,"#{step_name}")
       FileUtils.mkdir_p directory_name
       directory_name
     end
 
     def start_web_proxy_in(directory)
+
+      ## setting current step dir
+      @current_step_dir = directory
       ## This function assumes that the cache directory has already been created by the engine
       ## Stopping first the previous proxy
       ## have to check if polipo is running
-      @logger.debug("Starting web proxy Polipo in directory #{directory} using port: #{@polipo_port}")
-      @polipo_process.stop unless @polipo_process.nil?
-      command = ["#{@polipo_path}/polipo"]
+      Kameleon.ui.debug("Starting web proxy Polipo in directory #{directory} using port: #{@polipo_port}")
+      @polipo_process.stop(0) unless @polipo_process.nil?
+      command = ["#{@polipo_path}/polipo", "-c", "/dev/null"]
       @polipo_cmd_options[:diskCacheRoot] = directory
       @polipo_cmd_options.each{ |v,k| command.push("#{v}=#{k}") }
       ChildProcess.posix_spawn = true
+      Kameleon.ui.debug("Starting process '#{command}'")
       @polipo_process = ChildProcess.build(*command)
-      @polipo_process.io.stdout = Tempfile.new("polipo_output")
       @polipo_process.start
+      return true
     end
 
 
     def stop_web_proxy
       @polipo_process.stop
-      @logger.notice("Stopping web proxy polipo")
+      Kameleon.ui.info("Stopping web proxy polipo")
     end
 
     def pack()
-      @logger.notice("Packing up the generated cache in #{@cwd}")
-      execute("tar","-cf #{@name}-cache.tar cache/",@cwd)
-      # The cache directory cannot be deleted due to the checkpoints
+      Kameleon.ui.info("Packing up the generated cache in #{@cwd}/#{@name}-cache.tar")
+      execute("tar","-cf #{@name}-cache.tar -C cache/ .",@cwd)
     end
 
     def unpack(cache_path)
-      @logger.notice("Unpacking persistent cache: #{cache_path}")
-      execute("tar","-xf #{cache_path} -C #{@cwd}")
+      Kameleon.ui.info("Unpacking persistent cache: #{cache_path}")
+      FileUtils.mkdir_p @cache_dir
+      execute("tar","-xf #{cache_path} -C #{@cache_dir}")
+    end
+
+
+    # This function caches the command with its respective stdout
+    # a command id is associate to a file
+    def cache_cmd_id(cmd_identifier)
+      @current_cmd_id = cmd_identifier
+      return true
+    end
+
+    def cache_cmd(cmd,file_path)
+      Kameleon.ui.info("Caching file")
+      Kameleon.ui.debug("command: cp #{file_path} #{@cwd}/cache/files/")
+      FileUtils.mkdir_p @current_step_dir + "/data/"
+      FileUtils.cp file_path, @current_step_dir + "/data/"
+      @cmd_cached.push({:cmd_id => @current_cmd_id,
+                        :cmd => cmd ,
+                        :stdout_filename => File.basename(file_path)})
+    end
+
+    def get_cache_cmd(cmd)
+      return false if @mode == :build
+      cache_line = @cmd_cached.select{ |reg|
+        (reg[:cmd_id] == @current_cmd_id && reg[:cmd] == cmd) }.first
+
+      return File.new("#{@current_step_dir}/data/#{cache_line[:stdout_filename]}","r")
+    end
+
+    def stop()
+      @polipo_process.stop
+      Kameleon.ui.info("Stopping web proxy polipo")
+      Kameleon.ui.info("Finishing persistent cache with last files")
+
+      if @mode == :build then
+        File.open("#{@cache_dir}/cache_cmd_index",'w+') do |f|
+          f.puts(@cmd_cached.to_yaml)
+        end
+
+        unless @recipe_files.empty?
+          recipe_dir = Pathname.new(common_prefix(@recipe_files))
+          all_files = @recipe_files.push(@recipe_path)
+          Kameleon::Utils.copy_files(recipe_dir, @cache_dir, all_files)
+        end
+        ## Saving metadata information
+        Kameleon.ui.info("Caching recipe")
+        File.open("#{@cached_recipe_dir}/header",'w+') do |f|
+          f.puts({:recipe_path => @recipe_path.to_s}.to_yaml)
+        end
+        pack
+      end
+    end
+
+    def start()
+      check_polipo_binary
+      if @mode == :from then
+        begin
+          unpack(@cache_path)
+        rescue
+          raise BuildError, "Failed to untar the persistent cache file"
+        end
+        ## We have to load the file
+        @cmd_cached = YAML.load(File.read("#{@cache_dir}/cache_cmd_index"))
+      end
+      @activated = true
+      @cached_recipe_dir = @cache_dir
+      FileUtils.mkdir_p @cached_recipe_dir
+    end
+
+    def get_recipe()
+      cached_recipe=Dir.mktmpdir("cache")
+      puts "cache path : #{@cache_path}"
+      execute("tar","-xf #{@cache_path} -C #{cached_recipe} .")
+      Kameleon.ui.info("Getting cached recipe")
+      recipe_header = YAML::load(File.read("#{cached_recipe}/header"))
+      recipe_file = recipe_header[:recipe_path]
+      return recipe_file
     end
 
     def execute(cmd,args,dir=nil)
       command = [cmd ] + args.split(" ")
-#      @logger.notice(" command generated: #{command}")
       process = ChildProcess.build(*command)
       process.cwd = dir unless dir.nil?
       process.start
@@ -137,8 +226,17 @@ module Kameleon
       return nil
     end
 
+    def common_prefix(paths)
+      return '' if paths.empty?
+      return paths.first.split('/').slice(0...-1).join('/') if paths.length <= 1
+      arr = paths.sort
+      first = arr.first.to_s.split('/')
+      last = arr.last.to_s.split('/')
+      i = 0
+      i += 1 while first[i] == last[i] && i <= first.length
+      first.slice(0, i).join('/')
+    end
 
   end
 
 end
-

data/lib/kameleon/recipe.rb

@@ -13,9 +13,11 @@ module Kameleon
     attr_accessor :checkpoint
     attr_accessor :checkpoint_path
     attr_accessor :metainfo
+    attr_accessor :files
+    attr_accessor :base_recipes_files
+
 
     def initialize(path, kwargs = {})
-      @logger = Log4r::Logger.new("kameleon::[kameleon]")
       @path = Pathname.new(File.expand_path(path))
       @name = (@path.basename ".yaml").to_s
       @recipe_content = File.open(@path, 'r') { |f| f.read }
@@ -24,27 +26,24 @@ module Kameleon
         "setup" => Section.new("setup"),
         "export" => Section.new("export"),
       }
-      kameleon_id = SecureRandom.uuid
       @global = {
         "kameleon_recipe_name" => @name,
         "kameleon_recipe_dir" => File.dirname(@path),
-        "kameleon_uuid" => kameleon_id,
-        "kameleon_short_uuid" => kameleon_id.split("-").last,
         "kameleon_cwd" => File.join(Kameleon.env.build_path, @name),
-        "in_context" => {"cmd"=> "/bin/bash"},
-        "out_context" => {"cmd"=> "/bin/bash"}
+        "in_context" => {"cmd" => "/bin/bash", "proxy_cache" => "localhost"},
+        "out_context" => {"cmd" => "/bin/bash", "proxy_cache" => "localhost"}
       }
       @aliases = {}
       @checkpoint = nil
       @files = []
-      @logger.debug("Initialize new recipe (#{path})")
+      Kameleon.ui.debug("Initialize new recipe (#{path})")
       @base_recipes_files = [@path]
-      load! kwargs
+      load! :strict => false
     end
 
     def load!(kwargs = {})
       # Find recipe path
-      @logger.debug("Loading #{@path}")
+      Kameleon.ui.debug("Loading #{@path}")
       fail RecipeError, "Could not find this following recipe : #{@path}" \
          unless File.file? @path
       yaml_recipe = YAML.load File.open @path
@@ -59,22 +58,27 @@ module Kameleon
       @global.merge!(yaml_recipe.fetch("global", {}))
       # Resolve dynamically-defined variables !!
       resolved_global = Utils.resolve_vars(@global.to_yaml, @path, @global, kwargs)
-      @global.merge! YAML.load(resolved_global)
+      resolved_global = @global.merge YAML.load(resolved_global)
       # Loads aliases
       load_aliases(yaml_recipe)
       # Loads checkpoint configuration
       load_checkpoint_config(yaml_recipe)
 
       #Find and load steps
-      steps_dir = File.join(File.dirname(@path), 'steps')
-      @global['include_steps'] ||= []
-      @global['include_steps'] = [global['include_steps']].push ''
-      @global['include_steps'].flatten!
-      @global['include_steps'].compact!
+      steps_dirs = [
+        File.join(File.dirname(@path), 'steps'),
+        File.expand_path(File.join(File.dirname(@path), '..', 'steps')),
+      ]
+      resolved_global['include_steps'] ||= []
+      resolved_global['include_steps'].push ''
+      resolved_global['include_steps'].flatten!
+      resolved_global['include_steps'].compact!
       @sections.values.each do |section|
-        dir_to_search = @global['include_steps'].map do |path|
-          [File.join(steps_dir, section.name, path),
-            File.join(steps_dir, path)]
+        dir_to_search = resolved_global['include_steps'].map do |path|
+          steps_dirs.map do |steps_dir|
+            [File.join(steps_dir, section.name, path),
+              File.join(steps_dir, path)]
+          end
         end
         dir_to_search.flatten!
         if yaml_recipe.key? section.name
@@ -104,7 +108,7 @@ module Kameleon
               end
             end
             if embedded_step
-              @logger.debug("Loading embedded macrostep #{name}")
+              Kameleon.ui.debug("Loading embedded macrostep #{name}")
               macrostep = load_macrostep(nil, name, args)
               section.macrosteps.push(macrostep)
               next
@@ -114,16 +118,16 @@ module Kameleon
             dir_to_search.each do |dir|
               macrostep_path = Pathname.new(File.join(dir, name + '.yaml'))
               if File.file?(macrostep_path)
-                @logger.debug("Loading macrostep #{macrostep_path}")
+                Kameleon.ui.debug("Loading macrostep #{macrostep_path}")
                 macrostep = load_macrostep(macrostep_path, name, args)
                 section.macrosteps.push(macrostep)
                 @files.push(macrostep_path)
-                @logger.debug("Macrostep '#{name}' found in this path: " \
+                Kameleon.ui.debug("Macrostep '#{name}' found in this path: " \
                               "#{macrostep_path}")
                 loaded = true
                 break
               else
-                @logger.debug("Macrostep '#{name}' not found in this path: " \
+                Kameleon.ui.debug("Macrostep '#{name}' not found in this path: " \
                               "#{macrostep_path}")
               end
             end
@@ -131,7 +135,7 @@ module Kameleon
           end
         end
       end
-      @logger.debug("Loading recipe metadata")
+      Kameleon.ui.debug("Loading recipe metadata")
       @metainfo = {
         "description" => Utils.extract_meta_var("description", @recipe_content)
       }
@@ -194,12 +198,13 @@ module Kameleon
         elsif aliases.kind_of? String
           dir_search = [
             File.join(File.dirname(@path), "steps", "aliases"),
+            File.join(File.dirname(@path), "..", "steps", "aliases"),
             File.join(File.dirname(@path), "aliases")
           ]
           dir_search.each do |dir_path|
             path = Pathname.new(File.join(dir_path, aliases))
             if File.file?(path)
-              @logger.debug("Loading aliases #{path}")
+              Kameleon.ui.debug("Loading aliases #{path}")
               @aliases = YAML.load_file(path)
               @files.push(path)
               return path
@@ -219,20 +224,25 @@ module Kameleon
         elsif checkpoint.kind_of? String
           dir_search = [
             File.join(File.dirname(@path), "steps", "checkpoints"),
+            File.join(File.dirname(@path), "..", "steps", "checkpoints"),
             File.join(File.dirname(@path), "checkpoints")
           ]
           dir_search.each do |dir_path|
             path = Pathname.new(File.join(dir_path, checkpoint))
             if File.file?(path)
-              @logger.debug("Loading checkpoint configuration #{path}")
+              Kameleon.ui.debug("Loading checkpoint configuration #{path}")
               @checkpoint = YAML.load_file(path)
               @checkpoint["path"] = path.to_s
               @files.push(path)
-              return path
             end
           end
           fail RecipeError, "Checkpoint configuraiton file '#{path}' " \
-                            "does not exists"
+                            "does not exists" if @checkpoint.nil?
+        end
+        (@checkpoint.keys - ["path"]).each do |key|
+          @checkpoint[key].map! do |cmd|
+            Kameleon::Command.new(cmd, "checkpoint")
+          end
         end
       end
     end
@@ -295,15 +305,21 @@ module Kameleon
     end
 
     def find_microstep(microstep_name, loaded_microsteps)
-      @logger.debug("Looking for microstep #{microstep_name}")
+      Kameleon.ui.debug("Looking for microstep #{microstep_name}")
       loaded_microsteps.each do |microstep|
         if microstep_name.eql? microstep.name
           return microstep
         end
       end
+      return nil
     end
 
     def resolve!
+      unless @global.keys.include? "kameleon_uuid"
+        kameleon_id = SecureRandom.uuid
+        @global["kameleon_uuid"] = kameleon_id
+        @global["kameleon_short_uuid"] = kameleon_id.split("-").last
+      end
       # Resolve dynamically-defined variables !!
       resolved_global = Utils.resolve_vars(@global.to_yaml, @path, @global)
       @global.merge! YAML.load(resolved_global)
@@ -311,7 +327,7 @@ module Kameleon
       consistency_check
       resolve_checkpoint unless @checkpoint.nil?
 
-      @logger.notice("Resolving variables")
+      Kameleon.ui.info("Resolving variables")
       @sections.values.each do |section|
         section.macrosteps.each do |macrostep|
           macrostep.resolve_variables!(@global)
@@ -321,7 +337,7 @@ module Kameleon
       @sections.values.each do |section|
         section.macrosteps.each do |macrostep|
           # First pass : resolve aliases
-          @logger.debug("Resolving aliases for macrostep '#{macrostep.name}'")
+          Kameleon.ui.debug("Resolving aliases for macrostep '#{macrostep.name}'")
           macrostep.microsteps.each do |microstep|
             microstep.commands.map! do |cmd|
               # resolve alias
@@ -329,7 +345,7 @@ module Kameleon
             end
           end
           # flatten for multiple-command alias + variables
-          @logger.debug("Resolving check statements for macrostep '#{macrostep.name}'")
+          Kameleon.ui.debug("Resolving check statements for macrostep '#{macrostep.name}'")
           macrostep.microsteps.each { |microstep| microstep.commands.flatten! }
           # Second pass : resolve variables + clean/init hooks
           macrostep.microsteps.each do |microstep|
@@ -337,7 +353,7 @@ module Kameleon
               resolve_hooks(cmd, macrostep, microstep)
             end
           end
-          @logger.debug("Compacting macrostep '#{macrostep.name}'")
+          Kameleon.ui.debug("Compacting macrostep '#{macrostep.name}'")
           # remove empty steps
           macrostep.microsteps.map! do |microstep|
             microstep.commands.compact!
@@ -345,7 +361,7 @@ module Kameleon
           end
           # remove nil values
           macrostep.microsteps.compact!
-          @logger.debug("Resolving commands for macrostep '#{macrostep.name}'")
+          Kameleon.ui.debug("Resolving commands for macrostep '#{macrostep.name}'")
           macrostep.microsteps.each do |microstep|
             microstep.resolve!
           end
@@ -365,7 +381,7 @@ module Kameleon
           end
         end
       end
-      @logger.notice("Starting recipe consistency check")
+      Kameleon.ui.info("Starting recipe consistency check")
       # check context args
       required_args = %w(cmd)
       missings = []
@@ -385,10 +401,12 @@ module Kameleon
     end
 
     def resolve_checkpoint()
-      %w(create apply list clear).each do |key|
-        @checkpoint[key] = Utils.resolve_vars(@checkpoint[key],
+      (@checkpoint.keys - ["path"]).each do |key|
+        @checkpoint[key].each do |cmd|
+          cmd.string_cmd = Utils.resolve_vars(cmd.string_cmd,
                                               @checkpoint["path"],
                                               @global)
+        end
       end
     end
 
@@ -490,17 +508,21 @@ module Kameleon
     end
 
     def calculate_step_identifiers
-      @logger.notice("Calculating microstep identifiers")
+      Kameleon.ui.debug("Calculating microstep identifiers")
       base_salt = ""
       order = 0
       @sections.values.each do |section|
         section.sequence do |macrostep|
           macrostep.sequence do |microstep|
-            base_salt = microstep.calculate_identifier base_salt
+            if ["redo", "skip"].include? microstep.on_checkpoint
+              microstep.calculate_identifier ""
+            else
+              base_salt = microstep.calculate_identifier base_salt
+            end
             slug = "#{section.name}/#{macrostep.name}/#{microstep.name}"
             microstep.slug = slug
             microstep.order = (order += 1)
-            @logger.debug("  #{microstep.slug}: #{microstep.identifier}")
+            Kameleon.ui.debug("  #{microstep.slug}: #{microstep.identifier}")
           end
         end
       end
@@ -531,73 +553,8 @@ module Kameleon
   end
 
   class RecipeTemplate < Recipe
-
-    def get_answer(msg)
-      while true
-        @logger.progress_notice msg
-        answer = $stdin.gets.downcase
-        raise AbortError, "Execution aborted..." if answer.nil?
-        answer.chomp!
-        if ["y", "n" , "", "a"].include?(answer)
-          if ["y", ""].include? answer
-            return true
-          elsif answer.eql? "a"
-            raise AbortError, "Aborted..."
-          end
-          return false
-        end
-      end
-    end
-
-    def safe_copy_file(src, dst, force)
-      if File.exists? dst
-        diff = Diffy::Diff.new(dst.to_s, src.to_s, :source => "files").to_s
-        unless diff.chomp.empty?
-          @logger.notice("conflict #{dst}")
-          @logger.notice("Differences between the old and the new :")
-          puts Diffy::Diff.new(dst.to_s, src.to_s,
-                               :source => "files",
-                               :context => 1,
-                               :include_diff_info => true).to_s
-          msg = "Overwrite #{dst}? [Y]es/[n]o/[a]bort : "
-          if force || get_answer(msg)
-            FileUtils.copy_file(src, dst)
-          end
-        else
-          @logger.notice("identical #{dst}")
-        end
-      else
-        unless File.dirname(dst).eql? "/"
-          FileUtils.mkdir_p File.dirname(dst)
-        end
-        @logger.notice("create #{dst}")
-        FileUtils.copy_file(src, dst)
-      end
-    end
-
-    def copy_extended_recipe(recipe_name, force)
-      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")
-          tpl = ERB.new(File.open(extend_erb_tpl, 'rb') { |f| f.read })
-          result = tpl.result(binding)
-          file.write(result)
-        end
-        recipe_dst = File.join(Kameleon.env.workspace, recipe_name + '.yaml')
-        safe_copy_file(recipe_path, Pathname.new(recipe_dst), force)
-      end
-    end
-
-    def copy_template(force)
-      ## copying steps
-      files2copy = @base_recipes_files + @files
-      files2copy.each do |path|
-        relative_path = path.relative_path_from(Kameleon.env.templates_path)
-        dst = File.join(Kameleon.env.workspace, relative_path)
-        safe_copy_file(path, dst, force)
-      end
+    def relative_path()
+      @path.relative_path_from(Kameleon.env.templates_path)
     end
   end
 end