ra10ke 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ad7a9bc9ed535980433aee2a10afc3fe6b0060b9b85764fc692e1086bfabf46
-  data.tar.gz: b1c37034b07281ffe040748f34339acfd4cb0f82a014c4512463e077c645778b
+  metadata.gz: 244a7664e31597a415668faaeb3cf43b3c0243cf6aed478183f91317230e68eb
+  data.tar.gz: d241ae0aafcb1031dc1d6ef86a69796f79bcfefefe39622b22d5b165be34c696
 SHA512:
-  metadata.gz: 041f1c23f5cb71e8adbd419c9fd8a1b3662c536d5d5cbf7e2410db2c8d9f3c9e47673f257e29bb3a3ab900700f4bb219261e1d38d2b101983a828f33f1c2b5c6
-  data.tar.gz: 9fc86d2fe74f4c866cf1a4de68fb0dae662a952a4d9f5402ae983a966e607bad1bbec5f4943bdc5b29ba039d9bf5e9e5867711de5bc89e7c40b20c2056b018e1
+  metadata.gz: a889ad1d1f59c4781b895e7abc1f05b0b24776f7976f6c01bb6e45f258239908413f39d5e95def2cc032475243cb27aa39087b937fe6dd3e0a35147b28a6c0bb
+  data.tar.gz: e4ee4b06d70659f4fc836b90eb73ce22b1fc28076076704da334db5e52ddcd5fe138a0cf95edf80a86afea4885d1fd7fe883621ee04c0fc975a3ac32047711f9

data/.gitignore

@@ -1 +1,3 @@
 Gemfile.lock
+pkg
+.bundle

data/.ruby-version

@@ -0,0 +1 @@
+2.5.3

data/CHANGELOG.md

@@ -1,6 +1,22 @@
 CHANGELOG
 =========
 
