pups 1.0.0 → 1.1.1

data/lib/pups/command.rb

@@ -1,17 +1,20 @@
-class Pups::Command
+# frozen_string_literal: true
 
-  def self.run(command,params)
-    case command
-      when String then self.from_str(command,params).run
-      when Hash then self.from_hash(command,params).run
+module Pups
+  class Command
+    def self.run(command, params)
+      case command
+      when String then from_str(command, params).run
+      when Hash then from_hash(command, params).run
+      end
     end
-  end
 
-  def self.interpolate_params(cmd,params)
-    Pups::Config.interpolate_params(cmd,params)
-  end
+    def self.interpolate_params(cmd, params)
+      Pups::Config.interpolate_params(cmd, params)
+    end
 
-  def interpolate_params(cmd)
-    Pups::Command.interpolate_params(cmd,@params)
+    def interpolate_params(cmd)
+      Pups::Command.interpolate_params(cmd, @params)
+    end
   end
 end

data/lib/pups/config.rb

@@ -1,115 +1,171 @@
-class Pups::Config
+# frozen_string_literal: true
 
-  attr_reader :config, :params
+module Pups
+  class Config
+    attr_reader :config, :params
 
-  def self.load_file(config_file)
-    new YAML.load_file(config_file)
-  end
+    def initialize(config, ignored = nil)
+      @config = config
 
-  def self.load_config(config)
-    new YAML.load(config)
-  end
+      # remove any ignored config elements prior to any more processing
+      ignored&.each { |e| @config.delete(e) }
+
+      # set some defaults to prevent checks in various functions
+      ['env_template', 'env', 'labels', 'params'].each { |key| @config[key] = {} unless @config.has_key?(key) }
+
+      # Order here is important.
+      Pups::Config.combine_template_and_process_env(@config, ENV)
+      Pups::Config.prepare_env_template_vars(@config['env_template'], ENV)
+
+      # Templating is supported in env and label variables.
+      Pups::Config.transform_config_with_templated_vars(@config['env_template'], ENV)
+      Pups::Config.transform_config_with_templated_vars(@config['env_template'], @config['env'])
+      Pups::Config.transform_config_with_templated_vars(@config['env_template'], @config['labels'])
 
-  def initialize(config)
-    @config = config
-    validate!(@config)
-    @params = @config["params"]
-    @params ||= {}
-    ENV.each do |k,v|
-      @params["$ENV_#{k}"] = v
+      @params = @config["params"]
+      ENV.each do |k, v|
+        @params["$ENV_#{k}"] = v
+      end
+      inject_hooks
     end
-    inject_hooks
-  end
 
-  def validate!(conf)
-    # raise proper errors if nodes are missing etc
-  end
+    def self.load_file(config_file, ignored = nil)
+      Config.new(YAML.load_file(config_file), ignored)
+    rescue Exception
+      warn "Failed to parse #{config_file}"
+      warn "This is probably a formatting error in #{config_file}"
+      warn "Cannot continue. Edit #{config_file} and try again."
+      raise
+    end
 
-  def inject_hooks
-    return unless hooks = @config["hooks"]
+    def self.load_config(config, ignored = nil)
+      Config.new(YAML.safe_load(config), ignored)
+    end
 
-    run = @config["run"]
+    def self.prepare_env_template_vars(env_template, env)
+      # Merge env_template variables from env and templates.
+      env.each do |k, v|
+        if k.include?('env_template_')
+          key = k.gsub('env_template_', '')
+          env_template[key] = v.to_s
+        end
+      end
+    end
 
-    positions = {}
-    run.each do |row|
-      if Hash === row
-        command = row.first
-        if Hash === command[1]
-          hook = command[1]["hook"]
-          positions[hook] = row if hook
+    def self.transform_config_with_templated_vars(env_template, to_transform)
+      # Transform any templated variables prior to copying to params.
+      # This has no effect if no env_template was provided.
+      env_template.each do |k, v|
+        to_transform.each do |key, val|
+          if val.to_s.include?("{{#{k}}}")
+            to_transform[key] = val.gsub("{{#{k}}}", v.to_s)
+          end
         end
       end
     end
 
