ors 0.2.10 → 0.3.0

data/lib/ors/helpers.rb

@@ -1,90 +1,131 @@
-module ORS
+class ORS
   module Helpers
 
-    include Config
+    # Helpers for Commands when parsing in ARGV
+    module ParseHelpers
+      def parse_remote_and_or_branch
+        option = ORS.config[:args].shift
 
-    def setup_repo server
-      info "[#{server}] installing codebase..."
+        unless option.nil?
+          if option.match(/^[a-zA-Z0-9_\-]+\/[a-zA-Z0-9_\-]+$/)
+            remote, *branch = option.split("/")
 
-      execute_command server, %(cd #{base_path}),
-                              %(rm -rf #{deploy_directory}),
-                              %(git clone #{repo}:#{name} #{deploy_directory}),
-                              %(mkdir -p #{deploy_directory}/tmp/pids),
-                              %(mkdir -p #{deploy_directory}/log)
+            ORS.config[:remote] = remote
+            ORS.config[:branch] = branch.join('/')
+          else
+            ORS.config[:remote] = option
+          end
+        end
+      end
     end
+    include ParseHelpers
 
-    def setup_ruby server
-      info "[#{server}] installing ruby and gems..."
 
-      execute_command server, prepare_initial_environment,
-                              %(gem install rubygems-update),
-                              %(gem update --system),
-                              %(gem install bundler),
-                              %(bundle install --without development test osx_development > bundler.log)
-    end
+    # Helpers for preparing to run a command on a server
+    module PrepareHelpers
+      def prepare_environment
+        [%({ cd #{ORS.config[:deploy_directory]} > /dev/null; })]
+      end
 
-    def update_code server
-      info "[#{server}] updating codebase..."
+      def prepare_environment_with_rvm
+        [%(source ~/.rvm/scripts/rvm)] + prepare_environment
+      end
 
-      execute_command server, prepare_environment,
-                              %(git fetch),
-                              %(git checkout -q -f origin/#{environment}),
-                              %(git reset --hard),
-                              %(git submodule update --init)
+      def prepare_initial_environment
+        # We do a source and a git checkout here because the master
+        # branch may not always contain the proper rvmrc/Gemfile
+        # we need when setting up the rest of the deploy
+        prepare_environment_with_rvm + [
+                                        %(git checkout -q -f #{ORS.config[:remote]}/#{ORS.config[:branch]}),
+                                        %(git reset --hard),
+                                        %(source .rvmrc)
+                                       ]
+      end
     end
+    include PrepareHelpers
+
+    # Helpers for commands for re-use
+    module CommandHelpers
+      def setup_repo server
+        info "[#{server}] installing codebase..."
+
+        execute_command server, %(cd #{ORS.config[:base_path]}),
+        %(rm -rf #{ORS.config[:deploy_directory]}),
+        %(git clone #{ORS.config[:remote_url]} #{ORS.config[:deploy_directory]}),
+        %(mkdir -p #{ORS.config[:deploy_directory]}/tmp/pids),
+        %(mkdir -p #{ORS.config[:deploy_directory]}/log)
+      end
 
-    def bundle_install server
-      info "[#{server}] installing bundle..."
+      def setup_ruby server
+        info "[#{server}] installing ruby and gems..."
 
-      execute_command server, prepare_environment,
-                              %(bundle install --without development test osx_development > bundler.log)
-    end
+        execute_command server, prepare_initial_environment,
+        %(gem install rubygems-update),
+        %(gem update --system),
+        %(gem install bundler),
+        %(bundle install --without development test osx_development > bundler.log)
+      end
 
-    def start_server server
-      info "[#{server}] starting unicorn..."
+      def update_code server
+        info "[#{server}] updating codebase..."
 
-      execute_command server, prepare_environment,
-                              %(if [ -f config.ru ]; then RAILS_ENV=#{environment} bundle exec unicorn -c config/unicorn.rb -D -E #{environment}; else RAILS_ENV=#{environment} bundle exec unicorn_rails -c config/unicorn.rb -D -E #{environment}; fi)
-    end
+        execute_command server, prepare_environment,
+        %(git fetch #{ORS.config[:remote]}),
+        %(git checkout -q -f #{ORS.config[:remote]}/#{ORS.config[:branch]}),
+        %(git reset --hard),
+        %(git submodule update --init)
+      end
 
-    def stop_server server
-      info "[#{server}] stopping unicorn..."
+      def bundle_install server
+        info "[#{server}] installing bundle..."
 
-      execute_command server, prepare_environment,
-                              %(kill \\`cat tmp/pids/unicorn.pid\\`)
-    end
+        execute_command server, prepare_environment_with_rvm,
+        %(bundle install --without development test osx_development > bundler.log)
+      end
 
-    def restart_server server
-      info "[#{server}] restarting unicorn..."
+      def start_server server
+        info "[#{server}] starting unicorn..."
 
-      execute_command server, prepare_environment,
-                              %(kill -USR2 \\`cat tmp/pids/unicorn.pid\\`)
-    end
+        execute_command server, prepare_environment_with_rvm,
+        %(if [ -f config.ru ]; then RAILS_ENV=#{ORS.config[:environment]} bundle exec unicorn -c config/unicorn.rb -D; else RAILS_ENV=#{ORS.config[:environment]} bundle exec unicorn_rails -c config/unicorn.rb -D; fi)
+      end
 
-    def run_migrations server
-      info "[#{server}] running migrations..."
+      def stop_server server
+        info "[#{server}] stopping unicorn..."
 
-      execute_command server, prepare_environment,
-                              %(RAILS_ENV=#{environment} bundle exec rake db:migrate db:seed)
-    end
+        execute_command server, prepare_environment,
+        %(kill \\`cat tmp/pids/unicorn.pid\\`)
+      end
 
-    def execute_in_parallel servers
-      servers.map do |server|
-        Thread.new(server) do |server|
-          yield server
-        end
-      end.map {|thread| thread.join }
+      def restart_server server
+        info "[#{server}] restarting unicorn..."
+
+        execute_command server, prepare_environment,
+        %(kill -USR2 \\`cat tmp/pids/unicorn.pid\\`)
+      end
+
+      def run_migrations server
+        info "[#{server}] running migrations..."
+
+        execute_command server, prepare_environment_with_rvm,
+        %(RAILS_ENV=#{ORS.config[:environment]} bundle exec rake db:migrate db:seed)
+      end
     end
+    include CommandHelpers
+
+    #
+    # How we actually execute/build commands
+    #
 
     # options = {:exec => ?, :capture => ?, :quiet_ssh => ?}
-    def execute_command server, *command_array
+    def execute_command(server, *command_array)
       options = {:exec => false, :capture => false, :quiet_ssh => false}
       options.merge!(command_array.pop) if command_array.last.is_a?(Hash)
       options[:local] = true if server.to_s == "localhost"
 
       command = build_command(server, command_array, options)
 
-      if pretending
+      if ORS.config[:pretending]
         info("[#{server}] #{command}")
       else
         if options[:exec]
@@ -120,29 +161,20 @@ module ORS
       if options[:local]
         commands
       else
-        if use_gateway
-          %(ssh #{quiet_ssh}#{psuedo_tty}#{gateway} 'ssh #{quiet_ssh}#{psuedo_tty}#{deploy_user}@#{server} "#{commands}"')
+        if ORS.config[:use_gateway]
+          %(ssh #{quiet_ssh}#{psuedo_tty}#{ORS.config[:gateway]} 'ssh #{quiet_ssh}#{psuedo_tty}#{ORS.config[:user]}@#{server} "#{commands}"')
         else
-          %(ssh #{quiet_ssh}#{psuedo_tty}#{deploy_user}@#{server} "#{commands}")
+          %(ssh #{quiet_ssh}#{psuedo_tty}#{ORS.config[:user]}@#{server} "#{commands}")
         end
       end
     end
 
-    def prepare_initial_environment
-      # We do 2 cd's and a git checkout here because the master
-      # branch may not always contain the proper rvmrc/Gemfile
-      # we need when setting up the rest of the deploy
-      prepare_environment + [
-                             %(git checkout -q -f origin/#{environment}),
-                             %(git reset --hard),
-                             %(cd ../),
-                             %(cd #{deploy_directory})
-                            ]
-    end
-
-    def prepare_environment
-      [%(source ~/.rvm/scripts/rvm),
-       %({ cd #{deploy_directory} > /dev/null; })] # Silence RVM's "Using... gemset..."
+    def execute_in_parallel servers
+      servers.map do |server|
+        Thread.new(server) do |server|
+          yield server
+        end
+      end.map {|thread| thread.join }
     end
 
     def info message
@@ -153,6 +185,5 @@ module ORS
       info message
       exit 1
     end
-
   end
 end

data/lib/ors/log_unifier.rb

@@ -1,4 +1,4 @@
-module ORS
+class ORS
 
   class LogUnifier
 
@@ -20,7 +20,7 @@ module ORS
         sort_by {|entry| entry[:timestamp] }.
         map do |entry|
           entry[:lines].
-          map {|line| ["[#{entry[:server]}]".ljust(pretty_adjust + 3), line].join }.
+          map {|line| ["[#{entry[:server]}]".ljust(pretty_adjust + 3), line].join.strip }.
           join "\n"
         end.
         flatten.

data/lib/ors/version.rb

@@ -1,3 +1,3 @@
-module ORS
-  VERSION = "0.2.10"
+class ORS
+  VERSION = "0.3.0"
 end

data/spec/ors/{command_spec.rb → base_spec.rb}

@@ -1,31 +1,34 @@
 require "spec_helper"
 
-describe ORS::Command do
+describe ORS do
 
-  subject { ORS::Command }
+  subject { ORS.new }
 
   context ".run" do
+    before do
+      @command = ORS::Commands::Help.new
+      mock(ORS::Commands::Help).new { @command }
+      mock(@command).setup { "setup" }
+      mock(@command).execute { "execute" }
+    end
 
     it "should execute help when the command is help" do
-      mock(ORS::Commands::Help).new { mock!.execute.subject }
       subject.run ["help"]
     end
 
     it "should execute help when no command is given" do
-      mock(ORS::Commands::Help).new { mock!.execute.subject }
       subject.run []
     end
 
     it "should execute help when an unknown command is given" do
-      mock(ORS::Commands::Help).new { mock!.execute.subject }
       subject.run ["as0d9fja0s9djf"]
     end
+  end
 
+  context ".run with version" do
     it "should show the version when given version as a command" do
-      mock(ORS::Command).puts("ORS v#{ORS::VERSION}")
+      mock($stdout).puts("ORS v#{ORS::VERSION}")
       subject.run ["version"]
     end
-
   end
-
 end

data/spec/ors/commands/base_spec.rb

@@ -2,20 +2,28 @@ require "spec_helper"
 
 describe ORS::Commands::Base do
 
+  before do
+    @command = ORS::Commands::Base.new
+    mock(ORS::Commands::Base).new { @command }
+  end
+
   context ".run" do
+    it "should instantiate the command and call #setup and #execute on it" do
+      mock(ORS.config).finalize! {true}
+      mock(ORS.config).valid? {true}
+      mock(@command).setup.subject
+      mock(@command).execute.subject
 
-    it "should instantiate the command and call #execute on it" do
-      klass = mock!.new { mock!.execute.subject }.subject
-      ORS::Commands::Base.run klass
+      ORS::Commands::Base.run
     end
-
   end
 
-  context "#run" do
-    it "should call the class method" do
-      mock(ORS::Commands::Base).run("Foo")
-      subject.run "Foo"
+  context ".run_without_setup" do
+    it "should not run #setup but run #execute" do
+      dont_allow(@command).setup.subject
+      mock(@command).execute.subject
+
+      ORS::Commands::Base.run_without_setup
     end
   end
-
 end

data/spec/ors/commands/deploy_spec.rb

@@ -7,9 +7,10 @@ describe ORS::Commands::Deploy do
     it "should call update, migrate, then restart" do
       mock(subject).info /deploying/
 
-      mock(subject).run(ORS::Commands::Update)
-      mock(subject).run(ORS::Commands::Migrate)
-      mock(subject).run(ORS::Commands::Restart)
+      mock(ORS::Commands::Update).run_without_setup
+      mock(ORS::Commands::Symlink).run_without_setup
+      mock(ORS::Commands::Migrate).run_without_setup
+      mock(ORS::Commands::Restart).run_without_setup
 
       subject.execute
     end

data/spec/ors/commands/runner_spec.rb

@@ -4,39 +4,20 @@ describe ORS::Commands::Runner do
 
   context "#run" do
     before do
-      stub(subject).name {'abc/growhealthy'}
-      stub(subject).environment {'production'}
+      ORS.config[:name] = 'abc/growhealthy'
+      ORS.config[:environment] = 'production'
     end
 
-    it "should require --code 'ruby code'" do
-      lambda {subject.execute}.should raise_error
+    it "should require 'ruby code'" do
+      lambda {subject.setup; subject.execute}.should raise_error
     end
 
-    it "should require an argument to --code" do
-      ORS::Config.parse_options %w(--code)
-      lambda {subject.execute}.should raise_error
-    end
-
-    it "should require an argument to -c" do
-      ORS::Config.parse_options %w(--c)
-      lambda {subject.execute}.should raise_error
-    end
-
-    it "should require a non-empty argument to --code" do
-      ORS::Config.parse_options ['--code', ' ']
-      lambda {subject.execute}.should raise_error
-    end
-
-    it "should be successful with an argument to --code" do
-      ORS::Config.parse_options %w(--code true)
+    it "should be successful with some 'ruby code'" do
+      ORS.config.parse_options ["ruby code"]
       mock(subject).execute_command(is_a(String), is_a(Array), is_a(String), is_a(Hash)).returns("results")
-      lambda {subject.execute}.should_not raise_error
-    end
 
-    it "should be successful with an argument to -c" do
-      ORS::Config.parse_options %w(-c true)
-      mock(subject).execute_command(is_a(String), is_a(Array), is_a(String), is_a(Hash)).returns("results")
-      lambda {subject.execute}.should_not raise_error
+
+      lambda {subject.setup; subject.execute}.should_not raise_error
     end
   end
 end

data/spec/ors/commands/timestamps_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe ORS::Commands::Timestamps do
+
+  context "#execute" do
+    it "should get restart.timestamp from all of the app servers" do
+      ORS.config[:pretending] = false
+      ORS.config[:app_servers] = mock!.map { ["server", "timestamp"] }.subject
+
+      mock($stdout).puts("server\ntimestamp")
+
+      subject.execute
+    end
+  end
+
+end

data/spec/ors/commands/update_spec.rb

@@ -3,10 +3,15 @@ require "spec_helper"
 describe ORS::Commands::Update do
 
   context "#run" do
+    before do
+      ORS.config.parse_options([])
+      ORS.config.parse_config_file
+    end
+
     it "should update code, bundle install, and set up cron" do
-      stub(subject).all_servers { :all_servers }
-      stub(subject).ruby_servers { :ruby_servers }
-      stub(subject).cron_server { :cron_server }
+      ORS.config[:all_servers] = :all_servers
+      ORS.config[:ruby_servers] = :ruby_servers
+      ORS.config[:cron_server] = :cron_server
 
       mock(subject).info /updating/
       mock(subject).execute_in_parallel(:all_servers)

data/spec/ors/config_spec.rb

@@ -2,98 +2,66 @@ require "spec_helper"
 
 describe ORS::Config do
 
-  subject { class Foo; include ORS::Config; end; Foo.new }
+  subject { ORS::Config.new([]) }
 
   context ".parse_options" do
-    it("should default pretend to false") { subject.pretending.should be_false }
-    it("should default use_gateway to true") { subject.use_gateway.should be_true }
-    it("should default rails2 to false") { subject.rails2.should be_false }
+    it("should default pretend to false") { subject[:pretending].should be_false }
+    it("should default use_gateway to true") { subject[:use_gateway].should be_true }
 
     it "should set the environment when it is given" do
-      ORS::Config.parse_options %w(foobar -p)
-      subject.environment.should == "foobar"
+      subject.parse_options %w(to foobar -p)
+      subject[:environment].should == "foobar"
     end
 
     it "should set pretend to true if -p is given" do
-      ORS::Config.pretending = false
-      ORS::Config.parse_options %w(-p)
+      subject[:pretending] = false
+      subject.parse_options %w(-p)
 
-      subject.pretending.should be_true
+      subject[:pretending].should be_true
     end
 
     it "should set pretend to true if --pretend is given" do
-      ORS::Config.pretending = false
-      ORS::Config.parse_options %w(--pretend)
+      subject[:pretending] = false
+      subject.parse_options %w(--pretend)
 
-      subject.pretending.should be_true
+      subject[:pretending].should be_true
     end
 
     it "should set use_gateway to false if -ng is given" do
-      ORS::Config.use_gateway = true
-      ORS::Config.parse_options %w(-ng)
+      subject[:use_gateway] = true
+      subject.parse_options %w(-ng)
 
-      subject.use_gateway.should be_false
+      subject[:use_gateway].should be_false
     end
 
     it "should set use_gateway to false if --no-gateway is given" do
-      ORS::Config.use_gateway = true
-      ORS::Config.parse_options %w(--no-gateway)
+      subject[:use_gateway] = true
+      subject.parse_options %w(--no-gateway)
 
-      subject.use_gateway.should be_false
+      subject[:use_gateway].should be_false
     end
   end
 
-  context ".valid_options?" do
+  context ".valid?" do
 
-    it "should be true when there is a name and valid environment" do
-      subject.name = "foo"
-      subject.environment = "production"
+    it "should be true when there is a name" do
+      mock(subject).name { "foo" }
 
-      ORS::Config.valid_options?.should be_true
+      subject.valid?.should be_true
     end
 
-    it "should be false when there is a name but an invalid environment" do
-      subject.name = "foo"
-      subject.environment = "-p"
+    it "should be false when there is a blank name" do
+      mock(subject).name { "" }
 
-      ORS::Config.valid_options?.should be_false
-    end
-
-    it "should be false when there is a valid environment but a blank name" do
-      subject.name = ""
-      subject.environment = "production"
-
-      ORS::Config.valid_options?.should be_false
+      subject.valid?.should be_false
     end
 
   end
 
   context "#all_servers" do
     it "should return all servers" do
-      subject.all_servers.should == (subject.web_servers + subject.app_servers + [subject.migration_server])
-    end
-  end
-
-  context "config permanence" do
-    before do
-      class ORS::OtherConfig; include ORS::Config; end
-      @other_config = ORS::OtherConfig.new
-
-      class ORS::ConfigTest; include ORS::Config; end
-      @some_config = ORS::ConfigTest.new
-    end
-
-    %w(use_gateway pretending).each do |accessor|
-      it "should allow you to set #{accessor}" do
-        ORS::Config.should respond_to("#{accessor}")
-      end
-
-      it "should know if its #{accessor} across classes" do
-        ORS::Config.send("#{accessor}=", true)
-
-        @some_config.send(accessor).should == true
-        @other_config.send(accessor).should == true
-      end
+      subject.finalize!
+      subject[:all_servers].should == (subject[:web_servers] + subject[:app_servers] + [subject[:migration_server]])
     end
   end
 
@@ -105,13 +73,40 @@ describe ORS::Config do
      "git@github.com:testing/github" => "testing/github",
      "git@ghub.com:testing/gitlabhq.git" => "testing/gitlabhq",
      "git@ghub.com:gitlabhq.git" => "gitlabhq",
-     "git://ghub.com/gitlabhq.git" => "gitlabhq"
+     "git://ghub.com/gitlabhq.git" => "gitlabhq",
+     "git://ghub.com/level_git.git" => "level_git",
+     "git://ghub.com/level-up/two.git" => "level-up/two"
     }.each do |remote, name|
       it "should handle a remote origin url such as #{remote}" do
-        mock(ORS::Config).git { mock!.config { {"remote.origin.url" => remote} }}
-        ORS::Config.send(:name_from_git).should == name
+        stub(subject).git { mock!.config { {"remote.origin.url" => remote} }}
+        subject.send(:name).should == name
       end
     end
   end
 
+  context "#remote_from_git" do
+    before do
+      subject[:remote] = "origin"
+    end
+
+    it "should raise an error if the remote doesn't exist" do
+      stub(subject).git { mock!.config { {"remote.oregon.url" => "git://github.com/testing/git.git"} }}
+
+      lambda { subject.send(:remote_url) }.should raise_error
+    end
+
+    it "should return the remote based on the remote alias (origin)" do
+      stub(subject).git { mock!.config { {"remote.origin.url" => "git://github.com/testing/git.git"} }}
+
+      subject.send(:remote_url).should == "git://github.com/testing/git.git"
+    end
+
+    it "should return the remote based on the remote alias (arbit)" do
+      subject[:remote] = "arbit"
+      stub(subject).git { mock!.config { {"remote.arbit.url" => "git://github.com/arbit/git.git"} }}
+
+      subject.send(:remote_url).should == "git://github.com/arbit/git.git"
+    end
+  end
+
 end