screwcap 0.3.5 → 0.5

data/lib/screwcap/{deployer.rb → task_manager.rb}

@@ -1,12 +1,11 @@
-# The deployer is the class that holds the overall params from the screwcap tasks file, and it is also in charge of running the requested task.
+# The task manager is the class that holds the overall params from the screwcap tasks file, and it is also in charge of running the requested task.
 #
-# The deployer can be thought of as the "global scope" of your tasks file.
-class Deployer < Screwcap::Base
+# The task manager can be thought of as the "global scope" of your tasks file.
+class TaskManager < Screwcap::Base
   include MessageLogger
 
-  # create a new deployer.
+  # create a new task manager.
   def initialize(opts = {})
-    opts = {:recipe_file => File.expand_path("./config/recipe.rb")}.merge opts
     super
     self.__options = opts
     self.__tasks = []
@@ -14,15 +13,7 @@ class Deployer < Screwcap::Base
     self.__command_sets = []
     self.__sequences = []
 
-    # ensure that deployer options will not be passed to tasks
-    opts.each_key {|k| self.delete_field(k) }
-
-    Deployer.log "Reading #{self.__options[:recipe_file]}\n" unless self.__options[:silent] == true
-
-    file = File.open(self.__options[:recipe_file])
-    data = file.read
-
-    instance_eval(data)
+    instance_eval(File.read(self.__options[:recipe_file])) if self.__options[:recipe_file]
   end
 
 
@@ -89,9 +80,9 @@ class Deployer < Screwcap::Base
   # ====Any command sets that are nested within another command set will inerit all the variables from the parent command set.
   #
   def task name, options = {}, &block
-    t = Task.new(options.merge(:name => name, :nocolor => self.__options[:nocolor], :silent => self.__options[:silent], :deployment_servers => self.__servers, :command_sets => self.__command_sets), &block)
-    clone_table_for(t)
-    t.instance_eval(&block)
+    t = Task.new(options.merge(:name => name), &block)
+    t.clone_from(self)
+    t.validate(self.__servers) unless options[:local] == true
     self.__tasks << t
   end
   alias :task_for :task
@@ -123,10 +114,9 @@ class Deployer < Screwcap::Base
   #       redundant_task
   #     end
 
-
   def command_set(name,options = {},&block)
-    t = Task.new(options.merge(:name => name, :validate => false, :command_set => true, :command_sets => self.__command_sets), &block)
-    clone_table_for(t)
+    t = Task.new(options.merge(:name => name), &block)
+    t.clone_from(self)
     self.__command_sets << t
   end
 
@@ -142,7 +132,7 @@ class Deployer < Screwcap::Base
   #   * *:keys* can be used to specify the key to use to connect to the server
   #   * *:password* specify the password to connect with.  Not recommended.  Use keys.
   def server(name, options = {}, &block)
-    server = Server.new(options.merge(:name => name, :servers => self.__servers, :silent => self.__options[:silent]))
+    server = Server.new(options.merge(:name => name))
     self.__servers << server
   end
 
@@ -153,7 +143,7 @@ class Deployer < Screwcap::Base
   # * Gateways have the same option as a *:server*.
   # * You can specify :gateway => :mygateway in the *:server* definition.
   def gateway(name, options = {}, &block)
-    server = Server.new(options.merge(:name => name, :is_gateway => true))
+    server = Server.new(options.merge(:name => name, :is_gateway => true, :servers => self.__servers))
     self.__servers << server
   end
 
@@ -182,24 +172,52 @@ class Deployer < Screwcap::Base
 
   # ====Run one or more tasks or sequences.
   # * :tasks - the list of tasks to run, as an array of symbols.
-  def run!(*tasks)
-    tasks.flatten!
-    # sanity check each task
+  def run!(*tasks_to_run)
+    tasks_to_run.flatten!
 
