pdksync 0.2.0 → 0.6.0

data/lib/pdksync/conf/puppet_abs_supported_platforms.yaml

@@ -0,0 +1,41 @@
+# PUPPET VERSION PLATFORM COMPATIBILITY
+#
+# Define the Puppet version as a root key, then specify the OS platform(s) and versions(s) that this Puppet version is
+# compatible with AND that you wish to test on. If you wish to exclude a platform from testing, simply omit it.
+#
+# OS names and versions must conform to the VMPooler nomenclature and conventions.
+#
+# Running 'bundle exec rake 'pdksync:generate_vmpooler_release_checks[7]' will generate an entry in the 'provision.yaml'
+# for each managed module that contains a configuration that satisfies both:
+# - The module's compatible platforms
+# - The Puppet version's compatible platforms (in this example: '7')
+#
+# NOTE: arch will always be assumed to be 'x86_64'
+---
+5:
+  centos: ['5', '6', '7', '8']
+  debian: ['8', '9', '10']
+  oracle: ['5', '6', '7']
+  redhat: ['5', '6', '7', '8']
+  sles: ['12', '15']
+  scientific: ['6', '7']
+  ubuntu: ['14.04', '16.04', '18.04']
+  win: ['2008r2', '2012r2', '2016', '2019', '10-pro']
+6:
+  centos: ['5', '6', '7', '8']
+  debian: ['8', '9', '10']
+  oracle: ['5', '6', '7']
+  redhat: ['5', '6', '7', '8']
+  sles: ['12', '15']
+  scientific: ['6', '7']
+  ubuntu: ['14.04', '16.04', '18.04', '20.04']
+  win: ['2008r2', '2012r2', '2016', '2019', '10-pro']
+7:
+  centos: ['7', '8']
+  debian: ['9', '10']
+  oracle: ['7']
+  redhat: ['7', '8']
+  sles: ['12', '15']
+  scientific: ['7']
+  ubuntu: ['18.04', '20.04']
+  win: ['2012r2', '2016', '2019', '10-pro']

data/lib/pdksync/configuration.rb

