vtasks 0.0.8

data/lib/vtasks/docker/image/build.rb

@@ -0,0 +1,54 @@
+module Vtasks
+class Docker
+class Image
+# Docker Build class
+class Build
+  # Include utility modules
+  require 'vtasks/utils/git'
+  include Vtasks::Utils::Git
+  require 'vtasks/utils/output'
+  include Vtasks::Utils::Output
+
+  attr_reader :image, :path, :build_date, :build_tag
+
+  def initialize(image, path, args={})
+    @image      ||= image
+    @path       ||= path
+    @build_date ||= args.fetch(:build_date)
+    @build_tag  ||= args.fetch(:build_tag)
+
+    @cmd = 'docker image build'
+  end
+
+  def without_arguments
+    info "Pulling #{image}" # to speed up the building process
+    system "docker pull #{image}" unless ENV['DOCKER_NO_CACHE']
+
+    info "Building #{image}:#{build_tag}"
+    system "#{@cmd} -t #{image}:#{build_tag} #{path}"
+
+    if $?.exitstatus != 0
+      error 'Build command failed!'
+      abort
+    end
+  end
+
+  def with_arguments
+    build_args = {
+      'BUILD_DATE' => build_date,
+      'VERSION'    => build_tag,
+      'VCS_URL'    => git_url,
+      'VCS_REF'    => git_commit
+    }
+
+    build_args.map do |key, value|
+      @cmd += " --build-arg #{key}=#{value}"
+    end
+
+    without_arguments
+  end
+
+end # class Build
+end # class Image
+end # class Docker
+end # module Vtasks

data/lib/vtasks/docker/image/push.rb

@@ -0,0 +1,17 @@
+module Vtasks
+class Docker
+class Image
+# Docker Push class
+class Push
+  # Include utility modules
+  require 'vtasks/utils/output'
+  include Vtasks::Utils::Output
+
+  def initialize(image, tag)
+    info "Pushing #{image}:#{tag}"
+    system "docker image push #{image}:#{tag}"
+  end
+end # class Push
+end # class Image
+end # class Docker
+end # module Vtasks

data/lib/vtasks/docker/image/tag.rb

@@ -0,0 +1,17 @@
+module Vtasks
+class Docker
+class Image
+# Docker Tag module
+class Tag
+  # Include utility modules
+  require 'vtasks/utils/output'
+  include Vtasks::Utils::Output
+
+  def initialize(image, oldtag, newtag)
+    info "Tagging #{image}:#{newtag}"
+    system "docker image tag #{image}:#{oldtag} #{image}:#{newtag}"
+  end
+end # class Tag
+end # class Image
+end # class Docker
+end # module Vtasks

data/lib/vtasks/docker/image.rb

@@ -0,0 +1,83 @@
+module Vtasks
+class Docker
+# Docker Image class
+class Image
+  # Include utility modules
+  require 'vtasks/utils/git'
+  include Vtasks::Utils::Git
+  require 'vtasks/utils/semver'
+  include Vtasks::Utils::Semver
+
+  # Include utility classes
+  require 'vtasks/docker/image/build'
+  require 'vtasks/docker/image/push'
+  require 'vtasks/docker/image/tag'
+
+  attr_reader :image, :path, :has_build_args, :tags
+
+  def initialize(image, path, args = {})
+    @image          ||= image
+    @path           ||= path
+    @has_build_args ||= args.fetch(:has_build_args, false)
+  end
+
+  def tags
+    major, minor, patch = [
+      semver[:major],
+      semver[:minor],
+      semver[:patch]
+    ].freeze
+    @tags = [
+      "#{major}.#{minor}.#{patch}",
+      "#{major}.#{minor}",
+      "#{major}",
+      'latest'
+    ]
+  end
+
+  # Compose build date
+  def build_date
+    @build_date ||= ::Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+  end
+
+  # Compose build tag
+  def build_tag
+    @build_tag ||= gitver.to_s
+  end
+
+  # Build image
+  def build
+    args = {
+      build_date: build_date,
+      build_tag: build_tag
+    }
+    build = Vtasks::Docker::Image::Build.new(image, path, args)
+    if has_build_args
+      build.with_arguments
+    else
+      build.without_arguments
+    end
+  end
+
+  # Tag image
+  def tag
+    tags.each do |tag|
+      Vtasks::Docker::Image::Tag.new(image, build_tag, tag)
+    end
+  end
+
+  # Build image with tags
+  def build_with_tags
+    build
+    tag
+  end
+
+  # Push image
+  def push
+    tags.each do |tag|
+      Vtasks::Docker::Image::Push.new(image, tag)
+    end
+  end
+end # class Image
+end # class Docker
+end # module Vtasks

