kameleon-builder 2.1.3 → 2.2.0

data/lib/kameleon/context.rb

@@ -6,97 +6,125 @@ module Kameleon
     attr_accessor :shell
     attr_accessor :name
 
-    def initialize(name, cmd, workdir, exec_prefix, local_workdir)
+    def initialize(name, cmd, workdir, exec_prefix, local_workdir, kwargs = {})
       @name = name.downcase
-      @logger = Log4r::Logger.new("kameleon::[#{@name}_ctx]")
       @cmd = cmd
       @workdir = workdir
       @exec_prefix = exec_prefix
       @local_workdir = local_workdir
-      @shell = Kameleon::Shell.new(@name, @cmd, @workdir, @local_workdir)
-      @logger.debug("Initialize new ctx (#{name})")
-      @log_on_progress = false
+      @proxy_cache = kwargs[:proxy_cache]
+      @fail_silently = kwargs.fetch(:fail_silently, true)
+      @lazyload = kwargs.fetch(:lazyload, false)
+      @shell = Kameleon::Shell.new(@name,
+                                   @cmd,
+                                   @workdir,
+                                   @local_workdir,
+                                   @proxy_cache)
+      @already_loaded = false
+      Kameleon.ui.debug("Initialize new ctx (#{name})")
 
       instance_variables.each do |v|
-        @logger.debug("  #{v} = #{instance_variable_get(v)}")
+        Kameleon.ui.debug("  #{v} = #{instance_variable_get(v)}")
       end
 
       @cache = Kameleon::Persistent_cache.instance
+      unless @lazyload
+        load_shell
+      end
+    end
+
+    def already_loaded?
+      @already_loaded
     end
 
     def do_log(out, log_level)
-      if @log_on_progress
-        log_progress(log_level, out)
-        @log_on_progress = false if out.match(/\n$/)
-      else
-        if out.match(/\n$/)
-          out.split( /\r?\n/ ).each {|m| log(log_level, m) }
+      prefix = "[#{@name}] "
+      out.gsub!("\r", "\r#{prefix}")
+      out.gsub!("\n", "\n#{prefix}")
+      if Kameleon.log_on_progress
+        if out.end_with?("#{prefix}")
+          Kameleon.log_on_progress = false
+          log_progress(log_level, out.chomp(prefix))
         else
           log_progress(log_level, out)
-          @log_on_progress = true
+        end
+      else
+        if out.end_with?("#{prefix}")
+          log_progress(log_level, prefix + out.chomp(prefix))
+        else
+          Kameleon.log_on_progress = true
+          log_progress(log_level, prefix + out)
         end
       end
     end
 
-    def log(log_level, msg)
-      @logger.info msg if log_level == "info"
-      @logger.error msg if log_level == "error"
-      @logger.debug msg if log_level == "debug"
-    end
-
     def log_progress(log_level, msg)
-      @logger.progress_info msg if log_level == "info"
-      @logger.progress_error msg if log_level == "error"
-      @logger.debug msg if log_level == "debug"
+      Kameleon.ui.confirm(msg, false) if log_level == "info"
+      Kameleon.ui.error(msg, false) if log_level == "error"
+      Kameleon.ui.debug msg if log_level == "debug"
     end
 
     def execute(cmd, kwargs = {})
-      lazyload_shell
+      load_shell
       cmd_with_prefix = "#{@exec_prefix} #{cmd}"
-      cmd_with_prefix.split( /\r?\n/ ).each {|m| @logger.debug "+ #{m}" }
+      cmd_with_prefix.split( /\r?\n/ ).each {|m| Kameleon.ui.debug "+ #{m}" }
       log_level = kwargs.fetch(:log_level, "info")
       exit_status = @shell.execute(cmd_with_prefix, kwargs) do |out, err|
         do_log(out, log_level) unless out.nil?
         do_log(err, "error") unless err.nil?
       end
-      @logger.debug("Exit status : #{exit_status}")
+      Kameleon.ui.debug("Exit status : #{exit_status}")
       fail ExecError unless exit_status.eql? 0
     rescue ShellError, Errno::EPIPE  => e
