dynport_tools 0.2.18 → 0.2.19

data/VERSION

@@ -1 +1 @@
-0.2.18
+0.2.19

data/dynport_tools.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dynport_tools}
-  s.version = "0.2.18"
+  s.version = "0.2.19"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Tobias Schwab"]
-  s.date = %q{2011-09-05}
+  s.date = %q{2011-09-14}
   s.description = %q{Collection of various tools}
   s.email = %q{tobias.schwab@dynport.de}
   s.executables = ["xmldiff", "redis_dumper"]
@@ -40,6 +40,8 @@ Gem::Specification.new do |s|
     "lib/dynport_tools/eta.rb",
     "lib/dynport_tools/have_attributes.rb",
     "lib/dynport_tools/jenkins.rb",
+    "lib/dynport_tools/job_dsl.rb",
+    "lib/dynport_tools/log_tracer.rb",
     "lib/dynport_tools/redis_dumper.rb",
     "lib/dynport_tools/redis_q.rb",
     "lib/dynport_tools/xml_file.rb",
@@ -50,6 +52,8 @@ Gem::Specification.new do |s|
     "spec/dynport_tools/eta_spec.rb",
     "spec/dynport_tools/have_attributes_spec.rb",
     "spec/dynport_tools/jenkins_spec.rb",
+    "spec/dynport_tools/job_dsl_spec.rb",
+    "spec/dynport_tools/log_tracer_spec.rb",
     "spec/dynport_tools/redis_dumper_spec.rb",
     "spec/dynport_tools/redis_q_spec.rb",
     "spec/dynport_tools/xml_file_spec.rb",

data/lib/dynport_tools.rb

@@ -8,4 +8,4 @@ require "cgi"
 require "term/ansicolor"
 require "diff/lcs"
 
-%w(deep_merger differ jenkins redis_dumper xml_file have_attributes redis_q eta ascii_table embedded_redis).map { |m| require "dynport_tools/#{m}" }
+%w(deep_merger differ jenkins redis_dumper xml_file have_attributes redis_q eta ascii_table embedded_redis job_dsl log_tracer).map { |m| require "dynport_tools/#{m}" }

data/lib/dynport_tools/jenkins.rb

@@ -145,8 +145,10 @@ class DynportTools::Jenkins
   end
   
   class Project
-    attr_accessor :name, :commands, :crontab_pattern, :days_to_keep, :num_to_keep, :node, :child_projects, :locks, :disabled, :description, :email_addresses
-    DEFAUL_SCM = "hudson.scm.NullSCM"
+    attr_accessor :name, :commands, :crontab_pattern, :days_to_keep, :num_to_keep, :node, :child_projects, :locks, :disabled, :description, 
+      :email_addresses, :git_repository
+    DEFAULT_SCM = "hudson.scm.NullSCM"
+    GIT_SCM = "hudson.plugins.git.GitSCM"
     
     def initialize(name = nil)
       self.name = name
@@ -160,22 +162,77 @@ class DynportTools::Jenkins
       Digest::MD5.hexdigest(to_xml)
     end
     
