release_manager 0.4.0 → 0.5.0

data/lib/release_manager/r10k_deployer.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+require_relative 'puppetfile'
+require_relative 'puppet_module'
+require 'highline/import'
+require 'tempfile'
+
+class R10kDeployer
+  attr_reader :options, :path, :previous_branch
+
+  include ReleaseManager::Logger
+  include ReleaseManager::VCSManager
+  include ReleaseManager::Git::Utilities
+
+  def initialize(path, opts)
+    @path = path
+    @options = opts
+  end
+
+  def run
+    begin
+      @previous_branch = options[:src_ref]
+      mr, branch_name = create_mr(options[:src_ref], options[:dest_ref], options[:remote])
+    ensure
+      # cleanup branch, checkout previous branch
+    end
+    puts mr.web_url if mr
+  end
+
+  def cleanup(branch = nil)
+    control_repo.checkout_branch(previous_branch, strategy: :force)
+    control_repo.delete_branch(branch) if branch
+  end
+
+  alias_method :control_repo_path, :path
+
+  def self.run(path, options)
+    begin
+      deploy = new(path, options)
+      deploy.check_requirements
+      deploy.logger.info "Deploying R10k-Control #{options[:dest_ref]} with version: #{options[:src_ref]}"
+      deploy.run
+    rescue Gitlab::Error::Forbidden => e
+      logger.fatal(e.message)
+      logger.fatal("You don't have access to modify the repository")
+    rescue Gitlab::Error::MissingCredentials => e
+      deploy.logger.fatal(e.message)
+      code = 1
+    rescue PatchError => e
+      deploy.logger.fatal(e.message)
+      code = 1
+    rescue ModNotFoundException => e
+      deploy.logger.fatal(e.message)
+      code = 1
+    rescue InvalidBranchName => e
+      deploy.logger.fatal(e.message)
+      code = 1
+    rescue InvalidMetadataSource
+      deploy.logger.fatal "The puppet module's metadata.json source field must be a git url: ie. git@someserver.com:devops/module.git"
+      code = 1
+    rescue PuppetfileNotFoundException
+      deploy.logger.fatal "Cannot find the puppetfile at #{puppetfile_path}"
+      code = 1
+    rescue InvalidModuleNameException => e
+      deploy.logger.fatal e.message
+      code = 1
+    rescue Gitlab::Error::NotFound => e
+      deploy.logger.fatal e.message
+      deploy.logger.fatal "Either the project does not exist or you do not have enough permissions"
+      code = 1
+    rescue Exception => e
+      deploy.logger.fatal e.message
+      deploy.logger.fatal e.backtrace.join("\n")
+      code = 1
+    ensure
+      exit code.to_i
+    end
+  end
+
+  def control_repo
+    @control_repo ||= setup_control_repo(puppetfile.source)
+  end
+
+  def check_requirements
+    raise PuppetfileNotFoundException unless File.exists?(control_repo_path)
+  end
+
+  private
+
+  def create_mr(src_ref, dest_ref, remote = false)
+    url = puppetfile.source
+    message = "auto deploy #{src_ref} to #{dest_ref}"
+    branch_name = "#{dest_ref}_#{rand(10000)}"
+    control_repo.create_branch(branch_name, "upstream/#{dest_ref}")
+    control_repo.checkout_branch(branch_name, strategy: :force )
+    diff = control_repo.create_diff(src_ref,branch_name)
+    return control_repo.logger.info("nothing to commit or deploy") if diff.deltas.count < 1
+    Tempfile.open('git_patch') do |patchfile|
+      patchfile.write(diff.patch)
+      control_repo.apply_patch(patchfile.path)
+      control_repo.add_all
+    end
+    successful_commit = control_repo.commit(message, nil, nil, false)
+    control_repo.push_branch('myfork', branch_name, true) if successful_commit
+    mr = control_repo.create_merge_request(control_repo.url, message, {
+        source_branch: branch_name,
+        target_branch: dest_ref,
+        remove_source_branch: true,
+        target_project_url: url
+    })  if successful_commit
+    return [mr, branch_name]
+  end
+
+  # @return [ControlRepo] - creates a new control repo object and clones the url unless already cloned
+  # @param [String] url - the url to clone and fork
+  def setup_control_repo(url)
+    # clone r10k unless already cloned
+    fork = create_repo_fork(url)
+    c = ControlRepo.create(control_repo_path, fork.ssh_url_to_repo)
+    c.add_remote(fork.ssh_url_to_repo, 'myfork',true)
+    c.fetch('myfork')
+    c.fetch('origin')
+    c.add_remote(url, 'upstream', true)
+    c.fetch('upstream')
+    c
+  end
+
+  # @return [Puppetfile] - instance of Puppetfile object
+  def puppetfile
+    @puppetfile ||= begin
+      file = options[:puppetfile] || File.join(path, 'Puppetfile')
+      Puppetfile.new(file)
+    end
+  end
+
+end

