rumrunner 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da4a1989a2252315eba1d4bcd4d921b25ee90c53fd77b2ce6e720dad5a07b807
-  data.tar.gz: ed649270e0622f1aabc134ce1529403dc534b040b6857c5a7fd0db4c4daedbd6
+  metadata.gz: 7dd5856ce9705196280daf49018154662a937c97f6920401d880828744f1d042
+  data.tar.gz: 28b6ba6f5162b0446e0f36273627b6b5fdf766f95d9d949bf7a210ff3bbee5f9
 SHA512:
-  metadata.gz: 61514ca3d73be5d90755d2a82af2abee79c38ce673ec310e77e96f7f18ea924a03f0bba8a8821745eb9ff3ce27a5f3dd03470a956e2554610670a5677fe2bb1f
-  data.tar.gz: 59c77172cef86582a1973b761a1e2b9d7475db4d1d477f7f721379777e5f0bb6a448eea8aba4ae673de281f961dad73de549a14bb0300d76c55977ce5ea27941
+  metadata.gz: 7ff1900f6e1287812077722c9ffeac04916591011eecc0d1b44145aed0274861beb04d8715b35d0f026fae8046b26757cc00fddad7f7e461ab729b590ac65419
+  data.tar.gz: 8e829a928fa46f634a0d80fae78e787dd7c9342559a0a0f6b5e79aea4f68865ad23f2276403b419d957dd3947838e0e280c198cf35d8a2b3384ee6ad071a19a9

data/README.md

@@ -92,83 +92,89 @@ rum shell:test[shell]    # Shell into `test` stage
 rum test                 # Build `test` stage
 ```
 
-## Task Naming Convention
+## Customize Shells
 
-As of v0.3, rum runner uses a "verb-first" naming convention (eg. `clean:stage`) for tasks.
+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.
 
-To revert to the previous convention of "stage-first" (eg. `stage:clean`) use the environmental variable `RUM_TASK_NAMES`:
+Customize the shell for a stage with the `shell` method:
 
-```bash
-export RUM_TASK_NAMES=STAGE_FIRST  # => rum stage:clean
-export RUM_TASK_NAMES=VERB_FIRST   # => rum clean:stage (default)
+```ruby
+rum :image_name do
+  stage :dev
+
+  shell :dev do
+    entrypoint "/bin/zsh"
+    rm         false
+    volume     "#{Dir.pwd}:/var/task/"
+  end
+
+  # rum dev => docker run --entrypoint /bin/zsh --volume $PWD:/var/task/ ...
+end
 ```
 
-## Image Naming Convention
+## Customize Stages
 
-The name of the images are taken from the first argument to the main block and appended with the name of the stage.
+Stages can be customized with blocks:
 
-In the above example, built images would build be named:
+```ruby
+rum :image_name do
+  tag "1.2.3"
 
-- `image_name:1.2.3-build`
-- `image_name:1.2.3-test`
-- `image_name:1.2.3-deploy`
+  stage :build
 
-The first argument to the main block can be any Docker image reference:
+  stage :test => :build
 
-```ruby
-rum :"registry:5000/username/image" do
-  #...
+  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
 ```
 
-## Digest Location
+Methods invoked inside the stage block are interpreted as options for the eventual `docker build` command.
 
-Images build with the `stage` task have their digests cached for easy lookup.
+## Export Artifacts
 
-The default location for the digests is in `.docker`, but that can be modified:
+Use the `artifact` method to specify an artifact to be exported from the image.
 
 ```ruby
-rum :image_name => "tmp" do
-  # ...
+rum :image_name do
+  stage :build
+
+  artifact "package.zip" => :build
 end
 ```
 
-## Build vs. Run
-
-At the core, every directive within the `rum` block will eventually be interpreted as either a `docker build` or a `docker run` command. The type of directive is simply a way of specifying defaults for the command.
-
-If you simply wish to define a named task that executes a build or a run, you can use the `build` or `run` directives:
+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
-  build :fizz do
-    tag  "image_name"
-    path "."
-  end
+  stage :build
 
-  run :buzz do
-    rm    true
-    image "image_name"
-    cmd   %w{echo hello}
+  artifact "package.zip" => :build do
+    workdir "/var/task/"
+    cmd     %w[zip -r - .]
   end
-
-  # rum fizz => docker build --tag image_name .
-  # rum buzz => docker run --rm image_name echo hello
 end
 ```
 
-## Blocks
-
-The methods inside blocks for `build`, `run`, `stage`, `artifact`, and `shell` tasks are dynamically handled. Any option you might pass to the `docker run` or `docker build` command can be used.
+Methods invoked inside the artifact block are interpreted as options for the eventual `docker run` command.
 
-Simply drop any leading `-`s from the option and convert to snake-case.
+## Default Task
 
-Eg,
+Use the `default` method to set a default task when running the bare `rum` executable:
 
-`--build-arg` becomes `build_arg`
+```ruby
+rum :image_name do
+  stage :build
 
-`--env-file` becomes `env_file`.
+  artifact "package.zip" => :build
 
+  default "package.zip"
+end
+```
 ## Shared ENV variables
 
 The `env` method can be invoked in the `rum` block to declare a value that will be passed to all stages/artifacts/shells. For stages, the value will be passed using the `--build-arg` option; for artifacts and shells, the `--env` option.
@@ -179,10 +185,7 @@ rum :image_name do
 
   stage :build
 
