release_manager 0.3.0

data/lib/release_manager/control_mod.rb

@@ -0,0 +1,83 @@
+class ControlMod
+  attr_reader :name, :metadata, :repo
+  attr_accessor :version
+
+  def initialize(name, args)
+    @name = name
+    @metadata = args.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+  end
+
+  def repo
+    git_url
+  end
+
+  def git_url
+    metadata[:git]
+  end
+
+  def branch
+    metadata[:branch]
+  end
+
+  def to_json(state = nil)
+    metadata.to_json(state)
+  end
+
+  def to_s
+    name_line = "mod '#{name}',"
+    data = metadata.map { |k, v| ":#{k} => '#{v}'" }.join(",\n\  ")
+    "#{name_line}\n  #{data}"
+  end
+
+  def bump_patch_version
+    return unless metadata[:tag]
+    pieces = metadata[:tag].split('.')
+    raise "invalid semver structure #{metadata[:tag]}" if pieces.count != 3
+    pieces[2] = pieces[2].next
+    pin_version(pieces.join('.'))
+  end
+
+  def bump_minor_version
+    return unless metadata[:tag]
+    pieces = metadata[:tag].split('.')
+    raise "invalid semver structure #{metadata[:tag]}" if pieces.count != 3
+    pieces[2] = '0'
+    pieces[1] = pieces[1].next
+    pin_version(pieces.join('.'))
+  end
+
+  def bump_major_version
+    return unless metadata[:tag]
+    pieces = metadata[:tag].split('.')
+    raise "invalid semver structure #{metadata[:tag]}" if pieces.count != 3
+    pieces[2] = '0'
+    pieces[1] = '0'
+    pieces[0] = pieces[0].next
+    pin_version(pieces.join('.'))
+  end
+
+  def version
+    metadata[:tag]
+  end
+
+  def version=(v)
+    metadata[:tag] = v
+  end
+
+  def pin_version(v)
+    metadata.delete(:ref)
+    metadata.delete(:branch)
+    metadata[:tag] = v
+  end
+
+  def pin_branch(name)
+    metadata[:branch] = name
+    metadata.delete(:ref)
+    metadata.delete(:tag)
+  end
+
+  def pin_url(src)
+    metadata[:git] = src
+  end
+
+end

data/lib/release_manager/control_repo.rb

@@ -0,0 +1,35 @@
+require 'release_manager/puppetfile'
+require 'rugged'
+require 'release_manager/git/utilites'
+
+class ControlRepo
+  attr_accessor :path, :repo, :url
+
+  include ReleaseManager::Git::Utilities
+  include ReleaseManager::Logger
+
+  def initialize(path, url = nil)
+    @path = path
+    @url = url
+  end
+
+  # @return [ControlRepo] - creates a new control repo object and clones the url unless already cloned
+  def self.create(path, url)
+    c = ControlRepo.new(path, url)
+    c.clone(url, path)
+    c
+  end
+
+  def repo
+    @repo ||= ::Rugged::Repository.new(path)
+  end
+
+  def puppetfile
+    unless @puppetfile
+      @puppetfile = Puppetfile.new(File.join(path, 'Puppetfile'))
+      @puppetfile.base_path = path
+    end
+    @puppetfile
+  end
+
+end

data/lib/release_manager/errors.rb

@@ -0,0 +1,13 @@
+class ModNotFoundException < Exception; end
+class InvalidModuleNameException < Exception; end
+class PuppetfileNotFoundException < Exception; end
+class InvalidPuppetfileException < Exception; end
+class InvalidMetadataSource < Exception; end
+class NoUnreleasedLine < Exception; end
+class NoChangeLogFile < Exception; end
+class UpstreamSourceMatch < Exception; end
+class GitError < Exception; end
+class RepoNotFound < Exception; end
+class InvalidModule < Exception; end
+class InvalidToken < Exception; end
+class InvalidSshkey < Exception; end

data/lib/release_manager/git/credentials.rb