data/lib/release_manager/release.rb

@@ -1,20 +1,3 @@
-#!/usr/bin/env ruby
-#
-# Author: Corey Osman
-# Purpose: release a new version of a module or r10k-control from the src branch by performing
-#          the following tasks:
-#           - bump version in metadata file
-#           - bump changelog version using version in metadata file
-#           - tag the code matching the version in the metadata file
-#           - push to upstream
-#  This script can be used on modules or r10k-control.  If using on a module
-#  be sure to pass in the repo path using --repo.  The repo is where this script
-#  pushes too. 
-#
-#  You should also use the -d feature which simulates a run of the script without doing
-#  anything harmful.
-#
-#  Run with -h to see the help
 require 'json'
 require_relative 'puppet_module'
 
@@ -37,15 +20,19 @@ class Release
 
   # @returns [String] the version found in the metadata file
   def version
-     dry_run? ? puppet_module.version.next : puppet_module.version
+     dry_run? ? next_version : puppet_module.version
   end
 
-  def tag 
+  def next_version
+    puppet_module.version.next
+  end
+
+  def tag(id)
     if dry_run?
       logger.info "Would have just tagged the module to #{version}"
       return
     end
-    puppet_module.tag_module 
+    puppet_module.tag_module(options[:remote], id)
   end
 
   def bump
@@ -53,18 +40,20 @@ class Release
       logger.info "Would have just bumped the version to #{version}"
       return
     end
-    puppet_module.bump_patch_version unless options[:bump]
+    raise TagExists.new("Tag v#{version} already exists") if puppet_module.tag_exists?("v#{next_version}", options[:remote])
+    version = puppet_module.bump_patch_version unless options[:bump]
     # save the update version to the metadata file, then commit
-    puppet_module.commit_metadata
+    puppet_module.commit_metadata(options[:remote])
   end
 
+  # @return [String] - sha of the commit
   def bump_log
     if dry_run?
       logger.info "Would have just bumped the CHANGELOG to version #{version}"
       return
     end
     log = Changelog.new(puppet_module.path, version, {:commit => true})
-    log.run
+    log.run(options[:remote], puppet_module.src_branch)
   end
 
   def push
@@ -84,22 +73,25 @@ class Release
   end
 
   def check_requirements
+    @loop_count = @loop_count.to_i + 1
     begin
       PuppetModule.check_requirements(puppet_module.path)
+      raise AlreadyReleased.new("No new changes, skipping release") if puppet_module.already_latest?
       Changelog.check_requirements(puppet_module.path)
     rescue NoUnreleasedLine
       logger.fatal "No Unreleased line in the CHANGELOG.md file, please add a Unreleased line and retry"
-      exit 1
+      return false
     rescue UpstreamSourceMatch
-      logger.fatal "The upstream remote url does not match the source url in the metadata.json source"
+      logger.warn "The upstream remote url does not match the source url in the metadata.json source"
       add_upstream_remote
-      exit 1
+      return false if @loop_count > 2
+      check_requirements
     rescue InvalidMetadataSource
       logger.fatal "The puppet module's metadata.json source field must be a git url: ie. git@someserver.com:devops/module.git"
-      exit 1
+      return false
     rescue NoChangeLogFile
       logger.fatal "CHANGELOG.md does not exist, please create one"
-      exit 1
+      return false
     end
   end
 
@@ -115,12 +107,12 @@ class Release
       end
     end
 
-    # updates the metadata.js file to the next version
+    # updates the metadata.json file to the next version
     bump
     # updates the changelog to the next version based on the metadata file
-    bump_log
+    id = bump_log
     # tags the r10k-module with the version found in the metadata.json file
-    tag
+    tag(id)
     # pushes the updated code and tags to the upstream repo
     if auto_release? 
      push
@@ -138,6 +130,10 @@ class Release
   end
 
   def add_upstream_remote