@@ -0,0 +1,155 @@
+require 'yaml'
+require 'pdk/version'
+require 'ostruct'
+
+# @summary
+#   A class used to contain a set of configuration variables
+# @note
+#   Configuration is loaded from `$HOME/.pdksync.yml`. If $HOME is not set, the config_path will use the current directory.
+#   The configuration filename and path can be overridden with env variable PDK_CONFIG_PATH
+#   Set PDKSYNC_LABEL to '' to disable adding a label during pdksync runs.
+module PdkSync
+  class Configuration < OpenStruct
+    SUPPORTED_SCM_PLATFORMS = [:github, :gitlab].freeze
+    PDKSYNC_FILE_NAME = 'pdksync.yml'.freeze
+
+    # Any key value added to the default config or custom config
+    # will automatically be a new configuration item and referenced
+    # via Configuration.new.<key_name> ie.
+    # c = Configuration.new
+    # c.api_endpoint
+    DEFAULT_CONFIG = {
+      namespace: 'puppetlabs',
+      pdksync_dir: 'modules_pdksync',
+      pdksync_gem_dir: 'gems_pdksync',
+      push_file_destination: 'origin',
+      create_pr_against: 'main',
+      managed_modules: 'managed_modules.yml',
+      pdksync_label: 'maintenance',
+      git_platform: :github,
+      git_base_uri: 'https://github.com',
+      gitlab_api_endpoint: 'https://gitlab.com/api/v4',
+      api_endpoint: nil,
+      pdk_templates_prefix: nil,
+      pdk_templates_ref: PDK::VERSION,
+      pdk_templates_url: 'https://github.com/puppetlabs/pdk-templates.git',
+      jenkins_platform: :jenkins,
+      jenkins_base_uri: 'https://jenkins.io',
+      jenkins_api_endpoint: '',
+      jenkins_server_url: '',
+      module_is_authoritive: true
+    }.freeze
+
+    # @param config_path [String] -  the path to the pdk config file
+    def initialize(config_path = ENV['PDKSYNC_CONFIG_PATH'])
+      @config_path = locate_config_path(config_path)
+      @custom_config = DEFAULT_CONFIG.merge(custom_config(@config_path))
+      @custom_config[:pdk_templates_ref] = "#{@custom_config[:pdk_templates_prefix]}#{@custom_config[:pdk_templates_ref]}"
+      super(@custom_config)
+      valid_scm?(git_platform)
+      valid_access_token?
+    end
+
+    # @return [Hash] - returns the access settings for git scm
+    def git_platform_access_settings
+      @git_platform_access_settings ||= {
+        access_token: access_token,
+        gitlab_api_endpoint: gitlab_api_endpoint || api_endpoint,
+        api_endpoint: api_endpoint
+
+      }
+    end
+
+    def jenkins_platform_access_settings
+      @jenkins_platform_access_settings ||= {
+        jenkins_username: ENV['JENKINS_USERNAME'].freeze,
+        jenkins_password: ENV['JENKINS_PASSWORD'].freeze,
+        jenkins_api_endpoint: ''
+      }
+    end
+
+    # @return [Hash] - returns the access settings for gemfury account
+    def gemfury_access_settings
+      valid_access_token_gem_fury?
+      @gemfury_access_token = access_token_gem_fury
+    end
+
+    # @return [String] return a rendered string for pdk to use the templates
+    def templates
+      "--template-url=#{pdk_templates_url} --template-ref=#{pdk_templates_ref}"
+    end
+
+    # @param path [String] path to the pdksync config file in yaml format
+    # @return [Hash] the custom configuration as a hash
+    def custom_config(path = nil)
+      return {} unless path
+      return {} unless File.exist?(path)
+      c = (YAML.load_file(path) || {}).transform_keys_to_symbols
+      c[:git_base_uri] ||= 'https://gitlab.com' if c[:git_platform].eql?(:gitlab)
+      c
+    end
+
+    # @return [String] the path the pdksync config file, nil if not found
+    def locate_config_path(custom_file = nil)
+      files = [
+        custom_file,
+        PDKSYNC_FILE_NAME,
+        File.join(ENV['HOME'], PDKSYNC_FILE_NAME)
+      ]
+      files.find { |file| file && File.exist?(file) }
+    end
+
+    private
+
+    # @return [Boolean] true if the supported platforms were specified correctly
+    # @param scm [Symbol] - the scm type (:github or :gitlab)
+    def valid_scm?(scm)
+      unless SUPPORTED_SCM_PLATFORMS.include?(scm)
+        raise ArgumentError, "Unsupported Git hosting platform '#{scm}'."\
+          " Supported platforms are: #{SUPPORTED_SCM_PLATFORMS.join(', ')}"
+      end
+      true
+    end
+
+    # @return [Boolean] true if the access token for the scm platform was supplied
+    def valid_access_token?
+      if access_token.nil?
+        raise ArgumentError, "Git platform access token for #{git_platform.capitalize} not set"\
+          " - use 'export #{git_platform.upcase}_TOKEN=\"<your token>\"' to set"
+      end
+      true
+    end
+
+    # @return [Boolean] true if the access token for the gemfury was supplied
+    def valid_access_token_gem_fury?
+      if access_token_gem_fury.nil?
+        raise 'Gemfury access token not set'\
+        " - use 'export GEMFURY_TOKEN=\"<your token>\"' to set"
+      end
+      true
+    end
+
+    # @return [String] the platform specific access token
+    def access_token
+      case git_platform
+      when :github
+        ENV['GITHUB_TOKEN'].freeze
+      when :gitlab
+        ENV['GITLAB_TOKEN'].freeze
+      end
+    end
+
+    # @return [String] the gem_fury access token
+    def access_token_gem_fury
+      ENV['GEMFURY_TOKEN'].freeze
+    end
+  end
+end
+
+# monkey patch
+class Hash
+  # take keys of hash and transform those to a symbols
+  def transform_keys_to_symbols
+    each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v; }
+  end
+end

data/lib/pdksync/githubclient.rb

