pups 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f5203de15040af48165295c4d93c85351b5995c137e9334566877a7875733f05
-  data.tar.gz: 6337c83523bc6e0e17d9f3ba494d62e7a629415a4ce75f95db8e92e998837993
+  metadata.gz: 2474629aec1a6af05e0af5b4c87385bad16713e6fa86828f9233dd8140e5964f
+  data.tar.gz: 1bd85d9ed07b63633f9137aef9a7eae77537e05418eff260db5d1145ecbc999d
 SHA512:
-  metadata.gz: 8a4e356fde18db799f68049198eac4195a46c3d73f1919a66f473f195676a322a1759050bb01dfa6c447a4d705d6dce583bd6215e6a3412a339ffe55e2f57a48
-  data.tar.gz: 065473a360bac01f433757db10c513fc6790d49521218f6a3db5a55279386fa4ee89818c0aa16b07e37cc8f3375de705dae8fc9966191fabb2c17bf16675ad21
+  metadata.gz: 22d164fcb61b5e36da7893731bd51bf11ed9732ecd4540be6912a26c2ddbbeb7ded0c6f1f2d07abea66217d4d18d02e08aa365c73ed588b15d139978a6ed77f6
+  data.tar.gz: d45150d87661548887be59363d7de3b069f8ed094a5ebb71da89d920b449adf3002f21b0788a9b2e87bcfd40f6bd1852ef27eae3f53e36a9966530087ae88e5c

data/.github/workflows/ci.yml

@@ -1,12 +1,30 @@
-name: Tests
+name: CI
 
 on:
   push:
     branches:
-      - master
+      - main
   pull_request: {}
 
 jobs:
+  lint:
+    name: "pups lint"
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 5
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os: [ubuntu-latest]
+        ruby: ["3.2"]
+
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rubocop
   test:
     name: "pups tests"
     runs-on: ${{ matrix.os }}
@@ -16,10 +34,10 @@ jobs:
       fail-fast: true
       matrix:
         os: [ubuntu-latest]
-        ruby: ["2.7"]
+        ruby: ["3.2"]
 
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby }}
@@ -27,3 +45,18 @@ jobs:
       - name: Run minitest
         run: |
           rake test
+
+  publish:
+    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+    needs: [test]
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Release Gem
+        uses: discourse/publish-rubygems-action@v2
+        env:
+          RUBYGEMS_API_KEY: ${{ secrets.RUBYGEMS_API_KEY }}
+          GIT_EMAIL: team@discourse.org
+          GIT_NAME: discoursebot

data/CHANGELOG

@@ -1,3 +1,7 @@
+1.2.0 - 10-22-2023
+
+- Add --tags and --skip-tags options
+
 1.0.3 - 09-04-2021
 
 - Started changelog - release to rubygems

data/README.md

@@ -25,6 +25,8 @@ Usage: pups [options] [FILE|--stdin]
         --stdin                      Read input from stdin.
         --quiet                      Don't print any logs.
         --ignore <elements>          Ignore specific configuration elements, multiple elements can be provided (comma-delimited).
+        --tags <elements>            Only run tagged commands.
+        --skip-tags <elements>       Run all but listed tagged commands.
                                      Useful if you want to skip over config in a pups execution.
                                      e.g. `--ignore env,params`.
         --gen-docker-run-args        Output arguments from the pups configuration for input into a docker run command. All other pups config is ignored.
@@ -48,6 +50,32 @@ Running: `pups somefile.yaml` will execute the shell script resulting in a file
 
 ### Features
 
+#### Filtering run commands by tags
+
+The `--tags` and `--skip-tags` argument allows pups to target a subset of commands listed in the somefile.yaml. To use this, you may tag your commands in the runblock. `--tags` will only run commands when commands have a matching tag. `--skip-tags` will skip when commands have a matching tag.
+
+Note, hooks from tagged commands will be present or absent depending on if the tag is filtered out or not as well. A command filtered out by targeting tag will also filter out the command's `before_` and `after_` hooks.
+
+Example:
+
+```
+# somefile.yaml
+
+run:
+  - exec:
+      cmd: /bin/bash -c 'echo hello >> hello'
+      tag: sometag
+  - exec:
+      cmd: /bin/bash -c 'echo hi >> hello'
+      tag: anothertag
+  - exec:
+      cmd: /bin/bash -c 'echo goodbye >> hello'
+      tag: thirdtag
+```
+Running: `pups --tags="sometag,anothertag" somefile.yaml` will not run the echo goodbye statement.
+
+Running: `pups --skip-tags="sometag,anothertag" somefile.yaml` will ONLY run the echo goodbye statement.
+
 #### Docker run argument generation
 
 The `--gen-docker-run-args` argument is used to make pups output arguments be in the format of `docker run <arguments output>`. Specifically, pups