-    tasks_and_sequences = (self.__sequences.map(&:__name) + self.__tasks.map(&:__name))
-    tasks.each do |task_to_run|
-      raise(Screwcap::TaskNotFound, "Could not find task or sequence '#{task_to_run}' in recipe file #{self.__options[:recipe_file]}") unless tasks_and_sequences.include? task_to_run
+    tasks_to_run.map! do |ttr| 
+      unless ret = self.__tasks.find {|t| t.__name == ttr } 
+        seq = self.__sequences.find {|t| t.__name == ttr }
+        ret = seq.__task_names.map {|tn| self.__tasks.find {|t| t.__name == tn }}.compact if seq
+      end
+      ret
     end
-
-    tasks.each do |t| 
-      sequence = self.__sequences.find {|s| s.__name == t }
-      if sequence
-        sequence.__task_names.each {|task_name| Runner.execute! self.__tasks.find {|task| task.__name == task_name }, self.__options}
+    tasks_to_run.flatten!
+    tasks_to_run.compact!
+
+    ret = []
+    tasks_to_run.each do |task|
+      commands =  task.__build_commands(self.__command_sets)
+      if task.__options[:local] == true
+        Runner.execute_locally! :commands => commands, :silent => self.__options[:silent]
       else
-        Runner.execute! self.__tasks.select {|task| task.name.to_s == t.to_s }.first, self.__options
+        threads = []
+        self.__servers.select {|s| task.__servers.include? s.__name }.each do |server|
+          server.__addresses.each do |address|
+            if task.__options[:parallel] == false
+              Runner.execute!(:name => task.__name, 
+                              :commands => commands, 
+                              :address => address, 
+                              :server => server, 
+                              :silent => self.__options[:silent])
+            else
+              threads << Thread.new(server,address) do |server, address| 
+                Runner.execute!(:name => task.__name, 
+                                :commands => commands, 
+                                :address => address, 
+                                :server => server,
+                                :silent => self.__options[:silent]) 
+              end
+            end
+          end
+        end
+        threads.each {|t| t.join }
       end
+      ret << commands
     end
+
     $stdout << "\033[0m"
+    ret.flatten
   end
 
   # ====Use will dynamically include another file into an existing configuration file.
@@ -211,26 +229,17 @@ class Deployer < Screwcap::Base
   def use arg
     if arg.is_a? Symbol
       begin
-        dirname = File.dirname(self.__options[:recipe_file])
-        instance_eval(File.open(File.dirname(File.expand_path(self.__options[:recipe_file])) + "/" + arg.to_s + ".rb").read)
+        dirname = File.expand_path(File.dirname(self.__options[:recipe_file]))
+        instance_eval File.read("#{dirname}/#{arg.to_s}.rb")
       rescue Errno::ENOENT => e
         raise Screwcap::IncludeFileNotFound, "Could not find #{File.expand_path("./"+arg.to_s + ".rb")}! If the file is elsewhere, call it by using 'use '/path/to/file.rb'"
       end
     else
       begin
-        instance_eval(File.open(File.dirname(File.expand_path(self.__options[:recipe_file])) + "/" + arg).read)
+        instance_eval(File.read(arg))
       rescue Errno::ENOENT => e
         raise Screwcap::IncludeFileNotFound, "Could not find #{File.expand_path(arg)}! If the file is elsewhere, call it by using 'use '/path/to/file.rb'"
       end
     end
   end
-
-
-  private
-
-  def clone_table_for(object)
-    self.table.each do |k,v|
-      object.set(k, v) unless [:__options, :__tasks, :__servers, :__command_sets].include?(k)
-    end
-  end
 end

data/recipes/setup_rails.rb

@@ -8,7 +8,7 @@ task :setup_rails, :local => true do
     then
       echo "config/screwcap/rails_tasks.rb already exists!"; exit 1
     else
-      curl -s http://github.com/gammons/screwcap_recipes/raw/master/rails/rails_tasks.rb > config/screwcap/rails_tasks.rb
+      curl -s https://github.com/gammons/screwcap_recipes/raw/master/rails/rails_tasks.rb > config/screwcap/rails_tasks.rb
     fi
   EOF
 
@@ -17,7 +17,7 @@ task :setup_rails, :local => true do
     then
       echo "lib/tasks/screwcap.rake already exists!"; exit 1
     else