data/lib/vtasks/docker.rb

@@ -0,0 +1,124 @@
+module Vtasks
+  require 'rake/tasklib'
+
+  # Docker tasks
+  class Docker < ::Rake::TaskLib
+    # Include utility modules
+    require 'vtasks/utils/output'
+    include Vtasks::Utils::Output
+    require 'vtasks/utils/system'
+    include Vtasks::Utils::System
+
+    # Include utility classes
+    require 'vtasks/docker/image'
+
+    attr_reader :args, :repo
+
+    def initialize(args = {})
+      @args ||= args
+      @repo ||= args.fetch(:repo)
+
+      check_docker
+      define_tasks
+    end
+
+    def define_tasks
+      namespace :docker do
+        list_images
+        garbage_collect
+        tasks
+
+        dockerfiles.each do |dockerfile|
+          path = File.basename(dockerfile)
+          add_namespace("#{repo}/#{path}", path)
+        end # dockerfiles.each
+      end # namespace :docker
+    end # def define_tasks
+
+    # Image namespace
+    def add_namespace(image, path)
+      namespace path.to_sym do |_args|
+        require 'rspec/core/rake_task'
+        ::RSpec::Core::RakeTask.new(:spec) do |task|
+          task.pattern = "#{path}/spec/*_spec.rb"
+        end
+
+        docker_image = Vtasks::Docker::Image.new(image, path, args)
+
+        lint_image(path)
+
+        desc 'Build and tag docker image'
+        task :build do
+          docker_image.build_with_tags
+        end
+
+        desc 'Publish docker image'
+        task :push do
+          docker_image.push
+        end
+      end
+    end
+
+    # Tasks
+    def tasks
+      # Run tasks one by one for all images
+      [:spec, :lint].each { |task_name| run_task(task_name) }
+      # Run tasks in parallel for all images
+      [:build, :push].each { |task_name| run_task_parallel(task_name) }
+    end
+
+    # Run a task for all images
+    def run_task(name)
+      desc "Run #{name} for all images in repository"
+      task name => dockerfiles
+        .collect { |image| "docker:#{File.basename(image)}:#{name}" }
+    end
+
+    # Run a task for all images in parallel
+    def run_task_parallel(name)
+      desc "Run #{name} for all images in repository in parallel"
+      multitask name => dockerfiles
+        .collect { |image| "docker:#{File.basename(image)}:#{name}" }
+    end
+
+    # List all folders containing Dockerfiles
+    def dockerfiles
+      @dockerfiles = Dir.glob('*').select do |dir|
+        File.directory?(dir) && File.exist?("#{dir}/Dockerfile")
+      end
+    end
+
+    # Check Docker is installed
+    def check_docker
+      task :docker do
+        raise 'These tasks require docker to be installed' unless command? 'docker'
+      end
+    end
+
+    # List all images
+    def list_images
+      desc 'List all Docker images'
+      task :list do
+        info dockerfiles.map { |image| File.basename(image) }
+      end
+    end
+
+    # Lint image
+    def lint_image(path)
+      desc 'Run Hadolint against the Dockerfile'
+      task :lint do
+        dockerfile = "#{path}/Dockerfile"
+        info "Running Hadolint to check the style of #{dockerfile}"
+        system "docker container run --rm -i lukasmartinelli/hadolint hadolint --ignore DL3008 --ignore DL3013 - < #{dockerfile}"
+      end
+    end
+
+    # Garbage collect
+    def garbage_collect
+      desc 'Garbage collect unused docker data'
+      task :gc do
+        system 'docker system prune --all --force'
+      end
+    end
+  end # class Docker
+end # module Vtasks

data/lib/vtasks/lint.rb

