release_manager 0.4.0 → 0.5.0

data/lib/release_manager/git/utilites.rb

@@ -3,6 +3,7 @@ require 'uri'
 
 module ReleaseManager
   module Git
+    STATUSES = [:added, :deleted, :modified, :renamed, :copied, :ignored, :untracked, :typechange]
     module Utilities
 
       def repo
@@ -13,11 +14,10 @@ module ReleaseManager
       def fetch(remote_name = 'upstream')
         return unless remote_exists?(remote_name)
         remote = repo.remotes[remote_name]
+        options = {credentials: credentials.call(remote.url)}
         logger.info("Fetching remote #{remote_name} from #{remote.url}")
-        remote.fetch({
-                         #progress: lambda { |output| puts output },
-                         credentials: credentials.call(remote.url)
-                     })
+        options[:certificate_check] = lambda { |valid, host| true } if ENV['GIT_SSL_NO_VERIFY']
+        remote.fetch(options)
       end
 
       def transports
@@ -110,12 +110,16 @@ module ReleaseManager
       # @param [String] name - the name of the branch to delete
       def delete_branch(name)
         repo.branches.delete(name)
+        !branch_exist?(name)
       end
 
       # @param [String] remote_name - the remote name to push the branch to
-      def push_branch(remote_name, branch)
+      def push_branch(remote_name, branch, force = false)
         remote = find_or_create_remote(remote_name)
-        refs = [repo.branches[branch].canonical_name]
+        b = repo.branches[branch]
+        raise InvalidBranchName.new("Branch #{branch} does not exist locally, cannot push") unless b
+        refs = [b.canonical_name]
+        refs = refs.map { |r| r.prepend('+') } if force
         logger.info("Pushing branch #{branch} to remote #{remote.url}")
         remote.push(refs, credentials: credentials)
       end
