release_manager 0.3.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/app_startup_script.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+bundle install
+ssh-add

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "release_manager"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docker-compose.yml

@@ -0,0 +1,37 @@
+version: '2'
+services:
+  app:
+    image: nwops/release_manager
+    build: .
+    entrypoint:
+      - ssh-agent
+      - /bin/bash
+    environment:
+      GEM_HOME: '/home/appuser/.gems'
+      BUNDLE_PATH: '/home/appuser/.bundle'
+      GITLAB_API_ENDPOINT: 'http://web/api/v3'
+      # the token may change so this really needs to be more dynamic
+      GITLAB_API_PRIVATE_TOKEN: 'A_zJJfgE8P-8mFGK2_r9'
+      R10K_REPO_URL: "git@web:devops/control-repo.git"
+    working_dir: /app
+#    command:
+#      - app_startup_script.sh
+    volumes:
+      - .:/app
+
+  web:
+    image: 'gitlab/gitlab-ce:latest'
+    restart: always
+    environment:
+      GITLAB_OMNIBUS_CONFIG: |
+        external_url 'http://web'
+    ports:
+      - '8000:80'
+      - '4433:443'
+      - '2201:22'
+    volumes:
+      - './srv/gitlab/config:/etc/gitlab'
+      - './srv/gitlab/logs:/var/log/gitlab'
+      - './srv/gitlab/data:/var/opt/gitlab'
+
+# setup ssh key in gitlab

data/exe/bump-changelog

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'release_manager'
+
+Changelog.run

data/exe/deploy-mod

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'release_manager'
+require 'release_manager/cli/deploy_mod_cli'
+
+ReleaseManager::DeployModCli.run

data/exe/release-mod

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'release_manager'
+require 'release_manager/cli/release_mod_cli'
+
+ReleaseManager::ReleaseModCli.run

data/exe/sandbox-create

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'release_manager'
+require 'release_manager/cli/sandbox_create_cli'
+
+# we also need to allow the user to list all the modules the sandbox currently controls
+# in addition to allowing the user to update the list of modules
+# sandbox-deploy
+# sandbox-show or sandbox-list
+# sandbox-update
+# sandbox-create
+#ENV['R10K_CONTROL_URL']
+ReleaseManager::SandboxCreateCli.run

data/lib/release_manager.rb

@@ -0,0 +1,33 @@
+require "release_manager/version"
+require "release_manager/module_deployer"
+require "release_manager/release"
+require "release_manager/changelog"
+require 'release_manager/logger'
+require 'release_manager/workflow_action'
+require 'release_manager/sandbox'
+
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def fatal
+    red
+  end
+
+  def yellow
+    colorize(33)
+  end
+end
+module ReleaseManager
+
+end
+

