release_manager 0.3.0

data/lib/release_manager/logger.rb

@@ -0,0 +1,52 @@
+require 'logger'
+
+module ReleaseManager
+  module Logger
+    def logger
+      unless @logger
+        @logger = ::Logger.new(STDOUT)
+        @logger.level = log_level
+        @logger.progname = 'ReleaseManager'
+        @logger.formatter = proc do |severity, datetime, progname, msg|
+          "#{severity} - #{progname}: #{msg}\n".send(color(severity))
+        end
+      end
+      @logger
+    end
+
+    def color(severity)
+      case severity
+      when ::Logger::Severity::WARN, 'WARN'
+        :yellow
+      when ::Logger::Severity::INFO, 'INFO'
+        :green
+      when ::Logger::Severity::FATAL, 'FATAL'
+        :fatal
+      when ::Logger::Severity::ERROR, 'ERROR'
+        :fatal
+      when ::Logger::Severity::DEBUG, 'DEBUG'
+        :green
+      else
+        :green
+      end
+    end
+
+    def log_level
+      level = ENV['LOG_LEVEL'].downcase if ENV['LOG_LEVEL']
+      case level
+        when 'warn'
+          ::Logger::Severity::WARN
+        when 'fatal'
+          ::Logger::Severity::FATAL
+        when 'debug'
+          ::Logger::Severity::DEBUG
+        when 'info'
+          ::Logger::Severity::INFO
+        when 'error'
+          ::Logger::Severity::ERROR
+        else
+          ::Logger::Severity::INFO
+      end
+    end
+  end
+end

data/lib/release_manager/module_deployer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+require_relative 'puppetfile'
+require_relative 'puppet_module'
+class ModuleDeployer
+  attr_reader :options
+
+  def initialize(opts)
+    opts[:modulepath] = Dir.getwd if opts[:modulepath].nil? 
+    @options = opts
+  end
+  
+  def puppetfile_path
+    @puppetfile_path ||= options[:puppetfile] || ENV['PUPPET_FILE_PATH'] || File.expand_path("~/repos/r10k-control/Puppetfile")
+  end
+
+  def mod_path
+    @mod_path ||= options[:modulepath] || ENV['MOD_DIR'] || File.expand_path(Dir.getwd)
+  end
+
+  def puppet_module 
+    @puppet_module ||= PuppetModule.new(mod_path)
+  end
+
+  def latest_version
+    puppet_module.latest_tag
+  end
+
+  def check_requirements
+    raise PuppetfileNotFoundException unless File.exists?(puppetfile_path)
+    raise ModNotFoundException if !mod_path || ! File.exists?(mod_path)
+  end
+
+  def control_repo_remote
+    @control_repo_remote ||= options[:remote] || puppetfile.source
+  end
+  
+  def puppetfile
+    @puppetfile ||= Puppetfile.new(puppetfile_path)
+  end
+
+  def run
+    begin
+      check_requirements
+      puts "Found module #{puppet_module.name} with version: #{latest_version}".green
+      if options[:dry_run]
+        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
+        puts "Updated module #{puppet_module.name} in Puppetfile to version: #{latest_version}".green
+        puppetfile.write_version(puppet_module.name, latest_version)
+        puppetfile.write_source(puppet_module.name, puppet_module.source)
+        puppetfile.write_to_file
+        if options[:commit]
+          puppetfile.commit("bump #{puppet_module.name} to version #{latest_version}")
+          puts "Commited with message: bump #{puppet_module.name} to version #{latest_version}".green
+        end
+        if options[:push]
+          puppetfile.push(control_repo_remote, puppetfile.current_branch)
+          puts "Just pushed branch: #{puppetfile.current_branch} to remote: #{control_repo_remote}".green
+        end
+      end
+    rescue InvalidMetadataSource
+      puts "The puppet module's metadata.json source field must be a git url: ie. git@someserver.com:devops/module.git".red
+    rescue PuppetfileNotFoundException
+      puts "Cannot find the puppetfile at #{puppetfile_path}".red
+      exit -1
+    rescue InvalidModuleNameException => e
+      puts e.message
+      exit 1
+    rescue ModNotFoundException
+      puts "Invalid module path for #{mod_path}".red
+      puts "This means that the metadata.json name field does not match\nthe module name found in the Puppetfile or this is not a puppet module".fatal
+      exit -1
+    end
+  end
+end