+    if auto_release?
+      puppet_module.add_upstream_remote
+      return
+    end
     answer = nil
     while answer !~ /y|n/
       print "Ok to change your upstream remote from #{puppet_module.upstream}\n to #{puppet_module.source}? (y/n): "
@@ -152,7 +148,7 @@ class Release
 
   def run
     begin
-      check_requirements
+      exit -1 unless check_requirements
       puppet_module.create_dev_branch
       value = release
       unless value
@@ -162,10 +158,21 @@ class Release
       logger.info "Version #{version} has been released successfully"
       puts "This was a dry run so nothing actually happen".green if dry_run?
       exit 0
-    rescue GitError
-      logger.fatal "There was an issue when running a git command"
+    rescue Gitlab::Error::Forbidden => e
+      logger.fatal(e.message)
+      logger.fatal("You don't have access to modify the repository")
+      exit -1
+    rescue TagExists => e
+      logger.fatal(e.message)
+      exit -1
+    rescue GitError => e
+      logger.fatal "There was an issue when running a git command\n #{e.message}"
     rescue InvalidMetadataSource
       logger.fatal "The puppet module's metadata.json source field must be a git url: ie. git@someserver.com:devops/module.git"
+      exit -1
+    rescue AlreadyReleased => e
+      logger.warn(e.message)
+      exit 0
     rescue ModNotFoundException
       logger.fatal "Invalid module path for #{path}"
       exit -1

data/lib/release_manager/remote_release.rb

@@ -0,0 +1,68 @@
+require 'json'
+require_relative 'puppet_module'
+
+class RemoteRelease < Release
+  attr_reader :path, :options
+  include ReleaseManager::Logger
+
+  # runs all the required steps to release the software
+  # currently this must be done manually by a release manager
+  #
+  def release
+    unless auto_release?
+      print "Have you merged your code?  Did you fetch and rebase against the upstream?  Want to continue (y/n)?: ".yellow
+      answer = gets.downcase.chomp
+      if answer == 'n'
+        return false
+      end
+      print "Ready to release version #{version.next} to #{puppet_module.source}\n and forever change history(y/n)?: ".yellow
+      answer = gets.downcase.chomp
+      if answer != 'y'
+        puts "Nah, forget it, this release wasn't that cool anyways.".yellow
+        return false
+      end
+    end
+    # updates the metadata.js file to the next version
+    bump
+    # updates the changelog to the next version based on the metadata file
+    id = bump_log
+    # tags the r10k-module with the version found in the metadata.json file
+    tag(id)
+  end
+
+  def run
+    begin
+      check_requirements
+      exit 1 unless release
+      logger.info "Releasing Version #{version} to #{puppet_module.source}"
+      logger.info "Version #{version} has been released successfully"
+      puts "This was a dry run so nothing actually happen".green if dry_run?
+      exit 0
+    rescue Gitlab::Error::NotFound => e
+      logger.fatal(e.message)
+      logger.fatal("This probably means the user attached to the token does not have access")
+      exit -1
+    rescue Gitlab::Error::MissingCredentials
+      logger.fatal(e.message)
+      exit -1
+    rescue Gitlab::Error::Forbidden => e
+      logger.fatal(e.message)
+      logger.fatal("You don't have access to modify the repository")
+      exit -1
+    rescue AlreadyReleased => e
+      logger.warn(e.message)
+      exit 0
+    rescue TagExists => e
+      logger.fatal(e.message)
+      exit -1
+    rescue GitError
+      logger.fatal "There was an issue when running a git command"
+    rescue InvalidMetadataSource
+      logger.fatal "The puppet module's metadata.json source field must be a git url: ie. git@someserver.com:devops/module.git"
+      exit -1
+    rescue ModNotFoundException
+      logger.fatal "Invalid module path for #{path}, is there a metadata.json file?"
+      exit -1
+    end
+  end
+end

data/lib/release_manager/sandbox.rb

@@ -5,19 +5,21 @@ require 'rugged'
 require 'fileutils'
 require 'release_manager/logger'
 require 'release_manager/vcs_manager'
+require 'forwardable'
 
 class Sandbox
   attr_reader :modules, :name, :repos_dir, :options,
-              :control_repo, :module_names, :control_repo_path, :vcs
+              :control_repo, :module_names, :control_repo_path
 
+  include ReleaseManager::VCSManager
   include ReleaseManager::Logger
