overman 0.0.1 → 0.88.1

data/spec/foreman/export/systemd_spec.rb

@@ -0,0 +1,155 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/systemd"
+require "tmpdir"
+
+describe Foreman::Export::Systemd, :fakefs, :aggregate_failures do
+  let(:procfile)  { write_procfile("/tmp/app/Procfile") }
+  let(:formation) { nil }
+  let(:engine)    { Foreman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:systemd)   { Foreman::Export::Systemd.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("systemd") }
+  before(:each) { allow(systemd).to receive(:say) }
+
+  it "exports to the filesystem" do
+    systemd.export
+
+    expect(File.read("/tmp/init/app.target")).to eq(example_export_file("systemd/app.target"))
+    expect(File.read("/tmp/init/app-alpha.1.service")).to eq(example_export_file("systemd/app-alpha.1.service"))
+    expect(File.read("/tmp/init/app-bravo.1.service")).to eq(example_export_file("systemd/app-bravo.1.service"))
+  end
+
+  context "when systemd export was run using the previous version of systemd export" do
+    before do
+     write_file("/tmp/init/app.target")
+
+     write_file("/tmp/init/app-alpha@.service")
+     write_file("/tmp/init/app-alpha.target")
+     write_file("/tmp/init/app-alpha.target.wants/app-alpha@5000.service")
+
+     write_file("/tmp/init/app-bravo.target")
+     write_file("/tmp/init/app-bravo@.service")
+     write_file("/tmp/init/app-bravo.target.wants/app-bravo@5100.service")
+
+     write_file("/tmp/init/app-foo_bar.target")
+     write_file("/tmp/init/app-foo_bar@.service")
+     write_file("/tmp/init/app-foo_bar.target.wants/app-foo_bar@5200.service")
+
+     write_file("/tmp/init/app-foo-bar.target")
+     write_file("/tmp/init/app-foo-bar@.service")
+     write_file("/tmp/init/app-foo-bar.target.wants/app-foo-bar@5300.service")
+    end
+
+    it "cleans up service files created by systemd export" do
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app.target")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.target.wants/app-alpha@5000.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-alpha.target.wants")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.target.wants/app-bravo@5100.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-bravo.target.wants")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.target.wants/app-foo_bar@5200.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-foo_bar.target.wants")
+
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar@.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.target.wants/app-foo-bar@5300.service")
+      expect(FileUtils).to receive(:rm_r).with("/tmp/init/app-foo-bar.target.wants")
+
+      systemd.export
+    end
+  end
+
+  context "when systemd export was run using the current version of systemd export" do
+    before do
+      systemd.export
+    end
+
+    it "cleans up service files created by systemd export" do
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app.target")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.1.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.1.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.1.service")
+      expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.1.service")
+
+      systemd.export
+    end
+  end
+
+  it "includes environment variables" do
+    engine.env['KEY'] = 'some "value"'
+    systemd.export
+    expect(File.read("/tmp/init/app-alpha.1.service")).to match(/KEY=some "value"/)
+  end
+
+  it "includes ExecStart line" do
+    engine.env['KEY'] = 'some "value"'
+    systemd.export
+    expect(File.read("/tmp/init/app-alpha.1.service")).to match(/^ExecStart=/)
+  end
+
+  context "with a custom formation specified" do
+    let(:formation) { "alpha=2" }
+
+    it "exports only those services that are specified in the formation" do
+      systemd.export
+
+      expect(File.read("/tmp/init/app.target")).to include("Wants=app-alpha.1.service app-alpha.2.service\n")
+      expect(File.read("/tmp/init/app-alpha.1.service")).to eq(example_export_file("systemd/app-alpha.1.service"))
+      expect(File.read("/tmp/init/app-alpha.2.service")).to eq(example_export_file("systemd/app-alpha.2.service"))
+      expect(File.exist?("/tmp/init/app-bravo.1.service")).to be_falsey
+    end
+  end
+
+  context "with alternate template directory specified" do
+    let(:template) { "/tmp/alternate" }
+    let(:options)  { { :app => "app", :template => template } }
+
+    before do
+      FileUtils.mkdir_p template
+      File.open("#{template}/master.target.erb", "w") { |f| f.puts "alternate_template" }
+    end
+
+    it "uses template files found in the alternate directory" do
+      systemd.export
+      expect(File.read("/tmp/init/app.target")).to eq("alternate_template\n")
+    end
+
+    context "with alternate templates in the user home directory" do
+      before do
+        FileUtils.mkdir_p File.expand_path("~/.foreman/templates/systemd")
+        File.open(File.expand_path("~/.foreman/templates/systemd/master.target.erb"), "w") do |file|
+          file.puts "home_dir_template"
+        end
+      end
+
+      it "uses template files found in the alternate directory" do
+        systemd.export
+        expect(File.read("/tmp/init/app.target")).to eq("alternate_template\n")
+      end
+    end
+  end
+
+  context "with alternate templates in the user home directory" do
+    before do
+      FileUtils.mkdir_p File.expand_path("~/.foreman/templates/systemd")
+      File.open(File.expand_path("~/.foreman/templates/systemd/master.target.erb"), "w") do |file|
+        file.puts "home_dir_template"
+      end
+    end
+
+    it "uses template files found in the user home directory" do
+      systemd.export
+      expect(File.read("/tmp/init/app.target")).to eq("home_dir_template\n")
+    end
+  end
+end

