bowler 0.0.1

data/README.md

@@ -0,0 +1,3 @@
+# Bowler
+
+Bowler is a gem to manage process dependencies in Foreman.

data/Rakefile

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+
+require "bundler/gem_tasks"
+require "rdoc/task"
+require 'rspec/core/rake_task'
+
+RDoc::Task.new do |rd|
+  rd.rdoc_files.include("lib/**/*.rb")
+  rd.rdoc_dir = "rdoc"
+end
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end
+
+task :default => :spec

data/bin/bowl

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'bowler'
+require 'bowler/cli'
+
+Bowler::CLI.start(ARGV)

data/lib/bowler/cli.rb

@@ -0,0 +1,35 @@
+require 'logger'
+
+module Bowler
+  class CLI
+
+    def self.start(processes)
+      tree = Bowler::DependencyTree.load
+      process_list = processes.map(&:to_sym)
+
+      launch_string = tree.process_list_for(process_list)
+
+      logger.info "Starting #{tree.dependencies_for(process_list).join(', ')}.."
+
+      start_foreman_with launch_string
+    rescue PinfileNotFound
+      logger.error "Bowler could not find a Pinfile in the current directory."
+    rescue PinfileError => e
+      logger.error "Bowler could not load the Pinfile due to an error: #{e}"
+    end
+
+    def self.logger
+      @logger ||= Logger.new(STDOUT)
+    end
+
+    def self.build_command(launch_string)
+      "foreman start -c #{launch_string}"
+    end
+
+    private
+    def self.start_foreman_with(launch_string)
+      exec ( self.build_command launch_string )
+    end
+
+  end
+end

data/lib/bowler/dependency_tree.rb

@@ -0,0 +1,30 @@
+module Bowler
+
+  class DependencyTree
+
+    # Load the Pinfile
+    def self.load(absolute_path = nil)
+      absolute_path ||= File.join( Dir.pwd, 'Pinfile' )
+      definition = DSL.evaluate(absolute_path)
+      self.new(definition)
+    end
+
+    def initialize(definition)
+      @definition = definition
+    end
+
+    def dependencies_for(processes)
+      processes.inject([]) do |array, p|
+        array += [ (@definition.tree[p] || []), p ].flatten
+      end.uniq
+    end
+
+    def process_list_for(processes)
+      on = dependencies_for(processes)
+      off = @definition.processes.reject {|i| on.include? i }
+
+      [ on.map {|x| "#{x}=1" }, off.map {|x| "#{x}=0" } ].flatten.sort.join(',')
+    end
+
+  end
+end

data/lib/bowler/dsl.rb

@@ -0,0 +1,52 @@
+module Bowler
+  class DSL
+    attr_reader :processes, :global_dependencies
+
+    def self.evaluate(pinfile)
+      dsl = new
+      dsl.eval_pinfile(pinfile)
+      dsl.to_definition
+    end
+
+    def eval_pinfile(pinfile)
+      raise PinfileNotFound unless File.exists?(pinfile)
+      file = File.read(pinfile)
+      instance_eval( file )
+    rescue SyntaxError => e
+      raise PinfileError, e
+    end
+
+    def initialize
+      @processes = []
+      @global_dependencies = []
+      @specified_dependencies = []
+    end
+
+    def dependency(*dependencies)
+      @global_dependencies += [dependencies].flatten
+    end
+
+    def process(params)
+      if params.is_a? Hash
+        parent = params.keys.first
+        dependencies = [params.values.first]
+
+        @processes << { :process => parent, :dependencies => [dependencies].flatten }
+        @specified_dependencies += dependencies.flatten
+      else
+        @processes << { :process => params, :dependencies => [ ] }
+      end
+    end
+
+    def to_definition
+      definition = {
+        :tree => @processes.each_with_object({}) {|p, hash|
+          hash[p[:process]] = (p[:dependencies] + @global_dependencies).uniq
+        },
+        :processes => (@processes.map {|x| x[:process]} + @global_dependencies + @specified_dependencies).uniq
+      }
+      OpenStruct.new(definition)
+    end
+
+  end
+end

data/lib/bowler/version.rb

@@ -0,0 +1,3 @@
+module Bowler
+  VERSION = '0.0.1'
+end

data/lib/bowler.rb

@@ -0,0 +1,11 @@
+require 'ostruct'
+
+module Bowler
+
+  autoload :DependencyTree,       'bowler/dependency_tree'
+  autoload :DSL,                  'bowler/dsl'
+
+  class PinfileNotFound < Exception; end
+  class PinfileError < Exception; end
+
+end

data/spec/dependency_tree_spec.rb