-      @logger.debug("Shell cmd failed to launch: #{@shell.shell_cmd}")
-      raise ShellError, e.message + ". Check the cmd argument of the '#{@name}_context'."
+      Kameleon.ui.debug("Shell cmd failed to launch: #{@shell.shell_cmd}")
+      raise ExecError, e.message + ". The '#{@name}_context' is inaccessible."
     end
 
     def pipe(cmd, other_cmd, other_ctx)
-      tmp = Tempfile.new("pipe-#{ Kameleon::Utils.generate_slug(cmd)[0..20] }")
-      @logger.debug("Running piped commands")
-      @logger.debug("Saving STDOUT from #{@name}_ctx to local file #{tmp.path}")
-      execute(cmd, :stdout => tmp)
-      tmp.close
-      @logger.debug("Forwarding #{tmp.path} to STDIN of #{other_ctx.name}_ctx")
+      if @cache.mode == :from then
+        Kameleon.ui.info("Redirecting pipe into cache")
+        tmp = @cache.get_cache_cmd(cmd)
+      else
+        tmp = Tempfile.new("pipe-#{ Kameleon::Utils.generate_slug(cmd)[0..20] }")
+        Kameleon.ui.debug("Running piped commands")
+        Kameleon.ui.debug("Saving STDOUT from #{@name}_ctx to local file #{tmp.path}")
+        execute(cmd, :stdout => tmp)
+        tmp.close
+      end
+      ## Saving one side of the pipe into the cache
+      if @cache.mode == :build then
+        @cache.cache_cmd(cmd,tmp.path)
+      end
+
+      Kameleon.ui.debug("Forwarding #{tmp.path} to STDIN of #{other_ctx.name}_ctx")
       dest_pipe_path = "${KAMELEON_WORKDIR}/pipe-#{ Kameleon::Utils.generate_slug(other_cmd)[0..20] }"
       other_ctx.send_file(tmp.path, dest_pipe_path)
       other_cmd_with_pipe = "cat #{dest_pipe_path} | #{other_cmd} && rm #{dest_pipe_path}"
       other_ctx.execute(other_cmd_with_pipe)
     end
 
-    def lazyload_shell()
-      unless @shell.started?
+    def load_shell()
+      unless @shell.started? || @shell.exited?
         @shell.restart
-        # Start the shell process
         execute("echo The '#{name}_context' has been initialized", :log_level => "info")
+        @already_loaded = true
       end
-    rescue
+    rescue Exception => e
       @shell.stop
-      raise
+      if @fail_silently
+        e.message.split( /\r?\n/ ).each {|m| Kameleon.ui.error m }
+      else
+        raise
+      end
     end
 
     def start_shell
       #TODO: Load env and history
-      lazyload_shell
-      @logger.info("Starting interactive shell")
+      load_shell
+      Kameleon.ui.info("Starting interactive shell")
       @shell.fork_and_wait
     rescue ShellError => e
-      e.message.split( /\r?\n/ ).each {|m| @logger.error m }
+      e.message.split( /\r?\n/ ).each {|m| Kameleon.ui.error m }
     end
 
     def closed?
@@ -107,8 +135,13 @@ module Kameleon
       @shell.stop
     end
 
-    def reopen
-      @shell.restart
+    def reload
+      @shell = Kameleon::Shell.new(@name,
+                                   @cmd,
+                                   @workdir,
+                                   @local_workdir,
+                                   @proxy_cache)
+      @shell.start
     end
 
     def send_file(source_path, dest_path)

data/lib/kameleon/engine.rb

@@ -1,110 +1,137 @@
 require 'kameleon/recipe'
 require 'kameleon/context'
 require 'kameleon/persistent_cache'
-
 module Kameleon
 
   class Engine
     attr_accessor :recipe
     attr_accessor :cwd
-    attr_accessor :build_recipe_path
-    attr_accessor :pretty_list_checkpoints
 
     def initialize(recipe, options)
       @options = options
-      @logger = Log4r::Logger.new("kameleon::[kameleon]")
       @recipe = recipe
       @cleaned_sections = []
       @cwd = @recipe.global["kameleon_cwd"]
       @build_recipe_path = File.join(@cwd, "kameleon_build_recipe.yaml")
 
+      @recipe.global["persistent_cache"] = @options[:cache] ? "true" : "false"
+
       build_recipe = load_build_recipe
       # restore previous build uuid
       unless build_recipe.nil?
-        # binding.pry
         %w(kameleon_uuid kameleon_short_uuid).each do |key|
           @recipe.global[key] = build_recipe["global"][key]
         end
       end