data/lib/release_manager/puppet_module.rb

@@ -0,0 +1,211 @@
+require 'json'
+require 'release_manager/errors'
+require 'release_manager/workflow_action'
+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
+
+ def initialize(mod_path, upstream = nil)
+   raise ModNotFoundException if mod_path.nil?
+   @path = mod_path
+   @upstream = upstream 
+   @metadata_file = File.join(mod_path, 'metadata.json')
+ end
+
+ def repo
+   @repo ||= Rugged::Repository.new(path)
+ end
+
+ def self.check_requirements(path)
+   pm = new(path)
+   raise InvalidMetadataSource if pm.source !~ /\Agit\@/
+   raise UpstreamSourceMatch unless pm.git_upstream_set?
+ end
+
+ def name
+   namespaced_name.split(/\/|\-/).last
+ end
+ 
+ def namespaced_name 
+   metadata['name']
+ end
+
+ # @returns [Hash] the metadata object as a ruby hash
+ def metadata
+   unless @metadata
+     raise ModNotFoundException unless File.exists?(metadata_file) 
+     @metadata ||= JSON.parse(File.read(metadata_file))
+   end
+   @metadata
+ end
+
+ def add_upstream_remote
+   if upstream != source
+     `#{git_command} remote rm upstream`
+   end
+   `#{git_command} remote add upstream #{source}`
+ end
+
+ def git_upstream_url
+   `#{git_command} config --get remote.upstream.url`.chomp
+ end
+
+ def git_upstream_set?
+    source == git_upstream_url
+ end
+
+ def tags
+  `#{git_command} tag`.split("\n").map{|v| pad_version_string(v)}
+ end
+
+ def source=(s)
+   metadata['source'] = s
+ end
+
+ def source
+   metadata['source']
+ end
+
+ def pad_version_string(version_string)
+   parts = version_string.split('.').reject {|x| x == '*'}
+   while parts.length < 3
+     parts << '0'
+   end
+   parts.join '.'
+ 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
+   v.last
+ end
+
+ # @returns [String] the name of the module found in the metadata file
+ def mod_name
+   metadata['name']
+ end
+
+ def version=(v)
+   metadata['version'] = v
+ end
+
+ # @returns [String] the version found in the metadata file
+ def version
+   metadata['version']
+ end
+
+ def tag_module
+   `git --git-dir=#{path}/.git tag -m 'v#{version}' v#{version}`
+ end
+
+ def bump_patch_version
+    return unless version
+    pieces = version.split('.')
+    raise "invalid semver structure #{version}" if pieces.count != 3
+    pieces[2] = pieces[2].next
+    metadata['version'] = pieces.join('.')
+ end
+
+ def bump_minor_version
+    return unless version
+    pieces = version.split('.')
+    raise "invalid semver structure #{version}" if pieces.count != 3
+    pieces[2] = '0'
+    pieces[1] = pieces[1].next
+    metadata['version'] = pieces.join('.')
+ end
+
+ def bump_major_version
+    return unless version
+    pieces = version.split('.')
+    raise "invalid semver structure #{version}" if pieces.count != 3
+    pieces[2] = '0'
+    pieces[1] = '0'
+    pieces[0] = pieces[0].next
+    metadata['version'] = pieces.join('.')
+ end
+
+ def to_s
+   JSON.pretty_generate(metadata)
+ 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"
+ end
+
+ def upstream
+   @upstream ||= git_upstream_url
+ end
+
+ # 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?
+   # 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?
+ end
+
+ # @returns [String] - the source branch to push to
+ # if r10k-control this branch will be dev, otherwise master
+ def src_branch
+   r10k_module? ? 'dev' : 'master'
+ end
+
+ def push_to_upstream
+   push_branch(source, src_branch)
+   push_tags(source)
+ 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}")
+ 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}")
+ end
+
+ def to_metadata_file
+   logger.info("Writing to file #{metadata_file}")
+   File.write(metadata_file, to_s)
+ end
+
+ # @return [ControlRepo] - creates a new control repo object and clones the url unless already cloned
+ def self.create(path, url, branch = 'master')
+   c = PuppetModule.new(path, url)
+   c.clone(url, path)
+   c
+ end
+
+end

