motomike-bnr_tools 0.0.2

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 0
+:patch: 2
+:major: 0

data/bin/taggit

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+begin
+  require 'rubygems'
+  gem 'bnr_tools'
+rescue LoadError
+  $: << File.expand_path(File.dirname(__FILE__)) + "/../lib"
+  require 'bnr_tools'
+end
+
+require 'mergeinator'
+require 'ticket'
+require 'trollop'
+
+CURRENT_RELEASE_BRANCH="9.4"
+
+opts = Trollop::options do
+  opt :ticket, "A ticket number optionally followed by one or more changesets to merge", :type => :ints, :multi => true
+  opt :wc_root_path, "Root path to a working copy of the repository we can do merge gymnastics in", :default => "#{ENV["HOME"]}/diggRepository"
+  opt :release_branch, "Name of the release branch which will be the merge target", :default => CURRENT_RELEASE_BRANCH, :required => true, :multi => true  
+end
+
+tickets = Set.new
+Array(opts[:release_branch]).each { |release_branch|
+  opts[:ticket].each { |ticketRefAndChangesets|
+    ticket, *changesets = *ticketRefAndChangesets
+    tickets << Ticket.new(ticket, changesets, opts[:wc_root_path], release_branch)
+  }
+  Mergeinator.new(opts[:wc_root_path], release_branch, tickets).mergeStuff
+}

data/lib/bnr_tools.rb

@@ -0,0 +1,6 @@
+begin
+  myPath = File.expand_path(File.dirname(__FILE__))
+  libPath = "#{myPath}/bnr_tools"
+  $: << myPath unless $:.include?(myPath)
+  $: << libPath unless $:.include?(libPath)
+end

data/lib/bnr_tools/changeset.rb