-
-      @enable_checkpoint = !@options[:no_checkpoint]
+      @enable_checkpoint = @options[:checkpoint]
       # Check if the recipe have checkpoint entry
-      @enable_checkpoint = !@recipe.checkpoint.nil? if @enable_checkpoint
+      if @enable_checkpoint && @recipe.checkpoint.nil?
+        fail BuildError, "Checkpoint is unavailable for this recipe"
+      end
 
       @recipe.resolve!
 
       if @options[:cache] || @options[:from_cache] then
         @cache = Kameleon::Persistent_cache.instance
-        @cache.activated = true
         @cache.cwd = @cwd
         @cache.polipo_path = @options[:proxy_path]
-        @cache.check_polipo_binary
         @cache.name = @recipe.name
-        #saving_steps_files
+        @cache.mode = @options[:cache] ? :build : :from
+        @cache.cache_path = @options[:from_cache]
+        @cache.recipe_files = @recipe.files # I'm passing the Pathname objects
+        @cache.recipe_path = @recipe.path
+
+        if @recipe.global["in_context"]["proxy_cache"].nil? then
+          raise BuildError, "Missing varible for in context 'proxy_cache' when using the option --cache"
+        end
+
+        if @recipe.global["out_context"]["proxy_cache"].nil? then
+          raise BuildError, "Missing varible for out context 'proxy_cache' when using the option --cache"
+        end
       end
 
-      @in_context = nil
       begin
-        @logger.notice("Creating kameleon working directory : #{@cwd}")
+        Kameleon.ui.info("Creating kameleon build directory : #{@cwd}")
         FileUtils.mkdir_p @cwd
       rescue
-        raise BuildError, "Failed to create working directory #{@cwd}"
+        raise BuildError, "Failed to create build directory #{@cwd}"
       end
-      @logger.notice("Building local context [local]")
-      @local_context = Context.new("local", "bash", @cwd, "", @cwd)
-      @logger.notice("Building external context [out]")
+      @cache.start if @cache
+      build_contexts
+    end
+
+    def build_contexts
+      lazyload = @options.fetch(:lazyload, true)
+      fail_silently = @options.fetch(:fail_silently, false)
+      proxy_cache_out = @recipe.global["out_context"]["proxy_cache"]
+      proxy_cache_in = @recipe.global["in_context"]["proxy_cache"]
+
+      Kameleon.ui.debug("Building local context [local]")
+      @local_context = Context.new("local", "bash", @cwd, "", @cwd,
+                                   :proxy_cache => "localhost",
+                                   :lazyload => false,
+                                   :fail_silently => false)
+      Kameleon.ui.debug("Building external context [out]")
       @out_context = Context.new("out",
                                  @recipe.global["out_context"]["cmd"],
                                  @recipe.global["out_context"]["workdir"],
                                  @recipe.global["out_context"]["exec_prefix"],
-                                 @cwd)
-      @logger.notice("Building internal context [in]")
+                                 @cwd,
+                                 :proxy_cache => proxy_cache_out,
+                                 :lazyload => lazyload,
+                                 :fail_silently => fail_silently)
+
+      Kameleon.ui.debug("Building internal context [in]")
       @in_context = Context.new("in",
                                 @recipe.global["in_context"]["cmd"],
                                 @recipe.global["in_context"]["workdir"],
                                 @recipe.global["in_context"]["exec_prefix"],
-                                @cwd)
-      if @options[:from_cache] then
-        begin
-          @cache.unpack(@options[:from_cache])
-        rescue
-          raise BuildError, "Failed to untar the persistent cache file"
-        end
-      end
+                                @cwd,
+                                :proxy_cache => proxy_cache_in,
+                                :lazyload => lazyload,
+                                :fail_silently => fail_silently)
     end
 
     def saving_steps_files
       @recipe.files.each do |file|
-        @logger.notice("File #{file} loaded from the recipe")
-        sleep 1
+        Kameleon.ui.info("File #{file} loaded from the recipe")
       end
 
     end
 
     def create_cache_directory(step_name)
-      @logger.notice("Creating directory for cache #{step_name}")
+      Kameleon.ui.debug("Creating directory for cache #{step_name}")
       directory_name = @cache.cache_dir + "/#{step_name}"
       FileUtils.mkdir_p directory_name
       directory_name
     end
 
     def create_checkpoint(microstep_id)