@@ -0,0 +1,65 @@
+module Vtasks
+  require 'rake/tasklib'
+
+  # Lint tasks
+  class Lint < ::Rake::TaskLib
+    attr_reader :file_list
+
+    def initialize(options = {})
+      @file_list ||= options.fetch(:file_list, FileList['{lib,spec}/**/*.rb'])
+      define_tasks
+    end
+
+    # Define tasks
+    def define_tasks
+      desc 'Check for code smells with Reek and Rubocop'
+      task lint: ['lint:reek', 'lint:rubocop']
+
+      namespace :lint do
+        rubocop
+        reek
+        rubycritic
+      end
+    end
+
+    # RuboCop
+    def rubocop
+      begin
+        require 'rubocop/rake_task'
+      rescue LoadError
+        nil # Might be in a group that is not installed
+      end
+      desc 'Run RuboCop on the tasks and lib directory'
+      ::RuboCop::RakeTask.new(:rubocop) do |task|
+        task.patterns = file_list
+        task.options  = ['--display-cop-names', '--extra-details']
+      end
+    end
+
+    # Reek
+    def reek
+      begin
+        require 'reek/rake/task'
+      rescue LoadError
+        nil # Might be in a group that is not installed
+      end
+      ::Reek::Rake::Task.new do |task|
+        task.source_files  = file_list
+        task.fail_on_error = false
+        task.reek_opts     = '--wiki-links --color'
+      end
+    end
+
+    # Ruby Critic
+    def rubycritic
+      begin
+        require 'rubycritic/rake_task'
+      rescue LoadError
+        nil # Might be in a group that is not installed
+      end
+      ::RubyCritic::RakeTask.new do |task|
+        task.paths = file_list
+      end
+    end
+  end # class Lint
+end # module Vtasks

data/lib/vtasks/puppet.rb

