Extract commonality into the base class, make life easy for our plugi…

…n writers.

lib/foreman/cli.rb

@@ -49,7 +49,7 @@ def export(format, location=nil)
     classy_format = classify(format)
     formatter     = constantize("Foreman::Export::#{ classy_format }")
 
-    formatter.new(engine).export(location, options)
+    formatter.new(engine, options).export(location)
 
   rescue NameError => ex
     error "Unknown export format: #{format}."

lib/foreman/export/base.rb

@@ -3,10 +3,16 @@
 
 class Foreman::Export::Base
 
-  attr_reader :engine
-
-  def initialize(engine)
-    @engine = engine
+  attr_reader :engine, :app, :log, :port, :user, :template, :concurrency
+
+  def initialize(engine, options={})
+    @engine      = engine
+    @app         = options[:app]
+    @log         = options[:log]
+    @port        = options[:port]
+    @user        = options[:user]
+    @template    = options[:template]
+    @concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
   end
 
   def export

lib/foreman/export/bluepill.rb

@@ -8,18 +8,16 @@ def export(location, options={})
 
     FileUtils.mkdir_p location
 
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-    template_root = options[:template]
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     Dir["#{location}/#{app}.pill"].each do |file|
       say "cleaning up: #{file}"
       FileUtils.rm(file)
     end
 
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-
     master_template = export_template("bluepill", "master.pill.erb", template_root)
     master_config   = ERB.new(master_template).result(binding)
     write_file "#{location}/#{app}.pill", master_config

lib/foreman/export/inittab.rb

@@ -3,19 +3,17 @@
 class Foreman::Export::Inittab < Foreman::Export::Base
 
   def export(fname=nil, options={})
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
 
     inittab = []
     inittab << "# ----- foreman #{app} processes -----"
 
     engine.procfile.entries.inject(1) do |index, process|
-      1.upto(concurrency[process.name]) do |num|
+      1.upto(self.concurrency[process.name]) do |num|
         id = app.slice(0, 2).upcase + sprintf("%02d", index)
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         inittab << "#{id}:4:respawn:/bin/su - #{user} -c 'PORT=#{port} #{process.command} >> #{log_root}/#{process.name}-#{num}.log 2>&1'"
         index += 1
       end

lib/foreman/export/runit.rb

@@ -7,18 +7,16 @@ class Foreman::Export::Runit < Foreman::Export::Base
   def export(location, options={})
     error("Must specify a location") unless location
 
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-    template_root = options[:template]
-
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     run_template = export_template('runit', 'run.erb', template_root)
     log_run_template = export_template('runit', 'log_run.erb', template_root)
 
     engine.procfile.entries.each do |process|
-      1.upto(concurrency[process.name]) do |num|
+      1.upto(self.concurrency[process.name]) do |num|
         process_directory     = "#{location}/#{app}-#{process.name}-#{num}"
         process_env_directory = "#{process_directory}/env"
         process_log_directory = "#{process_directory}/log"
@@ -31,7 +29,7 @@ def export(location, options={})
         write_file "#{process_directory}/run", run
         FileUtils.chmod 0755, "#{process_directory}/run"
 
-        port = engine.port_for(process, num, options[:port])
+        port = engine.port_for(process, num, self.port)
         environment_variables = {'PORT' => port}.
             merge(engine.environment).
             merge(inline_variables(process.command))

lib/foreman/export/upstart.rb

@@ -8,32 +8,30 @@ def export(location, options={})
 
     FileUtils.mkdir_p location
 
-    app = options[:app] || File.basename(engine.directory)
-    user = options[:user] || app
-    log_root = options[:log] || "/var/log/#{app}"
-    template_root = options[:template]
+    app = self.app || File.basename(engine.directory)
+    user = self.user || app
+    log_root = self.log || "/var/log/#{app}"
+    template_root = self.template
 
     Dir["#{location}/#{app}*.conf"].each do |file|
       say "cleaning up: #{file}"
       FileUtils.rm(file)
     end
 
-    concurrency = Foreman::Utils.parse_concurrency(options[:concurrency])
-
     master_template = export_template("upstart", "master.conf.erb", template_root)
     master_config   = ERB.new(master_template).result(binding)
     write_file "#{location}/#{app}.conf", master_config
 
     process_template = export_template("upstart", "process.conf.erb", template_root)
 
     engine.procfile.entries.each do |process|