-      cmd = @recipe.checkpoint["create"].gsub("@microstep_id", microstep_id)
-      create_cmd = Kameleon::Command.new({"exec_out" => cmd}, "checkpoint")
-      safe_exec_cmd(create_cmd, :log_level => "debug")
+      @recipe.checkpoint["create"].each do |cmd|
+        safe_exec_cmd(cmd.dup.gsub!("@microstep_id", microstep_id))
+      end
+    end
+
+    def checkpoint_enabled?
+      @recipe.checkpoint["enabled?"].each do |cmd|
+        exec_cmd(cmd, :log_level => "debug")
+      end
+      return true
+    rescue ExecError
+      return false
     end
 
     def apply_checkpoint(microstep_id)
-      cmd = @recipe.checkpoint["apply"].gsub("@microstep_id", microstep_id)
-      apply_cmd = Kameleon::Command.new({"exec_out" => cmd}, "checkpoint")
-      safe_exec_cmd(apply_cmd, :log_level => "debug")
+      @recipe.checkpoint["apply"].each do |cmd|
+        safe_exec_cmd(cmd.dup.gsub!("@microstep_id", microstep_id))
+      end
     end
 
     def list_all_checkpoints
       list = ""
-      cmd = Kameleon::Command.new({"exec_out" => @recipe.checkpoint['list']},
-                                  "checkpoint")
-      safe_exec_cmd(cmd, :stdout => list)
+      @recipe.checkpoint["list"].each do |cmd|
+        safe_exec_cmd(cmd, :stdout => list)
+      end
       return list.split(/\r?\n/)
     end
 
@@ -124,34 +151,36 @@ module Kameleon
     def do_steps(section_name)
       section = @recipe.sections.fetch(section_name)
       section.sequence do |macrostep|
-
         if @cache then
+          Kameleon.ui.info("Starting proxy cache server for macrostep '#{macrostep.name}'...")
           # the following function start a polipo web proxy and stops a previous run
-          dir_cache = @cache.create_cache_directory(macrostep.name) #unless @options[:from_cache]
+          dir_cache = @cache.create_cache_directory(macrostep.name)
           @cache.start_web_proxy_in(dir_cache)
         end
-
         macrostep.sequence do |microstep|
-          @logger.notice("Step #{ microstep.order } : #{ microstep.slug }")
+          step_prefix = "Step #{ microstep.order } : "
+          Kameleon.ui.info("#{step_prefix}#{ microstep.slug }")
           if @enable_checkpoint
             if microstep.on_checkpoint == "skip"
-              @logger.notice(" ---> Skipped")
+              Kameleon.ui.info("--> Skipped")
               next
             end
             if microstep.in_cache && microstep.on_checkpoint == "use_cache"
-              @logger.notice(" ---> Using cache this time")
+              Kameleon.ui.info("--> Using checkpoint")
             else
-              @logger.notice(" ---> Running step")
+              Kameleon.ui.info("--> Running the step...")
               microstep.commands.each do |cmd|
                 safe_exec_cmd(cmd)
               end
               unless microstep.on_checkpoint == "redo"
-                @logger.notice(" ---> Creating checkpoint : #{ microstep.identifier }")
-                create_checkpoint(microstep.identifier)
+                if checkpoint_enabled?
+                  Kameleon.ui.info("--> Creating checkpoint : #{ microstep.identifier }")
+                  create_checkpoint(microstep.identifier)
+                end
               end
             end
           else
-            @logger.notice(" ---> Running step")
+            Kameleon.ui.info("--> Running the step...")
             microstep.commands.each do |cmd|
               safe_exec_cmd(cmd)
             end
@@ -159,12 +188,6 @@ module Kameleon
         end
       end
       @cleaned_sections.push(section.name)
-
-      if @cache then
-        @cache.stop_web_proxy
-        @cache.pack unless @options[:from_cache]
-      end
-
     end
 
     def safe_exec_cmd(cmd, kwargs = {})
@@ -178,11 +201,23 @@ module Kameleon
     end
 
     def exec_cmd(cmd, kwargs = {})
+      map = {"exec_in" => @in_context,
+             "exec_out" => @out_context,
+             "exec_local" => @local_context}
       case cmd.key
       when "breakpoint"
         breakpoint(cmd.value)