-      curl -s http://github.com/gammons/screwcap_recipes/raw/master/rails/screwcap.rake > lib/tasks/screwcap.rake
+      curl -s https://github.com/gammons/screwcap_recipes/raw/master/rails/screwcap.rake > lib/tasks/screwcap.rake
     fi
   EOF
    
@@ -26,7 +26,7 @@ task :setup_rails, :local => true do
     then
       echo "config/screwcap/recipe.rb already exists!"; exit 1
     else
-      curl -s http://github.com/gammons/screwcap_recipes/raw/master/rails/recipe.rb > config/screwcap/recipe.rb
+      curl -s https://github.com/gammons/screwcap_recipes/raw/master/rails/recipe.rb > config/screwcap/recipe.rb
     fi
   EOF
 end

data/runrdoc

@@ -0,0 +1 @@
+rdoc -x trollop -x spec -x runner -x object -x message -x tasknotfound -x runrdoc

data/screwcap.gemspec

@@ -6,7 +6,7 @@ require 'bundler/version'
  
 Gem::Specification.new do |s|
   s.name        = "screwcap"
-  s.version     = "0.3.5"
+  s.version     = "0.5"
   s.platform    = Gem::Platform::RUBY
   s.author     = "Grant Ammons"
   s.email       = ["grant@pipelinedealsco.com"]

data/spec/runner_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe "The Runner" do
+  before(:all) do
+    Net::SSH.stubs(:start).yields(SSHObject.new(:return_stream => :stdout, :return_data => "ok\n"))
+    @server = Server.new :name => :server,  :address => "fake.com", :user => "fake"
+    @task = Task.new :name => :test, :server => :server do
+      run "one"
+      run "two"
+    end
+  end
+
+  it "should be able to execute commands on an address of a server" do
+    Runner.stubs(:ssh_exec!).returns(["ok\n","",0,nil])
+
+    commands = Runner.execute! :name => "test", 
+      :server => @server, 
+      :address => "fake.com", 
+      :commands => @task.__build_commands, 
+      :silent => true
+
+    commands[0][:stderr].should == ""
+    commands[0][:stdout].should == "ok\n"
+
+    commands[1][:stderr].should == ""
+    commands[1][:stdout].should == "ok\n"
+  end
+
+  it "should be able to handle error commands" do
+    Runner.stubs(:ssh_exec!).returns(["ok\n","",0,nil]).then.returns(["","no\n",1,nil])
+    commands = Runner.execute! :name => "test", 
+      :server => @server, 
+      :address => "fake.com", 
+      :commands => @task.__build_commands, 
+      :silent => true
+
+    commands[0][:stderr].should == ""
+    commands[0][:stdout].should == "ok\n"
+
+    commands[1][:stderr].should == "no\n"
+    commands[1][:stdout].should == ""
+  end
+
+  it "should be able to execute local commands" do
+    task = Task.new :name => :localtest, :local => true do
+      run "echo 'bongle'"
+    end
+    commands = Runner.execute_locally! :name => :localtest, :commands => task.__build_commands, :silent => true
+    commands[0][:stdout].should == "bongle\n"
+  end
+end

data/spec/sequence_spec.rb

@@ -1,22 +1,8 @@
 require 'spec_helper'
 
 describe "Sequences" do
-  before(:all) do
-    Net::SSH.stubs(:start).yields(SSHObject.new(:return_stream => :stdout, :return_data => "hostname = asdf\n"))
-    Runner.stubs(:ssh_exec!).returns(["ok","",0,nil])
-  end
-  before(:each) do
-    @stdout = []
-    Deployer.any_instance.stubs(:log).with() { |msg| @stdout << msg}
-    @deployer = Deployer.new(:recipe_file => "./test/config/simple_recipe.rb", :silent => true)
-  end
-
   it "should contain a list of tasks to be called" do
-    sequence = @deployer.__sequences.find {|s| s.__name == :deploy}
-    sequence.__task_names.should == [:seq1, :seq2]
-  end
-
-  it "should be callable via Deployer.run!" do
-    lambda { @deployer.run! :deploy }.should_not raise_error
+    @seq = Sequence.new :tasks => [:task1, :task2]
+    @seq.__task_names.should == [:task1, :task2]
   end
 end