-    hooks.each do |full, list|
+    def self.combine_template_and_process_env(config, env)
+      # Merge all template env variables and process env variables, so that env
+      # variables can be provided both by configuration and runtime variables.
+      config["env"].each { |k, v| env[k] = v.to_s }
+    end
 
-      offset = nil
-      name = nil
+    def inject_hooks
+      return unless hooks = @config['hooks']
 
-      if full =~ /^after_/
-        name = full[6..-1]
-        offset = 1
-      end
+      run = @config['run']
 
-      if full =~ /^before_/
-        name = full[7..-1]
-        offset = 0
+      positions = {}
+      run.each do |row|
+        next unless row.is_a?(Hash)
+
+        command = row.first
+        if command[1].is_a?(Hash)
+          hook = command[1]['hook']
+          positions[hook] = row if hook
+        end
       end
 
-      index = run.index(positions[name])
+      hooks.each do |full, list|
+        offset = nil
+        name = nil
+
+        if full =~ /^after_/
+          name = full[6..-1]
+          offset = 1
+        end
+
+        if full =~ /^before_/
+          name = full[7..-1]
+          offset = 0
+        end
+
+        index = run.index(positions[name])
 
-      if index && index >= 0
-        run.insert(index + offset, *list)
-      else
-        Pups.log.info "Skipped missing #{full} hook"
+        if index && index >= 0
+          run.insert(index + offset, *list)
+        else
+          Pups.log.info "Skipped missing #{full} hook"
+        end
       end
+    end
 
+    def generate_docker_run_arguments
+      output = []
+      output << Pups::Docker.generate_env_arguments(config['env'])
+      output << Pups::Docker.generate_link_arguments(config['links'])
+      output << Pups::Docker.generate_expose_arguments(config['expose'])
+      output << Pups::Docker.generate_volume_arguments(config['volumes'])
+      output << Pups::Docker.generate_label_arguments(config['labels'])
+      output.sort!.join(" ").strip
     end
-  end
 
-  def run
-    run_commands
-  rescue => e
-    puts
-    puts
-    puts "FAILED"
-    puts "-" * 20
-    puts "#{e.class}: #{e}"
-    puts "Location of failure: #{e.backtrace[0]}"
-    if @last_command
-      puts "#{@last_command[:command]} failed with the params #{@last_command[:params].inspect}"
+    def run
+      run_commands
+    rescue StandardError => e
+      exit_code = 1
+      exit_code = e.exit_code if e.is_a?(Pups::ExecError)
+      unless exit_code == 77
+        puts
+        puts
+        puts 'FAILED'
+        puts '-' * 20
+        puts "#{e.class}: #{e}"
+        puts "Location of failure: #{e.backtrace[0]}"
+        puts "#{@last_command[:command]} failed with the params #{@last_command[:params].inspect}" if @last_command
+      end
+      exit exit_code
     end
-    exit 1
-  end
 
-  def run_commands
-    @config["run"].each do |item|
-      item.each do |k,v|
-        type = case k
-                  when "exec" then Pups::ExecCommand
-                  when "merge" then Pups::MergeCommand
-                  when "replace" then Pups::ReplaceCommand
-                  when "file" then Pups::FileCommand
-                  else raise SyntaxError.new("Invalid run command #{k}")
-              end
-
-        @last_command = { command: k, params: v }
-        type.run(v, @params)
+    def run_commands
+      @config['run']&.each do |item|
+        item.each do |k, v|
+          type = case k
+                 when 'exec' then Pups::ExecCommand
+                 when 'merge' then Pups::MergeCommand
+                 when 'replace' then Pups::ReplaceCommand
+                 when 'file' then Pups::FileCommand
+                 else raise SyntaxError, "Invalid run command #{k}"
+          end
+
+          @last_command = { command: k, params: v }
+          type.run(v, @params)
+        end
       end
     end
-  end
 
-  def interpolate_params(cmd)
-    self.class.interpolate_params(cmd,@params)
-  end
+    def interpolate_params(cmd)
+      self.class.interpolate_params(cmd, @params)
+    end
+
+    def self.interpolate_params(cmd, params)
+      return unless cmd
 
