pups 1.0.3 → 1.1.0

data/lib/pups/docker.rb

@@ -0,0 +1,73 @@
+# 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.
+      if str.to_s.include?(" ")
+        "\"#{Shellwords.escape(str)}\""
+      else
+        Shellwords.escape(str)
+      end
+    end
+
+    def normalize_output(output)
+      if output.empty?
+        ""
+      else
+        output.join(" ")
+      end
+    end
+  end
+end

data/lib/pups/exec_command.rb

@@ -1,124 +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
-        begin
-          Process.wait(pid)
-        rescue Errno::ECHILD
-          # already exited so skip
-        end
-        @@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
 
-    unless $? == 0
-      err = Pups::ExecError.new("#{command} failed with return #{$?.inspect}")
-      err.exit_code = $?.exitstatus
-      raise err
-    end
+    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
 
-    nil
+      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
 
-  end
+      unless $CHILD_STATUS == 0
+        err = Pups::ExecError.new("#{command} failed with return #{$CHILD_STATUS.inspect}")
+        err.exit_code = $CHILD_STATUS.exitstatus
+        raise err
+      end
 
-  def process_params(cmd)
-    processed = interpolate_params(cmd)
-    @cd ? "cd #{cd} && #{processed}" : processed
-  end
+      nil
+    end
 
+    def process_params(cmd)
+      processed = interpolate_params(cmd)
+      @cd ? "cd #{cd} && #{processed}" : processed
+    end
+  end
 end

data/lib/pups/file_command.rb

@@ -1,41 +1,37 @@
-class Pups::FileCommand < Pups::Command
-  attr_accessor :path, :contents, :params, :type, :chmod, :chown
+# frozen_string_literal: true
 
-  def self.from_hash(hash, params)
-    command = new
-    command.path = hash["path"]
-    command.contents = hash["contents"]
-    command.chmod = hash["chmod"]
-    command.chown = hash["chown"]
-    command.params = params
+module Pups
+  class FileCommand < Pups::Command
+    attr_accessor :path, :contents, :params, :type, :chmod, :chown
 
-    command
-  end
+    def self.from_hash(hash, params)
+      command = new
+      command.path = hash['path']
+      command.contents = hash['contents']
+      command.chmod = hash['chmod']
+      command.chown = hash['chown']
+      command.params = params
 
-  def initialize
-    @params = {}
-    @type = :bash
-  end
+      command
+    end
 
-  def params=(p)
-    @params = p
-  end
+    def initialize
+      @params = {}
+      @type = :bash
+    end
 
-  def run
-    path = interpolate_params(@path)
+    attr_writer :params
 
-    `mkdir -p #{File.dirname(path)}`
-    File.open(path, "w") do |f|
-      f.write(interpolate_params(contents))
-    end
-    if @chmod
-      `chmod #{@chmod} #{path}`
-    end
-    if @chown
-      `chown #{@chown} #{path}`
+    def run
+      path = interpolate_params(@path)
+
+      `mkdir -p #{File.dirname(path)}`
+      File.open(path, 'w') do |f|
+        f.write(interpolate_params(contents))
+      end
+      `chmod #{@chmod} #{path}` if @chmod
+      `chown #{@chown} #{path}` if @chown
+      Pups.log.info("File > #{path}  chmod: #{@chmod}  chown: #{@chown}")
     end
-    Pups.log.info("File > #{path}  chmod: #{@chmod}  chown: #{@chown}")
   end
-
 end
-

data/lib/pups/merge_command.rb

@@ -1,48 +1,50 @@
-class Pups::MergeCommand < Pups::Command
-  attr_reader :filename
-  attr_reader :merge_hash
-
-  def self.from_str(command, params)
-    new(command,params)
-  end
-
-  def self.parse_command(command)
-    split = command.split(" ")
-    raise ArgumentError.new("Invalid merge command #{command}") unless split[-1][0] == "$"
-
-    [split[0..-2].join(" ") , split[-1][1..-1]]
-  end
-
-  def initialize(command, params)
-    @params = params
-
-    filename, target_param = Pups::MergeCommand.parse_command(command)
-    @filename = interpolate_params(filename)
-    @merge_hash = params[target_param]
-  end
-
-  def run
-    merged = self.class.deep_merge(YAML.load_file(@filename), @merge_hash)
-    File.open(@filename,"w"){|f| f.write(merged.to_yaml) }
-    Pups.log.info("Merge: #{@filename} with: \n#{@merge_hash.inspect}")
+# frozen_string_literal: true
+
+module Pups
+  class MergeCommand < Pups::Command
+    attr_reader :filename, :merge_hash
+
+    def self.from_str(command, params)
+      new(command, params)
+    end
+
+    def self.parse_command(command)
+      split = command.split(' ')
+      raise ArgumentError, "Invalid merge command #{command}" unless split[-1][0] == '$'
+
+      [split[0..-2].join(' '), split[-1][1..-1]]
+    end
+
+    def initialize(command, params)
+      @params = params
+
+      filename, target_param = Pups::MergeCommand.parse_command(command)
+      @filename = interpolate_params(filename)
+      @merge_hash = params[target_param]
+    end
+
+    def run
+      merged = self.class.deep_merge(YAML.load_file(@filename), @merge_hash)
+      File.open(@filename, 'w') { |f| f.write(merged.to_yaml) }
+      Pups.log.info("Merge: #{@filename} with: \n#{@merge_hash.inspect}")
+    end
+
+    def self.deep_merge(first, second, *args)
+      args ||= []
+      merge_arrays = args.include? :merge_arrays
+
+      merger = proc { |_key, v1, v2|
+        if v1.is_a?(Hash) && v2.is_a?(Hash)
+          v1.merge(v2, &merger)
+        elsif v1.is_a?(Array) && v2.is_a?(Array)
+          merge_arrays ? v1 + v2 : v2
+        elsif v2.is_a?(NilClass)
+          v1
+        else
+          v2
+        end
+      }
+      first.merge(second, &merger)
+    end
   end
-
-  def self.deep_merge(first,second, *args)
-    args ||= []
-    merge_arrays = args.include? :merge_arrays
-
-    merger = proc { |key, v1, v2|
-      if Hash === v1 && Hash === v2
-        v1.merge(v2, &merger)
-      elsif Array === v1 && Array === v2
-        merge_arrays ? v1 + v2 : v2
-      elsif NilClass === v2
-        v1
-      else
-        v2
-      end
-    }
-    first.merge(second, &merger)
-  end
-
 end