data/lib/release_manager/changelog.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+#
+#
+#Author: Corey Osman
+#Purpose: updates the changelog.md file with the new version by reading the metadata.json file
+#Usage: ./bump_log.rb [CHANGELOG.md]
+#
+require 'json'
+require 'optparse'
+require_relative 'puppet_module'
+require 'release_manager/workflow_action'
+
+class Changelog < WorkflowAction
+  attr_reader :root_dir, :version, :options
+
+  include ReleaseManager::Git::Utilities
+  include ReleaseManager::Logger
+
+  def initialize(module_path, version, options = {})
+    @options = options
+    @root_dir = module_path
+    @version = version
+  end
+
+  def create_changelog_file
+    return if File.exists?(changelog_file)
+    contents = "# Module Name\n\n## Unreleased\n"
+    File.write(changelog_file, contents)
+    logger.info("Creating initial changelog file")
+    commit_changelog("[ReleaseManager] - create empty changelog")
+  end
+
+  def path
+    @root_dir
+  end
+
+  def run
+    create_changelog_file
+    # write the new changelog unless it does not need updating
+    if already_released? 
+      logger.fatal "Version #{version} had already been released, did you bump the version manually?"
+      exit 1
+    else
+      File.write(changelog_file, new_content)
+      commit_changelog if options[:commit]
+      logger.info "The changelog has been updated to version #{version}"
+    end
+  end
+
+  def self.run
+    options = {}
+    OptionParser.new do |opts|
+      opts.program_name = 'bump_changelog'
+      opts.version = ReleaseManager::VERSION
+      opts.on_head(<<-EOF
+
+Summary: updates the changelog.md file with the new
+         version by reading the metadata.json file
+
+EOF
+)
+      opts.on("-c", "--[no-]commit", "Commit the updated changelog") do |c|
+	options[:commit] = c
+      end
+      opts.on("-f", "--changelog FILE", "Path to the changelog file") do |c|
+	options[:file] = c
+      end
+    end.parse!
+    unless options[:file]
+      puts "Must supply --changelog FILE"
+      exit 1
+    end
+    module_path = File.dirname(options[:file])
+    puppet_module = PuppetModule.new(module_path)   
+    log = Changelog.new(module_path, puppet_module.version, options)
+    log.run
+  end
+
+  # @returns [String] the full path to the change log file
+  def changelog_file
+    options[:file] || File.join(root_dir, 'CHANGELOG.md')
+  end
+
+  # @returns [Array[String]]
+  def changelog_lines
+    @changelog_lines ||= File.readlines(changelog_file)
+  end
+
+  # @returns [Integer] line number of where the word unreleased is located
+  def unreleased_index
+    begin
+      linenum = changelog_lines.each_index.find {|index| changelog_lines[index] =~ /\A\s*\#{2}\s*Unreleased/i }
+    rescue ArgumentError => e
+      logger.fatal "Error with CHANGELOG.md #{e.message}"
+      exit 1
+    end
+    raise NoUnreleasedLine unless linenum
+    linenum
+  end
+
+  # @returns [Boolean]  returns true if the Changelog has already released this version
+  def already_released?
+    !!changelog_lines.each_index.find {|index| changelog_lines[index] =~ /\A\s*\#{2}\s*Version #{version}/i }
+  end
+
+  # @returns [Array[String]] - inserts the version header in the change log and returns the entire array of lines
+  def update_unreleased
+    time = Time.now.strftime("%B %d, %Y")
+    changelog_lines.insert(unreleased_index + 1, "\n## Version #{version}\nReleased: #{time}\n")
+  end
+
+  # @returns [String] the string representation of the update Changelog file
+  def new_content
+    update_unreleased.join
+  end
+
+  # @return [String] the oid of the commit that was created
+  def commit_changelog(msg = nil)
+    add_file(changelog_file)
+    message = msg || "[ReleaseManager] - bump changelog to version #{version}"
+    create_commit(message)
+  end
+
+  # checks to make sure the unreleased line is valid, and the file exists
+  def self.check_requirements(path)
+    log = new(path, nil)
+    log.unreleased_index if File.exists?(log.changelog_file)
+  end
+end
+

data/lib/release_manager/cli/deploy_mod_cli.rb

@@ -0,0 +1,44 @@
+require 'release_manager/module_deployer'
+require 'optparse'
+require 'release_manager/version'
+module ReleaseManager
+  class DeployModCli
+    def self.run
+      options = {}
+      OptionParser.new do |opts|
+        opts.program_name = 'deploy-mod'
+        opts.version = ReleaseManager::VERSION
+        opts.on_head(<<-EOF
+    
+    Summary: Gets the version of your module found in the metadata
+             and populates the r10k-control Puppetfile with the updated
+             tag version. Revmoes any branch or ref reference and replaces
+             with tag.  Currently it is up to you to commit and push the Puppetfile change.
+
+        EOF
+        )
+        opts.on('-p', "--puppetfile [PUPPETFILE]", 'Path to R10k Puppetfile, defaults to ~/repos/r10k-control/Puppetfile') do |p|
+          options[:puppetfile] = p
+        end
+        opts.on('-m', '--modulepath [MODULEPATH]', "Path to to module, defaults to: #{Dir.getwd}") do |p|
+          options[:modulepath] = p
+        end
+        opts.on('-c', '--commit', 'Optionally, Commit the Puppetfile change') do |p|
+          options[:commit] = p
+        end
+        # removing this option as it seems a little dangerous for now
+        # opts.on('-u', '--push', 'Optionally, Push the changes to the remote') do |p|
+        #   options[:push] = p
+        # end
+        # opts.on('-r', '--remote REMOTE', 'Optionally, specify a remote name or url to push changes to') do |p|
+        #   options[:remote] = p
+        # end
+        opts.on('-d', 'Perform a dry run without making changes') do |p|
+          options[:dry_run] = p
+        end
+      end.parse!
+      m = ModuleDeployer.new(options)
+      m.run
+    end
+  end
+end

data/lib/release_manager/cli/release_mod_cli.rb

@@ -0,0 +1,43 @@
+require 'release_manager/release'
+require 'optparse'
+require 'release_manager/version'
+module ReleaseManager
+  class ReleaseModCli
+    def self.run
+      options = {}
+      OptionParser.new do |opts|
+        opts.program_name = 'release-mod'
+        opts.version = ReleaseManager::VERSION
+        opts.on_head(<<-EOF
+
+Summary: Bumps the module version to the next revision and 
+         updates the changelog.md file with the new
+         version by reading the metadata.json file. This should
+         be run inside a module directory. 
+
+        EOF
+        )
+        opts.on("-d", "--dry-run", "Do a dry run, without making changes") do |c|
+          options[:dry_run] = c
+        end
+        opts.on('-a', '--auto', 'Run this script without interaction') do |c|
+          options[:auto] = c
+        end
+        opts.on('-m', '--module-path [MODULEPATH]', "The path to the module, defaults to #{Dir.getwd}") do |c|
+          options[:path] = c
+        end
+        opts.on('-b', '--no-bump', "Do not bump the version in metadata.json") do |c|
+          options[:bump] = c
+        end
+        opts.on('-r', '--repo [REPO]', "The repo to use, defaults to repo found in the metadata source") do |c|
+          options[:repo] = c
+        end
+        opts.on('--verbose', "Extra logging") do |c|
+          options[:verbose] = c
+        end
+      end.parse!
+      r = Release.new(options[:path], options)
+      r.run
+    end
+  end
+end

data/lib/release_manager/cli/sandbox_create_cli.rb

@@ -0,0 +1,138 @@
+require 'release_manager/sandbox'
+module ReleaseManager
+  class SandboxCreateCli
+
+    def self.gitlab_server
+      if ENV['GITLAB_API_ENDPOINT']
+        if data = ENV['GITLAB_API_ENDPOINT'].match(/(https?\:\/\/[\w\.]+)/)
+          return data[1]
+        end
+      end
+      'https://gitlab.com'
+    end
+
+    def self.run
+      options = {}
+      OptionParser.new do |opts|
+        opts.program_name = 'sandbox-create'
+        opts.version = ReleaseManager::VERSION
+        opts.on_head(<<-EOF
+
+Summary: Creates a new r10k sandbox by forking and creating a new branch on r10k-control,
+         creates a fork and branch for each module passed in, adds the upstream remote
+         for each module, updates the r10k-control Puppetfile to use those forks and branches
+         and pushes the branch to the upstream r10k-control.
+
+
+Note: If you already have any of these modules cloned, this script will attempt to update those modules
+      using git fetch and git checkout -b sandbox_name upstream/master.  So this should not destroy anything.
+
+Configuration:
+
+This script uses the following environment variables to automatically set some options, please ensure 
+they exist in your shell environment.  You can set an environment variable in the shell or define 
+in your shell startup files.
+
+Shell:  export VARIABLE_NAME=value
+
+R10K_REPO_URL            - The git repo url to r10k-control (ie. git@gitlab.com:devops/r10k-control.git)
+GITLAB_API_ENDPOINT      - The api path to the gitlab server  (ie. https://gitlab_server/api/v3)
+                           replace gitlab_server with your server hostname
+GITLAB_API_PRIVATE_TOKEN - The gitlab user api token.  
+                           You can get a token here (#{gitlab_server}/profile/personal_access_tokens, 
+                           Ensure api box is checked.
+DEFAULT_MODULES          - The default set of modules to fork use when 
+                           a sandbox (ie. export DEFAULT_MODULES='hieradata, roles')
+
+DEFAULT_MEMBERS          - The default members each forked project should add permissions
+                           to ( ie, DEFAULT_MEMBERS='ci_runner,r10k_user' )
+
+If your gitlab server has a invalid certificate you can set the following variable to "fix" that trust issue.
+export GITLAB_API_HTTPARTY_OPTIONS="{verify: false}"
+
+Examples:
+  #{opts.program_name} -n my_sandbox -m "roles,profiles,developer" 
+  #{opts.program_name} -n my_sandbox -m "roles,profiles,developer" --members="p1dksk2,devops,ci_runner"
+
+Options:
+        EOF
+        )
+        opts.on('--members DEFAULT_MEMBERS', "A comman seperated list of members to add to forked projects") do |m|
+          options[:default_members] = m.split(',').map(&:strip)
+        end
+        opts.on('-n', "--name NAME", "The name of your sandbox") do |n|
+          options[:sandbox_name] = n
+        end
+        opts.on('--control-url R10K_REPO_URL', "git url to the r10k-control repo, defaults to R10K_CONTROL_URL env variable") do |r|
+          options[:r10k_repo_url] = r
+        end
+        opts.on('-m', '--modules MODULES', "A comma separated list of modules names from the Puppetfile to fork and branch") do |c|
+          options[:modules] = c.split(',').map(&:strip)
+        end
+        opts.on('-r', '--repos-dir [REPOS_PATH]', "The repos path to clone modules to. " +
+            "Defaults to: #{File.expand_path(File.join(ENV['HOME'], 'repos'))}") do |c|
+          options[:repos_path] = c
+        end
+        opts.on('-c', '--control-dir [CONTROL_DIR]', "The r10k-control repo path. " +
+            "Defaults to: #{File.expand_path(File.join(ENV['HOME'], 'repos', 'r10k-control'))}") do |c|
+          options[:r10k_repo_path] = c
+        end
+        opts.on('--verbose', "Extra logging") do |c|
+          options[:verbose] = c
+        end
+      end.parse!
+      unless ENV['GITLAB_API_ENDPOINT']
+        puts "Please set the GITLAB_API_ENDPOINT environment variable".fatal
+        puts "Example: export GITLAB_API_ENDPOINT=https://gitlab.com/api/v3".fatal
+        exit 1
+      end
+
+      unless ENV['GITLAB_API_PRIVATE_TOKEN']
+        puts "Please set the GITLAB_API_PRIVATE_TOKEN environment variable".fatal
+        puts "Example: export GITLAB_API_PRIVATE_TOKEN=kdii2ljljijsldjfoa".fatal
+        exit 1
+      end
+
+      options[:modules] = add_defaults(:modules, options)
+      options[:default_members] = add_defaults(:default_members, options)
+
+      options[:r10k_repo_path] ||= File.expand_path(File.join(ENV['HOME'], 'repos', 'r10k-control'))
+      options[:repos_path] ||= File.expand_path(File.join(ENV['HOME'], 'repos'))
+      options[:r10k_repo_url] ||= ENV['R10K_REPO_URL']
+
+      unless options[:r10k_repo_url]
+        puts "Please set the R10K_REPO_URL environment variable or use the --control-url option".fatal
+        puts "Example: export R10K_REPO_URL='git@gitlab.com:devops/r10k-control.git'".fatal
+        exit 1
+      end
+      unless options[:sandbox_name]
+        puts "If you don't name your sandbox, you will not have anywhere to play".fatal
+        puts "Example: sandbox-create -n my_sandbox"
+        exit 1
+      end
+      unless options[:sandbox_name].length > 5
+        puts "Your sandbox name must be at least 6 characters long".fatal
+        puts "Example: sandbox-create -n my_sandbox"
+        exit 1
+      end
+      # check options to ensure all values are present
+      begin
+        s = Sandbox.create(options[:sandbox_name], options)
+      rescue InvalidToken => e
+        puts e.message.fatal
+        puts "Please update your Gitlab API token as it may be expired or incorrect".fatal
+        exit 1 
+      end
+    end
+
+    def self.add_defaults(key, options)
+      if key == :modules
+        defaults = (ENV['DEFAULT_MODULES'] || '').split(',').map(&:strip)
+        ( options[:modules].to_a + defaults ).uniq
+      elsif key == :default_members
+        defaults = (ENV['DEFAULT_MEMBERS'] || '').split(',').map(&:strip)
+        ( options[:default_members].to_a + defaults ).uniq
+      end
+    end
+  end
+end