+0.6.0
+-----
+
+2019-07-30
+
+Closed Pull Requests:
+
+* [#35](https://github.com/voxpupuli/ra10ke/pull/35) Adds new validate task for verifying the integrity of all modules      specified in the Puppetfile
+* [#33](https://github.com/voxpupuli/ra10ke/pull/33) Refactor tasks, Version tag handling fix, purge option
+* [#32](https://github.com/voxpupuli/ra10ke/pull/32) Make it possible to configure the tasks in the rakefile
+
+Many thanks to the following contributors for submitting PRs:
+
+* [Corey Osman](https://github.com/logicminds)
+* [Andreas Zuber](https://github.com/ZeroPointEnergy)
+
 0.5.0
 -----
 

data/README.md

@@ -13,12 +13,35 @@ Add the following line to your `Gemfile`:
 gem 'ra10ke'
 ```
 
-Add the following line in your `Rakefile`:
+Add the following lines in your `Rakefile`:
 
 ```ruby
 require 'ra10ke'
+Ra10ke::RakeTask.new
 ```
 
+## Configuration
+
+You can configure the tasks in a block:
+
+```ruby
+Ra10ke::RakeTask.new do |t|
+  t.basedir = File.join(Dir.pwd, 'some_dir')
+  t.moduledir = File.join(Dir.pwd, 'some_dir/strange_module_dir')
+end
+```
+
+Available settings are:
+
+| Setting         | Documentation                                                                                 |
+|-----------------|-----------------------------------------------------------------------------------------------|
+| basedir         | Base directory with the Puppetfile and modules directory (Default: Same directory as Rakefile)|
+| moduledir       | Directory to install the modules in (Default: 'modules' in basedir)                           |
+| puppetfile_path | Directroy where the Puppetfile is (Default: basedir)                                          |
+| puppetfile_name | The Puppetfile name (Default: basedir/Puppetfile)                                             |
+| force           | Overwrite locally changed files on install (Default: false)                                   |
+| purge           | Purge unmanaged modules from the modulesdir (Default: false)                                  |
+
 ## Rake tasks
 
 ### r10k:syntax
@@ -56,6 +79,41 @@ runs faster.
 
 Reads the Puppetfile in the current directory and installs them under the `path` provided as an argument.
 
+### r10k:validate[path]
+The validate rake task will determine if the url is a valid url by connecting 
+to the repository and verififying it actually exists and can be accessed.
+Additional if a branch, tag, or ref is specified in the Puppetfile the validate
+task will also verify that that branch/tag/ref exists in the remote repository.
+
+If you have ever deployed r10k to production only to find out a tag or branch is
+missing this validate task will catch that issue.  
+
+A exit status of 0 is returned if there are no faults, while a 1 is returned if
+any module has a bad status. 
+
+Status emojis can be customized by setting the following environment variables.
+
+Example
+
+ * `GOOD_EMOJI='👍'`
+ * `BAD_EMOJI='😨'`
+
+
+```
+NAME     | URL                                           | REF                            | STATUS
+---------|-----------------------------------------------|--------------------------------|-------
+splunk   | https://github.com/cudgel/splunk.git          | prod                           | 👍
+r10k     | https://github.com/acidprime/r10k             | v3.1.1                         | 👍
+gms      | https://github.com/npwalker/abrader-gms       | gitlab_disable_ssl_verify_s... | 👍
+rbac     | https://github.com/puppetlabs/pltraining-rbac | 2f60e1789a721ce83f8df061e13... | 👍
+acl      | https://github.com/dobbymoodge/puppet-acl.git | master                         | 👍
+deploy   | https://github.com/cudgel/deploy.git          | master                         | 👍
+dotfiles | https://github.com/cudgel/puppet-dotfiles.git | master                         | 👍
+gitlab   | https://github.com/vshn/puppet-gitlab         | 00397b86dfb3487d9df768cbd36... | 👍
+
+👍👍 Puppetfile looks good.👍👍
+```
+
 #### Limitations
 
   * It works only with modules from the [Forge](https://forge.puppetlabs.com), and Git.

data/Rakefile

@@ -3,8 +3,14 @@ require 'rake/clean'
 require 'rubygems'
 require 'bundler/gem_tasks'
 require 'fileutils'
+require 'rspec/core'
+require 'rspec/core/rake_task'
 
 CLEAN.include("pkg/", "tmp/")
 CLOBBER.include("Gemfile.lock")
 
-task :default => [:clean, :build]
+task :default => [:spec]
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+    spec.pattern = FileList['spec/**/*_spec.rb']
+end

data/lib/ra10ke/dependencies.rb

@@ -0,0 +1,71 @@
+module Ra10ke::Dependencies
+  def define_task_dependencies(*_args)
+    desc "Print outdated forge modules"
+    task :dependencies do
+      require 'r10k/puppetfile'
+      require 'puppet_forge'
+
+      PuppetForge.user_agent = "ra10ke/#{Ra10ke::VERSION}"
+      puppetfile = get_puppetfile
+      puppetfile.load!
+      PuppetForge.host = puppetfile.forge if puppetfile.forge =~ /^http/
+
+      # ignore file allows for "don't tell me about this"
+      ignore_modules = []
+      if File.exist?('.r10kignore')
+        ignore_modules = File.readlines('.r10kignore').each {|l| l.chomp!}
+      end
+
+      puppetfile.modules.each do |puppet_module|
+        next if ignore_modules.include? puppet_module.title
+        if puppet_module.class == R10K::Module::Forge
+          module_name = puppet_module.title.gsub('/', '-')
+          forge_version = PuppetForge::Module.find(module_name).current_release.version
+          installed_version = puppet_module.expected_version
+          if installed_version != forge_version
+            puts "#{puppet_module.title} is OUTDATED: #{installed_version} vs #{forge_version}"
+          end
+        end
+
+        if puppet_module.class == R10K::Module::Git
+          # use helper; avoid `desired_ref`
+          # we do not want to deal with `:control_branch`
+          ref = puppet_module.version
+          next unless ref
+
+          remote = puppet_module.instance_variable_get(:@remote)
+          remote_refs = Git.ls_remote(remote)
+
+          # skip if ref is a branch
+          next if remote_refs['branches'].key?(ref)
+
+          if remote_refs['tags'].key?(ref)
+            # there are too many possible versioning conventions
+            # we have to be be opinionated here
+            # so semantic versioning (vX.Y.Z) it is for us
+            # as well as support for skipping the leading v letter
+            tags = remote_refs['tags'].keys
+            latest_tag = tags.map do |tag|
+              begin
+                Semverse::Version.new tag[/\Av?(.*)\Z/, 1]
+              rescue Semverse::InvalidVersionFormat
+                # ignore tags that do not comply to semver
+                nil
+              end
+            end.select { |tag| !tag.nil? }.sort.last.to_s.downcase
+            latest_ref = tags.detect { |tag| tag[/\Av?(.*)\Z/, 1] == latest_tag }
+            latest_ref = 'undef (tags do not match semantic versioning)' if latest_ref.nil?
+          elsif ref.match(/^[a-z0-9]{40}$/)
+            # for sha just assume head should be tracked
+            latest_ref = remote_refs['head'][:sha]
+          else
+            raise "Unable to determine ref type for #{puppet_module.title}"
+          end
+
+          puts "#{puppet_module.title} is OUTDATED: #{ref} vs #{latest_ref}" if ref != latest_ref
+        end
+      end
+    end
+
+  end
+end

data/lib/ra10ke/install.rb

@@ -0,0 +1,32 @@
+module Ra10ke::Install
+  def define_task_install(*_args)
+    desc "Install modules specified in Puppetfile"
+    task :install do
+      require 'r10k/puppetfile'
+
+      puppetfile = get_puppetfile
+      puppetfile.load!
+
+      puts "Processing Puppetfile for fixtures"
+      puppetfile.modules.each do |mod|
+        if mod.status == :insync
+          puts "Skipping #{mod.name} (#{mod.version}) already in sync"
+        else
+          if mod.status == :absent
+            msg = "installed #{mod.name}"
+          else
+            msg = "updated #{mod.name} from #{mod.version} to"
+          end
+          mod.sync
+          if mod.status != :insync
+            puts "Failed to sync #{mod.name}".red
+          else
+            puts "Successfully #{msg} #{mod.version}".green
+          end
+        end
+      end
+
+      puppetfile.purge! if @purge
+    end
+  end
+end

data/lib/ra10ke/monkey_patches.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class String
+  # colorization
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  # removes specified markes from string. 
+  # @return [String] - the string with markers removed
+  def strip_comment(markers = ['#', "\n"])
+    re = Regexp.union(markers)
+    index = (self =~ re)
+    index.nil? ? rstrip : self[0, index].rstrip
+  end
+end

data/lib/ra10ke/puppetfile_parser.rb

@@ -0,0 +1,83 @@
+# it might be desirable to parse the Puppetfile as a string instead of evaling it. 
+# this module allows you to do just that.
+require 'ra10ke/monkey_patches'
+
+module Ra10ke
+    module PuppetfileParser
+
+      # @return [Array] - returns a array of hashes that contain modules with a git source
+      def git_modules(file = puppetfile)
+        modules(file).find_all do |mod|
+          mod[:args].key?(:git)
+        end
+      end
+
+      # @param puppetfile [String] - the absolute path to the puppetfile
+      # @return [Array] - returns an array of module hashes that represent the puppetfile
+      # @example
+      # [{:namespace=>"puppetlabs", :name=>"stdlib", :args=>[]},
+      # {:namespace=>"petems", :name=>"swap_file", :args=>["'4.0.0'"]}]
+      def modules(puppetfile)
+        @modules ||= begin
+          return [] unless File.exist?(puppetfile)
+
+          all_lines = File.read(puppetfile).lines.map(&:strip_comment)
+          # remove comments from all the lines
+          lines_without_comments = all_lines.reject { |line| line.match(/#.*\n/) }.join("\n").delete("\n")
+          lines_without_comments.split('mod').map do |line|
+            next nil if line =~ /^forge/
+            next nil if line.empty?
+
+            parse_module_args(line)
+          end.compact.uniq
+        end
+      end
+
+      # @param data [String] - the string to parse the puppetfile args out of
+      # @return [Array] -  an array of arguments in hash form
+      # @example
+      # {:namespace=>"puppetlabs", :name=>"stdlib", :args=>[]}
+      # {:namespace=>"petems", :name=>"swap_file", :args=>["'4.0.0'"]}
+      def parse_module_args(data)
+        return {} if data.empty?
+        args = data.split(',').map(&:strip)
+        # we can't guarantee that there will be a namespace when git is used
+        # remove quotes and dash and slash
+        namespace, name = args.shift.gsub(/'|"/, '').split(%r{-|/})
+        name ||= namespace
+        namespace = nil if namespace == name
+        {
+          namespace: namespace,
+          name: name,
+          args: process_args(args)
+        }
+      end
+
+      # @return [Array] - returns an array of hashes with the args in key value pairs
+      # @param [Array] - the arguments processed from each entry in the puppetfile
+      # @example
+      # [{:args=>[], :name=>"razor", :namespace=>"puppetlabs"},
+      #  {:args=>[{:version=>"0.0.3"}], :name=>"ntp", :namespace=>"puppetlabs"},
+      #  {:args=>[], :name=>"inifile", :namespace=>"puppetlabs"},
+      #  {:args=>
+      #    [{:git=>"https://github.com/nwops/reportslack.git"}, {:ref=>"1.0.20"}],
+      #   :name=>"reportslack",
+      #   :namespace=>"nwops"},
+      #  {:args=>{:git=>"git://github.com/puppetlabs/puppetlabs-apt.git"},
+      #   :name=>"apt",
+      #   :namespace=>nil}
+      # ]
+      def process_args(args)
+        results = {}
+        args.each do |arg|
+          a = arg.gsub(/'|"/, '').split(/\A\:|\:\s|\=\>/).map(&:strip).reject(&:empty?)
+          if a.count < 2
+            results[:version] = a.first
+          else
+            results[a.first.to_sym] = a.last
+          end
+        end
+        results
+      end
+    end
+end