rudder 0.1.0

data/examples/README.md

@@ -0,0 +1,6 @@
+# Examples
+
+These examples show several examples of how to use `rudder`. Start
+in [`hello_world_pipeline.rb`](hello_world_pipeline.rb):
+
+![Hello World Pipeline](images/hello_world.png)

data/examples/groups/README.md

@@ -0,0 +1,12 @@
+# Groups Example
+
+The [`groups_pipeline.rb`](./groups_pipeline.rb) shows how concourse groups can be utilized
+within `rudder`. This pipeline also shows how to indiscriminately import
+pipelines from other directories.
+
+- The All group:
+  ![Groups Pipeline](../images/groups/groups_all.png)
+- The Bash Stuff group:
+  ![Groups Pipeline](../images/groups/groups_bash_stuff.png)
+- The Git Stuff group:
+  ![Groups Pipeline](../images/groups/groups_git_stuff.png)

data/examples/groups/groups_pipeline.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+@parent_dir = File.dirname(__FILE__)
+def relative_files(path)
+  Dir[File.join(@parent_dir, path)]
+end
+
+# Load all the resources
+relative_files('resources/*').each do |path|
+  # Pipline#load includes always loads files relative to where itself, so
+  # we need to remove the parent directory from this path
+  res = load path.sub(@parent_dir, '')
+  resources.merge! res.resources
+end
+
+# Load all the jobs and stick them in groups by directory
+relative_files('jobs/*').each do |group_dir|
+  group_name = File.basename group_dir
+  group group_name do |pipeline|
+    Dir[File.join(group_dir, '*')].each do |job_path|
+      parent_dir = File.dirname __FILE__
+      job_pipe = pipeline.load(job_path.sub(parent_dir, ''), resources: pipeline.resources)
+      pipeline.jobs.merge! job_pipe.jobs
+      job_pipe.jobs.keys.each { |job_name| job job_name }
+    end
+  end
+end
+
+# Add all of the jobs to a super group
+group :all do |pipeline|
+  pipeline.jobs.keys.each do |job_name|
+    jobs << job_name
+  end
+end

data/examples/groups/jobs/bash_stuff/date.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+time_resources = @resources.values.select { |r| r.type == :time }
+
+time_resources.each do |r|
+  job :date do
+    plan << { get: r.name, trigger: true }
+    plan << { task: 'print_date', config: {
+      platform: 'linux',
+      image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+      run: {
+        path: 'date'
+      }
+    } }
+  end
+end

data/examples/groups/jobs/bash_stuff/hello.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+time_resources = resources.values.select { |r| r.type == :time }
+
+time_resources.each do |r|
+  job :hello do
+    plan << { get: r.name, trigger: true }
+    plan << { task: 'print_hello', config: {
+      platform: 'linux',
+      image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+      run: {
+        path: 'echo',
+        args: ['Hello']
+      }
+    } }
+  end
+end

data/examples/groups/jobs/git_stuff/log.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+git_resources = resources.values.select { |r| r.type == :git }
+
+git_resources.each do |r|
+  job "git log #{r.name}" do
+    plan << { get: r.name, trigger: true }
+    task = {
+      task: "git log #{r.name}", config: {
+        inputs: [name: r.name],
+        platform: 'linux',
+        image_resource: { type: 'docker-image', source: { repository: 'alpine/git' } },
+        run: {
+          path: 'git',
+          args: ['--git-dir', File.join(r.name.to_s, '.git'),
+                 '--no-pager', 'log']
+        }
+      }
+    }
+    plan << task
+  end
+end

data/examples/groups/jobs/git_stuff/ls.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+git_resources = resources.values.select { |r| r.type == :git }
+
+git_resources.each do |r|
+  job "ls #{r.name}" do
+    plan << { get: r.name, trigger: true }
+    task = {
+      task: "ls #{r.name}", config: {
+        inputs: [name: r.name],
+        platform: 'linux',
+        image_resource: { type: 'docker-image', source: { repository: 'alpine/git' } },
+        run: {
+          path: 'ls',
+          args: [r.name]
+        }
+      }
+    }
+    plan << task
+  end
+end

