rumrunner 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c2323b66b28f0897ada2d3f99a3caabb2ba3fe48347d2c482b9267f68044c327
+  data.tar.gz: b00540b6c558f1b1db377fc649acfeb20bbf4dfb6a4603fa376a9b6d86facc67
+SHA512:
+  metadata.gz: 8527ea31f1d909e0a4d335d3ec880594cd7b40d1ca04ad70284fa65bdca34cab3abe36c7fe16dd254275fd0fb49d6c43b6e3d487fa8cd6d98a51e84fb3761282
+  data.tar.gz: 8f0dafd92f2c32a86b7a1cfc24077652cbc578d38bbfd127556b96710c2a6c1742b8a8f9f0e79a538ea7ddc058a2c26de428430d2e325c0651c2c384e84b4bc6

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Alexander Mancevice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,164 @@
+<img alt="rumrunner" src="./docs/icon.png"/>
+
+[![Build Status](https://travis-ci.com/amancevice/rumrunner.svg?branch=master)](https://travis-ci.com/amancevice/rumrunner)
+[![codecov](https://codecov.io/gh/amancevice/rumrunner/branch/master/graph/badge.svg)](https://codecov.io/gh/amancevice/rumrunner)
+
+Rumrunner is a Rake-based utility for building projects using multi-stage Dockerfiles.
+
+Rumrunner allows users to minimally annotate builds using a Rake-like DSL
+and execute them with a rake-like CLI.
+
+Carfofile has the following features:
+* Rumfiles are completely defined in standard Ruby syntax, like Rakefiles.
+* Users can specify Docker build stages with prerequisites.
+* Artifacts can be exported from stages
+* Stages' build steps can be customized
+* Shell tasks are automatically provided for every stage
+
+## Installation
+
+```bash
+gem install rumrunner
+```
+
+## Example
+
+Imagine a simple multi-stage Dockerfile:
+
+```Dockerfile
+FROM ruby AS build
+# Run build steps here...
+
+FROM ruby AS test
+# Run test steps here...
+
+FROM ruby AS deploy
+# Run deploy steps here...
+```
+
+Create `Rumfile` and describe your build:
+
+```ruby
+rum :image_name do
+  tag "1.2.3"
+
+  stage :build
+  stage :test => :build
+  stage :deploy => :test
+end
+```
+
+Run `bundle exec rum --tasks` to view the installed tasks:
+
+```bash
+rum build                # Build `build` stage
+rum build:clean          # Remove any temporary images and products from `build` stage
+rum build:shell[shell]   # Shell into `build` stage
+rum clean                # Remove any temporary images and products
+rum clobber              # Remove any generated files
+rum deploy               # Build `deploy` stage
+rum deploy:clean         # Remove any temporary images and products from `deploy` stage
+rum deploy:shell[shell]  # Shell into `deploy` stage
+rum test                 # Build `test` stage
+rum test:clean           # Remove any temporary images and products from `test` stage
+rum test:shell[shell]    # Shell into `test` stage
+```
+
+Run the `<stage>` task to build the image up to that stage and cache the image digest.
+
+Run the `<stage>:shell` task to build the image and then shell into an instance of the image running as a temporary container.
+
+The default shell is `/bin/sh`, but this can be overridden at runtime with the task arg, eg `bundle exec rum build:shell[/bin/bash]`
+
+The name of the images are taken from the name of the initial block and appended with the name of the stage. The above example would build:
+
+- `image_name:1.2.3-build`
+- `image_name:1.2.3-test`
+- `image_name:1.2.3-deploy`
+
+The default location for the digests is in `.docker`, but that can be modified:
+
+```ruby
+rum :image_name => "tmp" do |c|
+  # ...
+end
+```
+
+## Customize Stages
+
+Stages can be customized with blocks. Methods invoked on the stage are (with a few exceptions) passed onto the `docker build` command.
+
+```ruby
+rum :image_name do
+  tag "1.2.3"
+
+  stage :build
+
+  stage :test => :build
+
+  stage :deploy => :test do
+    build_arg :AWS_ACCESS_KEY_ID
+    build_arg :AWS_SECRET_ACCESS_KEY
+    build_arg :AWS_DEFAULT_REGION => "us-east-1"
+    label     :Fizz
+  end
+end
+```
+
+## Export Artifacts
+
+Use the `artifact` method to specify an artifact to be exported from the image.
+
+```ruby
+rum :image_name do
+  stage :build
+
+  artifact "package.zip" => :build
+end
+```
+
+By default the container simply `cat`s the file from the container to the local file system, but more complex exports can be defined:
+
+```ruby
+rum :image_name do
+  stage :build
+
+  artifact "package.zip" => :build do
+    workdir "/var/task/"
+    cmd     %w[zip -r - .]
+  end
+end
+```
+
+## Customize Shells
+
+By default, all stages have a `:shell` task that can be invoked to build and shell into a container for a stage. By default the container is run as an ephemeral container (`--rm`) in interactive with TTY allocated and a bash shell open.
+
+Customize the shell for a stage with the `shell` method:
+
+```ruby
+rum :image_name do
+  stage :dev
+
+  shell :dev do
+    entrypoint "/bin/zsh"
+    rm         false
+    volume     "#{Dir.pwd}:/var/task/"
+  end
+end
+```
+
+## Default Task
+
+Use the `default` method to set a default task when running `bundle exec rum`:
+
+
+```ruby
+rum :image_name do
+  stage :build
+
+  artifact "package.zip" => :build
+
+  default "package.zip"
+end
+```

data/bin/rum

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require "rumrunner"
+Rake.application = Rum::Application.new
+Rake.application.run

data/lib/rumrunner/application.rb

@@ -0,0 +1,24 @@
+require "rake"
+
+module Rum
+  class Application < Rake::Application
+    DEFAULT_RAKEFILES = [
+      "rumfile",
+      "Rumfile",
+      "rumfile.rb",
+      "Rumfile.rb",
+    ]
+
+    # Initialize a Rumfile::Application object.
+    def initialize
+      super
+      @name = "rum"
+      @rakefiles = DEFAULT_RAKEFILES.dup
+    end
+
+    # Initialize the command line parameters and app name.
+    def init(app_name="rum", argv = ARGV)
+      super "rum", argv
+    end
+  end
+end

data/lib/rumrunner/docker.rb

@@ -0,0 +1,184 @@
+require "forwardable"
+
+module Rum
+  module Docker
+    module AttrCallable
+      def attr_method_accessor(*args)
+        args.each do |var|
+          define_method var do |value = nil|
+            if value.nil?
+              instance_variable_get :"@#{var}"
+            else
+              instance_variable_set :"@#{var}", value
+              self
+            end
+          end
+        end
+      end
+    end
+
+    module Executable
+      include Enumerable
+
+      attr_reader :options
+
+      def initialize(options:nil, &block)
+        @options = options || Options.new
+        instance_eval(&block) if block_given?
+      end
+
+      def each
+        self.class.name.split(/::/)[1..-1].each{|x| yield x.downcase }
+        @options.each{|x| yield x }
+      end
+
+      def method_missing(m, *args, &block)
+        @options.send(m, *args, &block)
+        args.any? ? self : @options[m]
+      end
+
+      def to_s
+        to_a.join(" ")
+      end
+
+      def with_defaults(options = {}, &block)
+        options.reject{|k,v| @options.include? k }.each{|k,v| @options[k] << v }
+        self
+      end
+    end
+
+    class Options
+      extend Forwardable
+      include Enumerable
+
+      attr_reader :data
+
+      def_delegators :@data, :[], :[]=, :include?, :to_h, :update
+
+      def initialize(options = {}, &block)
+        @data = Hash.new{|hash, key| hash[key] = [] }.update(options)
+        instance_eval(&block) if block_given?
+      end
+
+      def method_missing(m, *args, &block)
+        @data[m] += args unless args.empty?
+        self
+      end
+
+      def each
+        @data.each do |name, values|
+          option = name.length == 1 ? "-#{name}" : "--#{name.to_s.gsub(/_/, "-")}"
+          yield option if values.empty?
+          values.each do |value|
+            if value.is_a?(Hash)
+              value.map{|kv| kv.join("=") }.each do |val|
+                yield option
+                yield val
+              end
+            elsif [true, false].include? value
+              yield option
+            else
+              yield option
+              yield value.to_s
+            end
+          end
+        end
+      end
+
+      def to_s
+        to_a.join(" ")
+      end
+    end
+
+    class Build
+      extend AttrCallable
+      include Executable
+
+      attr_method_accessor :path
+
+      def initialize(options:nil, path:nil, &block)
+        @path = path
+        super options: options, &block
+      end
+
+      def each
+        super{|x| yield x }
+        yield @path || "."
+      end
+    end
+
+    class Run
+      extend AttrCallable
+      include Executable
+
+      attr_method_accessor :image, :cmd
+
+      def initialize(options:nil, image:nil, cmd:nil, &block)
+        @image = image
+        @cmd   = cmd
+        super options: options, &block
+      end
+
+      def each
+        super{|x| yield x }
+        yield @image
+        @cmd.is_a?(Array) ? @cmd.each{|x| yield x } : yield(@cmd) unless @cmd.nil?
+      end
+    end
+
+    class Image
+      extend AttrCallable
+      include Enumerable
+
+      attr_method_accessor :registry, :username, :name, :tag
+
+      def initialize(name:, registry:nil, username:nil, tag:nil, &block)
+        @registry = registry
+        @username = username
+        @name     = name
+        @tag      = tag
+        instance_eval(&block) if block_given?
+      end
+
+      def each
+        [@registry, @username, @name, @tag].compact.each{|x| yield x }
+      end
+
+      def family
+        File.join *[@registry, @username, @name].compact.map(&:to_s)
+      end
+
+      def to_s
+        "#{family}:#{@tag || :latest}"
+      end
+
+      class << self
+        def parse(string_or_symbol)
+          string = string_or_symbol.to_s
+          if string.count("/").zero? && string.count(":").zero?
+            # image
+            new name: string
+          elsif string.count("/").zero?
+            # image:tag
+            name, tag = string.split(/:/)
+            new name: name, tag: tag
+          elsif string.count("/") == 1 && string.count(":").zero?
+            # username/image
+            username, name = string.split(/\//)
+            new name: name, username: username
+          elsif string.count("/") == 1
+            # username/image:tag
+            username, name_tag = string.split(/\//)
+            name, tag          = name_tag.split(/:/)
+            new name: name, username: username, tag: tag
+          else
+            # registry/username/image[:tag]
+            registry, username, name_tag = string.split(/\//)
+            name, tag                    = name_tag.split(/:/)
+            new name: name, registry: registry, username: username, tag: tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rumrunner/dsl_definition.rb

@@ -0,0 +1,22 @@
+require "rake"
+
+require "rumrunner/manifest"
+
+module Rum
+  module DSL
+
+    private
+
+    # :call-seq:
+    #   rum image_name
+    #   rum image_name: digest_dir
+    #
+    def rum(*args, &block)
+      name, _, deps = Rake.application.resolve_args(args)
+      root = deps.first || :".docker"
+      Manifest.new(name: name, root: root, &block).install
+    end
+  end
+end
+
+self.extend Rum::DSL

data/lib/rumrunner/manifest.rb

@@ -0,0 +1,171 @@
+require "forwardable"
+require "rake"
+
+module Rum
+  class Manifest
+    extend Forwardable
+    include Rake::DSL if defined? Rake::DSL
+
+    attr_reader :image
+
+    def_delegator :@env, :<<, :env
+    def_delegator :@root, :to_s, :root
+    def_delegators :@image, :registry, :username, :name, :tag
+
+    def initialize(name:, root:nil, &block)
+      @name  = name
+      @root  = root || :".docker"
+      @image = Docker::Image.parse(name)
+      @env   = []
+      instance_eval(&block) if block_given?
+    end
+
+    def default(*args, &block)
+      name = Rake.application.resolve_args(args).first
+      task :default => name
+    end
+
+    def build(*args, &block)
+      name, _, deps = Rake.application.resolve_args(args)
+      task name => deps do
+        sh Docker::Build.new(&block).to_s
+      end
+    end
+
+    def run(*args, &block)
+      name, _, deps = Rake.application.resolve_args(args)
+      task name => deps do
+        sh Docker::Run.new(&block).to_s
+      end
+    end
+
+    def stage(*args, &block)
+      name, _, deps = Rake.application.resolve_args(args)
+
+      # Assemble image/iidfile from manifest/stage name
+      image   = "#{@image}-#{name}"
+      iidfile = File.join(root, image)
+      iidpath = File.split(iidfile).first
+
+      # Ensure path to iidfile exists
+      iiddeps = if deps.empty?
+        directory iidpath
+        iidpath
+      else
+        deps.map{|x| File.join(root, "#{@image}-#{x}") }
+      end
+
+      # Build stage and save digest in iidfile
+      file iidfile => iiddeps do
+        build = Docker::Build.new(options: build_options, &block)
+        build.with_defaults(iidfile: iidfile, tag: image, target: name)
+        sh build.to_s
+      end
+
+      # Shortcut to build stage by name
+      desc "Build `#{name}` stage"
+      task name => iidfile
+
+      # Shell into stage
+      desc "Shell into `#{name}` stage"
+      task :"#{name}:shell", [:shell] => iidfile do |t,args|
+        digest = File.read(iidfile)
+        shell  = args.any? ? args.to_a.join(" ") : "/bin/sh"
+        run    = Docker::Run.new(options: run_options)
+          .entrypoint(shell)
+          .interactive(true)
+          .rm(true)
+          .tty(true)
+          .image(digest)
+        sh run.to_s
+      end
+
+      # Clean stage
+      desc "Remove any temporary images and products from `#{name}` stage"
+      task :"#{name}:clean" do
+        if File.exists? iidfile
+          sh "docker", "image", "rm", "--force", File.read(iidfile)
+          rm iidfile
+        end
+      end
+
+      # Add stage to general clean
+      task :clean => :"#{name}:clean"
+
+      # Ensure subsequent stages are cleaned before this one
+      deps.each{|dep| task :"#{dep}:clean" => :"#{name}:clean" }
+    end
+
+    def artifact(*args, &block)
+      name, _, deps = Rake.application.resolve_args(args)
+
+      target  = deps.first
+      image   = "#{@image}-#{target}"
+      iidfile = File.join(root, image)
+      path    = File.split(name).first
+      deps    = [iidfile]
+
+      unless path == "."
+        directory path
+        deps << path
+      end
+
+      desc "Build `#{name}`"
+      file name => deps do
+        digest = File.read(iidfile)
+        run = Docker::Run.new(options: run_options, image: digest, cmd: ["cat", name], &block)
+        run.with_defaults(rm: true)
+        sh "#{run} > #{name}"
+      end
+
+      desc "Remove any generated files"
+      task :clobber do
+        rm name if File.exists?(name)
+        rm_r path if Dir.exists?(path) && path != "."
+      end
+    end
+
+    def shell(*args, &block)
+      target  = Rake.application.resolve_args(args).first
+      name    = :"#{target}:shell"
+      image   = "#{@image}-#{target}"
+      iidfile = File.join(root, image)
+
+      Rake::Task[name].clear if Rake::Task.task_defined?(name)
+
+      desc "Shell into `#{target}` stage"
+      task name, [:shell] => iidfile do |t,args|
+        digest = File.read(iidfile)
+        shell  = args.any? ? args.to_a.join(" ") : "/bin/sh"
+        run    = Docker::Run.new(options: run_options, image: digest, &block)
+        run.with_defaults(entrypoint: shell, interactive:true, rm: true, tty: true)
+        sh run.to_s
+      end
+    end
+
+    def install
+      install_clean
+    end
+
+    private
+
+    def build_options
+      Docker::Options.new(build_arg: @env) unless @env.empty?
+    end
+
+    def run_options
+      Docker::Options.new(env: @env) unless @env.empty?
+    end
+
+    def install_clean
+      desc "Remove any temporary images and products"
+      task :clean do
+        Dir[File.join root, "**/*"].reverse.each do |name|
+          sh "docker", "image", "rm", "--force", File.read(name) if File.file?(name)
+          rm_r name
+        end
+        rm_r root if Dir.exists?(root)
+      end
+    end
+  end
+end

data/lib/rumrunner/version.rb

@@ -0,0 +1,3 @@
+module Rum
+  VERSION = "0.2.0"
+end

data/lib/rumrunner.rb

@@ -0,0 +1,10 @@
+require "rumrunner/version"
+require "rumrunner/docker"
+require "rumrunner/manifest"
+require "rumrunner/dsl_definition"
+require "rumrunner/application"
+
+module Rum
+  class Error < StandardError
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: rumrunner
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Alexander Mancevice
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: codecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: gems
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+description: |
+  Rumfile is a Rake-based utility for building projects using multi-stage Dockerfiles.
+
+  Rumfile allows users to minimally annotate builds using a Rake-like DSL
+  and execute them with a rake-like CLI.
+
+  Carfofile has the following features:
+  * Rumfiles are completely defined in standard Ruby syntax, like Rakefiles.
+  * Users can specify Docker build stages with prerequisites.
+  * Artifacts can be exported from stages
+  * Stages' build steps can be customized
+  * Shell tasks are automatically provided for every stage
+email:
+- smallweirdnum@gmail.com
+executables:
+- rum
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/rum
+- lib/rumrunner.rb
+- lib/rumrunner/application.rb
+- lib/rumrunner/docker.rb
+- lib/rumrunner/dsl_definition.rb
+- lib/rumrunner/manifest.rb
+- lib/rumrunner/version.rb
+homepage: https://github.com/amancevice/rumrunner.git
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Rumfile is a Rake-based utility for building projects using multi-stage Dockerfiles
+test_files: []