+  include ReleaseManager::Git::Utilities
 
   def initialize(name, modules, control_repo_path, repos_dir = nil, options = {})
     @name = name
     @repos_dir = repos_dir
     @module_names = modules
     @control_repo_path = control_repo_path
-    @vcs = ReleaseManager::VCSManager.default_instance
     @options = options
   end
 
@@ -141,6 +143,9 @@ class Sandbox
       begin
         mod = puppetfile.find_mod(mod_name)
         setup_module_repo(mod)
+      rescue Rugged::CheckoutError => e
+        logger.fatal(e.message)
+        exit 1
       rescue InvalidModuleNameException => e
         logger.error(e.message)
         value = nil
@@ -157,23 +162,16 @@ class Sandbox
     @control_repo.checkout_branch(name)
     puppetfile.write_to_file
     logger.info("Committing Puppetfile changes to r10k-control branch: #{name}")
-    puppetfile.commit("Sandbox Creation for #{name} environment")
-    logger.info("Pushing new environment branch: #{name} to upstream")
-    puppetfile.push('upstream', name, true)
+    committed = puppetfile.commit("Sandbox Creation for #{name} environment")
+    # no need to push if we didn't commit anything
+    if committed
+      logger.info("Pushing new environment branch: #{name} to upstream")
+      puppetfile.push('upstream', name, true)
+    end
+    logger.info("Sandbox created successfully")
     return self
   end
 
-  # @param [String] url - a git url
-  # @return [String] a string representing the project id from gitlab
-  # gets the project id from gitlab using the remote API
-  def repo_id(url)
-    # ie. git@server:namespace/project.git
-    proj = url.match(/:(.*\/.*)\.git/)
-    raise RepoNotFound unless proj
-    # the gitlab api is supposed to encode the slash, but currently that doesn't seem to work
-    proj[1].gsub('/', '%2F')
-  end
-
   # TODO: extract this out to an adapter
   def verify_api_token
     begin
@@ -183,56 +181,6 @@ class Sandbox
     end
   end
 
-  # TODO: extract this out to an adapter
-  # replaces namespace from the url with the supplied or default namespace
-  def swap_namespace(url, namespace = nil)
-    url.gsub(/\:([\w-]+)\//, ":#{namespace || Gitlab.user.username}/")
-  end
-
-  # @return [Gitlab::ObjectifiedHash] Information about the forked project
-  # @param [ControlMod] the module you want to fork
-  # TODO: extract this out to an adapter
-  def create_repo_fork(url, namespace = nil )
-    new_url = swap_namespace(url, namespace)
-    repo = repo_exists?(new_url)
-    unless repo
-      upstream_repo_id = repo_id(url)
-      logger.info("Forking project from #{url} to #{new_url}")
-      repo = Gitlab.create_fork(upstream_repo_id)
-      # gitlab lies about having completed the forking process, so lets sleep until it is actually done
-      loop do
-        sleep(1)
-        break if repo_exists?(repo.ssh_url_to_repo)
-      end
-    end
-    vcs.add_permissions(repo.id, options[:default_members])
-    repo
-  end
-
-  # @param [String] url - the git url of the repository
-  # @return [Boolean] returns the project object (true) if found, false otherwise
-  # TODO: extract this out to an adapter
-  def repo_exists?(url)
-    upstream_repo_id = repo_id(url)
-    begin
-      Gitlab.project(upstream_repo_id)
-    rescue
-      false
-    end
-  end
-
-  # @return String - the branch name that was created
-  # TODO: extract this out to an adapter
-  def create_repo_branch(repo_id, branch_name)
-    Gitlab.repo_create_branch(repo_id, branch_name)
-  end
-
-  # TODO: extract this out to an adapter
-  def clone_repo(mod_name, url)
-    path = File.join(repos_dir, mod_name)
-    Rugged::Repository.clone_at(url, path, checkout_branch: name)
-  end
-
   # @returns [Hash[PuppetModules]] an hash of puppet modules
   def modules
     @modules ||= puppetfile.find_mods(module_names)
@@ -244,7 +192,7 @@ class Sandbox
 
   def check_requirements
     begin
-      vcs.add_ssh_key
+      add_ssh_key
     rescue InvalidModuleNameException => e
       logger.error(e.message)
       exit 1
@@ -268,5 +216,4 @@ class Sandbox
     box.verify_api_token
     box.create(options[:r10k_repo_url])
   end
-
 end