+    def log_rotate_xml(node)
+      node.logRotator do
+        node.daysToKeep days_to_keep || -1
+        node.numToKeep num_to_keep || -1 
+        node.artifactDaysToKeep -1
+        node.artifactNumToKeep -1
+      end
+    end
+    
+    def git_repository_xml(xml)
+      xml.send("org.spearce.jgit.transport.RemoteConfig") do
+        xml.string "origin"
+        xml.int 5
+        xml.string "fetch"
+        xml.string "+refs/heads/*:refs/remotes/origin/*"
+        xml.string "receivepack"
+        xml.string "git-upload-pack"
+        xml.string "uploadpack"
+        xml.string "git-upload-pack"
+        xml.string "url"
+        xml.string git_repository
+        xml.string "tagopt"
+        xml.string
+      end
+    end
+    
+    def git_options_xml(xml)
+      xml.mergeOptions
+      xml.recursiveSubmodules false
+      xml.doGenerateSubmoduleConfigurations false
+      xml.authorOrCommitter false
+      xml.clean false
+      xml.wipeOutWorkspace false
+      xml.pruneBranches false
+      xml.buildChooser(:class => "hudson.plugins.git.util.DefaultBuildChooser")
+      xml.gitTool "Default"
+      xml.submoduleCfg(:class => "list")
+      xml.relativeTargetDir
+      xml.excludedRegion
+      xml.excludedUsers
+      xml.skipTag false
+    end
+    
+    def git_xml(xml)
+      xml.scm(:class => GIT_SCM) do
+        xml.config_version 1
+        xml.remoteRepositories do
+          git_repository_xml(xml)
+        end
+        xml.branches do
+          xml.send("hudson.plugins.git.BranchSpec") do
+            xml.name "master"
+          end
+        end
+        git_options_xml(xml)
+      end
+    end
+    
     def to_xml
       Nokogiri::XML::Builder.new(:encoding => "UTF-8") do |xml|
         xml.project do
           xml.actions
           xml.description *[description].compact
-          if days_to_keep || num_to_keep
-            xml.logRotator do
-              xml.daysToKeep days_to_keep || -1
-              xml.numToKeep num_to_keep || -1 
-              xml.artifactDaysToKeep -1
-              xml.artifactNumToKeep -1
-            end
-          end
+          log_rotate_xml(xml) if days_to_keep || num_to_keep
           xml.keepDependencies false
           xml.properties
-          xml.scm(:class => DEFAUL_SCM)
+          if git_repository
+            git_xml(xml)
+          else
+            xml.scm(:class => DEFAULT_SCM)
+          end
           if node
             xml.assignedNode node 
             xml.canRoam false

data/lib/dynport_tools/job_dsl.rb

