abide_dev_utils 0.1.0

data/lib/abide_dev_utils/errors/xccdf.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'abide_dev_utils/errors/base'
+
+module AbideDevUtils
+  module Errors
+    # Raised when an xpath search of an xccdf file fails
+    class XPathSearchError < GenericError
+      @default = 'XPath seach failed to find anything at:'
+    end
+  end
+end

data/lib/abide_dev_utils/files.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AbideDevUtils
+  module Files
+    class Writer
+      MSG_EXT_APPEND = 'Appending %s extension to file'
+
+      def write(content, file: nil, add_ext: true, file_ext: nil)
+        valid_file = add_ext ? append_ext(file, file_ext) : file
+        File.open(valid_file, 'w') { |f| f.write(content) }
+        verify_write(valid_file)
+      end
+
+      def method_missing(m, *args, **kwargs, &_block)
+        if m.to_s.match?(/^write_/)
+          ext = m.to_s.split('_')[-1]
+          write(args[0], **kwargs, file_ext: ext)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        method_name.to_s.start_with?('write_') || super
+      end
+
+      def append_ext(file_path, ext)
+        return file_path if ext.nil?
+
+        s_ext = ".#{ext}"
+        unless File.extname(file_path) == s_ext
+          puts MSG_EXT_APPEND % s_ext
+          file_path << s_ext
+        end
+        file_path
+      end
+
+      def verify_write(file_path)
+        if File.file?(file_path)
+          puts "Successfully wrote to #{file_path}"
+        else
+          puts "Something went wrong! Failed writing to #{file_path}!"
+        end
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/jira.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'jira-ruby'
+require 'abide_dev_utils/output'
+require 'abide_dev_utils/prompt'
+require 'abide_dev_utils/config'
+require 'abide_dev_utils/errors/jira'
+
+module AbideDevUtils
+  module Jira
+    ERRORS = AbideDevUtils::Errors::Jira
+    COV_PARENT_SUMMARY_PREFIX = '::BENCHMARK:: '
+    COV_CHILD_SUMMARY_PREFIX = '::CONTROL:: '
+
+    def self.project(client, project)
+      client.Project.find(project)
+    end
+
+    def self.issue(client, issue)
+      client.Issue.find(issue)
+    end
+
+    def self.myself(client)
+      client.User.myself
+    end
+
+    def self.issuetype(client, id)
+      client.Issuetype.find(id)
+    end
+
+    def self.priority(client, id)
+      client.Priority.find(id)
+    end
+
+    def self.all_project_issues_attrs(project)
+      raw_issues = project.issues
+      raw_issues.collect(&:attrs)
+    end
+
+    def self.new_issue(client, project, summary, dry_run: false)
+      if dry_run
+        sleep(0.2)
+        return Dummy.new
+      end
+      fields = {}
+      fields['summary'] = summary
+      fields['project'] = project(client, project)
+      fields['reporter'] = myself(client)
+      fields['issuetype'] = issuetype(client, '3')
+      fields['priority'] = priority(client, '6')
+      issue = client.Issue.build
+      raise ERRORS::CreateIssueError, issue.attrs unless issue.save({ 'fields' => fields })
+
+      issue
+    end
+
+    # This should probably be threaded in the future
+    def self.bulk_new_issue(client, project, summaries, dry_run: false)
+      summaries.each { |s| new_issue(client, project, s, dry_run: dry_run) }
+    end
+
+    def self.new_subtask(client, issue, summary, dry_run: false)
+      if dry_run
+        sleep(0.2)
+        return Dummy.new
+      end
+      issue_fields = issue.attrs['fields']
+      fields = {}
+      fields['parent'] = issue
+      fields['summary'] = summary
+      fields['project'] = issue_fields['project']
+      fields['reporter'] = myself(client)
+      fields['issuetype'] = issuetype(client, '5')
+      fields['priority'] = issue_fields['priority']
+      subtask = client.Issue.build
+      raise ERRORS::CreateSubtaskError, subtask.attrs unless subtask.save({ 'fields' => fields })
+
+      subtask
+    end
+
+    def self.bulk_new_subtask(client, issue, summaries, dry_run: false)
+      summaries.each do |s|
+        new_subtask(client, issue, s, dry_run: dry_run)
+      end
+    end
+
+    def self.client(options: {})
+      opts = merge_options(options)
+      opts[:username] = AbideDevUtils::Prompt.username if opts[:username].nil?
+      opts[:password] = AbideDevUtils::Prompt.password if opts[:password].nil?
+      opts[:site] = AbideDevUtils::Prompt.single_line('Jira URL') if opts[:site].nil?
+      opts[:context_path] = '' if opts[:context_path].nil?
+      opts[:auth_type] = :basic if opts[:auth_type].nil?
+      JIRA::Client.new(opts)
+    end
+
+    def self.client_from_prompts(http_debug: false)
+      options = {}
+      options[:username] = AbideDevUtils::Prompt.username
+      options[:password] = AbideDevUtils::Prompt.password
+      options[:site] = AbideDevUtils::Prompt.single_line('Jira URL')
+      options[:context_path] = ''
+      options[:auth_type] = :basic
+      options[:http_debug] = http_debug
+      JIRA::Client.new(options)
+    end
+
+    def self.project_from_prompts(http_debug: false)
+      client = client_from_prompts(http_debug)
+      project = AbideDevUtils::Prompt.single_line('Project').upcase
+      client.Project.find(project)
+    end
+
+    def self.new_issues_from_coverage(client, project, report, dry_run: false)
+      dr_prefix = dry_run ? 'DRY RUN: ' : ''
+      i_attrs = all_project_issues_attrs(project)
+      rep_sums = summaries_from_coverage_report(report)
+      rep_sums.each do |k, v|
+        next if summary_exist?(k, i_attrs)
+
+        parent = new_issue(client, project.attrs['key'], k.to_s, dry_run: dry_run)
+        AbideDevUtils::Output.simple("#{dr_prefix}Created parent issue #{k}")
+        parent_issue = issue(client, parent.attrs['key']) unless parent.respond_to?(:dummy)
+        AbideDevUtils::Output.simple("#{dr_prefix}Creating subtasks, this can take a while...")
+        progress = AbideDevUtils::Output.progress(title: "#{dr_prefix}Creating Subtasks", total: nil)
+        v.each do |s|
+          next if summary_exist?(s, i_attrs)
+
+          progress.title = "#{dr_prefix}#{s}"
+          new_subtask(client, parent_issue, s, dry_run: dry_run)
+          progress.increment
+        end
+      end
+    end
+
+    def self.merge_options(options)
+      config.merge(options)
+    end
+
+    def self.config
+      AbideDevUtils::Config.config_section(:jira)
+    end
+
+    def self.summary_exist?(summary, issue_attrs)
+      issue_attrs.each do |i|
+        return true if i['fields']['summary'] == summary
+      end
+      false
+    end
+
+    def self.summaries_from_coverage_report(report)
+      summaries = {}
+      benchmark = nil
+      report.each do |k, v|
+        benchmark = v if k == 'benchmark'
+        next unless k.match?(/^profile_/)
+
+        parent_sum = k
+        v.each do |sk, sv|
+          next unless sk == 'uncovered'
+
+          summaries[parent_sum] = sv.collect { |s| "#{COV_CHILD_SUMMARY_PREFIX}#{s}" }
+        end
+      end
+      summaries.transform_keys { |k| "#{COV_PARENT_SUMMARY_PREFIX}#{benchmark}-#{k}"}
+    end
+
+    class Dummy
+      def attrs
+        { 'fields' => {
+          'project' => 'dummy',
+          'priority' => 'dummy'
+        } }
+      end
+
+      def dummy
+        true
+      end
+    end
+  end
+end