data/spec/foreman/export/upstart_spec.rb

@@ -0,0 +1,118 @@
+require "spec_helper"
+require "foreman/engine"
+require "foreman/export/upstart"
+require "tmpdir"
+
+describe Foreman::Export::Upstart, :fakefs do
+  let(:procfile)  { write_procfile("/tmp/app/Procfile") }
+  let(:formation) { nil }
+  let(:engine)    { Foreman::Engine.new(:formation => formation).load_procfile(procfile) }
+  let(:options)   { Hash.new }
+  let(:upstart)   { Foreman::Export::Upstart.new("/tmp/init", engine, options) }
+
+  before(:each) { load_export_templates_into_fakefs("upstart") }
+  before(:each) { allow(upstart).to receive(:say) }
+
+  it "exports to the filesystem" do
+    upstart.export
+
+    expect(File.read("/tmp/init/app.conf")).to         eq(example_export_file("upstart/app.conf"))
+    expect(File.read("/tmp/init/app-alpha.conf")).to   eq(example_export_file("upstart/app-alpha.conf"))
+    expect(File.read("/tmp/init/app-alpha-1.conf")).to eq(example_export_file("upstart/app-alpha-1.conf"))
+    expect(File.read("/tmp/init/app-bravo.conf")).to   eq(example_export_file("upstart/app-bravo.conf"))
+    expect(File.read("/tmp/init/app-bravo-1.conf")).to eq(example_export_file("upstart/app-bravo-1.conf"))
+  end
+
+  it "cleans up if exporting into an existing dir" do
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-alpha-1.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-bravo-1.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo-bar-1.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar.conf")
+    expect(FileUtils).to receive(:rm).with("/tmp/init/app-foo_bar-1.conf")
+
+    upstart.export
+    upstart.export
+  end
+
+  it "does not delete exported files for similarly named applications" do
+    FileUtils.mkdir_p "/tmp/init"
+
+    ["app2", "app2-alpha", "app2-alpha-1"].each do |name|
+      path = "/tmp/init/#{name}.conf"
+      FileUtils.touch(path)
+      expect(FileUtils).to_not receive(:rm).with(path)
+    end
+
+    upstart.export
+  end
+
+  it 'does not delete exported files for app which share name prefix' do
+    FileUtils.mkdir_p "/tmp/init"
+
+    ["app-worker", "app-worker-worker", "app-worker-worker-1"].each do |name|
+      path = "/tmp/init/#{name}.conf"
+      FileUtils.touch(path)
+      expect(FileUtils).to_not receive(:rm).with(path)
+    end
+
+    upstart.export
+    expect(File.exist?('/tmp/init/app.conf')).to be true
+    expect(File.exist?('/tmp/init/app-worker.conf')).to be true
+  end
+
+  it "quotes and escapes environment variables" do
+    engine.env['KEY'] = 'd"\|d'
+    upstart.export
+    expect("foobarfoo").to include "bar"
+    expect(File.read("/tmp/init/app-alpha-1.conf")).to match(/KEY='d"\\\|d'/)
+  end
+
+  context "with a formation" do
+    let(:formation) { "alpha=2" }
+
+    it "exports to the filesystem with concurrency" do
+      upstart.export
+
+      expect(File.read("/tmp/init/app.conf")).to            eq(example_export_file("upstart/app.conf"))
+      expect(File.read("/tmp/init/app-alpha.conf")).to      eq(example_export_file("upstart/app-alpha.conf"))
+      expect(File.read("/tmp/init/app-alpha-1.conf")).to    eq(example_export_file("upstart/app-alpha-1.conf"))
+      expect(File.read("/tmp/init/app-alpha-2.conf")).to    eq(example_export_file("upstart/app-alpha-2.conf"))
+      expect(File.exist?("/tmp/init/app-bravo-1.conf")).to eq(false)
+    end
+  end
+
+  context "with alternate templates" do
+    let(:template) { "/tmp/alternate" }
+    let(:options)  { { :app => "app", :template => template } }
+
+    before do
+      FileUtils.mkdir_p template
+      File.open("#{template}/master.conf.erb", "w") { |f| f.puts "alternate_template" }
+    end
+
+    it "can export with alternate template files" do
+      upstart.export
+      expect(File.read("/tmp/init/app.conf")).to eq("alternate_template\n")
+    end
+  end
+
+  context "with alternate templates from home dir" do
+
+    before do
+      FileUtils.mkdir_p File.expand_path("~/.foreman/templates/upstart")
+      File.open(File.expand_path("~/.foreman/templates/upstart/master.conf.erb"), "w") do |file|
+        file.puts "default_alternate_template"
+      end
+    end
+
+    it "can export with alternate template files" do
+      upstart.export
+      expect(File.read("/tmp/init/app.conf")).to eq("default_alternate_template\n")
+    end
+  end
+
+end