data/spec/server_spec.rb

@@ -29,13 +29,4 @@ describe "Servers" do
     server = Server.new(:name => :test, :user => :root, :address => "abc.com")
     server.should respond_to(:__with_connection_for)
   end
-
-  it "should provide a connection to the server with a gateway" do
-    @deployer = Deployer.new(:recipe_file => "./test/config/gateway.rb", :silent => true)
-    server = @deployer.__servers.find {|s| s.__name == :test}
-    gateway = @deployer.__servers.find {|s| s.__name == :gateway1}
-
-    output = []
-    lambda { server.__with_connection {} }.should_not raise_error 
-  end
 end

data/spec/task_manager_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe "Task Managers" do
+  before(:all) do
+    Net::SSH.stubs(:start).yields(SSHObject.new(:return_stream => :stdout, :return_data => "ok\n"))
+    Runner.stubs(:ssh_exec!).returns(["ok\n","",0,nil])
+  end
+
+  before(:each) do
+    @tm = TaskManager.new :silent => true
+  end
+
+  it "can have tasks and servers" do
+    @tm.server :server, :address => "test", :user => "root"
+    @tm.task :deploy, :server => :server do
+      run "test"
+    end
+
+    @tm.should have(1).__servers
+    @tm.should have(1).__tasks
+  end
+
+  it "should validate tasks" do
+    @tm = TaskManager.new
+    @tm.server :server, :address => "test", :user => "root"
+    lambda { @tm.task(:deploy, :server => :not_here) { run "test" } }.should raise_error(Screwcap::ConfigurationError)
+  end
+
+  it "should be able to define variables" do
+    @tm.moon_pie= "moon pie"
+    @tm.moon_pie.should == "moon pie"
+  end
+
+  it "should pass variables to tasks" do
+    @tm.pie_type = "moon pie"
+    @tm.server :server, :address => "test", :user => "root"
+    @tm.task :deploy, :server => :server do
+      run "#{pie_type} in the face!"
+    end
+
+    @tm.__tasks[0].__build_commands[0][:command].should == "moon pie in the face!"
+  end
+
+  it "should be able to define command sets" do
+    @tm.command_set :my_command_set do
+      run "test"
+    end
+    
+    @tm.should have(1).__command_sets
+  end
+
+  it "should be able to load a recipe file" do
+    @tm = TaskManager.new(:recipe_file => "test/config/super_simple_recipe.rb")
+    @tm.pie.should == "moon pie"
+    @tm.should have(1).__command_sets
+    @tm.should have(1).__tasks
+  end
+
+  it "should be able to execute a recipe" do
+    @tm.pie_type = "moon pie"
+    @tm.server :server, :address => "test", :user => "root"
+    @tm.task :deploy, :server => :server do
+      run "#{pie_type} in the face!"
+    end
+    commands = @tm.run! :deploy, :deploy2
+    commands.size.should == 1
+    commands.first[:command].should == "moon pie in the face!"
+  end
+
+  it "should be able to include multiple recipe files in a single recipe" do
+    @tm = TaskManager.new(:recipe_file => "test/config/use.rb")
+    @tm.pie.should == "moon pie"
+    @tm.should have(1).__command_sets
+    @tm.should have(1).__tasks
+
+    @tm = TaskManager.new(:recipe_file => "test/config/use2.rb")
+    @tm.pie.should == "moon pie"
+    @tm.should have(1).__command_sets
+    @tm.should have(1).__tasks
+  end
+
+  it "will complain if it can't find the use file" do
+    lambda { TaskManager.new(:recipe_file => "test/config/bad_use.rb") }.should raise_error(Screwcap::IncludeFileNotFound)
+  end
+
+  it "should be able to define gateways" do
+    @tm.gateway :gateway, :address => "xyz.com", :user => "root"
+  end
+
+  it "should be able to define and run sequences" do
+    @tm.server :server, :address => "test", :user => "root"
+    @tm.task(:task1, :server => :server) { run "task1" }
+    @tm.task(:task2, :server => :server) { run "task2" }
+    @tm.sequence :seq, :tasks => [:task1, :task2]
+    commands = @tm.run! :seq
+    commands.size.should == 2
+    commands[0][:command].should == "task1"
+    commands[1][:command].should == "task2"
+  end
+end