data/lib/abide_dev_utils/output.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pp'
+require 'yaml'
+require 'ruby-progressbar'
+require 'abide_dev_utils/validate'
+require 'abide_dev_utils/files'
+
+module AbideDevUtils
+  module Output
+    FWRITER = AbideDevUtils::Files::Writer.new
+    def self.simple(msg, stream: $stdout)
+      stream.puts msg
+    end
+
+    def self.json(in_obj, console: false, file: nil, pretty: true)
+      AbideDevUtils::Validate.hashable(in_obj)
+      json_out = pretty ? JSON.pretty_generate(in_obj) : JSON.generate(in_obj)
+      simple(json_out) if console
+      FWRITER.write_json(json_out, file: file) unless file.nil?
+    end
+
+    def self.yaml(in_obj, console: false, file: nil)
+      AbideDevUtils::Validate.hashable(in_obj)
+      # Use object's #to_yaml method if it exists, convert to hash if not
+      yaml_out = in_obj.respond_to?(:to_yaml) ? in_obj.to_yaml : in_obj.to_h.to_yaml
+      simple(yaml_out) if console
+      FWRITER.write_yaml(yaml_out, file: file) unless file.nil?
+    end
+
+    def self.yml(in_obj, console: false, file: nil)
+      AbideDevUtils::Validate.hashable(in_obj)
+      # Use object's #to_yaml method if it exists, convert to hash if not
+      yml_out = in_obj.respond_to?(:to_yaml) ? in_obj.to_yaml : in_obj.to_h.to_yaml
+      simple(yml_out) if console
+      FWRITER.write_yml(yml_out, file: file) unless file.nil?
+    end
+
+    def self.progress(title: 'Progress', start: 0, total: 100)
+      ProgressBar.create(title: title, starting_at: start, total: total)
+    end
+  end
+end