data/spec/foreman/export_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+require "foreman/export"
+
+describe "Foreman::Export" do
+  subject { Foreman::Export }
+
+  describe "with a formatter that doesn't declare the appropriate class" do
+    it "prints an error" do
+      expect(subject).to receive(:require).with("foreman/export/invalidformatter")
+      mock_export_error("Unknown export format: invalidformatter (no class Foreman::Export::Invalidformatter).") do
+        subject.formatter("invalidformatter") 
+      end
+    end
+  end
+
+  describe "with an invalid formatter" do
+
+    it "prints an error" do
+      mock_export_error("Unknown export format: invalidformatter (unable to load file 'foreman/export/invalidformatter').") do
+        subject.formatter("invalidformatter")
+      end
+    end
+  end
+end

data/spec/foreman/helpers_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "foreman/helpers"
+
+describe "Foreman::Helpers" do
+  before do
+    module Foo
+      class Bar; end
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :Foo)
+  end
+
+  subject { o = Object.new; o.extend(Foreman::Helpers); o }
+
+  it "should classify words" do
+    expect(subject.classify("foo")).to eq("Foo")
+    expect(subject.classify("foo-bar")).to eq("FooBar")
+  end
+
+  it "should constantize words" do
+    expect(subject.constantize("Object")).to eq(Object)
+    expect(subject.constantize("Foo::Bar")).to eq(Foo::Bar)
+  end
+end

data/spec/foreman/process_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'foreman/process'
+require 'timeout'
+require 'tmpdir'
+
+describe Foreman::Process do
+
+  def run(process, options={})
+    rd, wr = IO.method(:pipe).arity.zero? ? IO.pipe : IO.pipe("BINARY")
+    process.run(options.merge(:output => wr))
+    rd.gets
+  end
+
+  describe "#run" do
+
+    it "runs the process" do
+      process = Foreman::Process.new(resource_path("bin/test"))
+      expect(run(process)).to eq("testing\n")
+    end
+
+    it "can set environment" do
+      process = Foreman::Process.new(resource_path("bin/env FOO"), :env => { "FOO" => "bar" })
+      expect(run(process)).to eq("bar\n")
+    end
+
+    it "can set per-run environment" do
+      process = Foreman::Process.new(resource_path("bin/env FOO"))
+      expect(run(process, :env => { "FOO" => "bar "})).to eq("bar\n")
+    end
+
+    it "can handle env vars in the command" do
+      process = Foreman::Process.new(resource_path("bin/echo $FOO"), :env => { "FOO" => "bar" })
+      expect(run(process)).to eq("bar\n")
+    end
+
+    it "can handle per-run env vars in the command" do
+      process = Foreman::Process.new(resource_path("bin/echo $FOO"))
+      expect(run(process, :env => { "FOO" => "bar" })).to eq("bar\n")
+    end
+
+    it "should output utf8 properly" do
+      process = Foreman::Process.new(resource_path("bin/utf8"))
+      expect(run(process)).to eq(Foreman.ruby_18? ? "\xFF\x03\n" : "\xFF\x03\n".force_encoding('binary'))
+    end
+
+    it "can expand env in the command" do
+      process = Foreman::Process.new("command $FOO $BAR", :env => { "FOO" => "bar" })
+      expect(process.expanded_command).to eq("command bar $BAR")
+    end
+
+    it "can expand extra env in the command" do
+      process = Foreman::Process.new("command $FOO $BAR", :env => { "FOO" => "bar" })
+      expect(process.expanded_command("BAR" => "qux")).to eq("command bar qux")
+    end
+
+    it "can execute" do
+      expect(Kernel).to receive(:exec).with("bin/command")
+      process = Foreman::Process.new("bin/command")
+      process.exec
+    end
+
+    it "can execute with env" do
+      expect(Kernel).to receive(:exec).with("bin/command bar")
+      process = Foreman::Process.new("bin/command $FOO")
+      process.exec(:env => { "FOO" => "bar" })
+    end
+
+  end
+
+end