@@ -0,0 +1,212 @@
+module Vtasks
+  require 'rake/tasklib'
+
+  # Puppet tasks
+  class Puppet < ::Rake::TaskLib
+    # Include utility modules
+    require 'vtasks/utils/git'
+    include Vtasks::Utils::Git
+    require 'vtasks/utils/output'
+    include Vtasks::Utils::Output
+
+    require 'json'
+    require 'open-uri'
+    require 'yaml'
+
+    attr_reader :exclude_paths
+
+    def initialize(options = {})
+      # Fix for namespaced :syntax task
+      task syntax: ['puppet:syntax']
+
+      namespace :puppet do
+        begin
+          require 'r10k/cli'
+          require 'r10k/puppetfile'
+          require 'puppet_forge'
+          require 'puppetlabs_spec_helper/rake_tasks' # ORDER IS VERY IMPORTANT BECAUSE IT OVERRIDES A LOT OF OTHER TASKS; AS OF NOW IT NEEDS TO BE AFTER `r10k` and `puppet_forge` (BECAUSE OF FAST_GETTEXT INITIALIZATION) BUT BEFORE puppet-strings (BECAUSE ERROR: `Don't know how to build task 'spec_prep'`)
+          require 'metadata-json-lint/rake_task'
+          require 'puppet-syntax/tasks/puppet-syntax'
+          require 'puppet-lint/tasks/puppet-lint'
+          require 'puppet-strings/tasks'
+          require 'puppet_blacksmith/rake_tasks'
+        rescue LoadError
+          nil # Might be in a group that is not installed
+        end
+
+        @exclude_paths ||= options.fetch(
+          :exclude_paths,
+          [
+            'bundle/**/*',
+            'modules/**/*',
+            'pkg/**/*',
+            'spec/**/*',
+            'tmp/**/*',
+            'vendor/**/*'
+          ]
+        )
+
+        define_tasks
+      end # namespace :puppet
+    end
+
+    def define_tasks
+      ::PuppetLint::RakeTask.new :lint do |config|
+        config.relative = true
+        config.with_context = true
+        config.fail_on_warnings = true
+        config.ignore_paths = exclude_paths
+        config.disable_checks = [
+          '140chars'
+        ]
+      end
+
+      # Puppet syntax tasks
+      ::PuppetSyntax.exclude_paths = exclude_paths
+
+      desc 'Run syntax, lint, and spec tests'
+      task test: [
+        :metadata_lint,
+        :syntax,
+        :lint,
+        :unit
+      ]
+
+      desc 'Run unit tests'
+      task unit: [
+        :r10k_install_modules,
+        :spec_prep,
+        :spec_standalone
+      ]
+
+      desc 'Run acceptance tests'
+      task integration: [
+        :spec_prep,
+        :beaker
+      ]
+
+      desc 'Clean all test files'
+      task clean: [:spec_clean]
+
+      desc 'Use R10K to download all modules'
+      task :r10k_install_modules do
+        r10k_install_modules
+      end
+
+      desc 'Generates a new .fixtures.yml from a Puppetfile'
+      task :generate_fixtures do
+        generate_fixtures
+      end
+
+      desc 'Print outdated Puppetfile modules'
+      task :puppetfile_inspect do
+        check_puppetfile_versions
+      end
+    end # def define_tasks
+
+    def puppetfile
+      @puppetfile ||= ::R10K::Puppetfile.new(pwd)
+    end
+
+    def check_puppetfile
+      puppetfile.load
+      error 'Puppetfile was not found or is empty!' if puppetfile.modules.empty?
+    end
+
+    def r10k_install_modules
+      info 'Updating modules with R10K'
+      ::R10K::CLI.command.run(%w(puppetfile install --force --verbose))
+    rescue SystemExit # because R10K::CLI.command.run calls `exit 0`
+      info 'Modules have been updated'
+    end
+
+    def generate_fixtures
+      info 'Generating fixtures file'
+
+      check_puppetfile
+
+      fixtures = {
+        'fixtures' => {
+          'symlinks' => {
+            'role' => '#{source_dir}/dist/role',
+            'profile' => '#{source_dir}/dist/profile'
+          },
+          'repositories' => {}
+        }
+      }
+
+      puppetfile.modules.each do |mod|
+        module_name = mod.title.tr('/', '-')
+        remote      = mod.instance_variable_get('@remote')
+        ref         = mod.instance_variable_get('@desired_ref')
+
+        fixtures['fixtures']['repositories'][module_name] = {
+          'repo' => remote,
+          'ref' => ref
+        }
+      end
+
+      File.open('.fixtures.yml', 'w') { |file| file.write(fixtures.to_yaml) }
+      info 'Done'
+    end # def generate_fixtures
+
+    def check_puppetfile_versions
+      puppetfile.load
+      error 'Puppetfile was not found or is empty!' if puppetfile.modules.empty?
+
+      puppetfile.modules.each do |mod|
+        if mod.class == ::R10K::Module::Forge
+          module_name = mod.title.tr('/', '-')
+          forge_version = ::PuppetForge::Module.find(module_name)
+                                               .current_release.version
+          installed_version = mod.expected_version
+          if installed_version != forge_version
+            puts "#{module_name} is OUTDATED: " \
+              "#{installed_version} vs #{forge_version}"
+              .red
+          else
+            puts "#{module_name}: #{forge_version}".green
+          end
+        elsif mod.class == ::R10K::Module::Git
+          # Try to extract owner and repo name from remote string
+          remote = mod.instance_variable_get('@remote')
+          owner  = remote.gsub(%r{(.*)\/(.*)\/(.*)}, '\\2')
+          repo   = remote.gsub(%r{(.*)\/(.*)\/}, '\\3')
+
+          # It's better to query the API authenticated because of the rate
+          # limit. You can make up to 5,000 requests per hour. For unauthenticated
+          # requests, the rate limit is only up to 60 requests per hour.
+          # (https://developer.github.com/v3/#rate-limiting)
+          tags = if GITHUB_TOKEN
+                   open("https://api.github.com/repos/#{owner}/#{repo}/tags?access_token=#{GITHUB_TOKEN}")
+                 else
+                   open("https://api.github.com/repos/#{owner}/#{repo}/tags")
+                 end
+
+          # Get rid of non-semantic versions (for example
+          # https://github.com/puppetlabs/puppetlabs-ntp/releases/tag/push)
+          all_tags = JSON.parse(tags.read).select do |tag|
+            tag['name'] =~ /v?\d+\.\d+\.\d+/
+          end
+
+          # Use Gem::Version to sort tags
+          latest_tag = all_tags.map do |line|
+            ::Gem::Version.new line['name'].gsub(/[v]?(.*)/, '\\1')
+          end.max.to_s
+
+          # Print results
+          installed_version = mod.version.gsub(/[v]?(.*)/, '\\1')
+          if installed_version == 'master'
+            puts "#{mod.title}: 'master' branch (#{latest_tag})".blue
+          elsif installed_version != latest_tag
+            puts "#{mod.title} is OUTDATED: " \
+              "#{installed_version} vs #{latest_tag}"
+              .red
+          else
+            puts "#{mod.title}: #{latest_tag}".green
+          end
+        end
+      end
+    end # def check_puppetfile_versions
+  end # class Puppet
+end # module Vtasks