@@ -0,0 +1,98 @@
+require 'rugged'
+require 'release_manager/logger'
+require 'io/console'
+# Generate credentials for secured remote connections.
+module ReleaseManager
+  module Git
+    class Credentials
+      include ReleaseManager::Logger
+
+      # @param repository [Rugged::BaseRepository]
+      def initialize(repository = nil)
+        @repository = repository
+        @called = 0
+      end
+
+      def needs_auth?(url)
+        url =~ /\Agit@/
+      end
+
+      def call(url, username_from_url = 'git', allowed_types = [:ssh_key])
+        @called += 1
+        # Break out of infinite HTTP auth retry loop introduced in libgit2/rugged 0.24.0, libssh
+        # auth seems to already abort after ~50 attempts.
+        if @called > 50
+          raise Exception.new("Authentication failed for Git remote %{url}.") % {url: url.inspect}
+        end
+        if allowed_types.include?(:ssh_key)
+          # should also check to see if process is still alive
+          begin
+            if ENV['SSH_AUTH_SOCK'] or (ENV['SSH_AGENT_PID'] and Process.getpgid( ENV['SSH_AGENT_PID'].to_i ))
+              ssh_agent_credentials
+            else
+              logger.warn("Could not find ssh-agent running, falling back to ssh key")
+              ssh_key_credentials
+            end
+          rescue Errno::ESRCH
+            ssh_key_credentials
+          end
+        else
+          default_credentials
+        end
+      end
+
+      def prompt_for_password
+        print "Enter password for #{global_private_key}: "
+        STDIN.noecho(&:gets).chomp
+      end
+
+      # this assumes the user has the private key in their home folder
+      # we should be smarter about getting this, maybe consulting ssh
+      # directory to find out which key is for the host if using an ssh config file
+      # additionally if the key is password protected how do we prompt for the password?
+      def global_private_key
+        unless @global_private_key
+          @global_private_key = ENV['SSH_PRIVATE_KEY'] || File.expand_path(File.join(ENV['HOME'], '.ssh', 'id_rsa'))
+          logger.info("Using ssh private key #{@global_private_key}")
+        end
+        @global_private_key
+      end
+
+      def global_public_key
+        unless @global_public_key
+          @global_public_key = ENV['SSH_PUBLIC_KEY'] || File.expand_path(File.join(ENV['HOME'], '.ssh', 'id_rsa.pub'))
+          logger.info("Using ssh public key #{@global_public_key}")
+        end
+        @global_public_key
+      end
+
+      # SSH_AGENT_SOCK  must be set
+      def ssh_agent_credentials
+        Rugged::Credentials::SshKeyFromAgent.new(username: git_username)
+      end
+
+      # this method does currently now work
+      def ssh_key_credentials(url = nil)
+        logger.error("Must use ssh-agent, please run ssh-agent zsh, then ssh-add to load your ssh key")
+        exit 1
+        unless File.readable?(global_private_key)
+          raise Exception.new("Unable to use SSH key auth for %{url}: private key %{private_key} is missing or unreadable" % {url: url.inspect, private_key: global_private_key.inspect} )
+        end
+        Rugged::Credentials::SshKey.new(:username => git_username,
+                                        :privatekey => global_private_key,
+                                        :publickey => global_public_key,
+                                        :passphrase => prompt_for_password)
+      end
+
+      def default_credentials
+        Rugged::Credentials::Default.new
+      end
+
+      def git_username
+        'git'
+      end
+
+    end
+  end
+end
+

data/lib/release_manager/git/utilites.rb