data/examples/groups/resources/rudder_git.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+resource :rudder_git, :git do
+  source[:uri]    = 'https://github.com/jhmcstanton/rudder.git'
+  source[:branch] = 'master'
+end

data/examples/groups/resources/timer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+resource :timer, :time do
+  source[:interval] = '5m'
+end

data/examples/hello_world_pipeline.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+resource :rudder_git, :git do
+  # The source field dictionary is available to be directly interacted with
+  source[:uri]    = 'https://github.com/jhmcstanton/rudder.git'
+  source[:branch] = 'master'
+end
+
+resource :timer, :time do
+  # The source field can also be assigned via a method
+  source(interval: '5m')
+end
+
+job :getter do
+  plan [in_parallel: [{ get: :rudder_git }, { get: :timer, trigger: true }]]
+end
+
+job :hello_world do
+  # Plan array can be hooked into directly
+  plan << { get: :timer, trigger: true, passed: [:getter] }
+  plan << { task: 'print_hello', config: {
+    platform: 'linux',
+    image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+    run: {
+      path: 'echo',
+      args: ['Hello', 'World!']
+    }
+  } }
+end
+
+# pipeline here allows access to previously defined pipeline components
+job :cat_self do |pipeline|
+  # The plan can also be appended to as a method
+  plan({ get: :rudder_git, trigger: true, passed: [:getter] },
+       task: 'cat this pipeline', config: {
+         inputs: [name: :rudder_git],
+         platform: 'linux',
+         image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+         run: {
+           path: 'cat',
+           args: [pipeline.rudder_git.sub_path('examples/hello_world.rb')]
+         }
+       })
+end

data/examples/includes/README.md

@@ -0,0 +1,7 @@
+# Includes Example
+
+The [`includes_pipeline.rb`](./includes_pipeline.rb) pipeline shows how to load pipeline components
+(jobs, resources, resource_types, groups) from files and include them
+into your pipelines.
+
+![Includes Pipeline](../images/includes/includes.png)

data/examples/includes/includes_pipeline.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+load_component 'resources/rudder_git.rb', :resource, :rudder_git
+
+job = load_component 'jobs/log.rb', :job, :log_rudder_git
+job.plan.insert(0, get: :rudder_git, trigger: true)

data/examples/includes/jobs/log.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+task = {
+  task: 'git log', config: {
+    # input still needed
+    platform: 'linux',
+    image_resource: { type: 'docker-image', source: { repository: 'alpine/git' } },
+    run: {
+      path: 'find',
+      args: ['.', '-iname', '*.git', '-exec',
+             'git', '--git-dir', '{}', '--no-pager', 'log', ';']
+    }
+  }
+}
+plan << task

data/examples/includes/resources/rudder_git.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+type :git
+source[:uri]    = 'https://github.com/jhmcstanton/rudder.git'
+source[:branch] = 'master'

data/examples/shared/README.md

@@ -0,0 +1,21 @@
+# Shared Example
+
+This example is a bit contrived, but serves to illustrate how joining pipelines works.
+
+[`common_pipeline.rb`](./common_pipeline.rb) is a full, standalone pipeline with resources
+and several jobs that is fully flyable.
+
+![Common Pipeline](../images/shared/common.png)
+
+[`wrapper_pipeline.rb`](./wrapper_pipeline.rb) is another full pipeline that incorporates
+the entirety of `common_pipeline.rb` and augments it with an additional timer, one new
+job that requires the final job from `common_pipeline.rb`, and its own job that only
+depends on a single resource from the common pipeline.
+
+![Wrapper Pipeline](../images/shared/wrapper.png)
+
+[`borrows_pipeline.rb`](./borrows_pipeline.rb) is a single job pipeline that borrows
+the git resource from the `common_pipeline.rb` (actually, it would borrow any git
+resource from that pipeline, there just happens to be only one right now).
+
+![Borrows Pipeline](../images/shared/borrows.png)