+      when "reload_context"
+        context = "exec_" + cmd.value
+        expected_names = map.keys.map { |k| k.gsub "exec_", "" }
+        unless map.keys.include? context
+          Kameleon.ui.error("Invalid context name arguments. Expected : "\
+                           "#{expected_names}")
+          fail ExecError
+        else
+          map[context].reload
+        end
       when "exec_in"
-        skip_alert(cmd) if @in_context.nil?
         @in_context.execute(cmd.value, kwargs)
       when "exec_out"
         @out_context.execute(cmd.value, kwargs)
@@ -193,32 +228,31 @@ module Kameleon
         expected_cmds = ["exec_in", "exec_out", "exec_local"]
         [first_cmd.key, second_cmd.key].each do |key|
           unless expected_cmds.include?(key)
-            @logger.error("Invalid pipe arguments. Expected "\
-                          "#{expected_cmds} commands")
+            Kameleon.ui.error("Invalid pipe arguments. Expected : "\
+                              "#{expected_cmds}")
             fail ExecError
           end
         end
-        map = {"exec_in" => @in_context,
-               "exec_out" => @out_context,
-               "exec_local" => @local_context,}
         first_context = map[first_cmd.key]
         second_context = map[second_cmd.key]
+        @cache.cache_cmd_id(cmd.identifier) if @cache
         first_context.pipe(first_cmd.value, second_cmd.value, second_context)
       when "rescue"
         first_cmd, second_cmd = cmd.value
         begin
           exec_cmd(first_cmd)
         rescue ExecError
-          exec_cmd(second_cmd)
+          safe_exec_cmd(second_cmd)
         end
       else
-        @logger.warn("Unknown command : #{cmd.key}")
+        Kameleon.ui.warn("Unknown command : #{cmd.key}")
       end
     end
 
 
     def breakpoint(message, kwargs = {})
-      message.split( /\r?\n/ ).each {|m| @logger.error "#{m}" }
+      message = "Kameleon breakpoint!" if message.nil?
+      message.split( /\r?\n/ ).each {|m| Kameleon.ui.error "#{m}" }
       enable_retry = kwargs[:enable_retry]
       msg = ""
       msg << "Press [r] to retry\n" if enable_retry
@@ -233,13 +267,16 @@ module Kameleon
       responses.merge!({"o" => "launch out_context"})
       responses.merge!({"i" => "launch in_context"})
       while true
-        msg.split( /\r?\n/ ).each {|m| @logger.notice "#{m}" }
-        @logger.progress_notice "answer ? [" + responses.keys().join("/") + "]: "
-        answer = $stdin.gets
+        msg.split( /\r?\n/ ).each {|m| Kameleon.ui.info "#{m}" }
+        if Kameleon.env.script?
+          answer = "a"
+        else
+          answer = Kameleon.ui.ask "answer ? [" + responses.keys().join("/") + "]: "
+        end
         raise AbortError, "Execution aborted..." if answer.nil?
         answer.chomp!
         if responses.keys.include?(answer)
-          @logger.notice("User choice : [#{answer}] #{responses[answer]}")
+          Kameleon.ui.info("User choice : [#{answer}] #{responses[answer]}")
           if ["o", "i", "l"].include?(answer)
             if answer.eql? "l"
               @local_context.start_shell
@@ -248,7 +285,7 @@ module Kameleon
             else
               @in_context.start_shell
             end
-            @logger.notice("Getting back to Kameleon...")
+            Kameleon.ui.info("Getting back to Kameleon...")
           elsif answer.eql? "a"
             raise AbortError, "Execution aborted..."
           elsif answer.eql? "c"
@@ -258,7 +295,7 @@ module Kameleon
             @local_context.execute("true") unless @local_context.closed?
             return true
           elsif answer.eql? "r"
-            @logger.notice("Retrying the previous command...")
+            Kameleon.ui.info("Retrying the previous command...")
             return false
           end
         end
@@ -268,25 +305,43 @@ module Kameleon
     def rescue_exec_error(cmd)
       message = "Error occured when executing the following command :\n"
       cmd.string_cmd.split( /\r?\n/ ).each {|m| message << "\n> #{m}" }
