cumuli 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e61d96a9203fd5fed28980e2d3817ab7afcdfd5a
-  data.tar.gz: 0721f35292c999e27c9e7ad25904c93b2d59f353
+  metadata.gz: 99ef0de4fd4c50b58aaeb4ebe381eea7f06ebba6
+  data.tar.gz: 90149d60a66ab52a9b0769e611706d673fea480d
 SHA512:
-  metadata.gz: 557916c9a94781c074aad2eb6646a7d7cf99755f17a4c9800d0a89ae45061a0bc58ba4725700fe018a88b81ab653a21caaa53c0990701ed9583ea30278b203bf
-  data.tar.gz: c83034cfc14815ca7d13d9b3aed3a109993ddaeb5be4d3ff6ed4f3777514038477a9f6155f2a097c8d9ee2843c4edc97a62e47fac1a1dcb57c833c4cd2306aa4
+  metadata.gz: 934f662727f2fa25fa6c64fe7f93572b237f1fcf4b141e9a249e4e81d2cedc18850d8a73a5f43572bfb0f12b08ada252d67c57f63dbe8d6ef69e4b10812b5a40
+  data.tar.gz: b7305c29e3ae04e9cdcfc8201253dd72dcdd762b23ade163f3a48c57812ec927c50cc587644077bea517b941eb7a674fe737cf3e58a8b1fbc3fd45c741a69c06

data/README.md

@@ -55,7 +55,7 @@ framework.
     #   first argument: environment
     #   second argument: whether to try to establish a connection to 
     #     each of the apps with a port before continuing in the thread
-    app = Cumuli::App.new('test', false)
+    app = Cumuli::Spawner::App.new('test', false)
 
     app.start # starts all the applications and services in the Procfile
 
@@ -90,9 +90,9 @@ are likely related to cumuli.
 
 ## Known Issues
 
-If you start the Cumuli app and stop it the first time, it will successfully start and stop all processes.  However, if you use the same Cumuli app class to
-start and stop the processes again, it will fail to stop any of the
-processes.
+* An occasional orphan will be left around, still debugging
+* Mechanism for alerting spawner app that the foreman process has killed
+  children needs to be faster and more direct
 
 ## Contributing
 

data/features/step_definitions/app_steps.rb

@@ -1,5 +1,5 @@
 Given(/^the app suite is loaded$/) do