@@ -0,0 +1,77 @@
+require 'octokit'
+
+# @summary
+#   This class wraps Octokit::Client and provides the method implementations
+#   required by pdksync main to access the Github API for creating pull
+#   requests, adding labels, and so forth.
+class PdkSync::GithubClient
+  # @summary
+  #   Creates a new Octokit::Client and logs in the user based on the
+  #   supplied access token
+  # @param access_token
+  #   The Github access token, required to access the Github API
+  def initialize(access_token, api_endpoint = nil)
+    # USE ENV['OCTOKIT_API_ENDPOINT'] or pass in the api_endpoint
+    Octokit.configure { |c| c.api_endpoint = api_endpoint } unless api_endpoint.nil?
+    @client = Octokit::Client.new(access_token: access_token.to_s)
+    @client.user.login
+  end
+
+  # @summary Checks if the supplied repository exists on the Git hosting platform
+  # @param [String] repository
+  #   The full repository name, i.e. "namespace/repo_name"
+  # @return [Boolean] true if the repository exists, false otherwise
+  def repository?(repository)
+    @client.repository?(repository)
+  end
+
+  # @summary Creates a new pull request against the Git hosting platform
+  # @param [String] repo_name
+  #   The full repository name, i.e. "namespace/repo_name" in which to create
+  #   the pull request
+  # @param [String] create_pr_against
+  #   The target branch against which to create the pull request
+  # @param [String] head
+  #   The source branch from which to create the pull request
+  # @param [String] title
+  #   The title/name of the pull request to create
+  # @param [String] message
+  #   The pull request message/body
+  # @return An Octokit pull request object for the newly created pull request
+  def create_pull_request(repo_name, create_pr_against, head, title, message)
+    @client.create_pull_request(repo_name, create_pr_against, head, title, message)
+  end
+
+  # @summary Gets the labels available in the repository
+  # @param [String] repo_name
+  #   The full repository name, i.e. "namespace/repo_name", from which to get
+  #   the available labels
+  # @return [Array] List of available labels in the repository
+  def labels(repo_name)
+    @client.labels(repo_name)
+  end
+
+  # @summary Updates an existing issue/pull request in the repository
+  # @param [String] repo_name
+  #   The full repository name, i.e. "namespace/repo_name" in which to update
+  #   the issue
+  # @param [Integer] issue_number
+  #   The id number of the issue/pull request to update
+  # @param [Hash] options
+  #   A hash of options definint the changes to the issue
+  # @return An Octokit issue object of the updated issue
+  def update_issue(repo_name, issue_number, options)
+    @client.update_issue(repo_name, issue_number, options)
+  end
+
+  # @summary Deletes a branch in the repository
+  # @param [String] repo_name
+  #   The full repository name, i.e. "namespace/repo_name" in which to delete
+  #   the branch
+  # @param [String] branch_name
+  #   The name of the branch to delete
+  # @return [Boolean] true on success, false on failure
+  def delete_branch(repo_name, branch_name)
+    @client.delete_branch(repo_name, branch_name)
+  end
+end

data/lib/pdksync/gitlabclient.rb

@@ -0,0 +1,91 @@
+require 'gitlab'
+
+# @summary
+#   This class wraps Gitlab::Client and provides the method implementations
+#   required by pdksync main to access the Gitlab API for creating merge
+#   requests, adding labels, and so forth.
+class PdkSync::GitlabClient
+  # @summary
+  #   Creates a new Gitlab::Client and logs in the user based on the
+  #   supplied access token and the Gitlab API endpoint URL
+  # @param [String] access_token
+  #   The Gitlab private access token, required to access the Gitlab API
+  # @param [String] gitlab_api_endpoint
+  #   URL to the Gitlab API endpoint against which to work
+  def initialize(access_token, gitlab_api_endpoint)
+    @client = Gitlab.client(endpoint: gitlab_api_endpoint, private_token: access_token)
+  end
+
+  # @summary Checks if the supplied project exists on the Git hosting platform
+  # @param [String] project
+  #   The full repository name, i.e. "namespace/project"
+  # @return [Boolean] true if the project exists, false otherwise
+  def repository?(project)
+    @client.project(project)
+
+    true
+  rescue Gitlab::Error::NotFound
+    false
+  end
+
+  # @summary
+  #   Creates a new merge request (i.e. pull request) against the Gitlab
+  #   platform
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project" in which to create
+  #   the merge request
+  # @param [String] target_branch
+  #   The target branch against which to create the merge request
+  # @param [String] source_branch
+  #   The source branch from which to create the merge request
+  # @param [String] title
+  #   The title/name of the merge request to create
+  # @param [String] message
+  #   The pull request message/body
+  # @return
+  #   A Gitlab merge request object for the newly created merge request
+  def create_pull_request(project, target_branch, source_branch, title, message)
+    mr_options = {
+      source_branch: source_branch,
+      target_branch: target_branch,
+      description: message
+    }
+    @client.create_merge_request(project, title, mr_options)
+  end
+
+  # @summary Gets the labels available in the project
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project", from which to get
+  #   the available labels
+  # @return [Array] List of available labels in the project
+  def labels(project)
+    @client.labels(project)
+  end
+
+  # @summary Updates an existing merge request in the repository
+  # @note This method is specifically used to set labels for a merge request
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project" in which to update
+  #   the issue
+  # @param [Integer] id
+  #   The id number of the merge request to update
+  # @param [Hash] options
+  #   A hash of options defining the changes to the merge request
+  # @return A Gitlab merge request object of the updated merge request
+  def update_issue(project, id, options)
+    # Gitlab requires labels to be supplied as a comma-separated string
+    labels = options[:labels].join(',')
+    @client.update_merge_request(project, id, labels: labels)
+  end
+
+  # @summary Deletes a branch in the project
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project" in which to delete
+  #   the branch
+  # @param [String] branch_name
+  #   The name of the branch to delete
+  # @return [Boolean] true on success, false on failure
+  def delete_branch(project, branch_name)
+    @client.delete_branch(project, branch_name)
+  end
+end