data/lib/release_manager/puppetfile.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+require_relative 'control_mod'
+require_relative 'errors'
+require 'json'
+require 'release_manager/puppet_module'
+
+class Puppetfile
+  attr_accessor :modules, :puppetfile, :data, :base_path, :puppetmodule
+  BUMP_TYPES = %w{patch minor major}
+
+  # @param [String] puppetfile - the path to the puppetfile
+  def initialize(puppetfile = 'Puppetfile')
+    @puppetfile = puppetfile
+    @puppetmodule = PuppetModule.new(base_path)
+  end
+
+  def source
+    puppetmodule.source
+  end
+
+  def base_path
+    @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`
+  end
+
+  def add_module(name, metadata)
+    modules[name] = ControlMod.new(name, metadata)
+  end
+
+  def push(remote, branch, force = false)
+    opts = force ? '-f' : ''
+    `#{git_command} push #{remote} #{branch} #{opts}`
+  end
+
+  def data
+    unless @data
+      @data = File.read(puppetfile)
+    end
+    @data
+  end
+
+  # @return [Array[ControlMod]] - a list of control mod objects
+  def modules
+    unless @modules
+      @modules = {}
+      instance_eval(data) if data
+    end
+    @modules
+  end
+
+  def self.from_string(s)
+    instance = new
+    instance.data = s
+    instance
+  end
+
+  # @param Array[String] names - find all mods with the following names
+  # @return Hash[String, ControlMod] - returns the pupppet modules in a hash
+  def find_mods(names)
+    mods = {}
+    return mods if names.nil?
+    names.each do | mod_name |
+      m = find_mod(mod_name)
+      mods[m.name] = m
+    end
+    mods
+  end
+
+  # @param [String] name - the name of the mod you wish to find in the puppetfile
+  # @return ControlMod - a ControlMod object
+  def find_mod(name)
+    mod_name = name.strip.downcase
+    mod = modules[mod_name] || modules.find{ |module_name, mod| mod.repo =~ /#{mod_name}/i }
+    raise InvalidModuleNameException.new("Invalid module name #{name}, cannot locate in Puppetfile") unless mod
+    # since find returns an array we need to grab the element ouf of the array first
+    return mod.last if mod.instance_of?(Array)
+    mod
+  end
+
+  def write_version(mod_name, version)
+    mod = find_mod(mod_name)
+    mod.pin_version(version)
+  end
+
+  # @param [String] mod_name - the module name found in the puppetfile
+  # @param [String] src - the git url to the source
+  # @option [String] branch - the branch name to pin to if provided
+  # @return [ControlMod]
+  def write_source(mod_name, src, branch = nil)
+    mod = find_mod(mod_name)
+    mod.pin_url(src)
+    mod.pin_branch(branch) if branch
+    mod
+  end
+
+  def bump(mod_name, type = 'patch')
+    raise "Invalid type, must be one of #{BUMP_TYPES}" unless BUMP_TYPES.include?(type)
+    mod = find_mod(mod_name)
+    find_mod(mod_name).send("bump_#{type}_version")
+  end
+
+  def to_json(pretty = false)
+    if pretty
+      JSON.pretty_generate(modules)
+    else
+      modules.to_json
+    end
+  end
+
+  def write_to_file
+    File.write(puppetfile, to_s)
+  end
+
+  def to_s
+    modules.collect {|n, mod| mod.to_s }.join("\n\n")
+  end
+
+  def self.to_puppetfile(json_data)
+    obj = JSON.parse(json_data)
+    mods = obj.collect do |name, metadata|
+      name = "mod '#{name}',"
+      data = metadata.sort.map { |k, v| ":#{k} => '#{v}'" }.join(",\n\  ")
+      "#{name}\n  #{data}\n"
+    end.join("\n")
+    mods
+  end
+
+  def mod(name, *args)
+    @modules[name] = ControlMod.new(name, args.flatten.first)
+  end
+
+  def forge(name, *args)
+    # skip this for now
+  end
+
+end