pups 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 055f645c7b240abd8d9d8206029043d1097611c8
-  data.tar.gz: 9a0c6803b35b3813058ed89c33f937a959dc9fcb
+SHA256:
+  metadata.gz: f5203de15040af48165295c4d93c85351b5995c137e9334566877a7875733f05
+  data.tar.gz: 6337c83523bc6e0e17d9f3ba494d62e7a629415a4ce75f95db8e92e998837993
 SHA512:
-  metadata.gz: 2b64563d45db0ec09bb16465e09d81ca4ef39ac92dee8c1b6dd894a24ea4eda5ecc08e6890391e57e3653365f29a39fdcf17399ee383b7bcb9e7e5978ec44b52
-  data.tar.gz: 0069a7d13b2070240fc23b17befc9dc2a34d1a51c6e7573b575acf892d22251fbf1bd4c44a94820cc86c3d1dbdb5999e0b048fec6dc528a2ce44f0a81d62f9f7
+  metadata.gz: 8a4e356fde18db799f68049198eac4195a46c3d73f1919a66f473f195676a322a1759050bb01dfa6c447a4d705d6dce583bd6215e6a3412a339ffe55e2f57a48
+  data.tar.gz: 065473a360bac01f433757db10c513fc6790d49521218f6a3db5a55279386fa4ee89818c0aa16b07e37cc8f3375de705dae8fc9966191fabb2c17bf16675ad21

data/.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: Tests
+
+on:
+  push:
+    branches:
+      - master
+  pull_request: {}
+
+jobs:
+  test:
+    name: "pups tests"
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 5
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os: [ubuntu-latest]
+        ruby: ["2.7"]
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - name: Run minitest
+        run: |
+          rake test

data/.github/workflows/lint.yml

@@ -0,0 +1,27 @@
+name: Lint
+
+on:
+  push:
+    branches:
+      - master
+  pull_request: {}
+
+jobs:
+  lint:
+    name: "pups lint"
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 5
+
+    strategy:
+      fail-fast: true
+      matrix:
+        os: [ubuntu-latest]
+        ruby: ["2.7"]
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rubocop

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  rubocop-discourse: default.yml
+

data/CHANGELOG

@@ -0,0 +1,3 @@
+1.0.3 - 09-04-2021
+
+- Started changelog - release to rubygems

data/Gemfile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in pups.gemspec

data/Guardfile

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 guard :minitest do
   # with Minitest::Unit
-  watch(%r{^test/(.*)\/?(.*)_test\.rb$})
+  watch(%r{^test/(.*)/?(.*)_test\.rb$})
   watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[2]}_test.rb" }
   watch(%r{^test/test_helper\.rb$})      { 'test' }
 end

data/README.md

@@ -1,6 +1,6 @@
 # pups
 
-Simple yaml based bootstrapper
+Simple YAML--based bootstrapper
 
 ## Installation
 
@@ -20,6 +20,19 @@ Or install it yourself as:
 
 pups is a small library that allows you to automate the process of creating Unix images.
 
+```
+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).
+                                     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.
+    -h, --help
+```
+
+pups requires input either via a stdin stream or a filename. The entire input is parsed prior to any templating or command execution.
+
 Example:
 
 ```
@@ -28,55 +41,78 @@ params:
   hello: hello world
 
 run:
-  exec: /bin/bash -c 'echo $hello >>> hello'
+  - exec: /bin/bash -c 'echo $hello >> hello'
 ```
 
-Running: `pups somefile.yaml` will execute the shell script resulting in a file called "hello" with the "hello world" contents
+Running: `pups somefile.yaml` will execute the shell script resulting in a file called "hello" with the contents "hello world".
+
+### Features
 
-### Features:
+#### Docker run argument generation
 
-####Execution
+The `--gen-docker-run-args` argument is used to make pups output arguments be in the format of `docker run <arguments output>`. Specifically, pups
+will take any `env`, `volume`, `labels`, `links`, and `expose` configuration, and coerce that into the format expected by `docker run`. This can be useful
+when pups is being used to configure an image (e.g. by executing a series of commands) that is then going to be run as a container. That way, the runtime and image
+configuration can be specified within the same yaml files.
+
+
+#### Environment Variables
+
+By default, pups automatically imports your environment variables and includes them as params.
+
+```
+# In bash
+export SECRET_KEY="secret value"
+
+# In somefile.yaml
+run:
+  - exec: echo "$SECRET_KEY"
+```
+
+Running the above code with pups will produce `secret value`.
+
+#### Execution
 
 Run multiple commands in one path:
 
 ```
 run:
-  exec:
-    cd: some/path
-    cmd:
-      - echo 1
-      - echo 2
+  - exec:
+      cd: some/path
+      cmd:
+        - echo 1
+        - echo 2
 ```
 
 Run commands in the background (for services etc)
 
 ```
 run:
-  exec:
-    cmd: /usr/bin/sshd
-    background: true
-``` 
+  - exec:
+      cmd: /usr/bin/sshd
+      background: true
+```
 
 Suppress exceptions on certain commands
 
 ```
 run:
-   exec:
-     cmd: /test
-     raise_on_faile: false
+  - exec:
+      cmd: /test
+      raise_on_fail: false
 ```
 
-####Replacements:
+#### Replacements:
 
 ```
 run:
-  replace:
-    filename: "/etc/redis/redis.conf"
-    from: /^pidfile.*$/
-    to: ""
+  - replace:
+      filename: "/etc/redis/redis.conf"
+      from: /^pidfile.*$/
+      to: ""
 ```
 
-Will substitued the regex with blank, removing the pidfile line
+Will substitute the regex with blank, removing the pidfile line
 
 ```
 run:
@@ -88,9 +124,34 @@ run:
       }"
 ```
 
-Multiline replace using regex
+Additional params:
 
-####Merge yaml files:
+Global replace (as opposed to first match)
+```
+global: true
+```
+
+#### Hooks
+
+Execute commands before and after a specific command by defining a hook.
+
+```
+run
+  - exec:
+      hook: hello
+      cmd: echo 'Hello'
+
+hooks:
+  before_hello:
+    - exec:
+        cmd: echo 'Starting...'
+
+  after_hello:
+    - exec:
+        cmd: echo 'World'
+```
+
+#### Merge yaml files
 
 ```
 home: /var/www/my_app
@@ -105,17 +166,35 @@ run:
 
 ```
 
-Will merge the yaml file with the inline contents
+Will merge the yaml file with the inline contents.
+
+#### A common environment
+
+Environment variables can be specified under the `env` key, which will be included in the environment for the template.
+
+```
+env:
+  MY_ENV: "a couple of words"
+run:
+  - exec: echo $MY_ENV > tmpfile
+```
+
+`tmpfile` will contain `a couple of words`.
 
-####A common environment
+You can also specify variables to be templated within the environment, such as:
 
 ```
 env:
-   MY_ENV: 1
+  greeting: "hello, {{location}}!"
+env_template:
+  location: world
 ```
 
-All executions will get this environment set up
+In this example, the `greeting` environment variable will be set to `hello, world!` during initialisation as the `{{location}}` variable will be templated as `world`.
+Pups will also look in the environment itself at runtime for template variables, prefixed with `env_template_<variable name>`.
+Note that strings should be quoted to prevent YAML from parsing the `{ }` characters.
 
+All commands executed will inherit the environment once parsing and variable interpolation has been completed.
 
 ## Contributing
 

data/Rakefile

@@ -1,6 +1,12 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new do |t|
-  t.pattern = "test/*_test.rb"
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/*_test.rb']
 end
+
+task default: :test

data/bin/pups

@@ -1,9 +1,9 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 
-$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
 
-require "pups"
-require "pups/cli"
+require 'pups'
+require 'pups/cli'
 
 Pups::Cli.run(ARGV)
-

data/lib/pups.rb

@@ -1,23 +1,37 @@
-require "logger"
-require "yaml"
+# frozen_string_literal: true
 
-require "pups/version"
-require "pups/config"
-require "pups/command"
-require "pups/exec_command"
-require "pups/merge_command"
-require "pups/replace_command"
-require "pups/file_command"
+require 'logger'
+require 'yaml'
 
-require "pups/runit"
+require 'pups/version'
+require 'pups/config'
+require 'pups/command'
+require 'pups/exec_command'
+require 'pups/merge_command'
+require 'pups/replace_command'
+require 'pups/file_command'
+require 'pups/docker'
+require 'pups/runit'
 
 module Pups
+  class ExecError < RuntimeError
+    attr_accessor :exit_code
+  end
+
   def self.log
     # at the moment docker likes this
-    @logger ||= Logger.new(STDERR)
+    @logger ||= Logger.new($stderr)
   end
 
   def self.log=(logger)
     @logger = logger
   end
+
+  def self.silence
+    if @logger
+      @logger.close
+    end
+
+    @logger = Logger.new(File.open(File::NULL, "w"))
+  end
 end

data/lib/pups/cli.rb

@@ -1,36 +1,70 @@
-class Pups::Cli
+# frozen_string_literal: true
 
-  def self.usage
-    puts "Usage: pups FILE or pups --stdin"
-    exit 1
-  end
-  def self.run(args)
-    if args.length != 1
-      usage
-    end
+require 'optparse'
 
-    Pups.log.info("Loading #{args[0]}")
-    if args[0] == "--stdin"
-      conf = STDIN.readlines.join
-      split = conf.split("_FILE_SEPERATOR_")
-
-      conf = nil
-      split.each do |data|
-        current = YAML.load(data.strip)
-        if conf
-          conf = Pups::MergeCommand.deep_merge(conf, current, :merge_arrays)
-        else
-          conf = current
+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
+          puts opts
+          exit
         end
       end
+    end
 
-      config = Pups::Config.new(conf)
-    else
-      config = Pups::Config.load_file(args[0])
+    def self.parse_args(args)
+      options = {}
+      opts.parse!(args, into: options)
+      options
     end
-    config.run
 
-  ensure
-    Pups::ExecCommand.terminate_async
+    def self.run(args)
+      options = parse_args(args)
+      input_file = options[:stdin] ? 'stdin' : args.last
+      unless input_file
+        puts opts.parse!(%w[--help])
+        exit
+      end
+
+      if options[:quiet]
+        Pups.silence
+      end
+
+      Pups.log.info("Reading from #{input_file}")
+
+      if options[:stdin]
+        conf = $stdin.readlines.join
+        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
+        end
+
+        config = Pups::Config.new(conf, options[:ignore])
+      else
+        config = Pups::Config.load_file(input_file, options[:ignore])
+      end
+
+      if options[:"gen-docker-run-args"]
+        print config.generate_docker_run_arguments
+        return
+      end
+
+      config.run
+    ensure
+      Pups::ExecCommand.terminate_async
+    end
   end
 end