data/lib/vtasks/release.rb

@@ -0,0 +1,101 @@
+module Vtasks
+  require 'rake/tasklib'
+
+  # Release tasks
+  class Release < ::Rake::TaskLib
+    # Include utility modules
+    require 'vtasks/utils/git'
+    include Vtasks::Utils::Git
+    require 'vtasks/utils/output'
+    include Vtasks::Utils::Output
+    require 'vtasks/utils/semver'
+    include Vtasks::Utils::Semver
+
+    attr_reader :write_changelog,
+                :wait_for_ci_success,
+                :bug_labels,
+                :enhancement_labels
+
+    def initialize(options = {})
+      @write_changelog = options.fetch(:write_changelog, false)
+      @wait_for_ci_success = options.fetch(:wait_for_ci_success, false)
+      @bug_labels = options.fetch(:bug_labels, 'bug')
+      @enhancement_labels = options.fetch(:enhancement_labels, 'enhancement')
+      define_tasks
+    end
+
+    # Configure the github_changelog_generator/task
+    def changelog(config, release: nil)
+      config.bug_labels         = bug_labels #'Type: Bug'
+      config.enhancement_labels = enhancement_labels #'Type: Enhancement'
+      config.future_release     = "v#{release}" if release
+    end
+
+    def define_tasks
+      desc "Release patch version"
+      task release: ['release:patch']
+
+      namespace :release do
+        begin
+          require 'github_changelog_generator/task'
+
+          # Create release:changes task
+          ::GitHubChangelogGenerator::RakeTask.new(:changes) do |config|
+              changelog(config)
+          end
+        rescue LoadError
+          nil # Might be in a group that is not installed
+        end
+
+        SEM_LEVELS.each do |level|
+          desc "Release #{level} version"
+          task level.to_sym do
+            new_version = bump(level)
+            release = "#{new_version[:major]}.#{new_version[:minor]}.#{new_version[:patch]}"
+            release_branch = "release_v#{release.gsub(/[^0-9A-Za-z]/, '_')}"
+            initial_branch = git_branch
+
+            info 'Check if the repository is clean'
+            git_clean_repo
+
+            # Write changelog
+            # Create a separate release branch (works with  protected branches as well)
+            if write_changelog == true
+              info 'Generate new changelog'
+              ::GitHubChangelogGenerator::RakeTask.new(:latest_release) do |config|
+                changelog(config, release: release)
+              end
+              task('latest_release').invoke
+
+              if system 'git diff --quiet HEAD'
+                info 'CHANGELOG has not changed. Skipping...'
+              else
+                info 'Create a new release branch'
+                sh "git checkout -b #{release_branch}"
+
+                info 'Commit the new changes'
+                sh "git commit --gpg-sign --message 'Update change log for v#{release}' CHANGELOG.md"
+
+                info 'Push the new changes'
+                sh "git push --set-upstream origin #{release_branch}"
+
+                if wait_for_ci_success == true
+                  info 'Waiting for CI to finish'
+                  sleep 5 until git_ci_status(release_branch) == 'success'
+                end
+
+                info 'Merge release branch'
+                sh "git checkout #{initial_branch}"
+                sh "git merge --gpg-sign --no-ff --message 'Release v#{release}' #{release_branch}"
+              end
+            end
+
+            info "Tag #{release}"
+            sh "git tag --sign v#{release} --message 'Release v#{release}'"
+            sh 'git push --follow-tags'
+          end # task
+        end # LEVELS
+      end # namespace :release
+    end # def define_tasks
+  end # class Release
+end # module Vtasks