data/spec/foreman/procfile_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'foreman/procfile'
+require 'pathname'
+require 'tmpdir'
+
+describe Foreman::Procfile, :fakefs do
+  subject { Foreman::Procfile.new }
+
+  it "can load from a file" do
+    write_procfile
+    subject.load "Procfile"
+    expect(subject["alpha"]).to eq("./alpha")
+    expect(subject["bravo"]).to eq("./bravo")
+  end
+
+  it "loads a passed-in Procfile" do
+    write_procfile
+    procfile = Foreman::Procfile.new("Procfile")
+    expect(procfile["alpha"]).to   eq("./alpha")
+    expect(procfile["bravo"]).to   eq("./bravo")
+    expect(procfile["foo-bar"]).to eq("./foo-bar")
+    expect(procfile["foo_bar"]).to eq("./foo_bar")
+  end
+
+  it "raises an error if Procfile is empty" do
+    write_file "Procfile" do |procfile|
+      procfile.puts
+    end
+
+    expect { Foreman::Procfile.new("Procfile") }.to raise_error described_class::EmptyFileError
+  end
+
+  it 'only creates Procfile entries for lines matching regex' do
+    write_procfile
+    procfile = Foreman::Procfile.new("Procfile")
+    keys = procfile.instance_variable_get(:@entries).map(&:first)
+    expect(keys).to match_array(%w[alpha bravo foo-bar foo_bar])
+  end
+
+  it "returns nil when attempting to retrieve an non-existing entry" do
+    write_procfile
+    procfile = Foreman::Procfile.new("Procfile")
+    expect(procfile["unicorn"]).to eq(nil)
+  end
+
+  it "can have a process appended to it" do
+    subject["charlie"] = "./charlie"
+    expect(subject["charlie"]).to eq("./charlie")
+  end
+
+  it "can write to a string" do
+    subject["foo"] = "./foo"
+    subject["bar"] = "./bar"
+    expect(subject.to_s).to eq("foo: ./foo\nbar: ./bar")
+  end
+
+  it "can write to a file" do
+    subject["foo"] = "./foo"
+    subject["bar"] = "./bar"
+    Dir.mkdir('/tmp')
+    subject.save "/tmp/proc"
+    expect(File.read("/tmp/proc")).to eq("foo: ./foo\nbar: ./bar\n")
+  end
+
+end

data/spec/foreman_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+require "foreman"
+
+describe Foreman do
+
+  describe "VERSION" do
+    subject { Foreman::VERSION }
+    it { is_expected.to be_a String }
+  end
+
+  describe "runner" do
+    it "should exist" do
+      expect(File.exist?(Foreman.runner)).to eq(true)
+    end
+  end
+end

data/spec/helper_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "spec helpers" do
+  describe "#preserving_env" do
+    after { ENV.delete "FOO" }
+
+    it "should remove added environment vars" do
+      old = ENV["FOO"]
+      preserving_env { ENV["FOO"] = "baz" }
+      expect(ENV["FOO"]).to eq(old)
+    end
+
+    it "should reset modified environment vars" do
+      ENV["FOO"] = "bar"
+      preserving_env { ENV["FOO"] = "baz"}
+      expect(ENV["FOO"]).to eq("bar")
+    end
+  end
+end