data/lib/pups/cli.rb

@@ -1,17 +1,30 @@
 # frozen_string_literal: true
 
-require 'optparse'
+require "optparse"
 
 module Pups
   class Cli
     def self.opts
       OptionParser.new do |opts|
-        opts.banner = 'Usage: pups [FILE|--stdin]'
-        opts.on('--stdin', 'Read input from stdin.')
-        opts.on('--quiet', "Don't print any logs.")
-        opts.on('--ignore <element(s)>', Array, "Ignore these template configuration elements, multiple elements can be provided (comma-delimited).")
-        opts.on('--gen-docker-run-args', 'Output arguments from the pups configuration for input into a docker run command. All other pups config is ignored.')
-        opts.on('-h', '--help') do
+        opts.banner = "Usage: pups [FILE|--stdin]"
+        opts.on("--stdin", "Read input from stdin.")
+        opts.on("--quiet", "Don't print any logs.")
+        opts.on(
+          "--ignore <element(s)>",
+          Array,
+          "Ignore these template configuration elements, multiple elements can be provided (comma-delimited)."
+        )
+        opts.on(
+          "--gen-docker-run-args",
+          "Output arguments from the pups configuration for input into a docker run command. All other pups config is ignored."
+        )
+        opts.on("--tags <tag(s)>", Array, "Only run tagged commands.")
+        opts.on(
+          "--skip-tags <tag(s)>",
+          Array,
+          "Run all but listed tagged commands."
+        )
+        opts.on("-h", "--help") do
           puts opts
           exit
         end
@@ -26,35 +39,46 @@ module Pups
 
     def self.run(args)
       options = parse_args(args)
-      input_file = options[:stdin] ? 'stdin' : args.last
+      input_file = options[:stdin] ? "stdin" : args.last
       unless input_file
         puts opts.parse!(%w[--help])
         exit
       end
 
-      if options[:quiet]
-        Pups.silence
-      end
+      Pups.silence if options[:quiet]
 
       Pups.log.info("Reading from #{input_file}")
 
       if options[:stdin]
         conf = $stdin.readlines.join
-        split = conf.split('_FILE_SEPERATOR_')
+        split = conf.split("_FILE_SEPERATOR_")
 
         conf = nil
         split.each do |data|
           current = YAML.safe_load(data.strip)
-          conf = if conf
-            Pups::MergeCommand.deep_merge(conf, current, :merge_arrays)
-          else
-            current
-          end
+          conf =
+            if conf
+              Pups::MergeCommand.deep_merge(conf, current, :merge_arrays)
+            else
+              current
+            end
         end
 
-        config = Pups::Config.new(conf, options[:ignore])
+        config =
+          Pups::Config.new(
+            conf,
+            options[:ignore],
+            tags: options[:tags],
+            skip_tags: option[:"skip-tags"]
+          )
       else
-        config = Pups::Config.load_file(input_file, options[:ignore])
+        config =
+          Pups::Config.load_file(
+            input_file,
+            options[:ignore],
+            tags: options[:tags],
+            skip_tags: options[:"skip-tags"]
+          )
       end
 
       if options[:"gen-docker-run-args"]

data/lib/pups/command.rb

@@ -4,8 +4,10 @@ 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
+      when String
+        from_str(command, params).run
+      when Hash
+        from_hash(command, params).run
       end
     end
 

data/lib/pups/config.rb

@@ -4,33 +4,59 @@ module Pups
   class Config
     attr_reader :config, :params
 
-    def initialize(config, ignored = nil)
+    def initialize(
+      config,
+      ignored = nil,
+      tags: tags = nil,
+      skip_tags: skip_tags = nil
+    )
       @config = config
 
       # remove any ignored config elements prior to any more processing
       ignored&.each { |e| @config.delete(e) }
 
+      filter_tags(include_tags: tags, exclude_tags: skip_tags)
+
       # set some defaults to prevent checks in various functions
-      ['env_template', 'env', 'labels', 'params'].each { |key| @config[key] = {} unless @config.has_key?(key) }
+      %w[env_template env labels params].each do |key|
+        @config[key] = {} unless @config.has_key?(key)
+      end
 
       # Order here is important.
       Pups::Config.combine_template_and_process_env(@config, ENV)