+      if Kameleon.env.script?
+        raise ExecError, message
+      end
       return breakpoint(message, :enable_retry => true)
     end
 
-    def clean()
+    def clean(kwargs = {})
+      map = {"exec_in" => @in_context,
+             "exec_out" => @out_context,
+             "exec_local" => @local_context}
+      if kwargs.fetch(:with_checkpoint, false)
+        Kameleon.ui.info("Removing all checkpoints")
+        @recipe.checkpoint["clear"].each do |cmd|
+          if map.keys.include? cmd.key
+            begin
+              exec_cmd(cmd) unless map[cmd.key].closed?
+            rescue
+              Kameleon.ui.warn("An error occurred while executing : #{cmd.value}")
+            end
+          end
+        end
+      end
       @recipe.sections.values.each do |section|
         next if @cleaned_sections.include?(section.name)
-        map = {"exec_in" => @in_context,
-               "exec_out" => @out_context,
-               "exec_local" => @local_context}
-        @logger.notice("Cleaning #{section.name} section")
+        Kameleon.ui.info("Cleaning #{section.name} section")
         section.clean_macrostep.sequence do |microstep|
+          if @enable_checkpoint
+            if microstep.on_checkpoint == "skip"
+              next
+            end
+          end
           microstep.commands.each do |cmd|
             if map.keys.include? cmd.key
-              unless map[cmd.key].closed?
-                begin
-                  exec_cmd(cmd)
-                rescue
-                  @logger.warn("An error occurred while executing : #{cmd.value}")
-                end
+              begin
+                exec_cmd(cmd) unless map[cmd.key].closed?
+              rescue
+                Kameleon.ui.warn("An error occurred while executing : #{cmd.value}")
               end
             end
           end
@@ -295,16 +350,6 @@ module Kameleon
       @cache.stop_web_proxy if @options[:cache] ## stopping polipo
     end
 
-    def clear
-      clean
-      unless @recipe.checkpoint.nil?
-        @logger.notice("Removing all old checkpoints")
-        cmd = @recipe.checkpoint["clear"]
-        clear_cmd = Kameleon::Command.new({"exec_out" => cmd}, "checkpoint")
-        safe_exec_cmd(clear_cmd, :log_level => "info")
-      end
-    end
-
     def build
       if @enable_checkpoint
         @from_checkpoint = @options[:from_checkpoint]
@@ -318,7 +363,7 @@ module Kameleon
           end
         end
         unless @from_checkpoint.nil?
-          @logger.notice("Restoring last build from step : #{@from_checkpoint}")
+          Kameleon.ui.info("Restoring last build from step : #{@from_checkpoint}")
           apply_checkpoint @from_checkpoint
           @recipe.microsteps.each do |microstep|
             microstep.in_cache = true
@@ -333,24 +378,25 @@ module Kameleon
         ["bootstrap", "setup", "export"].each do |section|
           do_steps(section)
         end
+        @cache.stop if @cache
         clean
       rescue Exception => e
         if e.is_a?(AbortError)
-          @logger.error("Aborted...")
+          Kameleon.ui.error("Aborted...")
         elsif e.is_a?(SystemExit) || e.is_a?(Interrupt)
-          @logger.error("Interrupted...")
-          @out_context.reopen
-          @in_context.reopen
-          @local_context.reopen
+          Kameleon.ui.error("Interrupted...")
+          @out_context.reload if @out_context.already_loaded?
+          @in_context.reload  if @in_context.already_loaded?
+          @local_context.reload  if @local_context.already_loaded?
         else
-          @logger.fatal("fatal error...")
+          Kameleon.ui.error("fatal error...")
         end
-        @logger.warn("Waiting for cleanup before exiting...")
+        Kameleon.ui.warn("Waiting for cleanup before exiting...")
         clean
         @out_context.close!
         @in_context.close!
         @local_context.close!
-        raise
+        raise e
       end
     end
 
@@ -369,15 +415,13 @@ module Kameleon
     end
 
     def pretty_checkpoints_list
-
-
       def find_microstep_slug_by_id(id)
         @recipe.microsteps.each do |m|
           return m.slug if m.identifier == id
         end
       end
       dict_checkpoints = []
-      if @enable_checkpoint
+      unless @recipe.checkpoint.nil?
         list_checkpoints.each do |id|
           slug = find_microstep_slug_by_id id
           unless slug.nil?