data/spec/task_spec.rb

@@ -1,87 +1,150 @@
 require 'spec_helper'
 
 describe "Tasks" do
-  before(:each) do
-    @stdout = []
-    @stderr = []
-    Runner.stubs(:log).with() { |msg,opts| @stdout <<  msg }
-    Runner.stubs(:errorlog).with() { |msg,opts| @stderr <<  msg }
-    @deployer = Deployer.new(:recipe_file => "./test/config/simple_recipe.rb", :silent => true)
+  it "should have a task-like structure" do
+    task = Task.new :name => :test do
+      run "test"
+    end
+
+    task.__commands.should have(0).__commands
+    task.__build_commands
+    task.__commands.should_not be_nil
+    task.should have(1).__commands
+
+    task.__commands[0][:type].should == :remote
+    task.__commands[0][:from].should == :test
+    task.__commands[0][:command].should == "test"
   end
 
-  before(:all) do
-    Net::SSH.stubs(:start).yields(SSHObject.new(:return_stream => :stdout, :return_data => "hostname = asdf\n"))
-    Net::SCP.stubs(:upload!).returns(nil)
-    Runner.stubs(:ssh_exec!).returns(["ok","",0,nil])
-  end
+  it "should be able to build commands" do
+    unknown = Task.new :name => :unknown_action do
+      run "unknown"
+    end
 
-  it "should be able to create variables" do
-    task = @deployer.__tasks.find {|t| t.name == :task1 }
-    task.bango.should == "bongo"
+    task = Task.new :name => :test do
+      run "test"
+      unknown_action
+    end
+
+    commands = task.__build_commands([unknown])
+    commands.size.should == 2
+
+    commands[0][:type].should == :remote
+    commands[0][:from].should == :test
+    commands[0][:command].should == "test"
+
+    commands[1][:type].should == :remote
+    commands[1][:from].should == :unknown_action
+    commands[1][:command].should == "unknown"
   end
 
-  it "should compile run statements" do
-    task = @deployer.__tasks.find {|t| t.name == :task1 }
-    task.should have(6).__commands
+  it "should throw an error if we cannot find a command" do
+    task = Task.new :name => :test do
+      run "test"
+      unknown_action
+    end
+
+    lambda {task.__build_commands([task])  }.should raise_error(NoMethodError)
   end
 
-  it "should be able to execute statements on a remote server" do
-    task = @deployer.__tasks.find {|t| t.name == :task1 }
-    Runner.execute! task, @deployer.__options
-    @stderr.size.should == 0
-    @stdout.size.should == 28
+  it "should be able to create variables" do
+    task = Task.new :name => :test do
+      set :blaster, "stun"
+      run "fire #{blaster}"
+    end
+    task.__build_commands
+    task.blaster.should == "stun"
+    task.__commands.first[:command].should == "fire stun"
   end
 
-  it "should be able to use variables in the run statement" do
-    task = @deployer.__tasks.find {|t| t.name == :task1 }
-    command = task.__commands.map{|c| c[:command] }.find {|c| c.index "deploy dir" }
-    command.should == "deploy dir = tester"
+  it  "command sets should inherit the parent's variables" do
+    subsub = Task.new :name => :subsubtask do
+      set :from, "venus"
+      run "fly to #{where} from #{from}"
+    end
+
+    sub = Task.new :name => :subtask do
+      set :from, "mars"
+      run "fly to #{where} from #{from}"
+      subsubtask
+    end
+
+    task = Task.new :name => :task do
+      set :where, "the moon"
+      set :from, "earth"
+      run "fly to #{where} from #{from}"
+      subtask
+    end
+
+    commands = task.__build_commands([sub, subsub])
+    commands[0][:from].should == :task
+    commands[0][:command].should == "fly to the moon from earth"
+
+    commands[1][:from].should == :subtask
+    commands[1][:command].should == "fly to the moon from mars"
+
+    commands[2][:from].should == :subsubtask
+    commands[2][:command].should == "fly to the moon from venus"
   end
 