data/lib/pdksync/gitplatformclient.rb

@@ -0,0 +1,109 @@
+require 'pdksync/pullrequest'
+
+# @summary
+#   The GitPlatformClient class creates a PdkSync::GithubClient or
+#   PdkSync::GitlabClient and provides methods wrapping the client's
+#   corresponding methods
+class PdkSync::GitPlatformClient
+  # @summary
+  #   Creates a PdkSync::GithubClient or PdkSync::GitlabClient based on the
+  #   value of git_platform.
+  # @param [Symbol] git_platform
+  #   The symbol designating the Git hosting platform to use and thus which
+  #   client to create
+  # @param [Hash] git_platform_access_settings
+  #   Hash of Git platform access settings, such as access_token or
+  #   gitlab_api_endpoint. access_token is always required,
+  #   gitlab_api_endpoint only for Gitlab.
+  def initialize(git_platform, git_platform_access_settings)
+    @git_platform = git_platform
+
+    # TODO: raise exceptions when git_platform_access_settings hash is not
+    # set up correctly? Or let PdkSync::GithubClient or PdkSync::GitlabClient
+    # raise errors later and let them propagate upwards?
+    access_token = git_platform_access_settings[:access_token]
+    @client = case git_platform
+              when :github
+                require 'pdksync/githubclient'
+
+                PdkSync::GithubClient.new(access_token, git_platform_access_settings[:api_endpoint])
+              when :gitlab
+                require 'pdksync/gitlabclient'
+
+                gitlab_api_endpoint = git_platform_access_settings[:gitlab_api_endpoint] || git_platform_access_settings[:api_endpoint]
+                PdkSync::GitlabClient.new(access_token, gitlab_api_endpoint)
+              end
+  end
+
+  # @summary Checks if the supplied project exists on the Git hosting platform
+  # @param [String] project
+  #   The full repository name, i.e. "namespace/project"
+  # @return [Boolean] true if the project exists, false otherwise
+  def repository?(project)
+    @client.repository?(project)
+  end
+
+  # @summary
+  #   Creates a new pull/merge request against the Git hosting platform and
+  #   wraps the Github or Gitlab result in a PdkSync::PullRequest object for
+  #   consumption by pdksync main
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project" in which to create
+  #   the pull/merge request
+  # @param [String] target_branch
+  #   The target branch against which to create the pull/merge request
+  # @param [String] source_branch
+  #   The source branch from which to create the pull/merge request
+  # @param [String] title
+  #   The title/name of the pull/merge request to create
+  # @param [String] message
+  #   The pull/merge request message/body
+  # @return [PdkSync::PullRequest]
+  #   A pdksync pull request object for the newly created pull/merge request
+  #   for consumption by pdksync main
+  def create_pull_request(project, target_branch, source_branch, title, message)
+    client_pr = @client.create_pull_request(project, target_branch, source_branch, title, message)
+    pr = case @git_platform
+         when :github
+           PdkSync::PullRequest.github(client_pr)
+         when :gitlab
+           PdkSync::PullRequest.gitlab(client_pr)
+         end
+    pr
+  end
+
+  # @summary Gets the labels available in the project
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project", from which to get
+  #   the available labels
+  # @return [Array] List of available labels in the project
+  def labels(project)
+    @client.labels(project)
+  end
+
+  # @summary Updates an existing pull/merge request in the repository
+  # @note
+  #   This method is specifically used to set labels for a pull/merge request
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project" in which to update
+  #   the issue
+  # @param [Integer] id
+  #   The id number of the pull/merge request to update
+  # @param [Hash] options
+  #   A hash of options defining the changes to the pull/merge request
+  # @return A pull/merge request object of the updated pull/merge request
+  def update_issue(project, id, options)
+    @client.update_issue(project, id, options)
+  end
+
+  # @summary Deletes a branch in the project
+  # @param [String] project
+  #   The full project name, i.e. "namespace/project" in which to delete
+  #   the branch
+  # @param [String] branch_name
+  #   The name of the branch to delete
+  # @return [Boolean] true on success, false on failure
+  def delete_branch(project, branch_name)
+    @client.delete_branch(project, branch_name)
+  end
+end