-      next if (conc = concurrency[process.name]) < 1
+      next if (conc = self.concurrency[process.name]) < 1
       process_master_template = export_template("upstart", "process_master.conf.erb", template_root)
       process_master_config   = ERB.new(process_master_template).result(binding)
       write_file "#{location}/#{app}-#{process.name}.conf", process_master_config
 
-      1.upto(concurrency[process.name]) do |num|
-        port = engine.port_for(process, num, options[:port])
+      1.upto(self.concurrency[process.name]) do |num|
+        port = engine.port_for(process, num, self.port)
         process_config = ERB.new(process_template).result(binding)
         write_file "#{location}/#{app}-#{process.name}-#{num}.conf", process_config
       end

spec/foreman/cli_spec.rb

@@ -30,7 +30,9 @@
       it "respects --env" do
         write_procfile
         write_env("envfile")
-        mock.instance_of(Foreman::Export::Upstart).export("/upstart", { "env" => "envfile" })
+        mock_export = mock(Foreman::Export::Upstart)
+        mock(Foreman::Export::Upstart).new(is_a(Foreman::Engine), { "env" => "envfile" }) { mock_export }
+        mock_export.export("/upstart")
         foreman %{ export upstart /upstart --env envfile }
       end
     end
@@ -60,7 +62,9 @@
 
         it "runs successfully" do
           dont_allow(subject).error
-          mock.instance_of(Foreman::Export::Upstart).export("/tmp/foo", {})
+          mock_export = mock(Foreman::Export::Upstart)
+          mock(Foreman::Export::Upstart).new(is_a(Foreman::Engine), {}) { mock_export }
+          mock_export.export("/tmp/foo")
           subject.export("upstart", "/tmp/foo")
         end
       end

spec/foreman/export/bluepill_spec.rb

@@ -6,7 +6,7 @@
 describe Foreman::Export::Bluepill, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
   let(:engine) { Foreman::Engine.new(procfile) }
-  let(:bluepill) { Foreman::Export::Bluepill.new(engine) }
+  let(:bluepill) { Foreman::Export::Bluepill.new(engine, :concurrency => "alpha=2") }
 
   before(:each) { load_export_templates_into_fakefs("bluepill") }
   before(:each) { stub(bluepill).say }

spec/foreman/export/runit_spec.rb

@@ -6,15 +6,16 @@
 describe Foreman::Export::Runit, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile", 'bar=baz') }
   let(:engine) { Foreman::Engine.new(procfile) }
-  let(:runit) { Foreman::Export::Runit.new(engine) }
+  let(:runit) { Foreman::Export::Runit.new(engine, :concurrency => 'alpha=2') }
 
   before(:each) { load_export_templates_into_fakefs("runit") }
   before(:each) { stub(runit).say }
   before(:each) { stub(FakeFS::FileUtils).chmod }
 
   it "exports to the filesystem" do
     FileUtils.mkdir_p('/tmp/init')
-    runit.export('/tmp/init', :concurrency => "alpha=2,bravo=1")
+
+    runit.export('/tmp/init')
 
     File.read("/tmp/init/app-alpha-1/run").should == example_export_file('runit/app-alpha-1-run')
     File.read("/tmp/init/app-alpha-1/log/run").should ==

spec/foreman/export/upstart_spec.rb

@@ -6,7 +6,7 @@
 describe Foreman::Export::Upstart, :fakefs do
   let(:procfile) { FileUtils.mkdir_p("/tmp/app"); write_procfile("/tmp/app/Procfile") }
   let(:engine) { Foreman::Engine.new(procfile) }
-  let(:upstart) { Foreman::Export::Upstart.new(engine) }
+  let(:upstart) { Foreman::Export::Upstart.new(engine, :concurrency => "alpha=2") }
 
   before(:each) { load_export_templates_into_fakefs("upstart") }
   before(:each) { stub(upstart).say }
@@ -33,14 +33,15 @@
 
   context "with alternate templates" do
     let(:template_root) { "/tmp/alternate" }
+    let(:upstart) { Foreman::Export::Upstart.new(engine, :template => template_root) }
 
     before do
       FileUtils.mkdir_p template_root
       File.open("#{template_root}/master.conf.erb", "w") { |f| f.puts "alternate_template" }
     end
 
     it "can export with alternate template files" do
-      upstart.export("/tmp/init", :template => template_root)
+      upstart.export("/tmp/init")
 
       File.read("/tmp/init/app.conf").should == "alternate_template\n"
     end