data/lib/abide_dev_utils/ppt.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+require 'yaml'
+require 'puppet_pal'
+
+module AbideDevUtils
+  module Ppt
+    def self.coverage_report(puppet_class_dir, hiera_path, profile = nil)
+      coverage = {}
+      coverage['classes'] = {}
+      all_cap = find_all_classes_and_paths(puppet_class_dir)
+      invalid_classes = find_invalid_classes(all_cap)
+      valid_classes = all_cap.dup.transpose[0] - invalid_classes
+      coverage['classes']['invalid'] = invalid_classes
+      coverage['classes']['valid'] = valid_classes
+      hiera = YAML.safe_load(File.open(hiera_path))
+      matcher = profile.nil? ? /^profile_/ : /^profile_#{profile}/
+      hiera.each do |k, v|
+        key_base = k.split('::')[-1]
+        coverage['benchmark'] = v if key_base == 'title'
+        next unless key_base.match?(matcher)
+
+        coverage[key_base] = generate_uncovered_data(v, valid_classes)
+      end
+      coverage
+    end
+
+    def self.generate_uncovered_data(ctrl_list, valid_classes)
+      out_hash = {}
+      out_hash[:num_total] = ctrl_list.length
+      out_hash[:uncovered] = []
+      out_hash[:covered] = []
+      ctrl_list.each do |c|
+        if valid_classes.include?(c)
+          out_hash[:covered] << c
+        else
+          out_hash[:uncovered] << c
+        end
+      end
+      out_hash[:num_covered] = out_hash[:covered].length
+      out_hash[:num_uncovered] = out_hash[:uncovered].length
+      out_hash[:coverage] = Float(
+        (Float(out_hash[:num_covered]) / Float(out_hash[:num_total])) * 100.0
+      ).floor(3)
+      out_hash
+    end
+
+    # Given a directory holding Puppet manifests, returns
+    # the full namespace for all classes in that directory.
+    # @param puppet_class_dir [String] path to a dir containing Puppet manifests
+    # @return [String] The namespace for all classes in manifests in the dir
+    def self.find_class_namespace(puppet_class_dir)
+      path = Pathname.new(puppet_class_dir)
+      mod_root = nil
+      ns_parts = []
+      found_manifests = false
+      path.ascend do |p|
+        if found_manifests
+          mod_root = find_mod_root(p)
+          break
+        end
+        if File.basename(p) == 'manifests'
+          found_manifests = true
+          next
+        else
+          ns_parts << File.basename(p)
+        end
+      end
+      "#{mod_root}::#{ns_parts.reverse.join('::')}::"
+    end
+
+    # Given a Pathname object of the 'manifests' directory in a Puppet module,
+    # determines the module namespace root. Does this by consulting
+    # metadata.json, if it exists, or by using the parent directory name.
+    # @param pathname [Pathname] A Pathname object of the module's manifests dir
+    # @return [String] The module's namespace root
+    def self.find_mod_root(pathname)
+      metadata_file = nil
+      pathname.entries.each do |e|
+        metadata_file = "#{pathname}/metadata.json" if File.basename(e) == 'metadata.json'
+      end
+      if metadata_file.nil?
+        File.basename(p)
+      else
+        File.open(metadata_file) do |f|
+          file = JSON.parse(f.read)
+          File.basename(p) unless file.key?('name')
+          file['name'].split('-')[-1]
+        end
+      end
+    end
+
+    # @return [Array] An array of frozen arrays where each sub-array's
+    #   index 0 is class_name and index 1 is the full path to the file.
+    def self.find_all_classes_and_paths(puppet_class_dir)
+      all_cap = []
+      Dir.each_child(puppet_class_dir) do |c|
+        path = "#{puppet_class_dir}/#{c}"
+        next if File.directory?(path) || File.extname(path) != '.pp'
+
+        all_cap << [File.basename(path, '.pp'), path].freeze
+      end
+      all_cap
+    end
+
+    def self.find_valid_classes(all_cap)
+      all_classes = all_cap.dup.transpose[0]
+      all_classes - find_invalid_classes(all_cap)
+    end
+
+    def self.find_invalid_classes(all_cap)
+      invalid_classes = []
+      all_cap.each do |cap|
+        invalid_classes << cap[0] unless class_valid?(cap[1])
+      end
+      invalid_classes
+    end
+
+    def self.class_valid?(manifest_path)
+      compiler = Puppet::Pal::Compiler.new(nil)
+      ast = compiler.parse_file(manifest_path)
+      ast.body.body.statements.each do |s|
+        next unless s.respond_to?(:arguments)
+        next unless s.arguments.respond_to?(:each)
+
+        s.arguments.each do |i|
+          return false if i.value == 'Not implemented'
+        end
+      end
+      true
+    end
+  end
+end

data/lib/abide_dev_utils/prompt.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module AbideDevUtils
+  module Prompt
+    def self.yes_no(msg)
+      print "#{msg} (Y/n): "
+      return true if $stdin.cooked(&:gets).match?(/^[Yy].*/)
+
+      false
+    end
+
+    def self.single_line(msg)
+      print "#{msg}: "
+      $stdin.cooked(&:gets).chomp
+    end
+
+    def self.username
+      print 'Username: '
+      $stdin.cooked(&:gets).chomp
+    end
+
+    def self.password
+      $stdin.getpass('Password:')
+    end
+
+    def self.secure(msg)
+      $stdin.getpass(msg)
+    end
+  end
+end