-      Pups::Config.prepare_env_template_vars(@config['env_template'], 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'])
+      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"]
+      )
 
       @params = @config["params"]
-      ENV.each do |k, v|
-        @params["$ENV_#{k}"] = v
-      end
+      ENV.each { |k, v| @params["$ENV_#{k}"] = v }
       inject_hooks
     end
 
-    def self.load_file(config_file, ignored = nil)
-      Config.new(YAML.load_file(config_file), ignored)
+    def self.load_file(
+      config_file,
+      ignored = nil,
+      tags: tags = nil,
+      skip_tags: skip_tags = nil
+    )
+      Config.new(
+        YAML.load_file(config_file),
+        ignored,
+        tags: tags,
+        skip_tags: skip_tags
+      )
     rescue Exception
       warn "Failed to parse #{config_file}"
       warn "This is probably a formatting error in #{config_file}"
@@ -38,15 +64,25 @@ module Pups
       raise
     end
 
-    def self.load_config(config, ignored = nil)
-      Config.new(YAML.safe_load(config), ignored)
+    def self.load_config(
+      config,
+      ignored = nil,
+      tags: tags = nil,
+      skip_tags: skip_tags = nil
+    )
+      Config.new(
+        YAML.safe_load(config),
+        ignored,
+        tags: tags,
+        skip_tags: skip_tags
+      )
     end
 
     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_', '')
+        if k.include?("env_template_")
+          key = k.gsub("env_template_", "")
           env_template[key] = v.to_s
         end
       end
@@ -70,10 +106,41 @@ module Pups
       config["env"].each { |k, v| env[k] = v.to_s }
     end
 
+    # Filter run commands by tag: by default, keep all commands that contain tags.
+    # If skip_tags argument is true, keep all commands that DO NOT contain tags.
+    def filter_tags(
+      include_tags: include_tags = nil,
+      exclude_tags: exclude_tags = nil
+    )
+      if include_tags
+        @config["run"] = @config["run"].select do |row|
+          keep = false
+          command = row.first
+          if command[1].is_a?(Hash)
+            tag = command[1]["tag"]
+            keep = include_tags.include?(tag)
+          end
+          keep
+        end
+      end
+
+      if exclude_tags
+        @config["run"] = @config["run"].select do |row|
+          keep = true
+          command = row.first
+          if command[1].is_a?(Hash)
+            tag = command[1]["tag"]
+            keep = !exclude_tags.include?(tag)
+          end
+          keep
+        end
+      end
+    end
+
     def inject_hooks
-      return unless hooks = @config['hooks']
+      return unless hooks = @config["hooks"]
 
-      run = @config['run']
+      run = @config["run"]
 
       positions = {}
       run.each do |row|
@@ -81,7 +148,7 @@ module Pups
 
         command = row.first
         if command[1].is_a?(Hash)
-          hook = command[1]['hook']
+          hook = command[1]["hook"]
           positions[hook] = row if hook
         end
       end
@@ -112,11 +179,11 @@ module Pups
 
     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 << 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
 
@@ -128,25 +195,33 @@ module Pups
       unless exit_code == 77
         puts
         puts
-        puts 'FAILED'
-        puts '-' * 20
+        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
+        if @last_command
+          puts "#{@last_command[:command]} failed with the params #{@last_command[:params].inspect}"
+        end
       end
       exit exit_code
     end
 
     def run_commands
-      @config['run']&.each do |item|
+      @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
+          type =
+            case k
+            when "exec"
+              Pups::ExecCommand
+            when "merge"
+              Pups::MergeCommand
+            when "replace"
+              Pups::ReplaceCommand
+            when "file"
+              Pups::FileCommand
+            else
+              raise SyntaxError, "Invalid run command #{k}"
+            end
 
           @last_command = { command: k, params: v }
           type.run(v, @params)
@@ -162,9 +237,7 @@ module Pups
       return unless cmd
 
       processed = cmd.dup
-      params.each do |k, v|
-        processed.gsub!("$#{k}", v.to_s)
-      end
+      params.each { |k, v| processed.gsub!("$#{k}", v.to_s) }
       processed
     end
   end

data/lib/pups/docker.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require 'shellwords'
+require "shellwords"
 
 class Pups::Docker
   class << self
@@ -16,7 +16,7 @@ class Pups::Docker
     def generate_link_arguments(config)
       output = []
       config&.each do |c|