@@ -0,0 +1,114 @@
+class Jenkins
+  class JobDSL
+    class << self
+      attr_accessor :jobs
+      
+      def setup(namespace = :default, &block)
+        dsl = self.new
+        dsl.instance_eval(&block) if block_given?
+        self.jobs ||= {}
+        self.jobs[namespace] ||= Array.new
+        self.jobs[namespace] += dsl.jobs
+        self.jobs[namespace]
+      end
+    end
+    
+    attr_accessor :name, :jobs, :current_scope, :current_prefix
+    
+    def initialize(options = {})
+      options.each do |key, value|
+        self.send(:"#{key}=", value) if self.respond_to?(:"#{key}=")
+      end
+      self.jobs = []
+      self.current_scope = {}
+    end
+    
+    MULTIPLE = [:notify, :cron_patterns, :locks, :commands]
+    
+    [
+      :node, :disabled, :days_to_keep, :num_to_keep, :notify, :cron_patterns, :locks, :commands, :ordered, :rails_root,
+      :rails_env
+    ].each do |method|
+      attr_writer method
+      
+      define_method(method) do |*values, &block|
+        self.setter_or_getter(method, *values, &block)
+      end
+    end
+    
+    alias_method :cron_pattern, :cron_patterns
+    alias_method :lock, :locks
+    alias_method :command, :commands
+    alias_method :prefix, :ordered
+    
+    def disabled!(&block)
+      disabled(true, &block)
+    end
+    
+    def use_rails3!
+      @rails3 = true
+    end
+    
+    def use_bundle_exec!
+      @bundle_exec = true
+    end
+    
+    def rails_command(cmd, options = {})
+      rails_command_or_script(%("#{cmd.gsub('"', '\\"')}"), options)
+    end
+    
+    def rails_script(*args)
+      rails_command_or_script(*args)
+    end
+    
+    def rake_task(task, options = {})
+      options[:env] = (options[:env] || {}).merge("RAILS_ENV" => options[:rails_env]) if options[:rails_env]
+      command "cd #{rails_root} && " + command_with_env("rake #{task}", options[:env])
+    end
+    
+    def rails_command_or_script(cmd_or_script, options = {})
+      raise "rails_root must be set" if rails_root.nil?
+      command %(cd #{rails_root} && #{command_with_env(runner_command(options[:rails_env]), options[:env])} #{cmd_or_script})
+    end
+    
+    def runner_command(env = nil)
+      env ||= rails_env
+      [@rails3 ? "rails runner" : "./script/runner", env ? "-e #{env}" : nil].compact.join(" ")
+    end
+    
+    def command_with_env(cmd, env = {})
+      ((env || {}).sort.map { |key, value| "#{key}=#{value}" } + [@bundle_exec ? "bundle exec" : nil, cmd].compact).join(" ")
+    end
+    
+    def with(options, &block)
+      old_scope = self.current_scope
+      self.current_scope = self.current_scope.merge(options)
+      self.instance_eval(&block)
+      self.current_scope = old_scope
+    end
+    
+    def current_prefix
+      self.current_scope[:ordered] || self.current_scope[:prefix]
+    end
+    
+    def setter_or_getter(key, *values, &block)
+      value = MULTIPLE.include?(key) ? values : values.first
+      if block_given?
+        with(key => value, &block)
+      elsif ![[], nil].include?(value)
+        self.send(:"#{key}=", value)
+      end
+      self.instance_variable_get("@#{key}")
+    end
+    
+    def job(name, &block)
+      if current_prefix
+        @prefix_indexes ||= Hash.new(0)
+        name = "#{current_prefix}%03d %s" % [@prefix_indexes[current_prefix] += 1, name]
+      end
+      job = JobDSL.new(self.current_scope.merge(:name => name))
+      job.instance_eval(&block) if block_given?
+      self.jobs << job
+    end
+  end
+end

data/lib/dynport_tools/log_tracer.rb

@@ -0,0 +1,42 @@
+class DynportTools::LogTracer
+  REMOVE_COLOR = /\e.*?\dm/
+  FILTER_BACKTRACE = /\/(gems|ruby)\//
+  LOGGER_METHODS = %w(unknown fatal error warn info debug)
+  
+  def self.setup(logger)
+    return if logger.respond_to?(:log_trace)
+    logger.class.class_eval do
+      LOGGER_METHODS.each do |meth|
+        alias_method :"#{meth}_without_log_tracer", meth
+
+        def register_tracer(re_or_messahge, &block)
+          tracers[re_or_messahge] = block
+        end
+
+        def tracers
+          @tracers ||= Hash.new
+        end
+
+        def log_trace(message)
+          self.tracers.each do |re_or_string, block|
+            filtered_backtrace = filter_backtrace(caller)
+            if filtered_backtrace.any? && (re_or_string.is_a?(String) ? message.include?(re_or_string) : message.match(re_or_string))
+              block.call(message.gsub(REMOVE_COLOR, "").strip, filtered_backtrace)
+            end
+          end
+        end
+
+        def filter_backtrace(trace)
+          trace.reject { |t| t.match(FILTER_BACKTRACE) }
+        end
+
+        eval <<-EOM, nil, __FILE__, __LINE__ + 1
+          def #{meth}(message = nil)
+            log_trace(message)
+            #{meth}_without_log_tracer(message)
+          end
+        EOM
+      end
+    end
+  end
+end

data/spec/dynport_tools/jenkins_spec.rb

@@ -135,6 +135,11 @@ describe "DynportTools::Jenkins" do
         end
       end
       
+      it "adds a git entry when git is set" do
+        job.git_repository = "git@github.com:dynport/dynport_tools.git"
+        job.to_xml.should include(%(scm class="hudson.plugins.git.GitSCM">))
+      end
+      
       it "sets the correct email_addresses when present" do
         job.email_addresses = %w(test@test.xx test2@test.xx)
         doc.xpath("/project/publishers/hudson.tasks.Mailer/recipients").map(&:inner_text).should == ["test@test.xx,test2@test.xx"]

data/spec/dynport_tools/job_dsl_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+
+describe Jenkins::JobDSL do
+  let(:job) { Jenkins::JobDSL.new }
+  
+  after(:each) do
+    Jenkins::JobDSL.jobs = nil
+  end
+  
+  describe "Job" do
+    it "can be initialized with a scope" do
+      Jenkins::JobDSL.new(:node => "Some Node").node.should == "Some Node"
+    end
+    
+    it "sets the current scope to an empty hash" do
+      Jenkins::JobDSL.new.current_scope.should == {}
+    end
+  end
+  
+  
+  describe "#runner_command" do
+    it "returns ./script/runner when no env given" do
+      job.runner_command.should == "./script/runner"
+    end
+    
+    it "returns rails runner when rails3 is set" do
+      job.use_rails3!
+      job.runner_command.should == "rails runner"
+    end
+    
+    it "adds the rails env when given" do
+      job.runner_command("staging").should == "./script/runner -e staging"
+    end
+    
+    it "adds the default rails_env" do
+      job.rails_env = "staging"
+      job.runner_command.should == "./script/runner -e staging"
+    end
+    
+    it "uses given rails env when both given" do
+      job.rails_env = "staging"
+      job.runner_command("staging2").should == "./script/runner -e staging2"
+    end
+  end
+  
+  describe "#rails_script" do
+    it "calls rails_command_or_script with script" do
+      job.should_receive(:rails_command_or_script).with("./jobs/do_something.rb", :rails_env => "staging")
+      job.rails_script("./jobs/do_something.rb", :rails_env => "staging")
+    end
+  end
+  
+  describe "#rake_task" do
+    before(:each) do
+      job.rails_root "/rails/root"
+    end
+    
+    it "sets the correct rails command" do
+      job.rake_task "db:check"
+      job.commands.should == ["cd /rails/root && rake db:check"]
+    end
+    
+    it "hands in env variables" do
+      job.should_receive(:command_with_env).with("rake db:check", { "A" => "true" }).and_return "some command"
+      job.rake_task "db:check", :env => { "A" => "true"}
+      job.commands.should == ["cd /rails/root && some command"]
+    end
+    
+    it "correctly merges the rails env when given" do
+      job.should_receive(:command_with_env).with("rake db:check", { "A" => "true", "RAILS_ENV" => "staging" }).and_return "some other command"
+      job.rake_task "db:check", :env => { "A" => "true"}, :rails_env => "staging"
+      job.commands.should == ["cd /rails/root && some other command"]
+    end
+  end
+  
+  describe "#rails_command" do
+    it "calls rails_command_or_script with script" do
+      job.should_receive(:rails_command_or_script).with(%("puts 1"), :rails_env => "staging")
+      job.rails_command("puts 1", :rails_env => "staging")
+    end
+    
+    it "correctly escapes the command" do
+      job.should_receive(:rails_command_or_script).with(%("puts \\\"hello\\\""), :rails_env => "staging")
+      job.rails_command(%(puts "hello"), :rails_env => "staging")
+    end
+  end
+  
+  describe "#command_with_env" do
+    it "puts all env variables in front of command" do
+      job.command_with_env("some command", "A" => "true").should == "A=true some command"
+    end
+    
+    it "returns the command without env when env is nil" do
+      job.command_with_env("some command").should == "some command"
+    end
+    
+    it "adds bundle exec between env and command" do
+      job.use_bundle_exec!
+      job.command_with_env("some command", "A" => "true").should == "A=true bundle exec some command"
+    end
+  end
+  
+  describe "#rails_command_or_script" do
+    before(:each) do
+      job.rails_root = "/path/to/rails"
+      job.stub!(:runner_command).and_return "./script/runner"
+    end
+    
+    it "calls command with correct args" do
+      job.rails_command_or_script "./some/script.rb"
+      job.commands.should == [%(cd /path/to/rails && ./script/runner ./some/script.rb)]
+    end
+    
+    it "calls runner_command with correct env" do
+      job.should_receive(:runner_command).with("staging")
+      job.rails_command_or_script "puts 1", :rails_env => "staging"
+      job.commands
+    end
+    
+    it "can set various env flags" do
+      job.rails_command_or_script "./script.rb", :env => { "A" => "a", "B" => "b"}
+      job.commands.should == [%(cd /path/to/rails && A=a B=b ./script/runner ./script.rb)]
+    end
+    
+    it "raises an error when rails_root is nil" do
+      job.rails_root = nil
+      lambda {
+        job.rails_command_or_script "some"
+      }.should raise_error("rails_root must be set")
+    end
+  end
+  
+  describe "setters and getters" do
+    { 
+      :node => "Some Node", :disabled => true, :days_to_keep => 10, :num_to_keep => 1, :ordered => "A", 
+      :rails_root => "/some/path"
+    }.each do |key, value|
+      it "sets #{key} to #{value}" do
+        job.send(key, value)
+        job.send(key).should == value
+      end
+    end
+    
+    it "allows setting multiple email addresses" do
+      job.notify "email1@test.xx", "email2@test.xx"
+      job.notify.should == %w(email1@test.xx email2@test.xx)
+    end
+    
+    %w(cron_pattern lock command command).each do |singular|
+      it "allows setting #{singular}s with #{singular}" do
+        job.send(singular, "#{singular}1")
+        job.send("#{singular}").should == ["#{singular}1"]
+      end
+      
+      it "allows setting #{singular}s with #{singular}s" do
+        job.send("#{singular}s", "#{singular}1", "#{singular}2")
+        job.send("#{singular}").should == ["#{singular}1", "#{singular}2"]
+      end
+    end
+    
+    it "provides a simple setter_or_getter" do
+      lambda {
+        job.disabled!
+      }.should change(job, :disabled).to(true)
+    end
+  end
+  
+  describe "#node" do
+    before(:each) do
+      job.current_scope = { :ttl => 1 }
+    end
+    
+    it "can set the node" do
+      job.node "Some Node"
+      job.node.should == "Some Node"
+    end
+    
+    it "does not set the node when block given" do
+      job.node "Some Node" do
+      end
+      job.node.should be_nil
+    end
+    
+    it "resets the correct scope" do
+      job.node "Some Node" do
+      end
+      job.current_scope.should == { :ttl => 1 }
+    end
+    
+    it "merges the current scope with the node" do
+      scope = nil
+      job.node "Some Node" do
+        scope = self.current_scope
+      end
+      scope.should have_attributes(:ttl => 1, :node => "Some Node")
+    end
+  end
+  
+  describe "#setup" do
+    it "returns a new instance of Jenkins" do
+      Jenkins::JobDSL.setup.should be_kind_of(Array)
+    end
+    
+    it "sets the new jobs to the default key when no namespace given" do
+      Jenkins::JobDSL.setup do
+        job "Default Job"
+      end
+      Jenkins::JobDSL.jobs[:default].count.should == 1
+      Jenkins::JobDSL.jobs[:default].first.name.should == "Default Job"
+    end
+    
+    it "does not overwrite jobs" do
+      Jenkins::JobDSL.setup do
+        job "First Job"
+      end
+      Jenkins::JobDSL.setup do
+        job "Second Job"
+      end
+      Jenkins::JobDSL.jobs[:default].count.should == 2
+    end
+    
+    it "dass the jobs to a custom key" do
+      Jenkins::JobDSL.setup :custom do
+        job "Default Job"
+      end
+      Jenkins::JobDSL.jobs[:custom].count.should == 1
+      Jenkins::JobDSL.jobs[:custom].first.name.should == "Default Job"
+    end
+  end
+  
+  describe "#job" do
+    it "adds a new job to the children" do
+      job.job "Some Name"
+      job.jobs.count.should == 1
+      job.jobs.first.name.should == "Some Name"
+    end
+    
+    it "initializes the job with current_scope" do
+      job.current_scope = { :node => "Test" }
+      job.job "Some Name"
+      job.jobs.first.node.should == "Test"
+    end
+    
+    it "adds a prefix to the name when current_prefix is set" do
+      job.current_scope = { :ordered => "A" }
+      job.job "Some Name"
+      job.jobs.first.name.should == "A001 Some Name"
+    end
+  end
+  
+  describe "integration" do
+    it "adds a new job to the dsl object" do
+      Jenkins::JobDSL.setup do
+        job "some name" do
+          node "Import"
+        end
+        
+        job "some other name" do
+          command "ls"
+          
+          job "child job"
+        end
+        
+        node "Backup" do
+          job "Backup Task"
+        end
+        
+        with :locks => %w(Lock1 Lock2), :node => "Other Node" do
+          job "Other Job"
+        end
+        
+        ordered "A" do
+          job "First" do
+            with :prefix => "B" do
+              job "Third"
+              job "Fourth"
+            end
+          end
+          
+          job "Second"
+        end
+      end
+      jobs = Jenkins::JobDSL.jobs[:default]
+      jobs.count.should == 6
+      jobs.first.name.should == "some name"
+      jobs.first.node.should == "Import"
+      jobs.at(1).commands.should == %w(ls)
+      jobs.at(1).jobs.count.should == 1
+      jobs.at(1).jobs.first.name.should == "child job"
+      jobs.at(2).name.should == "Backup Task"
+      jobs.at(2).node.should == "Backup"
+      
+      jobs.at(3).node.should == "Other Node"
+      jobs.at(3).locks.should == %w(Lock1 Lock2)
+      jobs.at(3).name.should == "Other Job"
+      jobs.at(4).name.should == "A001 First"
+      jobs.at(5).name.should == "A002 Second"
+      jobs.at(4).jobs.map { |j| j.name }.should == ["B001 Third", "B002 Fourth"]
+    end
+  end
+end

data/spec/dynport_tools/log_tracer_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require "logger"
+
+describe "DynportTools::LogTracer" do
+  let(:clazz) { Class.new(Logger) }
+  let(:logger) { clazz.new("/dev/null") }
+  
+  it "adds filters to all methods" do
+    DynportTools::LogTracer.setup(logger)
+    logger.should respond_to(:log_trace)
+  end
+  
+  it "calls class_eval once" do
+    clazz.should_receive(:class_eval)
+    DynportTools::LogTracer.setup(logger)
+  end
+  
+  it "does not call class_eval when already responding to log_trace" do
+    logger.should_receive(:respond_to?).with(:log_trace).and_return true
+    clazz.should_not_receive(:class_eval)
+    DynportTools::LogTracer.setup(logger)
+  end
+  
+  it "catches all messages with a specific pattern" do
+    DynportTools::LogTracer.setup(logger)
+    messages = []
+    logger.register_tracer(/rgne/) do |message, trace|
+      messages << message
+    end
+    logger.info("hello")
+    logger.info("rgne1")
+    logger.info("world")
+    logger.info("rgne2")
+    messages.should == %w(rgne1 rgne2)
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dynport_tools
 version: !ruby/object:Gem::Version 
-  hash: 51
+  hash: 49
   prerelease: 
   segments: 
   - 0
   - 2
-  - 18
-  version: 0.2.18
+  - 19
+  version: 0.2.19
 platform: ruby
 authors: 
 - Tobias Schwab
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-05 00:00:00 +02:00
+date: 2011-09-14 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -255,6 +255,8 @@ files:
 - lib/dynport_tools/eta.rb
 - lib/dynport_tools/have_attributes.rb
 - lib/dynport_tools/jenkins.rb
+- lib/dynport_tools/job_dsl.rb
+- lib/dynport_tools/log_tracer.rb
 - lib/dynport_tools/redis_dumper.rb
 - lib/dynport_tools/redis_q.rb
 - lib/dynport_tools/xml_file.rb
@@ -265,6 +267,8 @@ files:
 - spec/dynport_tools/eta_spec.rb
 - spec/dynport_tools/have_attributes_spec.rb
 - spec/dynport_tools/jenkins_spec.rb
+- spec/dynport_tools/job_dsl_spec.rb
+- spec/dynport_tools/log_tracer_spec.rb
 - spec/dynport_tools/redis_dumper_spec.rb
 - spec/dynport_tools/redis_q_spec.rb
 - spec/dynport_tools/xml_file_spec.rb