data/spec/resources/Procfile

@@ -0,0 +1,5 @@
+echo: bin/echo echoing
+env:  bin/env  FOO
+test: bin/test
+utf8: bin/utf8
+ps:   bin/echo PS env var is $PS

data/spec/resources/Procfile.bad

@@ -0,0 +1,2 @@
+good: sleep 1
+bad: false

data/spec/resources/bin/echo

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo $*

data/spec/resources/bin/env

@@ -0,0 +1,2 @@
+#!/bin/bash
+echo ${!1}

data/spec/resources/bin/test

@@ -0,0 +1,2 @@
+#!/bin/sh
+echo "testing"

data/spec/resources/bin/utf8

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+puts "\xff\x03"

data/spec/resources/export/bluepill/app-concurrency.pill

@@ -0,0 +1,49 @@
+Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepill.log") do |app|
+
+  app.uid = "app"
+  app.gid = "app"
+
+
+
+
+  app.process("alpha-1") do |process|
+    process.start_command = %Q{./alpha}
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT"=>"5000"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
+
+    process.stdout = process.stderr = "/var/log/app/app-alpha-1.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill {{PID}}"
+    end
+    
+    process.group = "app-alpha"
+  end
+
+
+  app.process("alpha-2") do |process|
+    process.start_command = %Q{./alpha}
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT"=>"5001"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
+
+    process.stdout = process.stderr = "/var/log/app/app-alpha-2.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill {{PID}}"
+    end
+    
+    process.group = "app-alpha"
+  end
+
+
+
+
+end

data/spec/resources/export/bluepill/app.pill

@@ -0,0 +1,81 @@
+Bluepill.application("app", :foreground => false, :log_file => "/var/log/bluepill.log") do |app|
+
+  app.uid = "app"
+  app.gid = "app"
+
+
+
+
+  app.process("alpha-1") do |process|
+    process.start_command = %Q{./alpha}
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT"=>"5000"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
+
+    process.stdout = process.stderr = "/var/log/app/app-alpha-1.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill {{PID}}"
+    end
+
+    process.group = "app-alpha"
+  end
+
+  app.process("bravo-1") do |process|
+    process.start_command = %Q{./bravo}
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT"=>"5100"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
+
+    process.stdout = process.stderr = "/var/log/app/app-bravo-1.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill {{PID}}"
+    end
+
+    process.group = "app-bravo"
+  end
+
+  app.process("foo_bar-1") do |process|
+    process.start_command = %Q{./foo_bar}
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT"=>"5200"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
+
+    process.stdout = process.stderr = "/var/log/app/app-foo_bar-1.log"
+
+    process.monitor_children do |children|
+      children.stop_command "kill {{PID}}"
+    end
+
+    process.group = "app-foo_bar"
+  end
+
+  app.process("foo-bar-1") do |process|
+    process.start_command = %Q{./foo-bar}
+
+    process.working_dir = "/tmp/app"
+    process.daemonize = true
+    process.environment = {"PORT"=>"5300"}
+    process.stop_signals = [:quit, 30.seconds, :term, 5.seconds, :kill]
+    process.stop_grace_time = 45.seconds
+
+    process.stdout = process.stderr = "/var/log/app/app-foo-bar-1.log"
+
+    process.monitor_children do |children|
+
+    children.stop_command "kill {{PID}}"
+    end
+
+    process.group = "app-foo-bar"
+  end
+end

data/spec/resources/export/daemon/app-alpha-1.conf

@@ -0,0 +1,7 @@
+start on starting app-alpha
+stop on stopping app-alpha
+respawn
+
+env PORT=5000
+
+exec start-stop-daemon --start --chuid app --chdir /tmp/app --make-pidfile --pidfile /var/run/app/app-alpha-1.pid --exec ./alpha >> /var/log/app/app-alpha-1.log 2>&1

data/spec/resources/export/daemon/app-alpha-2.conf

@@ -0,0 +1,7 @@
+start on starting app-alpha
+stop on stopping app-alpha
+respawn
+
+env PORT=5001
+
+exec start-stop-daemon --start --chuid app --chdir /tmp/app --make-pidfile --pidfile /var/run/app/app-alpha-2.pid --exec ./alpha >> /var/log/app/app-alpha-2.log 2>&1