@@ -0,0 +1,50 @@
+require 'bowler'
+require_relative 'helpers/definition_helper'
+
+module Bowler
+
+  describe DependencyTree do
+
+    include DefinitionHelper
+
+    context "given a Pinfile" do
+      it "should load a dependency tree" do
+        tree = DependencyTree.load File.join( File.dirname(__FILE__), 'fixtures', 'dependency_tree_pinfile' )
+
+        tree.should be_instance_of DependencyTree
+        tree.dependencies_for([:foo]).should =~ [:bar, :foo, :required]
+        tree.dependencies_for([:nyan]).should =~ [:bar, :foo, :nyan, :required]
+      end
+    end
+
+    context "given an array of one process" do
+      before do
+        @tree = DependencyTree.new stub_definition
+      end
+
+      it "should find the correct dependencies" do
+        @tree.dependencies_for([:app1]).should =~ [:app2, :app3, :app1]
+      end
+
+      it "should give a correct process list" do
+        @tree.process_list_for([:app2]).should == "a=0,app1=0,app2=1,app3=1,b=0,c=0,other=0"
+      end
+    end
+
+    context "given an array of multiple processes" do
+      before do
+        @tree = DependencyTree.new stub_definition
+      end
+
+      it "should find the correct dependencies" do
+        @tree.dependencies_for([:app1, :other]).should =~ [:app2, :app3, :app1, :a, :b, :c, :other]
+      end
+
+      it "should give a correct process list" do
+        @tree.process_list_for([:app2, :other]).should == "a=1,app1=0,app2=1,app3=1,b=1,c=1,other=1"
+      end
+    end
+
+  end
+
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,71 @@
+require 'bowler'
+
+module Bowler
+
+  describe DSL do
+
+    include DefinitionHelper
+
+    context "given a valid pinfile" do
+      it "should return a valid definition" do
+        path_to_pinfile = File.join( File.dirname(__FILE__), 'fixtures', 'dsl_valid_pinfile' )
+        definition = DSL.evaluate path_to_pinfile
+
+        definition.should be_instance_of OpenStruct
+        definition.tree.should == {
+          :app => [ :database, :tiles, :templates ],
+          :tiles => [ :database, :templates ]
+        }
+        definition.processes.should =~ [ :app, :database, :templates, :tiles ]
+      end
+    end
+
+    context "given an invalid pinfile" do
+      it "should raise a gem-defined exception" do
+        path_to_pinfile = File.join( File.dirname(__FILE__), 'fixtures', 'dsl_invalid_pinfile' )
+        expect do
+          DSL.evaluate path_to_pinfile
+        end.to raise_error(PinfileError)
+      end
+    end
+
+    context "given a process" do
+      before do
+        @dsl = DSL.new
+        @dsl.process :test
+      end
+
+      it "should update the processes list with the specified process" do
+        @dsl.processes.should == [{ :process => :test, :dependencies => [] }]
+        @dsl.to_definition.processes.should == [ :test ]
+      end
+    end
+
+    context "given a process with dependencies" do
+      before do
+        @dsl = DSL.new
+        @dsl.process :test => [ :dependency1, :dependency2 ]
+      end
+
+      it "should update the processes list with all specified processes" do
+        @dsl.processes.should == [{ :process => :test, :dependencies => [:dependency1, :dependency2] }]
+        @dsl.to_definition.processes.should =~ [ :dependency1, :dependency2, :test ]
+      end
+    end
+
+    context "given global dependencies" do
+      before do
+        @dsl = DSL.new
+        @dsl.dependency :global1, :global2
+        @dsl.dependency :global3
+      end
+
+      it "should update the processes list with all specified processes" do
+        @dsl.global_dependencies.should =~ [:global1, :global2, :global3]
+        @dsl.to_definition.processes.should =~ [ :global1, :global2, :global3 ]
+      end
+    end
+
+  end
+
+end

data/spec/fixtures/dependency_tree_pinfile

@@ -0,0 +1,5 @@
+dependency :required
+
+process :foo => :bar
+process :nyan => [:foo, :bar]
+process :rick

data/spec/fixtures/dsl_invalid_pinfile

@@ -0,0 +1,3 @@
+dependey :templates
+
+process :app => [:database,,,]

data/spec/fixtures/dsl_valid_pinfile

@@ -0,0 +1,4 @@
+dependency :templates
+
+process :app => [:database, :tiles]
+process :tiles => :database

data/spec/helpers/definition_helper.rb

@@ -0,0 +1,19 @@
+module Bowler
+  module DefinitionHelper
+
+    require 'ostruct'
+
+    def stub_definition
+      OpenStruct.new ({
+        :processes => [ :app1, :app2, :app3, :other, :a, :b, :c ],
+        :tree => {
+          :app1 => [ :app2, :app3 ],
+          :app2 => [ :app3 ],
+          :app3 => [ ],
+          :other => [ :a, :b, :c ]
+        }
+      })
+    end
+
+  end
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: bowler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jordan Hatch
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-16 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: foreman
+  requirement: &70276368515620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70276368515620
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70276368514980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2.2
+  type: :development
+  prerelease: false
+  version_requirements: *70276368514980
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70276368514300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70276368514300
+description: 
+email:
+- jordan@jordanh.net
+executables:
+- bowl
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bowler/cli.rb
+- lib/bowler/dependency_tree.rb
+- lib/bowler/dsl.rb
+- lib/bowler/version.rb
+- lib/bowler.rb
+- README.md
+- Rakefile
+- spec/dependency_tree_spec.rb
+- spec/dsl_spec.rb
+- spec/fixtures/dependency_tree_pinfile
+- spec/fixtures/dsl_invalid_pinfile
+- spec/fixtures/dsl_valid_pinfile
+- spec/helpers/definition_helper.rb
+- bin/bowl
+homepage: 
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1393360155367898551
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1393360155367898551
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.12
+signing_key: 
+specification_version: 3
+summary: A wrapper for large Foreman-managed apps with dependent processes
+test_files:
+- spec/dependency_tree_spec.rb
+- spec/dsl_spec.rb
+- spec/fixtures/dependency_tree_pinfile
+- spec/fixtures/dsl_invalid_pinfile
+- spec/fixtures/dsl_valid_pinfile
+- spec/helpers/definition_helper.rb