-  artifact "pkg.zip" => :build
-
-  # rum build   => docker build --build-arg FIZZ=BUZZ ...
-  # rum pkg.zip => docker run         --env FIZZ=BUZZ ...
+  # rum build => docker build --build-arg FIZZ=BUZZ ...
 end
 ```
 
@@ -194,87 +197,101 @@ Run with the `:shell` suffix to build the image and then shell into an instance
 
 The default shell is `/bin/sh`, but this can be overridden at runtime with the task arg, eg. `rum build:shell[/bin/bash]`
 
-## Customize Shells
+## Build vs. Run
 
-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.
+At the core, every directive within the `rum` block will eventually be interpreted as either a `docker build` or a `docker run` command. The type of directive is simply a way of specifying defaults for the command.
 
-Customize the shell for a stage with the `shell` method:
+If you simply wish to define a named task that executes a build or a run, you can use the `build` or `run` directives:
 
 ```ruby
 rum :image_name do
-  stage :dev
+  env :JAZZ => "fuzz"
 
-  shell :dev do
-    entrypoint "/bin/zsh"
-    rm         false
-    volume     "#{Dir.pwd}:/var/task/"
+  build :fizz do
+    tag  "image_name"
+    path "."
   end
 
-  # rum dev => docker run --entrypoint /bin/zsh --volume $PWD:/var/task/ ...
+  run :buzz do
+    rm    true
+    image "image_name"
+    cmd   %w{echo hello}
+  end
+
+  # rum fizz => docker build --build-arg JAZZ=fuzz --tag image_name .
+  # rum buzz => docker run --rm --env JAZZ=fuzz image_name echo hello
 end
 ```
 
-## Customize Stages
+Note that the build/run commands will still import any shared ENV values defined above.
 
-Stages can be customized with blocks:
+If this is undesirable, use the `clear_options` method inside your block to clear ALL the default options:
 
 ```ruby
 rum :image_name do
-  tag "1.2.3"
 
-  stage :build
+  env :JAZZ => "fuzz"
 
-  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
+  run :buzz do
+    clear_options
+    image "image_name"
+    cmd   %w{echo hello}
   end
+
+  # rum buzz => docker run image_name echo hello
 end
 ```
 
-Methods invoked inside the stage block are interpreted as options for the eventual `docker build` command.
+## Blocks
 
-## Export Artifacts
+The methods inside blocks for `build`, `run`, `stage`, `artifact`, and `shell` tasks are dynamically handled. Any option you might pass to the `docker run` or `docker build` command can be used.
 
-Use the `artifact` method to specify an artifact to be exported from the image.
+Simply drop any leading `-`s from the option and convert to snake-case.
 
-```ruby
-rum :image_name do
-  stage :build
+Eg,
 
-  artifact "package.zip" => :build
-end
-```
+`--build-arg` becomes `build_arg`
 
-By default the container simply `cat`s the file from the container to the local file system, but more complex exports can be defined:
+`--env-file` becomes `env_file`.
 
-```ruby
-rum :image_name do
-  stage :build
+## Task Naming Convention
 
-  artifact "package.zip" => :build do
-    workdir "/var/task/"
-    cmd     %w[zip -r - .]
-  end
-end
+As of v0.3, rum runner uses a "verb-first" naming convention (eg. `clean:stage`) for tasks.
+
+To revert to the previous convention of "stage-first" (eg. `stage:clean`) use the environmental variable `RUM_TASK_NAMES`:
+
+```bash
+export RUM_TASK_NAMES=STAGE_FIRST  # => rum stage:clean
+export RUM_TASK_NAMES=VERB_FIRST   # => rum clean:stage (default)
 ```
 
-Methods invoked inside the artifact block are interpreted as options for the eventual `docker run` command.
+## Image Naming Convention
 
-## Default Task
+The name of the images are taken from the first argument to the main block and appended with the name of the stage.
 
-Use the `default` method to set a default task when running the bare `rum` executable:
+In the above example, built images would build be named:
+
+- `image_name:1.2.3-build`
+- `image_name:1.2.3-test`
+- `image_name:1.2.3-deploy`
+
+The first argument to the main block can be any Docker image reference:
 
 ```ruby
-rum :image_name do
-  stage :build
+rum :"registry:5000/username/image" do
+  #...
+end
+```
 
-  artifact "package.zip" => :build
+## Digest Location
 
-  default "package.zip"
+Images build with the `stage` task have their digests cached for easy lookup.
+
+The default location for the digests is in `.docker`, but that can be modified:
+
+```ruby
+rum :image_name => "tmp" do
+  # ...
 end
 ```
 

data/lib/rumrunner/docker.rb

@@ -72,6 +72,13 @@ module Rum
         args.empty? ? @options[m] : self
       end
 
+      ##
+      # Clear all @options
+      def clear_options
+        @options = Options.new
+        self
+      end
+
       ##
       # Convert Docker command to string.
       def to_s

data/lib/rumrunner/manifest.rb

@@ -60,7 +60,7 @@ module Rum
     def build(*args, &block)
       name, _, deps = Rake.application.resolve_args(args)
       task name => deps do
-        sh Docker::Build.new(&block).to_s
+        sh Docker::Build.new(options: build_options, &block).to_s
       end
     end
 
@@ -73,8 +73,13 @@ module Rum
     #
     def run(*args, &block)
       name, _, deps = Rake.application.resolve_args(args)
-      task name => deps do
-        sh Docker::Run.new(image: to_s, &block).to_s
+
+      images   = deps.map{|dep| Docker::Image.parse("#{@image}-#{dep}") }
+      iidfiles = images.map{|image| File.join(root, *image) }
+
+      task name => iidfiles do
+        image = iidfiles.empty? ? to_s : File.read(iidfiles.first)
+        sh Docker::Run.new(options: run_options, image: image, &block).to_s
       end
     end
 

data/lib/rumrunner/version.rb

@@ -1,5 +1,5 @@
 module Rum
   ##
   # Rum Runner gem version.
-  VERSION = "0.3.4"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rumrunner
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Alexander Mancevice