-        output << "--link #{c['link']['name']}:#{c['link']['alias']}"
+        output << "--link #{c["link"]["name"]}:#{c["link"]["alias"]}"
       end
       normalize_output(output)
     end
@@ -36,7 +36,7 @@ class Pups::Docker
     def generate_volume_arguments(config)
       output = []
       config&.each do |c|
-        output << "--volume #{c['volume']['host']}:#{c['volume']['guest']}"
+        output << "--volume #{c["volume"]["host"]}:#{c["volume"]["guest"]}"
       end
       normalize_output(output)
     end
@@ -50,6 +50,7 @@ class Pups::Docker
     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:
@@ -59,11 +60,7 @@ class Pups::Docker
     end
 
     def normalize_output(output)
-      if output.empty?
-        ""
-      else
-        output.join(" ")
-      end
+      output.empty? ? "" : output.join(" ")
     end
   end
 end

data/lib/pups/exec_command.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'timeout'
-require 'English'
+require "timeout"
+require "English"
 
 module Pups
   class ExecCommand < Pups::Command
@@ -9,12 +9,14 @@ module Pups
     attr_accessor :background, :raise_on_fail, :stdin, :stop_signal
 
     def self.terminate_async(opts = {})
-      return unless defined? @@asyncs
+      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]}")
+        Pups.log.info(
+          "Sending #{async[:stop_signal]} to #{async[:command]} pid: #{async[:pid]}"
+        )
         begin
           Process.kill(async[:stop_signal], async[:pid])
         rescue StandardError
@@ -22,37 +24,43 @@ module Pups
         end
       end
 
-      @@asyncs.map do |async|
-        Thread.new do
-          Timeout.timeout(opts[:wait] || 10) do
-            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.wait(async[:pid])
-          rescue Errno::ESRCH
-          rescue Errno::ECHILD
+      @@asyncs
+        .map do |async|
+          Thread.new do
+            Timeout.timeout(opts[:wait] || 10) do
+              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.wait(async[:pid])
+            rescue Errno::ESRCH
+            rescue Errno::ECHILD
+            end
           end
         end
-      end.each(&:join)
+        .each(&:join)
     end
 
     def self.from_hash(hash, params)
-      cmd = new(params, hash['cd'])
+      cmd = new(params, hash["cd"])
 
-      case c = hash['cmd']
-      when String then cmd.add(c)
-      when Array then c.each { |i| cmd.add(i) }
+      case c = hash["cmd"]
+      when String
+        cmd.add(c)
+      when Array
+        c.each { |i| cmd.add(i) }
       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)
+      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)
 
       cmd
     end
@@ -88,7 +96,11 @@ module Pups
     def spawn(command)
       if background
         pid = Process.spawn(command)
-        (@@asyncs ||= []) << { pid: pid, command: command, stop_signal: (stop_signal || 'TERM') }
+        (@@asyncs ||= []) << {
+          pid: pid,
+          command: command,
+          stop_signal: (stop_signal || "TERM")
+        }
         Thread.new do
           begin
             Process.wait(pid)
@@ -100,7 +112,7 @@ module Pups
         return pid
       end
 
-      IO.popen(command, 'w+') do |f|
+      IO.popen(command, "w+") do |f|
         if stdin
           # need a way to get stdout without blocking
           Pups.log.info(stdin)
@@ -112,7 +124,10 @@ module Pups
       end
 
       unless $CHILD_STATUS == 0
-        err = Pups::ExecError.new("#{command} failed with return #{$CHILD_STATUS.inspect}")
+        err =
+          Pups::ExecError.new(
+            "#{command} failed with return #{$CHILD_STATUS.inspect}"
+          )
         err.exit_code = $CHILD_STATUS.exitstatus
         raise err
       end

data/lib/pups/file_command.rb

@@ -6,10 +6,10 @@ module Pups
 
     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.path = hash["path"]
+      command.contents = hash["contents"]
+      command.chmod = hash["chmod"]
+      command.chown = hash["chown"]
       command.params = params
 
       command
@@ -26,9 +26,7 @@ module Pups
       path = interpolate_params(@path)
 
       `mkdir -p #{File.dirname(path)}`
-      File.open(path, 'w') do |f|
-        f.write(interpolate_params(contents))
-      end
+      File.open(path, "w") { |f| f.write(interpolate_params(contents)) }
       `chmod #{@chmod} #{path}` if @chmod
       `chown #{@chown} #{path}` if @chown
       Pups.log.info("File > #{path}  chmod: #{@chmod}  chown: #{@chown}")