@@ -0,0 +1,263 @@
+require 'release_manager/git/credentials'
+require 'uri'
+
+module ReleaseManager
+  module Git
+    module Utilities
+
+      def repo
+        @repo ||= Rugged::Repository.new(path)
+      end
+
+      # @param [String] remote_name - the name of the remote
+      def fetch(remote_name = 'upstream')
+        return unless remote_exists?(remote_name)
+        remote = repo.remotes[remote_name]
+        logger.info("Fetching remote #{remote_name} from #{remote.url}")
+        remote.fetch({
+                         #progress: lambda { |output| puts output },
+                         credentials: credentials.call(remote.url)
+                     })
+      end
+
+      def transports
+        [:ssh, :https].each do |transport|
+          unless ::Rugged.features.include?(transport)
+            logger.warn("Rugged has been compiled without support for %{transport}; Git repositories will not be reachable via %{transport}.  Try installing libssh-devel") % {transport: transport}
+          end
+        end
+      end
+
+      def credentials
+        @credentials ||= ReleaseManager::Git::Credentials.new(nil)
+      end
+
+      # @param [String] branch - the name of the branch you want checked out when cloning
+      # @param [String] url - the url to clone
+      # @return [Rugged::Repository] - the clond repository
+      # Clones the url
+      # if the clone path already exists, nothing is done
+      def clone(url, path)
+        if File.exists?(File.join(path, '.git'))
+          add_remote(url, 'upstream')
+          fetch('upstream')
+          repo
+        else
+          logger.info("Cloning repo with url: #{url} to #{path}")
+          r = Rugged::Repository.clone_at(url, path, {
+              #progress: lambda { |output| puts output },
+              credentials: credentials.call(url)
+          })
+          r
+        end
+      end
+
+      # @param [String] url - the url of the remote
+      # @param [String] remote_name - the name of the remote
+      # @param [Boolean] reset_url - set to true if you wish to reset the remote url
+      # @return [Rugged::Remote] a rugged remote object
+      def add_remote(url, remote_name = 'upstream', reset_url = false )
+        return unless git_url?(url)
+        if remote_exists?(remote_name)
+          # ensure the correct url is set
+          # this sets a non persistant fetch url
+          unless remote_url_matches?(remote_name, url)
+            if reset_url
+              logger.info("Resetting #{remote_name} remote to #{url} for #{path}")
+              repo.remotes.set_url(remote_name,url)
+              repo.remotes[remote_name]
+            end
+          end
+        else
+          logger.info("Adding #{remote_name} remote to #{url} for #{path}")
+          repo.remotes.create(remote_name, url)
+        end
+      end
+
+      # @param [String] name - the name of the remote
+      # @return [Boolean] - return true if the remote name and url are defined in the git repo
+      def remote_exists?(name)
+        repo.remotes[name]
+      end
+
+      # @param [String] name - the name of the remote
+      # @param [String] url - the url of the remote
+      # @return [Boolean] - true if the url matches a remote url already defined
+      def remote_url_matches?(name, url)
+        repo.remotes[name].url.eql?(url)
+      end
+
+      # @param [String] name - the name of the branch
+      # @return [Boolean] - true if the branch exist
+      def branch_exist?(name)
+        repo.branches.exist?(name)
+      end
+
+      # we should be creating the branch from upstream
+      # @return [Rugged::Branch]
+      def create_branch(name, target = 'upstream/master')
+        # fetch the remote if defined in the target
+        unless branch_exist?(name)
+          fetch(target.split('/').first) if target.include?('/')
+          logger.info("Creating branch: #{name} for #{path}")
+          repo.create_branch(name, target)
+        else
+          repo.branches[name]
+        end
+      end
+
+      # deletes the branch with the given name
+      # @param [String] name - the name of the branch to delete
+      def delete_branch(name)
+        repo.branches.delete(name)
+      end
+
+      # @param [String] remote_name - the remote name to push the branch to
+      def push_branch(remote_name, branch)
+        remote = find_or_create_remote(remote_name)
+        refs = [repo.branches[branch].canonical_name]
+        logger.info("Pushing branch #{branch} to remote #{remote.url}")
+        remote.push(refs, credentials: credentials)
+      end
+
+      # push all the tags to the remote
+      # @param [String] remote_name - the remote name to push tags to
+      def push_tags(remote_name)
+        remote = find_or_create_remote(remote_name)
+        refs = repo.tags.map(&:canonical_name)
+        logger.info("Pushing tags to remote #{remote.url}")
+        remote.push(refs, credentials: credentials)
+      end
+
+      # @return [String] the name of the current branch
+      def current_branch
+        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)
+        else
+          # already checked out
+          logger.debug("Currently on branch #{name} for #{path}")
+          repo.branches[name]
+        end
+      end
+
+      # @param [String] remote_name - the remote name
+      # @return [Rugged::Remote] the remote object
+      # find the remote or create a new remote with the name as source
+      def find_or_create_remote(remote_name)
+        remote_from_name(remote_name) ||
+            remote_from_url(remote_name) ||
+            add_remote(remote_name, 'source', true)
+      end
+
+      # @param [String] name - the remote name to push the branch to
+      # @return [Rugged::Remote] the remote object if found
+      # Given the url find the remote with that url
+      def remote_from_name(name)
+        repo.remotes.find { |r| r.name.eql?(name) } unless git_url?(name)
+      end
+
+      # @param [String] url - the remote url to push the branch to
+      # @return [Rugged::Remote] the remote object if found
+      # Given the url find the remote with that url
+      def remote_from_url(url)
+        repo.remotes.find { |r| r.url.eql?(url) } if git_url?(url)
+      end
+
+      # @param [String] name - the remote name or url to check
+      # @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)
+      end
+
+      # @return [String] - the author name found in the config
+      def author_name
+        repo.config.get('user.name') || Rugged::Config.global.get('user.name')
+      end
+
+      # @return [String] - the author email found in the config
+      def author_email
+        repo.config.get('user.email') || Rugged::Config.global.get('user.email')
+      end
+
+      # @return [Hash] the author information used in a commit message
+      def author
+        {: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 [String] file - the path to the file you want to add
+      def add_file(file)
+        # TODO: change this to rugged implementation
+      `git --work-tree=#{path} --git-dir=#{repo.path} add #{file}`
+      end
+
+      # @param [String] file - the path to the file you want to remove
+      def remove_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
+
+      # @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`
+        if $?.success?
+          logger.info("Created commit #{message}")
+        else
+          logger.error output
+        end
+      end
+
+      # @return [String] the current branch name
+      def current_branch
+        repo.head.name.sub(/^refs\/heads\//, '')
+      end
+
+      def cherry_pick(commit)
+        return unless commit
+        repo.cherrypick(commit)
+        logger.info("Cherry picking commit with id: #{commit}")
+      end
+
+    end
+  end
+end