@@ -134,10 +138,28 @@ module ReleaseManager
         repo.head.name.sub(/^refs\/heads\//, '')
       end
 
-      def checkout_branch(name)
-        if current_branch != name
-          logger.info("Checking out branch: #{name} for #{path}")
-          repo.checkout(name)
+      # @param name [String] - the name of the branch
+      # @return [Boolean] returns true if the current branch is the name
+      def current_branch?(name)
+        current_branch != name
+      end
+
+      # @param name [String] - the name of the tag
+      # @param ref [String] - the ref oid the tag should point to
+      # @param message [String] - optional tag message
+      def create_local_tag(name, ref, message = nil)
+        message ||= name
+        logger.info("Creating tag #{name} which points to #{ref}")
+        repo.tags.create(name, ref, {:message => message} )
+      end
+
+      # @param name [String] - the name of the branch to checkout
+      # @return [Rugged::Branch] returns the rugged branch object
+      def checkout_branch(name, options = {})
+        if current_branch?(name)
+          logger.debug("Checking out branch: #{name} for #{path}")
+          repo.checkout(name, options)
+          logger.debug("Checked out branch: #{current_branch} for #{path}")
         else
           # already checked out
           logger.debug("Currently on branch #{name} for #{path}")
@@ -172,7 +194,7 @@ module ReleaseManager
       # @return [MatchData] MatchData if the remote name is a url
       # Is the name actually a url?
       def git_url?(name)
-        /((git|ssh|http(s)?)|(git@[\w\.]+))(:(\/\/)?)([\w\.@\:\/\-~]+)(\.git)(\/)?/.match(name)
+        /([A-Za-z0-9]+@|http(|s)\:\/\/)([A-Za-z0-9.]+)(:|\/)([A-Za-z0-9\/]+)(\.git)?/.match(name)
       end
 
       # @return [String] - the author name found in the config
@@ -190,66 +212,128 @@ module ReleaseManager
         {:email=>author_email, :time=>Time.now, :name=>author_name}
       end
 
-      # # @param [String] file - the path to the file you want to add
-      # def add_file(file)
-      #   return unless File.exists?(file)
-      #   index = repo.index
-      #   file.slice!(repo.workdir)
-      #   index.add(:path => file, :oid => Rugged::Blob.from_workdir(repo, file), :mode => 0100644)
-      #   index.write
-      # end
+      # @param pathspec Array[String] path specs as strings in an array
+      def add_all(pathspec = [])
+        index = repo.index
+        index.add_all
+        index.write
+      end
 
       # @param [String] file - the path to the file you want to add
       def add_file(file)
+        logger.debug("Adding file #{file}")
+        return add_all if file == '.'
+        index = repo.index
+        file.slice!(repo.workdir)
+        index.add(:path => file, :oid => Rugged::Blob.from_workdir(repo, file), :mode => 0100644)
+      end
+
+      # @param [String] file - the path to the patch file you want to apply
+      def apply_patch(file)
         # TODO: change this to rugged implementation
-      `git --work-tree=#{path} --git-dir=#{repo.path} add #{file}`
+        logger.info("Applying patch #{file}")
+        Dir.chdir(path) do
+          output = `#{git_command} apply #{file} 2>&1`
+        end
+        raise PatchError.new(output) unless $?.success?
+      end
+
+      # [Rugged::Diff] a rugged diff object
+      # Not fully tested
+      def apply_diff(diff)
+        diff.deltas.each do |d|
+          case d.status
+            when :deleted
+              remove_file(d.new_file[:path])
+              File.delete(File.join(path, path))
+            when :added, :modified
+              add_file(d.new_file[:path])
+            when :renamed
+              remove_file(d.old_file[:path])
+              File.delete(File.join(path, path))
+              add_file(d.new_file[:path])
+            else
+              logger.warn("File has a status of #{d.status}")
+          end
+        end
+      end
+
+      def up2date?(src_ref, dst_ref)
+        create_diff(src_ref, dst_ref).deltas.count < 1
+      end
+
+      # @return [String] the git command with
+      def git_command
+        @git_command ||= "git --work-tree=#{path} --git-dir=#{repo.path}"
       end
 
       # @param [String] file - the path to the file you want to remove
       def remove_file(file)
+        logger.debug("Removing file #{file}")
         index = repo.index
         File.unlink(file)
         index.remove(file)
-        index.write
       end
 
-      # # @param [String] message - the message you want in the commit
-      # def create_commit(message)
-      #   # get the index for this repository
-      #   logger.info repo.status { |file, status_data| puts "#{file} has status: #{status_data.inspect}" }
-      #
-      #   index = repo.index
-      #   index.read_tree repo.head.target.tree unless repo.empty?
-      #   require 'pry'; binding.pry
-      #   #repo.lookup
-      #   tree_new = index.write_tree repo
-      #   oid = Rugged::Commit.create(repo,
-      #                         author: author,
-      #                         message: message,
-      #                         committer: author,
-      #                         parents: repo.empty? ? [] : [repo.head.target].compact,
-      #                         tree: tree_new,
-      #                         update_ref: 'HEAD')
-      #   logger.info("Created commit #{oid} with #{message}")
-      #   index.write
-      #   #repo.status { |file, status_data| puts "#{file} has status: #{status_data.inspect}" }
-      #   oid
-      # end
+      def update_cli_index
+        `#{git_command} update-index --really-refresh`
+      end
 
       # @param [String] message - the message you want in the commit
-      # TODO: change this to rugged implementation
       def create_commit(message)
-        output = `git --work-tree=#{path} --git-dir=#{repo.path} commit --message '#{message}' 2>&1`
+        # get the index for this repository
+        repo.status { |file, status_data| logger.debug "#{file} has status: #{status_data.inspect}" }
+        index = repo.index
+        index.write
+        options = {}
+        options[:author] = author
+        options[:message] = message
+        options[:committer] = author
+        options[:parents] = repo.empty? ? [] : [repo.head.target_id].compact
+        options[:update_ref] = 'HEAD'
+        options[:tree] = index.write_tree
+        oid = Rugged::Commit.create(repo, options)
+        if oid
+          logger.info("Created commit #{message}")
+          repo.status { |file, status_data| logger.debug "#{file} has status: #{status_data.inspect}" }
+        else
+          logger.warn("Something went wrong with the commit")
+        end
+        update_cli_index # for some reason the command line doesn't refresh the index after committing.
+        oid
+      end
+
+      # @param [String] message - the message you want in the commit
+      # TODO: change this to rugged implementation
+      def cli_create_commit(message)
+        output = nil
+        Dir.chdir(path) do
+          output = `#{git_command} commit --message '#{message}' 2>&1`
+        end
         if $?.success?
           logger.info("Created commit #{message}")
         else
-          logger.error output
+          if output =~ /nothing\sto\scommit/
+            logger.info("Nothing to commit")
+          else
+            logger.error output
+          end
+          return false
         end
       end
 
-      # @return [String] the current branch name
-      def current_branch
-        repo.head.name.sub(/^refs\/heads\//, '')
+      # @param [String] branch_name - the branch name you want to update
+      # @param [String] target - the target branch you want to rebase against
+      # @param [String] remote - the remote name to rebase from, defaults to local
+      # TODO: change this to rugged implementation
+      def rebase_branch(branch_name, target, remote = nil)
+        src = [remote, target].compact.join('/') # produces upstream/master
+        Dir.chdir(path) do
+          checkout_branch(branch_name)
+          logger.info("Rebasing #{branch_name} with #{src}")
+          output = `#{git_command} rebase #{src} 2>&1`
+          raise GitError.new(output) unless $?.success?
+        end
       end
 
       def cherry_pick(commit)
@@ -258,6 +342,60 @@ module ReleaseManager
         logger.info("Cherry picking commit with id: #{commit}")
       end
 
+      # @param src [Rubbed::Object] - the rugged object to compare from
+      # @param dst [Rubbed::Object] - the rugged object to compare to
+      # @return [Array[String]] the changed files in the commit or all the commits in the diff between src and dst
+      def changed_files(src_ref, dst_ref)
+        src = repo.lookup(find_ref(src_ref))
+        src = src.kind_of?(Rugged::Tag::Annotation) ? src.target : src
+        dst = repo.lookup(find_ref(dst_ref))
+        dst.diff(src).deltas.map { |d| [d.old_file[:path], d.new_file[:path]] }.flatten.uniq
+      end
+
+      # @param oid [String] the oid of the file object
+      # @return [String] the contents of the file from the object
+      def get_content(oid)
+        return nil if oid =~ /0000000000000000000000000000000000000000/
+        obj = repo.read(oid)
+        obj.data
+      end
+
+      # @param src [Rugged::Object] - the rugged object or string to compare from
+      # @param dst [Rugged::Object] - the rugged object or string to compare to
+      # @return Array[Hash] the changed files in the commit or all the commits in the diff between src and dst
+      # with status, old_path, new_path, and content
+      # status can be one of: :added, :deleted, :modified, :renamed, :copied, :ignored, :untracked, :typechange
+      def create_diff_obj(src, dst)
+        diff = create_diff(src, dst)
+        diff.deltas.map do |d|
+          { old_path: d.old_file[:path], status: d.status,
+            new_path: d.new_file[:path], content: get_content(d.new_file[:oid])
+          }
+        end
+      end
+
+      # @param src_ref [Rugged::Object] - the rugged object or string to compare from
+      # @param dst_ref [Rugged::Object] - the rugged object or string to compare to
+      # @return [Rugged::Diff] a rugged diff object between src and dst
+      def create_diff(src_ref, dst_ref)
+        logger.debug("Creating a diff between #{dst_ref} and #{src_ref}")
+        src = repo.lookup(find_ref(src_ref))
+        src = src.kind_of?(Rugged::Tag::Annotation) ? src.target : src
+        dst = repo.lookup(find_ref(dst_ref))
+        dst = dst.kind_of?(Rugged::Tag::Annotation) ? dst.target : dst
+        dst.diff(src)
+      end
+
+      # @param sha_or_ref [String] - the name or sha of the ref
+      # @return [String] the oid of the sha or ref
+      def find_ref(sha_or_ref)
+        case sha_or_ref
+          when Rugged::Object
+            sha_or_ref.oid
+          else
+            repo.rev_parse_oid(sha_or_ref)
+        end
+      end
     end
   end
 end

data/lib/release_manager/module_deployer.rb

@@ -41,12 +41,16 @@ class ModuleDeployer
     @puppetfile ||= Puppetfile.new(puppetfile_path)
   end
 
+  def remote_deploy?
+    options[:remote]
+  end
+
   # @param [PuppetModule] puppet_module - the puppet module to check for existance
   # raises
   def add_module(puppet_module)
     unless puppetfile.mod_exists?(puppet_module.name)
-      answer = ask("The #{puppet_module.name} module does not exist, do you want to add it? (y/n): ", String) { |q| q =~ /y|n/i }.downcase
-      if answer == 'y'
+      answer = ask("The #{puppet_module.name} module does not exist, do you want to add it? (y/n): ", String) { |q| q =~ /y|n/i }.downcase unless options[:auto]
+      if answer == 'y' or options[:auto]
         puppetfile.add_module(puppet_module.name, git: puppet_module.repo, tag: "v#{puppet_module.version}") unless options[:dry_run]
       end
     end
@@ -56,22 +60,20 @@ class ModuleDeployer
     begin
       check_requirements
       logger.info "Deploying module #{puppet_module.name} with version: #{latest_version}"
+      add_module(puppet_module)
       if options[:dry_run]
-        add_module(puppet_module)
         puts "Would have updated module #{puppet_module.name} in Puppetfile to version: #{latest_version}".green
         puts "Would have committed with message: bump #{puppet_module.name} to version: #{latest_version}".green if options[:commit]
         puts "Would have just pushed branch: #{puppetfile.current_branch} to remote: #{control_repo_remote}".green if options[:push]
       else
-        add_module(puppet_module)
         puppetfile.write_version(puppet_module.name, latest_version)
         puppetfile.write_source(puppet_module.name, puppet_module.source)
         puppetfile.write_to_file
         logger.info "Updated module #{puppet_module.name} in Puppetfile to version: #{latest_version}"
         if options[:commit]
           puppetfile.commit("bump #{puppet_module.name} to version #{latest_version}")
-          logger.info "Commited with message: bump #{puppet_module.name} to version #{latest_version}"
         end
-        if options[:push]
+        if remote_deploy?
           puppetfile.push(control_repo_remote, puppetfile.current_branch)
           logger.info "Just pushed branch: #{puppetfile.current_branch} to remote: #{control_repo_remote}"
         end

data/lib/release_manager/puppet_module.rb

@@ -1,19 +1,20 @@
 require 'json'
 require 'release_manager/errors'
 require 'release_manager/workflow_action'
+require 'release_manager/vcs_manager'
 require 'release_manager/git/utilites'
 require 'rugged'
 
-
 class PuppetModule < WorkflowAction
  attr_reader :name, :metadata_file, :path, :version, :upstream
  attr_writer :version, :source
 
  include ReleaseManager::Git::Utilities
  include ReleaseManager::Logger
+ include ReleaseManager::VCSManager
 
  def initialize(mod_path, upstream = nil)
-   raise ModNotFoundException if mod_path.nil?
+   raise ModNotFoundException.new("#{mod_path} is not a valid puppet module path") if mod_path.nil?
    @path = mod_path
    @upstream = upstream 
    @metadata_file = File.join(mod_path, 'metadata.json')
@@ -40,21 +41,23 @@ class PuppetModule < WorkflowAction
  # @returns [Hash] the metadata object as a ruby hash
  def metadata
    unless @metadata
-     raise ModNotFoundException unless File.exists?(metadata_file) 
+     raise ModNotFoundException.new("#{path} does not contain a metadata file") unless File.exists?(metadata_file)
      @metadata ||= JSON.parse(File.read(metadata_file))
    end
    @metadata
  end
 
+ def already_latest?
+   return false unless latest_tag
+   up2date?(latest_tag, src_branch)
+ end
+
  def add_upstream_remote
-   if upstream != source
-     `#{git_command} remote rm upstream`
-   end
-   `#{git_command} remote add upstream #{source}`
+   add_remote(source,'upstream',true )
  end
 
  def git_upstream_url
-   `#{git_command} config --get remote.upstream.url`.chomp
+   repo.remotes['upstream'].url if remote_exists?('upstream')
  end
 
  def git_upstream_set?
@@ -62,7 +65,7 @@ class PuppetModule < WorkflowAction
  end
 
  def tags
-  `#{git_command} tag`.split("\n").map{|v| pad_version_string(v)}
+   repo.tags.map{|v| pad_version_string(v.name)}
  end
 
  def source=(s)
@@ -82,7 +85,6 @@ class PuppetModule < WorkflowAction
  end
 
  def latest_tag
-   Gem::Version.new('0.0.12') >= Gem::Version.new('0.0.2')
    v = tags.sort do |a,b|
     Gem::Version.new(a.tr('v', '')) <=> Gem::Version.new(b.tr('v', ''))
    end
@@ -103,10 +105,20 @@ class PuppetModule < WorkflowAction
    metadata['version']
  end
 
- def tag_module
-   `git --git-dir=#{path}/.git tag -m 'v#{version}' v#{version}`
+ # @param remote [Boolean] - create the tag remotely using the remote VCS
+ # @param id [String] - the commit id to tag to
+ def tag_module(remote = false, id = nil)
+   id ||= repo.head.target_id
+   if remote
+     # TODO add release_notes as the last argument, currently nil
+     # where we get the latest from the changelog
+     create_tag(source, "v#{version}", id, "v#{version}", nil)
+   else
+     create_local_tag("v#{version}", id)
+   end
  end
 
+ # Updates the version in memory
  def bump_patch_version
     return unless version
     pieces = version.split('.')
@@ -115,6 +127,7 @@ class PuppetModule < WorkflowAction
     metadata['version'] = pieces.join('.')
  end
 
+ # Updates the version in memory
  def bump_minor_version
     return unless version
     pieces = version.split('.')
@@ -124,6 +137,7 @@ class PuppetModule < WorkflowAction
     metadata['version'] = pieces.join('.')
  end
 
+ # Updates the version in memory
  def bump_major_version
     return unless version
     pieces = version.split('.')
@@ -139,16 +153,7 @@ class PuppetModule < WorkflowAction
  end
 
  def r10k_module?
-   name =~ /r10k_control/i
- end
-
- def branch_exists?(name)
-   `#{git_command} branch |grep '#{name}$'`
-   $?.success?
- end
-
- def git_command
-   @git_command ||= "git --work-tree=#{path} --git-dir=#{path}/.git"
+   mod_name =~ /r10k[-_]?control/i
  end
 
  def upstream
@@ -157,18 +162,11 @@ class PuppetModule < WorkflowAction
 
  # ensures the dev branch has been created and is up to date
  def create_dev_branch
-   `#{git_command} fetch upstream`
-   raise GitError unless $?.success?
-   #puts "#{git_command} checkout -b #{src_branch} upstream/#{src_branch}"
-  `#{git_command} checkout -b #{src_branch} upstream/#{src_branch}` unless branch_exists?(src_branch)
-   raise GitError unless $?.success?
+   fetch('upstream')
+   create_branch(src_branch, "upstream/#{src_branch}")
    # ensure we have updated our local branch
-   #puts "#{git_command} checkout #{src_branch}"
-  `#{git_command} checkout #{src_branch}`
-   raise GitError unless $?.success?
-   #puts "#{git_command} rebase upstream/#{src_branch}"
-  `#{git_command} rebase upstream/#{src_branch}`
-   raise GitError unless $?.success?
+   checkout_branch(src_branch)
+   rebase_branch(src_branch, src_branch, 'upstream')
  end
 
  # @returns [String] - the source branch to push to
@@ -183,17 +181,48 @@ class PuppetModule < WorkflowAction
  end
 
  # @return [String] the oid of the commit that was created
- def commit_metadata
-   to_metadata_file
-   add_file(metadata_file)
-   create_commit("[ReleaseManager] - bump version to #{version}")
+ # @param remote [Boolean] if true creates the commit on the remote repo
+ def commit_metadata(remote = false)
+   message = "[ReleaseManager] - bump version to #{version}"
+   if remote
+     actions = [{
+       action: 'update',
+       file_path: metadata_file.split(repo.workdir).last,
+       content: JSON.pretty_generate(metadata)
+     }]
+     obj = vcs_create_commit(source, src_branch, message, actions)
+     obj.id if obj
+   else
+     to_metadata_file
+     add_file(metadata_file)
+     create_commit(message)
+   end
  end
 
  # @return [String] the oid of the commit that was created
- def commit_metadata_source
-   to_metadata_file
-   add_file(metadata_file)
-   create_commit("[ReleaseManager] - change source to #{source}")
+ def commit_metadata_source(remote = false)
+   message = "[ReleaseManager] - change source to #{source}"
+   if remote
+     actions = [{
+       action: 'update',
+       file_path: metadata_file.split(repo.workdir).last,
+       content: JSON.pretty_generate(metadata)
+     }]
+     obj = vcs_create_commit(source, src_branch, message, actions)
+     obj.id if obj
+   else
+     to_metadata_file
+     add_file(metadata_file)
+     create_commit(message)
+   end
+ end
+
+ def tag_exists?(tag, remote = false)
+   if remote
+     remote_tag_exists?(source, tag)
+   else
+     latest_tag == tag
+   end
  end
 
  def to_metadata_file

data/lib/release_manager/puppetfile.rb

@@ -8,6 +8,12 @@ class Puppetfile
   attr_accessor :modules, :puppetfile, :data, :base_path, :puppetmodule
   BUMP_TYPES = %w{patch minor major}
 
+  include ReleaseManager::Git::Utilities
+  include ReleaseManager::Logger
+  include ReleaseManager::VCSManager
+
+  alias_method :path, :base_path
+
   # @param [String] puppetfile - the path to the puppetfile
   def initialize(puppetfile = 'Puppetfile')
     @puppetfile = puppetfile
@@ -22,17 +28,21 @@ class Puppetfile
     @base_path ||= File.dirname(puppetfile)
   end
 
-  def git_command
-    "git --work-tree=#{base_path} --git-dir=#{base_path}/.git"
-  end
-
-  def commit(message)
-    puts `#{git_command} add #{puppetfile}`
-    puts `#{git_command} commit -n -m "[ReleaseManager] - #{message}"`
-  end
-
-  def current_branch
-    `#{git_command} rev-parse --abbrev-ref HEAD`
+  def commit(message, remote = false)
+    message = "[ReleaseManager] - #{message}"
+    if remote
+      actions = [{
+         action: 'update',
+         file_path: puppetfile.split(repo.workdir).last,
+         content: to_s
+      }]
+      obj = vcs_create_commit(source, 'master', message, actions)
+      obj.id if obj
+    else
+      write_to_file
+      add_file(puppetfile)
+      create_commit(message)
+    end
   end
 
   def add_module(name, metadata)
@@ -40,8 +50,8 @@ class Puppetfile
   end
 
   def push(remote, branch, force = false)
-    opts = force ? '-f' : ''
-    `#{git_command} push #{remote} #{branch} #{opts}`
+    push_branch(remote, branch, force)
+    push_tags(remote)
   end
 
   def data