-  it "should be able to override a globally set variable" do
-    @deployer.deploy_var_2.should == "bongo"
-    @deployer.deploy_var_3.should == %w(one two)
+  it "should respond to :before or before_ calls" do
+    before = Task.new :name => :do_before do
+      run "before"
+    end
+    task = Task.new :name => :test, :before => :do_before do
+      run "task"
+    end
 
-    task = @deployer.__tasks.find {|t| t.name == :task1 }
-    task.deploy_var_2.should == "shasta"
+    before2 = Task.new :name => :before_deploy do
+      run "before"
+    end
 
-    task = @deployer.__tasks.find {|t| t.name == :task2 }
-    task.deploy_var_2.should == "purple"
-    task.deploy_var_3.should == "mountain dew"
-  end
+    task2 = Task.new :name => :deploy do
+      run "deploy"
+    end
 
-  it "should complain if you do not pass the task a server argument" do
-    lambda { Deployer.new(:recipe_file => "./test/config/no_server.rb", :silent => true)}.should raise_error(Screwcap::ConfigurationError)
-  end
+    commands = task.__build_commands([before])
+    commands.map {|c| c[:command] }.should == ["before","task"]
 
-  it "should complain if you pass a server that is not defined" do
-    lambda { Deployer.new(:recipe_file => "./test/config/undefined_server.rb", :silent => true)}.should raise_error(Screwcap::ConfigurationError)
+    commands = task2.__build_commands([before2])
+    commands.map {|c| c[:command] }.should == ["before","deploy"]
   end
 
-  it "should be able to disable parallel running" do
-    # this is hard to test.  with threads and stuff
-    lambda { @deployer.run! :non_parallel }.should_not raise_error
-  end
+  it "should respond to :after or after_ calls" do
+    after = Task.new :name => :do_after do
+      run "after"
+    end
+    task = Task.new :name => :test, :after => :do_after do
+      run "task"
+    end
 
-  it "should be able to run local commands" do 
-    lambda { @deployer.run! :task3 }.should_not raise_error
-  end
+    after2 = Task.new :name => :after_deploy do
+      run "after"
+    end
 
-  it "should be able to upload files using the scp command" do
-    deployer = Deployer.new(:recipe_file => "./test/config/upload.rb", :silent => true)
-    deployer.run! :upload
-  end
+    task2 = Task.new :name => :deploy do
+      run "deploy"
+    end
+
+    commands = task.__build_commands([after])
+    commands.map {|c| c[:command] }.should == ["task","after"]
 
-  it "should respond to onfailure" do
-    deployer = Deployer.new(:recipe_file => "./test/config/expect.rb", :silent => true)
-    t = deployer.__tasks.find {|t| t.__name == :expect }
-    Runner.stubs(:ssh_exec!).returns(["","fail",1,nil]).then.returns(["ok","",0,nil])
-    Runner.execute! t, deployer.__options
-    t.__commands.map {|c| [c[:command], c[:from]] }.first.should == ["echo 'we failed'", :failover]
+    commands = task2.__build_commands([after2])
+    commands.map {|c| c[:command] }.should == ["deploy", "after"]
   end
 
-  it "should be able to create local tasks" do
-    # TODO better testing on this
-    lambda { Deployer.new(:recipe_file => "./test/config/local_task.rb", :silent => true).run! :local }.should_not raise_error
+  it "should validate" do
+    task = Task.new :name => :test 
+    lambda { task.validate([]) }.should raise_error(Screwcap::ConfigurationError)
+
+    server = Server.new :name => :server, :address => "none", :user => "yeah"
+    other_server = Server.new :name => :server2, :address => "none", :user => "yeah"
+    task = Task.new :name => :test, :server => :server
+    lambda { task.validate([server]) }.should_not raise_error
+    lambda { task.validate([other_server]) }.should raise_error(Screwcap::ConfigurationError)
+    task = Task.new :name => :test, :servers => :server
+    lambda { task.validate([server]) }.should_not raise_error
+    task = Task.new :name => :test, :servers => [:server, :server2]
+    lambda { task.validate([server,other_server]) }.should_not raise_error
   end
 end