-  def self.interpolate_params(cmd, params)
-    return unless cmd
-    processed = cmd.dup
-    params.each do |k,v|
-      processed.gsub!("$#{k}", v.to_s)
+      processed = cmd.dup
+      params.each do |k, v|
+        processed.gsub!("$#{k}", v.to_s)
+      end
+      processed
     end
-    processed
   end
-
 end

data/lib/pups/docker.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+require 'shellwords'
+
+class Pups::Docker
+  class << self
+    def generate_env_arguments(config)
+      output = []
+      config&.each do |k, v|
+        if !v.to_s.empty?
+          output << "--env #{k}=#{escape_user_string_literal(v)}"
+        end
+      end
+      normalize_output(output)
+    end
+
+    def generate_link_arguments(config)
+      output = []
+      config&.each do |c|
+        output << "--link #{c['link']['name']}:#{c['link']['alias']}"
+      end
+      normalize_output(output)
+    end
+
+    def generate_expose_arguments(config)
+      output = []
+      config&.each do |c|
+        if c.to_s.include?(":")
+          output << "--publish #{c}"
+        else
+          output << "--expose #{c}"
+        end
+      end
+      normalize_output(output)
+    end
+
+    def generate_volume_arguments(config)
+      output = []
+      config&.each do |c|
+        output << "--volume #{c['volume']['host']}:#{c['volume']['guest']}"
+      end
+      normalize_output(output)
+    end
+
+    def generate_label_arguments(config)
+      output = []
+      config&.each do |k, v|
+        output << "--label #{k}=#{escape_user_string_literal(v)}"
+      end
+      normalize_output(output)
+    end
+
+    private
+    def escape_user_string_literal(str)
+      # We need to escape the following strings as they are more likely to contain
+      # special characters than any of the other config variables on a Linux system:
+      # - the value side of an environment variable
+      # - the value side of a label.
+      Shellwords.escape(str)
+    end
+
+    def normalize_output(output)
+      if output.empty?
+        ""
+      else
+        output.join(" ")
+      end
+    end
+  end
+end

data/lib/pups/exec_command.rb

@@ -1,116 +1,128 @@
-require 'timeout'
+# frozen_string_literal: true
 
-class Pups::ExecCommand < Pups::Command
-  attr_reader :commands, :cd
-  attr_accessor :background, :raise_on_fail, :stdin, :stop_signal
+require 'timeout'
+require 'English'
 
-  def self.terminate_async(opts={})
+module Pups
+  class ExecCommand < Pups::Command
+    attr_reader :commands, :cd
+    attr_accessor :background, :raise_on_fail, :stdin, :stop_signal
 
-    return unless defined? @@asyncs
+    def self.terminate_async(opts = {})
+      return unless defined? @@asyncs
 
-    Pups.log.info("Terminating async processes")
+      Pups.log.info('Terminating async processes')
 
-    @@asyncs.each do |async|
-      Pups.log.info("Sending #{async[:stop_signal]} to #{async[:command]} pid: #{async[:pid]}")
-      Process.kill(async[:stop_signal],async[:pid]) rescue nil
-    end
-
-    @@asyncs.map do |async|
-      Thread.new do
+      @@asyncs.each do |async|
+        Pups.log.info("Sending #{async[:stop_signal]} to #{async[:command]} pid: #{async[:pid]}")
         begin
+          Process.kill(async[:stop_signal], async[:pid])
+        rescue StandardError
+          nil
+        end
+      end
+
+      @@asyncs.map do |async|
+        Thread.new do
           Timeout.timeout(opts[:wait] || 10) do
-            Process.wait(async[:pid]) rescue nil
+            Process.wait(async[:pid])
+          rescue StandardError
+            nil
           end
         rescue Timeout::Error
           Pups.log.info("#{async[:command]} pid:#{async[:pid]} did not terminate cleanly, forcing termination!")
           begin
-            Process.kill("KILL",async[:pid])
+            Process.kill('KILL', async[:pid])
             Process.wait(async[:pid])
           rescue Errno::ESRCH
           rescue Errno::ECHILD
           end
-
         end
-      end
-    end.each(&:join)
-
-  end
-
-  def self.from_hash(hash, params)
-    cmd = new(params, hash["cd"])
-
-    case c = hash["cmd"]
-    when String then cmd.add(c)
-    when Array then c.each{|i| cmd.add(i)}
+      end.each(&:join)
     end
 