@@ -0,0 +1,60 @@
+require 'svn_commands'
+require 'digg_module'
+
+class Changeset
+  include Comparable
+  attr_reader :revision
+  attr_accessor :wcBasePath, :releaseBranch
+  def initialize(rev, wc_base_path=SvnCommands::DIGG_DEFAULT_WC_PATH, release_branch="9.4")
+    @revision = Integer(rev)
+    @modified = {}
+    @affectedModules = {}
+    self.wcBasePath=wc_base_path
+    self.releaseBranch=release_branch
+  end
+  
+  def modifiedPaths(relativeStartPath = self.wcBasePath)
+    @modified[relativeStartPath] ||= begin
+      SvnCommands::Log.new(relativeStartPath,"-r #{self.revision}", true).entries.first.paths.map {|p| p.to_s}
+    rescue
+      []
+    end
+  end
+  
+  def affectedModulesbak(modulePath = "LOLz/trunk")
+    @affectedModules[modulePath] ||= self.modifiedPaths(modulePath).inject(Set.new) { |memo, modifiedPath|
+      (modifiedPath =~ /#{modulePath}\/([^\/]*)/) ?  memo << DiggModule.new($1, self.wcBasePath, self.releaseBranch) : memo
+    }
+  end
+  
+  def affectedModules(modulePath = "LOLz/trunk")
+    @affectedModules[modulePath] ||= begin
+      self.modifiedPaths(modulePath).inject(Set.new) { |memo, modifiedPath|
+        if modifiedPath =~ /#{modulePath}\/([^\/]*)/
+          moduleName = $1
+          unless (memo.detect{ |m| m.moduleName == moduleName })
+            memo << DiggModule.new($1, self.wcBasePath, self.releaseBranch)
+          end
+        end
+        memo
+      }
+    end
+  end
+  
+  def to_s
+    "r#{revision}"
+  end
+  
+  def <=>(other)
+    self.revision <=> other.revision
+  end
+  
+  def hash
+    self.revision.hash
+  end
+  
+  def eql?(other)
+    self.revision == other.revision
+  end
+  
+end

data/lib/bnr_tools/digg_module.rb

@@ -0,0 +1,103 @@
+require 'svn_commands'
+require 'version_number'
+require 'fileutils'
+
+class DiggModule
+  include Comparable
+  attr_reader :moduleName, :wcBasePath, :releaseBranch
+  def initialize(module_name, wc_base_path, release_branch)
+    @moduleName = module_name
+    @wcBasePath = wc_base_path
+    @releaseBranch = release_branch
+  end
+  
+  def utilDir
+    @utilDir ||= begin
+      provisionalDir = "#{self.wcBasePath}/build/trunk"
+      unless File.exist? provisionalDir
+        SvnCommands::Update.new("build/trunk", nil, true, false, self.wcBasePath) # update the current working copy to be sure the dir is there
+      end
+      provisionalDir
+    end
+  end
+  
+  def myCatDir
+    "#{self.wcBasePath}/LOLcat/branches/#{self.releaseBranch}"
+  end
+  
+  def myDir
+    "#{self.myCatDir}/modules/#{self.moduleName}"
+  end
+  
+  def getVersion
+    Dir.chdir(myDir) { |cwd|
+      VersionNumber.new(IO.popen(%Q{ #{self.utilDir}/version package.xml }).readlines.first.strip)
+    }
+  end
+  
+  def updateVersion
+    Dir.chdir(myDir) { |cwd|
+      current_version = self.getVersion
+      new_version = block_given?() ? (yield current_version) : (current_version.next_after_patchlevel_increment)
+      puts IO.popen(%Q{ #{self.utilDir}/setversion package.xml #{new_version} }).readlines
+      self.updateManifest("#{myCatDir}/manifest/pear-common",new_version)
+    }
+  end
+  
+  def updateManifest(manifest_path,new_version)
+    manifest_lines = File.readlines(manifest_path)
+    File.open(manifest_path, "w+") { |f|
+      manifest_lines.each { |line|
+        if line =~ /^pear.digg.internal\/#{self.moduleName}-/
+          f.puts("pear.digg.internal/#{self.moduleName}-#{new_version}")
+        else
+          f.puts(line)
+        end
+      }
+    }
+  end
+  
+  def updateContents
+    Dir.chdir(myDir) { |cwd|
+      puts IO.popen(%Q{ #{self.utilDir}/update-contents package.xml }).readlines
+    }
+  end
+  
+  def updateStability(stability="stable")
+    Dir.chdir(myDir) { |cwd|
+      puts IO.popen(%Q{ #{self.utilDir}/setstability package.xml #{stability} }).readlines
+    }
+  end
+  
+  def buildPearPackage
+    Dir.chdir(myDir) { |cwd|
+      puts IO.popen(%Q{ pear package }).readlines
+    }
+    %Q{ #{self.utilDir}/upload #{myDir}/#{self.moduleName}-#{self.getVersion}.tgz }
+  end
+  
+  def cleanupPackageXmlFormatting
+    Dir.chdir(myDir) { |cwd|
+      FileUtils.copy("package.xml","package.xml.unformatted")
+      puts IO.popen(%Q{ XMLLINT_INDENT="    " xmllint --format package.xml.unformatted > package.xml }).readlines
+      FileUtils.rm("package.xml.unformatted")
+    }
+  end
+  
+  def to_s
+    self.moduleName
+  end
+  
+  def <=>(other)
+    self.moduleName <=> other.moduleName
+  end
+  
+  def eql?(other)
+    self.moduleName == other.moduleName
+  end
+  
+  def hash
+    self.moduleName.hash
+  end
+  
+end

data/lib/bnr_tools/mergeinator.rb

@@ -0,0 +1,129 @@
+require 'svn_commands'
+require 'version_number'
+require 'highline/import'
+require 'set'
+require 'tempfile'
+
+class Mergeinator
+  attr_reader :wcPath, :releaseBranchVersion
+  attr_accessor :catPath, :modulePath, :ticketsToMerge
+  
+  def initialize(wc_path = SvnCommands::DIGG_DEFAULT_WC_PATH, release = VersionNumber.new(CURRENT_RELEASE_BRANCH,false), tickets=Set.new )
+    @wcPath = wc_path
+    @releaseBranchVersion = release.kind_of?(VersionNumber) ? release : VersionNumber.new(release,false)
+    self.ticketsToMerge = Set.new(Array(tickets))
+    self.catPath = "LOLcat/branches/#{releaseBranch}"
+    self.modulePath = "#{self.catPath}/modules"
+  end
+  
+  def releaseBranch
+    "#{self.releaseBranchVersion.major}.#{self.releaseBranchVersion.minor}"
+  end
+  
+  def branchWorkingDir
+    "#{self.wcPath}/LOLcat/branches/#{self.releaseBranch}"
+  end
+  
+  def version
+    @versionToTag ||= begin
+      preExistingVersions = []
+      SvnCommands::Ls.new("LOLcat/tags").entries.each { |entry|
+        begin
+          entryVersion = VersionNumber.new(entry.name)
+          preExistingVersions << entryVersion
+        rescue Exception => e
+          puts "Exception processing entry: #{e}"
+        end
+      }
+      candidateVersions = preExistingVersions.find_all { |version| version.major == self.releaseBranchVersion.major && version.minor == self.releaseBranchVersion.minor }
+      highestCandidateVersion = candidateVersions.sort.last
+      puts "Highest existing version: #{highestCandidateVersion}"
+      ask("LOL{z,cat} version to tag?") { |q| 
+        q.default = highestCandidateVersion.next_after_patchlevel_increment.to_s
+        q.validate = /#{self.releaseBranchVersion.major}\.#{self.releaseBranchVersion.minor}\.\d+/ 
+      }
+    end
+  end
+  
+  def tagLOLCat
+    ref_msg = self.ticketsToMerge ? "Refs #{(self.ticketsToMerge.map {|t| "#{t}"}).join(", ")}" : "No tickets referenced"
+    if agree("References: #{ref_msg}\nOkay to tag branch #{self.releaseBranch} as version #{self.version}?")
+      SvnCommands.copy("LOLcat/branches/#{self.releaseBranch}","LOLcat/tags/#{version}", nil, nil, "Tagged LOLcat-#{version}. #{ref_msg}")
+      SvnCommands.copy("LOLz/branches/#{self.releaseBranch}","LOLz/tags/#{version}", nil, nil, "Tagged LOLz-#{version}. #{ref_msg}")
+    else
+      exit(1) unless agree("Oh. Well, would you like to keep going anyway, even though we can't commit anything?")
+    end
+    SvnCommands::Update.new("LOLcat/tags/#{version}",nil,true,true,self.wcPath) # shallowly checkout the new tag to ~/diggRepository/, no extra args for svn, force update
+    t = Tempfile.new("svn_externals").open { |tempfile|
+      tempfile.puts "modules svn+ssh://svn.digg.internal/repository/LOLz/tags/#{version}"
+      tempfile.puts "build svn+ssh://svn.digg.internal/repository/build/trunk"
+    }
+    cmd = "svn ps svn:externals --file #{t.path} #{SvnCommands::DIGG_DEFAULT_WC_PATH}/LOLcat/tags/#{version}"
+    puts "Running command : #{cmd}"
+    puts IO.popen(cmd).readlines
+  end
+
+  def svnMergeCommand(project, changeset)
+    "svn merge -c #{changeset.revision} svn+ssh://svn.digg.internal/repository/#{project}/trunk"
+  end
+
+  def mergeStuff
+    modules = Set.new
+    allChangesets = Set.new
+    self.cleanWorkingCopy
+    ticketsToMerge.each { |ticket|
+      allChangesets.merge(ticket.changesets)
+      modules.merge(ticket.affectedModules)
+    }
+    puts "Affected modules: #{modules.to_a.join(", ")}."
+    commitMessage = "Refs #{(ticketsToMerge.sort.map {|ticket| ticket.to_s(false)}).join(", ")} : Merged #{(allChangesets.sort.map {|c| c.to_s }).join(", ")} from trunk"
+    puts "Commit message = #{commitMessage}"
+    allChangesets.sort.each { |changeset|
+      # We could check paths and such, but that's just an extra step for the cat ...
+      SvnCommands.merge("LOLcat/trunk",self.catPath,changeset.revision,nil,nil,self.wcPath)
+      unless changeset.affectedModules("LOLz/trunk").empty? # OTOH, for modules, we already cached the information
+        SvnCommands.merge("LOLz/trunk",self.modulePath,changeset.revision,nil,nil,self.wcPath)
+      end
+    }
+      
+    @module_upload_cmds = []
+    modules.each { |m| 
+      m.updateVersion
+      m.updateContents
+      m.updateStability("stable")
+      m.cleanupPackageXmlFormatting
+      @module_upload_cmds << m.buildPearPackage
+    }
+    
+    # Sanity check - spew the entire diff before committing it
+    Dir.chdir(self.branchWorkingDir) { |cwd|
+      puts IO.popen(%Q{ svn st && svn diff . modules }).readlines
+      @module_upload_cmds.each { |cmd| puts cmd }
+      puts "Before I commit - does everything look okay?"
+      if agree("Commit message: #{commitMessage}")
+        system %Q{ svn st | awk '/^\s?[MAD]/ { print $NF } ' | xargs svn commit -m'#{commitMessage}' }
+      else
+        exit(1) unless agree("Oh. Well, would you like to keep going anyway, even though we can't commit anything?")
+      end
+    }
+    tagLOLCat
+    if agree("Upload modified modules now?")
+      @module_upload_cmds.each { |cmd|
+        puts IO.popen(cmd).readlines
+      }
+    else
+      exit(1) unless agree("Oh. Well, would you like to keep going anyway, even though we can't commit anything?")
+    end
+  end
+  
+  def cleanWorkingCopy(force=false)
+    if (force || agree("Clean working copy now?")) then
+      SvnCommands::Update.new(self.catPath, nil, true, false, self.wcPath) # update the current working copy to be sure the dir is there
+      Dir.chdir(branchWorkingDir) {
+        puts IO.popen(%Q{ svn revert -R . && svn revert -R modules && svn stat | grep "^\?" | cut -c8- | xargs rm -rf }).readlines
+      }
+    else
+      puts "Okay, trusting you ... it's all going to end in tears, I just know it ..."
+    end
+  end
+end

data/lib/bnr_tools/svn_commands.rb

@@ -0,0 +1,264 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'lib/bnr_tools'
+rescue
+end
+
+require 'svn_xml'
+require 'fileutils'
+require 'open4'
+
+module SvnCommands
+  DIGG_DEFAULT_SVN_URL="svn+ssh://svn.digg.internal/repository"
+  DIGG_DEFAULT_WC_PATH="#{ENV['HOME']}/diggRepository"
+
+  class SvnException < RuntimeError
+    def initialize(status_code, output)
+      @status_code = status_code
+      @output = output
+    end
+    
+    def to_s
+      "Status code:#{@status_code} / output:#{@output} #{super}"
+    end
+  end
+  
+  class << self
+    def svnVersion
+      @@svnVersion ||= VersionNumber.new(`svn --version --quiet`)
+    end
+    
+    def extra_merge_flags
+      (Integer(svnVersion.major) >= 1 && Integer(svnVersion.minor) >= 5) ? ["--accept postpone"] : []
+    end
+    
+    def new_cmd(command_string, expected_result_class=nil, max_retries=3)
+      puts "Executing: '#{command_string}'"
+      retry_count = 0
+      begin
+        out = ""
+        err = ""
+        status = Open4::popen4(command_string) do |pid, stdin, stdout, stderr|
+          stdin.close
+          out = stdout.read
+          err = stderr.read
+        end
+        unless status.exitstatus == 0
+          raise SvnException.new(status.exitstatus, "stdout: #{out}\n\nstderr: #{err}")
+        end
+        if (expected_result_class)
+          parsed = REXML::Document.new(out)
+          expected_result_class.new(parsed.elements[expected_result_class.expected_node_name])
+        else
+          nil
+        end
+      rescue Exception => e
+        if e.kind_of?(Interrupt)
+          exit(1)
+        elsif retry_count < max_retries
+          # puts "invocation failed with #{e.class} #{e} ... trying again"
+          retry_count += 1
+          retry
+        else
+          raise e
+        end
+      end
+    end
+    
+    def copy(fromPath, toPath, extra_args=nil, working_copy_path=nil, commit_msg=nil, repository_base_url=DIGG_DEFAULT_SVN_URL)
+      path_base = working_copy_path || repository_base_url
+      full_from_path = "#{path_base.chomp("/")}/#{fromPath}"
+      full_to_path = "#{path_base.chomp("/")}/#{toPath}"
+      if (working_copy_path)
+        SvnCommands.new_cmd("svn cp #{Array(extra_args).join(" ")} \"#{full_from_path}\" \"#{full_to_path}\"",nil,1)
+      else
+        if (commit_msg)
+          SvnCommands.new_cmd("svn cp #{Array(extra_args).join(" ")} \"#{full_from_path}\" \"#{full_to_path}\" -m\"#{commit_msg}\"",nil,1)
+        else
+          raise SvnException.new(-1, "Without a commit message, I can't svn cp a remote URL. Sorry.")
+        end
+      end
+    end
+    
+    def merge(fromPath, toPath, start_rev, end_rev = nil, extra_args=nil, working_copy_path=nil, repository_base_url=DIGG_DEFAULT_SVN_URL)
+      extra_args = (Array(extra_args) << SvnCommands.extra_merge_flags).compact
+      full_from_path = "#{repository_base_url.chomp("/")}/#{fromPath}"
+      full_to_path = "#{working_copy_path.chomp("/")}/#{toPath}"
+      rev_spec = begin
+        if end_rev.nil?() || Integer(end_rev) == 0
+          "-c #{Integer(start_rev)}"
+        else
+          "-r#{Integer(start_rev)}:#{Integer(end_rev)}"
+        end
+      end
+      SvnCommands.new_cmd("svn merge #{rev_spec} #{extra_args.join(" ")} \"#{full_from_path}\" \"#{full_to_path}\"")
+    end
+    
+    def sync(fromPath, toPath, working_copy_path, extra_args=nil, repository_base_url=DIGG_DEFAULT_SVN_URL)
+      extra_args = (Array(extra_args) << SvnCommands.extra_merge_flags).compact
+      repository_from_path = "#{repository_base_url.chomp("/")}/#{fromPath}"
+      repository_to_path = "#{repository_base_url.chomp("/")}/#{toPath}"
+      wc_to_path = "#{working_copy_path.chomp("/")}/#{toPath}"
+      SvnCommands.new_cmd("svn merge #{extra_args.join(" ")} \"#{repository_to_path}\" \"#{repository_from_path}\" \"#{wc_to_path}\"")
+    end
+    
+    def mkdir(path, commit_msg=nil, working_copy_path=nil, repository_base_url=DIGG_DEFAULT_SVN_URL)
+      path_base = working_copy_path || repository_base_url
+      full_path = "#{path_base.chomp("/")}/#{path}"
+      extra_args = (Array(extra_args) << SvnCommands.extra_merge_flags).compact
+      if (working_copy_path)
+        SvnCommands.new_cmd("svn mkdir #{full_path}")
+      else
+        if (commit_msg)
+          SvnCommands.new_cmd("svn mkdir #{full_path} -m'#{commit_msg}'")
+        else
+          raise SvnException.new(-1, "No commit message specified; cannot mkdir directly in the repository")
+        end
+      end
+    end
+    
+  end
+
+  class PathOp
+    attr_accessor :fullpath, :entries
+    def initialize(relativePath, repository_base_url=DIGG_DEFAULT_SVN_URL)
+      @fullpath=relativePath.nil? ? repository_base_url : "#{repository_base_url}/#{relativePath}"
+    end    
+  end
+  
+  class Ls < PathOp
+    attr_accessor :lists
+    @@all_lists ||= {}
+    def initialize(relativePath=nil, extra_args=nil, force_update=false, repository_base_url=DIGG_DEFAULT_SVN_URL)
+      super(relativePath, repository_base_url)
+      cmd = "svn ls --xml #{Array(extra_args).join(" ")} #{fullpath}"
+      @@all_lists[fullpath] = if (force_update || @@all_lists[fullpath].nil?) 
+        SvnCommands.new_cmd(cmd, SvnXml::Lists)
+      else
+        @@all_lists[fullpath]
+      end
+      @lists = @@all_lists[fullpath]
+      @entries = @lists.entries
+    end
+  end
+  
+  class Log < PathOp
+    attr_reader :entries
+    @@all_entries ||= {}
+    def initialize(relativePath=nil, extra_args=nil, force_update=false, repository_base_url=DIGG_DEFAULT_SVN_URL)
+      super(relativePath, repository_base_url)
+      @@all_entries[fullpath] = if (force_update || @@all_entries[fullpath].nil?) 
+        SvnCommands.new_cmd("svn log -vv --xml #{Array(extra_args).join(" ")} #{fullpath}", SvnXml::Log).entries
+      else
+        @@all_entries[fullpath]
+      end
+      @entries = @@all_entries[fullpath]
+    end
+    
+    def messages
+      @messages ||= self.entries.collect { |entry| entry.msg }
+    end
+    
+    def revisions
+      @revisions ||= self.entries.collect { |entry| entry.revision }
+    end
+    
+    def oldest_revision
+      self.revisions.sort.first
+    end
+    
+    def newest_revision
+      self.revisions.sort.last
+    end
+  end
+  
+  class Update < PathOp
+    @@shallow_paths ||= {}
+    @@recursive_paths ||= {}
+    
+    def updatedShallow?(path)
+      path_parent = File.dirname(path)
+      if [".","/",""].include?(path_parent)
+        @@shallow_paths[path] || false
+      else
+        @@shallow_paths[path] || updatedRecursive?(path_parent)
+      end
+    end
+    
+    def updatedRecursive?(path)
+      path_parent = File.dirname(path)
+      if [".","/",""].include? path_parent
+        @@recursive_paths[path] || false
+      else
+        @@recursive_paths[path] || updatedRecursive?(path_parent)
+      end
+    end
+    
+    def alreadyUpdated?(shallowUpdate)
+      if shallowUpdate
+        updatedShallow?(fullpath)
+      else
+        updatedRecursive?(fullpath)
+      end
+    end
+    
+    def pretty_hash(h)
+      if h.kind_of?(Hash)
+        h.inject(nil) { |memo, kv|
+          key = kv[0]
+          val = kv[1]
+          (memo ? "#{memo}; " : "") + "#{key}=#{pretty_hash(val)}"
+        }
+      else
+        h.to_s
+      end
+    end
+    
+    def updateCache(shallow)
+      if shallow
+        @@shallow_paths[fullpath] ||= 0
+        @@shallow_paths[fullpath] += 1 
+        #puts "Updated shallow cache; current contents #{pretty_hash(@@shallow_paths)}"
+      else
+        @@recursive_paths[fullpath] ||= 0
+        @@recursive_paths[fullpath] += 1
+        #puts "Updated recursive cache; current contents #{pretty_hash(@@recursive_paths)}"
+      end
+    end
+    
+    def ensureWorkingCopyExistsAt(aPath)
+      out = `svn info #{aPath}`
+      unless $? == 0
+        FileUtils.mkdir_p(aPath)
+        SvnCommands.new_cmd("svn co -N svn+ssh://svn.digg.internal/repository/ #{aPath.chomp("/")}")
+      end
+    end
+
+    def initialize(path, extra_args=nil, force_update=false, shallow=false, working_copy_path=DIGG_DEFAULT_WC_PATH)
+      super(path, working_copy_path)
+      cache_hit = alreadyUpdated?(shallow)
+      #puts "Update requested on #{path} - cache hit = #{cache_hit}"
+      if force_update || cache_hit == false || cache_hit.nil?
+        argPile = Array(extra_args)
+        if (shallow) 
+          argPile << "-N"
+        end
+        argPile << fullpath
+        if (path == nil || path.size < 2)
+          ensureWorkingCopyExistsAt(working_copy_path)
+        else
+          wc_fullpath = "#{working_copy_path}/#{path}"
+          unless (File.exist? wc_fullpath)
+            # make sure our parent dir is in good shape ...
+            #puts "Hm, #{fullpath} doesn't exist. Calling checkOut (shallow) on #{File.dirname(relative_path)} ..."
+            SvnCommands::Update.new(File.dirname(path), nil, force_update, true, working_copy_path)
+          end
+        end
+        SvnCommands.new_cmd("svn up #{argPile.join(" ")}")
+      end
+      updateCache(shallow)
+    end
+  end
+  
+end