data/examples/shared/borrows_pipeline.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+common = load 'common_pipeline.rb'
+
+resource :timer, :time do
+  source[:interval] = '30m'
+end
+
+# Borrow any git resources defined in common
+git_resources = common.resources.select { |_name, r| r.type == :git }
+resources.merge! git_resources
+
+job 'Just borrowing the git resource' do
+  git_names = git_resources.keys
+  gets = git_names.map { |name| { get: name } }
+  gets << { get: :timer, trigger: true }
+  plan [in_parallel: gets]
+
+  task = {
+    task: 'ls all the gits', config: {
+      platform: 'linux',
+      inputs: [name: :rudder_git],
+      image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+      run: {
+        path: 'ls',
+        args: git_names
+      }
+    }
+  }
+  plan << task
+end

data/examples/shared/common_pipeline.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+resource :rudder_git, :git do
+  source[:uri]    = 'https://github.com/jhmcstanton/rudder.git'
+  source[:branch] = 'master'
+end
+
+get_rudder = { get: :rudder_git, trigger: true }
+
+print_hello = {
+  task: 'print_hello', config: {
+    platform: 'linux',
+    image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+    run: {
+      path: 'echo',
+      args: ['Hello', 'World!']
+    }
+  }
+}
+
+def mk_name(job_index)
+  "Yo #{job_index}"
+end
+
+num_jobs = 3
+(1..num_jobs).each do |i|
+  name = mk_name i
+  job name do |p|
+    get = get_rudder.dup
+    get[:passed] = [p.mk_name(i - 1)] if i > 1
+    plan << get
+    plan << print_hello
+  end
+end

data/examples/shared/wrapper_pipeline.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+common = load('common_pipeline.rb')
+
+resource :timer, :time do
+  source[:interval] = '5m'
+end
+
+# Add a timer to the first job
+get_timer_task = { get: :timer, trigger: true }
+start_plan = common.jobs.values.first.plan
+start_plan << get_timer_task
+
+resources.merge! common.resources
+jobs     .merge! common.jobs
+
+job 'An extra job that the wrapper pipeline requires' do
+  plan << get_timer_task
+  date = {
+    task: 'print the date', config: {
+      platform: 'linux',
+      image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+      run: {
+        path: 'date'
+      }
+    }
+  }
+  plan << date
+end
+
+job 'Goodbye from the Wrapper Pipeline' do |_pipeline|
+  # Get the last job defined in the previous pipeline
+  # so that we can depend on it in this job
+  last_job = common.jobs.values.last
+  last_job.plan.select { |task| task.key? :get }.each do |task|
+    task = task.dup
+    task[:passed] = [last_job.name]
+    plan << task
+  end
+  task = {
+    task: 'print_outer', config: {
+      platform: 'linux',
+      image_resource: { type: 'docker-image', source: { repository: 'busybox' } },
+      run: {
+        path: 'echo',
+        args: ['This is the outer pipeline. Good bye!']
+      }
+    }
+  }
+  plan << task
+end

data/exe/rudder

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'optparse'
+require 'yaml'
+
+require 'rudder'
+
+name = File.basename __FILE__
+
+# TODO: Figure out a nice way to join these options with fly's without
+# tieing them together
+options = {}
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: #{name} [options]"
+
+  opts.on('-o', '--output YAML_PATH', 'YAML_PATH to write the pipeline config') do |p|
+    options[:output] = p
+  end
+
+  opts.on('-c', '--config RUDDER_CONFIG', 'Path to the RUDDER_CONFIG file to evaluate') do |c|
+    options[:rudder] = c
+  end
+
+  opts.on('-v', '--version', 'Show version') do
+    options[:version] = true
+  end
+end
+optparse.parse!
+
+if options[:version]
+  puts "Rudder Version: #{Rudder::VERSION}"
+  exit
+end
+
+unless options[:rudder]
+  puts 'Must provide RUDDER_CONFIG as option'
+  puts optparse.help
+  exit 1
+end
+
+pipeline = Rudder.compile(options[:rudder])
+
+output   = STDOUT
+if options[:output]
+  output = File.open(options[:output], 'w+')
+  at_exit do
+    output.close
+  end
+end
+
+Rudder.dump(pipeline, output)