-    cmd.background = hash["background"]
-    cmd.stop_signal = hash["stop_signal"] || "TERM"
-    cmd.raise_on_fail = hash["raise_on_fail"] if hash.key? "raise_on_fail"
-    cmd.stdin = interpolate_params(hash["stdin"], params)
+    def self.from_hash(hash, params)
+      cmd = new(params, hash['cd'])
 
-    cmd
-  end
+      case c = hash['cmd']
+      when String then cmd.add(c)
+      when Array then c.each { |i| cmd.add(i) }
+      end
 
-  def self.from_str(str, params)
-    cmd = new(params)
-    cmd.add(str)
-    cmd
-  end
+      cmd.background = hash['background']
+      cmd.stop_signal = hash['stop_signal'] || 'TERM'
+      cmd.raise_on_fail = hash['raise_on_fail'] if hash.key? 'raise_on_fail'
+      cmd.stdin = interpolate_params(hash['stdin'], params)
 
-  def initialize(params, cd = nil)
-    @commands = []
-    @params = params
-    @cd = interpolate_params(cd)
-    @raise_on_fail = true
-  end
+      cmd
+    end
 
-  def add(cmd)
-    @commands << process_params(cmd)
-  end
+    def self.from_str(str, params)
+      cmd = new(params)
+      cmd.add(str)
+      cmd
+    end
 
-  def run
-    commands.each do |command|
-      Pups.log.info("> #{command}")
-      pid = spawn(command)
-      Pups.log.info(@result.readlines.join("\n")) if @result
-      pid
+    def initialize(params, cd = nil)
+      @commands = []
+      @params = params
+      @cd = interpolate_params(cd)
+      @raise_on_fail = true
     end
-  rescue
-    raise if @raise_on_fail
-  end
 
-  def spawn(command)
-    if background
-      pid = Process.spawn(command)
-      (@@asyncs ||= []) << {pid: pid, command: command, stop_signal: (stop_signal || "TERM")}
-      Thread.new do
-        Process.wait(pid)
-        @@asyncs.delete_if{|async| async[:pid] == pid}
-      end
-      return pid
+    def add(cmd)
+      @commands << process_params(cmd)
     end
 
-    IO.popen(command, "w+") do |f|
-      if stdin
-        # need a way to get stdout without blocking
-        Pups.log.info(stdin)
-        f.write stdin
-        f.close
-      else
-        Pups.log.info(f.readlines.join)
+    def run
+      commands.each do |command|
+        Pups.log.info("> #{command}")
+        pid = spawn(command)
+        Pups.log.info(@result.readlines.join("\n")) if @result
+        pid
       end
+    rescue StandardError
+      raise if @raise_on_fail
     end
 
-    raise RuntimeError.new("#{command} failed with return #{$?.inspect}") unless $? == 0
+    def spawn(command)
+      if background
+        pid = Process.spawn(command)
+        (@@asyncs ||= []) << { pid: pid, command: command, stop_signal: (stop_signal || 'TERM') }
+        Thread.new do
+          begin
+            Process.wait(pid)
+          rescue Errno::ECHILD
+            # already exited so skip
+          end
+          @@asyncs.delete_if { |async| async[:pid] == pid }
+        end
+        return pid
+      end
+
+      IO.popen(command, 'w+') do |f|
+        if stdin
+          # need a way to get stdout without blocking
+          Pups.log.info(stdin)
+          f.write stdin
+          f.close
+        else
+          Pups.log.info(f.readlines.join)
+        end
+      end
 
-    nil
+      unless $CHILD_STATUS == 0
+        err = Pups::ExecError.new("#{command} failed with return #{$CHILD_STATUS.inspect}")
+        err.exit_code = $CHILD_STATUS.exitstatus
+        raise err
+      end
 
-  end
+      nil
+    end
 
-  def process_params(cmd)
-    processed = interpolate_params(cmd)
-    @cd ? "cd #{cd} && #{processed}" : processed
+    def process_params(cmd)
+      processed = interpolate_params(cmd)
+      @cd ? "cd #{cd} && #{processed}" : processed
+    end
   end
-
 end