-  @app = Cumuli::App.new({
+  @app = Cumuli::Spawner::App.new({
     env: 'test',
     wait_time: 5,
     log_dir: File.dirname(__FILE__) + "/../../spec/fixtures/log",

data/lib/cumuli/cli/remote_command.rb

@@ -25,7 +25,7 @@ module Cumuli
 
       def get_passed_command
         matched = argv.first.match(/\[(.*)\]/)
-        matched && matched[1]
+        (matched && matched[1]) || argv.first
       end
 
       def command

data/lib/cumuli/project_manager/manager.rb

@@ -0,0 +1,47 @@
+module Cumuli
+  module ProjectManager
+    class Manager
+      DEFAULT_PROJECT_PATH = Dir.pwd
+
+      attr_accessor :config_path, :procfile_path
+
+      def initialize(path=DEFAULT_PROJECT_PATH)
+        @path = path
+        @config_path = "#{path}/config/projects.yml"
+        @procfile_path = "#{path}/Procfile"
+      end
+
+      def publish
+        File.open(procfile_path, 'w') do |f|
+          projects.each do |project|
+            f.write project.to_procfile
+          end
+        end
+      end
+
+      def setup
+        submodules_init
+        system('git submodule init')
+        system('git submodule update')
+        system("git submodule foreach git pull")
+        setup_projects
+      end
+
+      def submodules_init
+        projects.each { |project| project.submodule_init }
+      end
+
+      def setup_projects
+        projects.each { |project| project.setup }
+      end
+
+      def projects
+        @projects ||= config.map{ |name, opts| Cumuli::ProjectManager::Project.new(name, opts) }
+      end
+
+      def config
+        @config ||= YAML.load( File.read(config_path) )
+      end
+    end
+  end
+end

data/lib/cumuli/project_manager/project.rb

@@ -0,0 +1,106 @@
+module Cumuli
+  module ProjectManager
+    class Project
+      DEFAULT_WAIT_TIME = 10
+      LOCALHOST = '127.0.0.1'
+
+      attr_reader :name, :database_config, :database_sample_config, :port, :path,
+        :repository, :type, :setup_scripts, :wait_time, :domain
+      
+      def initialize(name, opts)
+        @name = name
+
+        @repository = opts['repository']
+        @path = opts['path'] || "./#{name}"
+        @port = opts['port']
+        @type = opts['type'] || 'app'
+        @wait_time = opts['wait_time'] || DEFAULT_WAIT_TIME
+        @domain = opts['domain'] || '127.0.0.1'
+
+        @database_config = opts['database_config'] || []
+        @database_sample_config = opts['database_sample_config'] || []
+        @setup_scripts = opts['setup_scripts'] || []
+
+        @database_config = [@database_config] unless @database_config.is_a?(Array)
+        @database_sample_config = [@database_sample_config] unless @database_sample_config.is_a?(Array)
+      end
+
+      def wait?
+        type == 'app' && (wait_time && wait_time > 0) && (port || domain != LOCALHOST)
+      end
+
+      def wait_for_start
+        return unless wait?
+        Waiter.new("Unable to start #{name}").wait_until(wait_time) { socket_available? }
+      end
+
+      def wait_for_stop
+        return unless wait?
+        Waiter.new("Unable to stop #{name}").wait_until(wait_time) { !socket_available? }
+      end
+
+      def socket_available?
+        TCPSocket.new(domain, port)
+        true
+      rescue Errno::ECONNREFUSED
+        false
+      end
+
+      def url
+        "http://#{domain}#{port ? ":#{port}" : ''}"
+      end
+
+      def database_sample_paths
+        database_sample_config.map { |config_path| "#{path}/#{config_path}" }
+      end
+
+      def database_config_paths
+        database_config.map { |config_path| "#{path}/#{config_path}" }
+      end
+
+      def database_configured?(path)
+        File.exist?(path)
+      end
+
+      def write_database_config!
+        database_config_paths.each_with_index do |config_path, i|
+          FileUtils.cp(database_sample_paths[i], config_path)
+        end
+      end
+
+      def write_database_config
+        database_config_paths.each_with_index do |config_path, i|
+          FileUtils.cp(database_sample_paths[i], config_path) unless configured?(config_path)
+        end
+      end
+
+      def to_procfile
+        send("#{type}_to_procfile") rescue ''
+      end
+
+      def app_to_procfile
+        "#{name}: cumuli #{path} -p #{port}\n"
+      end
+
+      def service_to_procfile
+        "#{name}: cumuli #{path}\n"
+      end
+
+      def submodule_init
+        system "git submodule add #{repository} #{path}" if repository
+      end
+
+      def setup
+        # checkout master, because sometimes on setup no branch is
+        # checked out
+        CLI::RemoteCommand.new(['git checkout master', "DIR=#{path}"])
+
+        write_database_config
+
+        setup_scripts.each do |script|
+          CLI::RemoteCommand.new([script, "DIR=#{path}"]).perform
+        end
+      end
+    end
+  end
+end

data/lib/cumuli/project_manager.rb

@@ -0,0 +1,2 @@
+require "cumuli/project_manager/project"
+require "cumuli/project_manager/manager"

data/lib/cumuli/spawner/app.rb

@@ -0,0 +1,81 @@
+module Cumuli
+  module Spawner
+    class App
+      SIGNALS = ['TERM', 'INT', 'HUP']
+
+      attr_accessor :env, :app_dir, :log_dir
+
+      def initialize(options={})
+        @env = options[:env]
+        @log_dir = options[:log_dir] || "#{Dir.pwd}/log"
+        @app_dir = options[:app_dir] || Dir.pwd
+      end
+
+      def start
+        return if foreman_process.started?
+
+        Dir.chdir(app_dir) do
+          listen_for_signals
+          logger.print "Starting ..."
+          foreman_process.start
+          wait_for_apps
+        end
+      end
+
+      def stop
+        if foreman_process.started?
+          foreman_process.stop
+          wait_for_apps('stop')
+          @foreman_process = nil
+        end
+      end
+
+      def logger
+        @logger = StdoutLogger.new
+      end
+
+      def foreman_process
+        @foreman_process ||= Spawner::ForemanProc.new(env, log_dir)
+      end
+
+      def apps
+        @apps ||= ProjectManager::Manager.new(app_dir).projects
+      end
+
+      def process_pids
+        PS.new.family
+      end
+
+      def pid
+        foreman_process.group_id
+      end
+
+      def listen_for_signals
+        SIGNALS.each do |signal|
+          trap(signal) do
+            puts "#{self.class}: trapped signal #{signal} in #{Process.pid} ... stopping"
+            stop
+          end
+        end
+      end
+
+      def wait_for_apps(direction = 'start')
+        logger.add_space
+        apps.each do |app|
+          log_and_wait(app, direction)
+        end
+        logger.add_space
+      end
+
+      def log_and_wait(app, direction)
+        logger.print "#{direction}: waiting for app named '#{app.name}' at #{app.url}"
+        app.send("wait_for_#{direction}")
+        logger.print "#{direction}: application '#{app.name}' on #{app.url} complete"
+        logger.add_space
+      rescue Exception => e
+        stop
+        raise e
+      end
+    end
+  end
+end

data/lib/cumuli/{app/spawner.rb → spawner/foreman_proc.rb}

@@ -1,6 +1,6 @@
 module Cumuli
-  class App
-    class Spawner
+  module Spawner
+    class ForemanProc
       attr_reader :pid, :env, :log_dir
 
       def initialize(env, log_dir)

data/lib/cumuli/{app → spawner}/stdout_logger.rb

@@ -1,5 +1,5 @@
 module Cumuli
-  class App
+  module Spawner
     class StdoutLogger
       GRAY = "\033[0;37m"
       RESET = "\033[0m"

data/lib/cumuli/spawner.rb

@@ -0,0 +1,4 @@
+require "cumuli/spawner/app"
+require "cumuli/spawner/foreman_proc"
+require "cumuli/spawner/stdout_logger"
+

data/lib/cumuli/tasks/cumuli.rake

@@ -1,42 +1,53 @@
-require_relative "../ps"
-require_relative "../cli/remote_command"
-require_relative "../cli/commander"
-require_relative "../cli/terminal"
+require_relative "../../cumuli"
 
 namespace :cumuli do
-  namespace :kill do
-    desc "kill all foreman related processes"
-    task :all do
-      ps = Cumuli::PS.new
-      ps.kill(ps.foremans.map(&:pid))
+  namespace :project do
+    desc "install submodules and run setup scripts based on the project.yml"
+    task :setup do
+      Cumuli::ProjectManager::Manager.new.setup
     end
 
-    desc "kill the first spawned foreman process"
-    task :root do
-      ps = Cumuli::PS.new
-      ps.kill
+    desc "copy database config and rerun setup scripts"
+    task :config do
+      Cumuli::ProjectManager::Manager.new.setup_projects
     end
   end
 
-  desc "kill the root process"
-  task :kill => ['cumuli:kill:root']
-
-  namespace :int do
-    desc "interrupt all foreman related processes"
-    task :all do
-      ps = Cumuli::PS.new
-      ps.int(ps.foremans.map(&:pid))
+  namespace :ps do
+    namespace :kill do
+      desc "kill all foreman related processes"
+      task :all do
+        ps = Cumuli::PS.new
+        ps.kill(ps.foremans.map(&:pid))
+      end
+
+      desc "kill the first spawned foreman process"
+      task :root do
+        ps = Cumuli::PS.new
+        ps.kill
+      end
     end
 
-    desc "kill the first spawned foreman process"
-    task :root do
-      ps = Cumuli::PS.new
-      ps.int
+    desc "kill the root process"
+    task :kill => ['cumuli:kill:root']
+
+    namespace :int do
+      desc "interrupt all foreman related processes"
+      task :all do
+        ps = Cumuli::PS.new
+        ps.int(ps.foremans.map(&:pid))
+      end
+
+      desc "kill the first spawned foreman process"
+      task :root do
+        ps = Cumuli::PS.new
+        ps.int
+      end
     end
-  end
 
-  desc "interrupt the root process"
-  task :int => ['cumuli:int:root']
+    desc "interrupt the root process"
+    task :int => ['cumuli:int:root']
+  end
 
   desc "look at the list of foreman related processes"
   task :ps do

data/lib/cumuli/version.rb

@@ -1,3 +1,3 @@
 module Cumuli
-  VERSION = "0.3.4"
+  VERSION = "0.4.0"
 end

data/lib/cumuli.rb

@@ -11,5 +11,6 @@ require "cumuli/facade"
 require "cumuli/ps"
 require "cumuli/waiter"
 require "cumuli/cli"
-require "cumuli/app"
+require "cumuli/spawner"
+require "cumuli/project_manager"
 require "cumuli/version"

data/spec/fixtures/app_set/config/projects.yml

@@ -0,0 +1,6 @@
+loopy:
+  type: service
+nodified:
+  path: ./noded
+  port: 2323
+

data/spec/fixtures/project_manager/config/projects.yml

@@ -0,0 +1,71 @@
+activator:
+  repository: git@github.com:socialchorus/activator.git
+  database_yml: config/database.yml
+  database_sample_yml: config/database.example.yml
+  type: app
+  port: 3000
+  setup_scripts:
+    - bundle
+    - rake db:create:all
+    - rake db:migrate
+
+mactivator:
+  repository: git@github.com:socialchorus/mactivator.git
+  database_yml: config/database.yml
+  database_sample_yml: config/database.example.yml
+  type: app
+  port: 4000
+  setup_scripts:
+    - bundle
+
+bossanova:
+  repository: git@github.com:socialchorus/bossanova.git
+  database_yml: config/database.yml
+  database_sample_yml: config/database.example.yml
+  type: app
+  port: 6000
+  setup_scripts:
+    - bundle
+    - rake db:drop:all
+    - rake db:create:all
+    - rake db:migrate
+
+linktimigrator:
+  repository: git@github.com:socialchorus/linktimigrator.git
+  database_yml: database.json
+  database_sample_yml: ../linktivator/database.json.sample
+  type: helper
+  setup_scripts:
+    - bundle
+    - ruby bin/migrate.rb
+
+linktivator:
+  repository: git@github.com:socialchorus/linktivator.git
+  database_yml: database.json
+  database_sample_yml: database.json.sample
+  type: app
+  port: 5000
+  setup_scripts:
+    - bundle
+    - npm install
+
+augury:
+  repository: git@github.com:socialchorus/augury.git
+  type: node
+  port: 5010
+  setup_scripts:
+    - bundle
+    - npm install
+
+transducer:
+  repository: git@github.com:socialchorus/transducer.git
+  database_yml:
+    - config/activator_database.yml
+    - config/bossanova_database.yml']
+  database_sample_yml:
+    - config/activator_database.example.yml
+    - config/bossanova_database.example.yml
+  type: service
+  setup_scripts:
+    - bundle
+

data/spec/project_manager/manager_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Cumuli::ProjectManager::Manager do
+  let(:app_path) { File.dirname(__FILE__) + "/../fixtures/project_manager" }
+  let(:loader) { 
+    Cumuli::ProjectManager::Manager.new(app_path)
+  }
+  let(:procfile_path) { "#{app_path}/Procfile" }
+  let(:procfile_contents) { File.read(procfile_path) }
+
+  describe "#publish" do
+    before do
+      File.delete(procfile_path) if File.exist?(procfile_path)
+    end
+
+    it "write a procfile with a line for every service or app" do
+      loader.publish
+      procfile_contents.lines.size.should == 5
+    end
+  end
+
+  describe "#projects" do
+    it "is a collection of project objects, one for each entry in the yml" do
+      loader.projects.size.should == 7
+      loader.projects.map{|a| a.class }.uniq.should == [Cumuli::ProjectManager::Project]
+    end
+  end
+end

data/spec/project_manager/project_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Cumuli::ProjectManager::Project do
+  let(:type) { 'app' }
+  let(:port) { 3000 }
+  let(:wait_time) { 0.1 }
+  let(:app) {
+    Cumuli::ProjectManager::Project.new('activator', {
+      'repository' => 'git@github.com:socialchorus/activator.git',
+      'database_config' => 'config/database.config',
+      'database_sample_config' => 'config/database.example.config',
+      'type' => type,
+      'port' => port,
+      'wait_time' => wait_time,
+      'setup_scripts' => ['bundle', 'rake db:create:all', 'rake db:migrate']
+    })
+  }
+
+  it "stores configuration data" do
+    app.name.should == 'activator'
+    app.path.should == './activator'
+    app.repository.should == 'git@github.com:socialchorus/activator.git'
+    app.type.should == 'app'
+    app.port.should == 3000
+    app.wait_time.should == 0.1
+  end
+
+  describe '#wait?' do
+    context "when the type is 'app'" do
+      context "when there is no port" do
+        let(:port) { nil }
+
+        it "should be false" do
+          app.wait?.should be_false
+        end
+      end
+
+      context "when there is a port" do
+        it "should be true" do
+          app.wait?.should be_true
+        end
+      end
+    end
+
+    context "when the type is something else" do
+      let(:type) { 'service' }
+
+      it "is false" do
+        app.wait?.should be_false
+      end
+    end
+  end
+
+  describe '#to_procfile' do
+    context "when an app" do
+      it "returns a line with a port number" do
+        app.to_procfile.should == "activator: cumuli ./activator -p 3000\n"
+      end
+    end
+
+    context "when a service" do
+      let(:type) { 'service' }
+
+      it "returns a line without a port" do
+        app.to_procfile.should == "activator: cumuli ./activator\n"
+      end
+    end
+
+    context "when something else" do
+      let(:type) { 'helper' }
+
+      it "returns an empty string" do
+        app.to_procfile.should == ""
+      end
+    end
+  end
+
+  describe 'waiting' do
+    describe '#wait_for_start' do
+      it "raises an error if the app in unavailable via TCP socket after timeout" do
+        TCPSocket.should_receive(:new).with('127.0.0.1', 3000).and_raise(Exception)
+        expect {
+          app.wait_for_start
+        }.to raise_error
+      end
+
+      it "does not raise an error if the TCP socket is available" do
+        TCPSocket.should_receive(:new).with('127.0.0.1', 3000)
+        expect {
+          app.wait_for_start
+        }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/{app → spawner}/app_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Cumuli::App do
+describe Cumuli::Spawner::App do
   let(:opts) {
     {
       env: 'test',
@@ -9,7 +9,7 @@ describe Cumuli::App do
       app_dir: app_set_dir
     }
   }
-  let(:app) { Cumuli::App.new(opts) }
+  let(:app) { Cumuli::Spawner::App.new(opts) }
   let(:logs) { File.readlines("#{log_dir}/test.log") }
 
   describe '#start' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cumuli
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - SocialChorus
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-25 00:00:00.000000000 Z
+date: 2013-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: foreman
@@ -106,12 +106,6 @@ files:
 - features/step_definitions/app_steps.rb
 - features/support/env.rb
 - lib/cumuli.rb
-- lib/cumuli/app.rb
-- lib/cumuli/app/app.rb
-- lib/cumuli/app/procs.rb
-- lib/cumuli/app/spawner.rb
-- lib/cumuli/app/stdout_logger.rb
-- lib/cumuli/app/sub_app.rb
 - lib/cumuli/cli.rb
 - lib/cumuli/cli/args.rb
 - lib/cumuli/cli/cli.rb
@@ -119,27 +113,36 @@ files:
 - lib/cumuli/cli/remote_command.rb
 - lib/cumuli/cli/terminal.rb
 - lib/cumuli/facade.rb
+- lib/cumuli/project_manager.rb
+- lib/cumuli/project_manager/manager.rb
+- lib/cumuli/project_manager/project.rb
 - lib/cumuli/ps.rb
+- lib/cumuli/spawner.rb
+- lib/cumuli/spawner/app.rb
+- lib/cumuli/spawner/foreman_proc.rb
+- lib/cumuli/spawner/stdout_logger.rb
 - lib/cumuli/tasks.rb
 - lib/cumuli/tasks/cumuli.rake
 - lib/cumuli/version.rb
 - lib/cumuli/waiter.rb
-- spec/app/app_spec.rb
-- spec/app/procs_spec.rb
-- spec/app/sub_app_spec.rb
 - spec/cli/args_spec.rb
 - spec/cli/commander_spec.rb
 - spec/cli/remote_command_spec.rb
 - spec/cli/terminal_spec.rb
 - spec/fixtures/app_set/Procfile
+- spec/fixtures/app_set/config/projects.yml
 - spec/fixtures/app_set/loopy/.rvmrc
 - spec/fixtures/app_set/loopy/Procfile
 - spec/fixtures/app_set/loopy/half_loop.rb
 - spec/fixtures/app_set/loopy/loop.rb
 - spec/fixtures/app_set/noded/.rvmrc
 - spec/fixtures/app_set/noded/nodified.js
+- spec/fixtures/project_manager/config/projects.yml
 - spec/fixtures/ps.txt
+- spec/project_manager/manager_spec.rb
+- spec/project_manager/project_spec.rb
 - spec/ps_spec.rb
+- spec/spawner/app_spec.rb
 - spec/spec_helper.rb
 - spec/support/functional_helpers.rb
 - spec/support/log_helpers.rb
@@ -175,22 +178,24 @@ test_files:
 - features/graceful_exits.feature
 - features/step_definitions/app_steps.rb
 - features/support/env.rb
-- spec/app/app_spec.rb
-- spec/app/procs_spec.rb
-- spec/app/sub_app_spec.rb
 - spec/cli/args_spec.rb
 - spec/cli/commander_spec.rb
 - spec/cli/remote_command_spec.rb
 - spec/cli/terminal_spec.rb
 - spec/fixtures/app_set/Procfile
+- spec/fixtures/app_set/config/projects.yml
 - spec/fixtures/app_set/loopy/.rvmrc
 - spec/fixtures/app_set/loopy/Procfile
 - spec/fixtures/app_set/loopy/half_loop.rb
 - spec/fixtures/app_set/loopy/loop.rb
 - spec/fixtures/app_set/noded/.rvmrc
 - spec/fixtures/app_set/noded/nodified.js
+- spec/fixtures/project_manager/config/projects.yml
 - spec/fixtures/ps.txt
+- spec/project_manager/manager_spec.rb
+- spec/project_manager/project_spec.rb
 - spec/ps_spec.rb
+- spec/spawner/app_spec.rb
 - spec/spec_helper.rb
 - spec/support/functional_helpers.rb
 - spec/support/log_helpers.rb

data/lib/cumuli/app/app.rb

@@ -1,86 +0,0 @@
-module Cumuli
-  class App
-    DEFAULT_WAIT_TIME = 5 #120
-    SIGNALS = ['TERM', 'INT', 'HUP']
-
-    attr_accessor :env, :wait_time, :app_dir, :log_dir
-
-    def initialize(options={})
-      @env = options[:env]
-      @wait_time = options[:wait_time]
-      @log_dir = options[:log_dir] || "#{Dir.pwd}/log"
-      @app_dir = options[:app_dir] || Dir.pwd
-    end
-
-    def start
-      return if foreman_process.started?
-
-      Dir.chdir(app_dir) do
-        listen_for_signals
-        logger.print "Starting ..."
-        foreman_process.start
-        wait_for_apps if wait?
-      end
-    end
-
-    def stop
-      if foreman_process.started?
-        foreman_process.stop
-        wait_for_apps('stop') if wait?
-        @foreman_process = nil
-      end
-    end
-
-    def logger
-      @logger = StdoutLogger.new
-    end
-
-    def foreman_process
-      @foreman_process ||= Spawner.new(env, log_dir)
-    end
-
-    def apps
-      @apps ||= Procs.new(app_dir).apps
-    end
-
-    def process_pids
-      PS.new.family
-    end
-
-    def pid
-      foreman_process.group_id
-    end
-
-    def wait?
-      wait_time && wait_time > 0
-    end
-
-    def listen_for_signals
-      SIGNALS.each do |signal|
-        trap(signal) do
-          puts "#{self.class}: trapped signal #{signal} in #{Process.pid} ... stopping"
-          stop
-        end
-      end
-    end
-
-    def wait_for_apps(direction = 'start')
-      logger.add_space
-      apps.each do |app|
-        log_and_wait(app, direction)
-      end
-      logger.add_space
-    end
-
-    def log_and_wait(app, direction)
-      timeout = wait_time || DEFAULT_WAIT_TIME
-      logger.print "#{direction}: waiting for app named '#{app.name}' at #{app.url}"
-      app.send("wait_for_#{direction}", timeout)
-      logger.print "#{direction}: application '#{app.name}' on #{app.url} complete"
-      logger.add_space
-    rescue Exception => e
-      stop
-      raise e
-    end
-  end
-end

data/lib/cumuli/app/procs.rb

@@ -1,33 +0,0 @@
-module Cumuli
-  class App
-    class Procs
-      attr_reader :port_map, :path, :apps
-
-      def initialize(path=nil)
-        @path = (path || Dir.pwd) + "/Procfile"
-        parse_procfile
-      end
-
-      def map
-        @map ||= apps.inject({}) do |hash, app|
-          hash[app.name] = app.port
-          hash
-        end
-      end
-
-      def file
-        @file ||= File.read(path)
-      end
-
-      def parse_procfile
-        @apps = file.lines.map do |line|
-          SubApp.new(line)
-        end
-      end
-
-      def names
-        map.keys
-      end
-    end
-  end
-end

data/lib/cumuli/app/sub_app.rb

@@ -1,50 +0,0 @@
-module Cumuli
-  class App
-    class SubApp
-      attr_reader :parts
-      attr_accessor :host
-
-      def initialize(line)
-        @parts = line.split
-        @host = 'localhost'
-      end
-
-      def name
-        parts.first.gsub(':', '')
-      end
-
-      def port
-        if index = parts.find_index('-p')
-          parts[index + 1] && parts[index + 1].to_i
-        end
-      end
-
-      def waitable?
-        host != 'localhost' || port
-      end
-
-      def wait_for_start(timeout)
-        return unless waitable?
-        Waiter.new("Application #{name} on port #{port} unavailable after #{timeout} seconds")
-          .wait_until(timeout) { socket_available? }
-      end
-
-      def wait_for_stop(timeout)
-        return unless waitable?
-        Waiter.new("Application #{name} on port #{port} still connected after #{timeout} seconds")
-          .wait_until(timeout) { !socket_available? }
-      end
-
-      def url
-        "http://#{host}#{port ? ':' + port.to_s : ''}"
-      end
-
-      def socket_available?
-        TCPSocket.new(host, port)
-        true
-      rescue Errno::ECONNREFUSED
-        false
-      end
-    end
-  end
-end

data/lib/cumuli/app.rb

@@ -1,6 +0,0 @@
-require "cumuli/app/app"
-require "cumuli/app/spawner"
-require "cumuli/app/stdout_logger"
-require "cumuli/app/procs"
-require "cumuli/app/sub_app"
-

data/spec/app/procs_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-
-describe Cumuli::App::Procs do
-  let(:procs) { Cumuli::App::Procs.new(app_set_dir) }
-
-  it "#names includes all the app names listed in the Procfile" do
-    procs.names.should =~ [
-      'loopy', 'nodified'
-    ]
-  end
-
-  describe '#map' do
-    it "maps names to ports" do
-      procs.map['nodified'].should == 2323
-    end
-
-    it "return a nil port when the app has no port" do
-      procs.map['loopy'].should == nil
-    end 
-  end
-end

data/spec/app/sub_app_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Cumuli::App::SubApp do
-  let(:sub_app) {
-    Cumuli::App::SubApp.new(
-      "nodified: ../../../bin/cumuli ./noded -p 2323"
-    )
-  }
-
-  describe '#wait_for_start' do
-    it "raises an error if the app in unavailable via TCP socket after timeout" do
-      TCPSocket.should_receive(:new).with('localhost', 2323).and_raise(Exception)
-      expect {
-        sub_app.wait_for_start(0.002)
-      }.to raise_error
-    end
-
-    it "does not raise an error if the TCP socket is available" do
-      TCPSocket.should_receive(:new).with('localhost', 2323)
-      expect {
-        sub_app.wait_for_start(10)
-      }.not_to raise_error
-    end
-  end
-end