payping-gitlab-triage 0.1.1

data/lib/gitlab/triage/network_adapters/base_adapter.rb

@@ -0,0 +1,17 @@
+require_relative '../version'
+
+module Gitlab
+  module Triage
+    module NetworkAdapters
+      class BaseAdapter
+        USER_AGENT = "GitLab Triage #{Gitlab::Triage::VERSION}".freeze
+
+        attr_reader :options
+
+        def initialize(options)
+          @options = options
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/network_adapters/graphql_adapter.rb

@@ -0,0 +1,92 @@
+require 'graphql/client'
+require 'graphql/client/http'
+
+require_relative 'base_adapter'
+require_relative '../ui'
+require_relative '../errors'
+
+module Gitlab
+  module Triage
+    module NetworkAdapters
+      class GraphqlAdapter < BaseAdapter
+        Client = GraphQL::Client
+
+        def query(graphql_query, resource_path: [], variables: {})
+          response = client.query(graphql_query, variables: variables, context: { token: options.token })
+
+          raise_on_error!(response)
+
+          parsed_response = parse_response(response, resource_path)
+          headers = response.extensions.fetch('headers', {})
+
+          graphql_response = {
+            ratelimit_remaining: headers['ratelimit-remaining'].to_i,
+            ratelimit_reset_at: Time.at(headers['ratelimit-reset'].to_i)
+          }
+
+          return graphql_response.merge(results: {}) if parsed_response.nil?
+          return graphql_response.merge(results: parsed_response.map(&:to_h)) if parsed_response.is_a?(Client::List)
+          return graphql_response.merge(results: parsed_response.to_h) unless parsed_response.nodes?
+
+          graphql_response.merge(
+            more_pages: parsed_response.page_info.has_next_page,
+            end_cursor: parsed_response.page_info.end_cursor,
+            results: parsed_response.nodes.map(&:to_h)
+          )
+        end
+
+        delegate :parse, to: :client
+
+        private
+
+        def parse_response(response, resource_path)
+          resource_path.reduce(response.data) { |data, resource| data&.send(resource) }
+        end
+
+        def raise_on_error!(response)
+          return if response.errors.blank?
+
+          puts Gitlab::Triage::UI.debug response.inspect if options.debug
+
+          raise "There was an error: #{response.errors.messages.to_json}"
+        end
+
+        def http_client
+          Client::HTTP.new("#{options.host_url}/api/graphql") do
+            def execute(document:, operation_name: nil, variables: {}, context: {}) # rubocop:disable Lint/NestedMethodDefinition
+              body = {}
+              body['query'] = document.to_query_string
+              body['variables'] = variables if variables.any?
+              body['operationName'] = operation_name if operation_name
+
+              response = HTTParty.post(
+                uri,
+                body: body.to_json,
+                headers: {
+                  'User-Agent' => USER_AGENT,
+                  'Content-type' => 'application/json',
+                  'PRIVATE-TOKEN' => context[:token]
+                }
+              )
+
+              case response.code
+              when 200, 400
+                JSON.parse(response.body).merge('extensions' => { 'headers' => response.headers })
+              else
+                { 'errors' => [{ 'message' => "#{response.code} #{response.message}" }] }
+              end
+            end
+          end
+        end
+
+        def schema
+          @schema ||= Client.load_schema(http_client)
+        end
+
+        def client
+          @client ||= Client.new(schema: schema, execute: http_client).tap { |client| client.allow_dynamic_queries = true }
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/network_adapters/httparty_adapter.rb

@@ -0,0 +1,116 @@
+require 'httparty'
+
+require_relative 'base_adapter'
+require_relative '../ui'
+require_relative '../errors'
+
+module Gitlab
+  module Triage
+    module NetworkAdapters
+      class HttpartyAdapter < BaseAdapter
+        def get(token, url)
+          response = HTTParty.get(
+            url,
+            headers: {
+              'User-Agent' => USER_AGENT,
+              'Content-type' => 'application/json',
+              'PRIVATE-TOKEN' => token
+            }
+          )
+
+          raise_on_unauthorized_error!(response)
+          raise_on_internal_server_error!(response)
+          raise_on_too_many_requests!(response)
+
+          {
+            more_pages: (response.headers["x-next-page"].to_s != ""),
+            next_page_url: next_page_url(url, response),
+            results: response.parsed_response,
+            ratelimit_remaining: response.headers["ratelimit-remaining"].to_i,
+            ratelimit_reset_at: Time.at(response.headers["ratelimit-reset"].to_i)
+          }
+        end
+
+        def post(token, url, body)
+          response = HTTParty.post(
+            url,
+            body: body.to_json,
+            headers: {
+              'User-Agent' => "GitLab Triage #{Gitlab::Triage::VERSION}",
+              'Content-type' => 'application/json',
+              'PRIVATE-TOKEN' => token
+            }
+          )
+
+          raise_on_unauthorized_error!(response)
+          raise_on_internal_server_error!(response)
+          raise_on_too_many_requests!(response)
+
+          {
+            results: response.parsed_response,
+            ratelimit_remaining: response.headers["ratelimit-remaining"].to_i,
+            ratelimit_reset_at: Time.at(response.headers["ratelimit-reset"].to_i)
+          }
+        end
+
+        def delete(token, url)
+          response = HTTParty.delete(
+            url,
+            headers: {
+              'User-Agent' => USER_AGENT,
+              'PRIVATE-TOKEN' => token
+            }
+          )
+
+          raise_on_unauthorized_error!(response)
+          raise_on_internal_server_error!(response)
+          raise_on_too_many_requests!(response)
+
+          {
+            results: response.parsed_response,
+            ratelimit_remaining: response.headers["ratelimit-remaining"].to_i,
+            ratelimit_reset_at: Time.at(response.headers["ratelimit-reset"].to_i)
+          }
+        end
+
+        private
+
+        def raise_on_unauthorized_error!(response)
+          return unless response.response.is_a?(Net::HTTPUnauthorized)
+
+          puts Gitlab::Triage::UI.debug response.inspect if options.debug
+
+          raise 'The provided token is unauthorized!'
+        end
+
+        def raise_on_internal_server_error!(response)
+          return unless response.response.is_a?(Net::HTTPInternalServerError)
+
+          puts Gitlab::Triage::UI.debug response.inspect if options.debug
+
+          raise Errors::Network::InternalServerError, 'Internal server error encountered!'
+        end
+
+        def raise_on_too_many_requests!(response)
+          return unless response.response.is_a?(Net::HTTPTooManyRequests)
+
+          puts Gitlab::Triage::UI.debug response.inspect if options.debug
+
+          raise Errors::Network::TooManyRequests, 'Too many requests made!'
+        end
+
+        def next_page_url(url, response)
+          return unless response.headers['x-next-page'].present?
+
+          next_page = "&page=#{response.headers['x-next-page']}"
+
+          if url.include?('&page')
+            url.gsub(/&page=\d+/, next_page)
+          else
+            url + next_page
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/network_adapters/test_adapter.rb

@@ -0,0 +1,39 @@
+require 'httparty'
+
+require_relative 'base_adapter'
+
+module Gitlab
+  module Triage
+    module NetworkAdapters
+      class TestAdapter < BaseAdapter
+        def get(_token, url)
+          results =
+            case url
+            when %r{\Ahttps://gitlab.com/v4/issues?per_page=100}
+              [
+                { id: 1, title: 'First issue' }
+              ]
+            else
+              []
+            end
+
+          {
+            more_pages: false,
+            next_page_url: nil,
+            results: results,
+            ratelimit_remaining: 600,
+            ratelimit_reset_at: Time.now
+          }
+        end
+
+        def post(token, url, body)
+          {
+            results: {},
+            ratelimit_remaining: 600,
+            ratelimit_reset_at: Time.now
+          }
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/option_parser.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal
+
+require 'optparse'
+require 'fileutils'
+require_relative 'options'
+
+module Gitlab
+  module Triage
+    class OptionParser
+      class << self
+        # rubocop:disable Metrics/AbcSize
+        def parse(argv)
+          options = Options.new
+          options.host_url = 'https://gitlab.com'
+
+          parser = ::OptionParser.new do |opts|
+            opts.banner = "Usage: gitlab-triage [options]\n\n"
+
+            opts.on('-n', '--dry-run', "Don't actually update anything, just print") do |value|
+              options.dry_run = value
+            end
+
+            opts.on('-f', '--policies-file [string]', String, 'A valid policies YML file') do |value|
+              options.policies_files << value
+            end
+
+            opts.on('--all-projects', 'Process all projects the token has access to') do |value|
+              options.all = value
+            end
+
+            opts.on('-s', '--source [type]', [:projects, :groups], 'The source type between [ projects or groups ], default value: projects') do |value|
+              options.source = value
+            end
+
+            opts.on('-i', '--source-id [string]', String, 'Source ID or path') do |value|
+              options.source_id = value
+            end
+
+            opts.on('-p', '--project-id [string]', String, '[Deprecated] A project ID or path, please use `--source-id`') do |value|
+              puts Gitlab::Triage::UI.warn("The option `--project-id` has been deprecated, please use `--source-id` instead")
+              puts
+              options.source = 'projects'
+              options.source_id = value
+            end
+
+            opts.on('--resource-reference [string]', String, 'Resource short-reference, e.g. #42, !33, or &99') do |value|
+              options.resource_reference = value
+            end
+
+            opts.on('-t', '--token [string]', String, 'A valid API token') do |value|
+              options.token = value
+            end
+
+            opts.on('-H', '--host-url [string]', String, 'A valid host url') do |value|
+              options.host_url = value
+            end
+
+            opts.on('-r', '--require [string]', String, 'Require a file before performing') do |value|
+              options.require_files << value
+            end
+
+            opts.on('-d', '--debug', 'Print debug information') do |value|
+              options.debug = value
+            end
+
+            opts.on('-h', '--help', 'Print help message') do
+              $stdout.puts opts
+              exit # rubocop:disable Rails/Exit
+            end
+
+            opts.on('-v', '--version', 'Print version') do
+              require_relative 'version'
+              $stdout.puts Gitlab::Triage::VERSION
+              exit # rubocop:disable Rails/Exit
+            end
+
+            opts.on('--init', 'Initialize the project with a policy file') do
+              example_path =
+                File.expand_path('../../../support/.triage-policies.example.yml', __dir__)
+
+              FileUtils.cp(example_path, '.triage-policies.yml')
+              exit # rubocop:disable Rails/Exit
+            end
+
+            opts.on('--init-ci', 'Initialize the project with a .gitlab-ci.yml file') do
+              example_path =
+                File.expand_path('../../../support/.gitlab-ci.example.yml', __dir__)
+
+              FileUtils.cp(example_path, '.gitlab-ci.yml')
+              exit # rubocop:disable Rails/Exit
+            end
+          end
+
+          parser.parse!(argv)
+
+          options.source = nil if options.all
+          options.token ||= ''
+
+          options
+        end
+        # rubocop:enable Metrics/AbcSize
+      end
+    end
+  end
+end

data/lib/gitlab/triage/options.rb

@@ -0,0 +1,30 @@
+module Gitlab
+  module Triage
+    Options = Struct.new(
+      :dry_run,
+      :policies_files,
+      :resources,
+      :all,
+      :source,
+      :source_id,
+      :resource_reference,
+      :token,
+      :debug,
+      :host_url,
+      :require_files,
+      :api_version
+    ) do
+      def initialize(*args)
+        super
+
+        # Defaults
+        self.host_url ||= 'https://gitlab.com'
+        self.api_version ||= 'v4'
+        self.all ||= false
+        self.source ||= 'projects'
+        self.require_files ||= []
+        self.policies_files ||= Set.new
+      end
+    end
+  end
+end

data/lib/gitlab/triage/param_builders/date_param_builder.rb

@@ -0,0 +1,64 @@
+require_relative '../validators/params_validator'
+
+module Gitlab
+  module Triage
+    module ParamBuilders
+      class DateParamBuilder
+        CONDITIONS = %w[older_than newer_than].freeze
+        TIME_BASED_INTERVALS = %w[minutes hours].freeze
+        DATE_BASED_INTERVALS = %w[days weeks months years].freeze
+        INTERVAL_TYPES = TIME_BASED_INTERVALS + DATE_BASED_INTERVALS
+
+        def initialize(allowed_attributes, condition_hash)
+          @allowed_attributes = allowed_attributes
+          @attribute = condition_hash[:attribute].to_s
+          @interval_condition = condition_hash[:condition].to_sym
+          @interval_type = condition_hash[:interval_type]
+          @interval = condition_hash[:interval]
+
+          validate_condition(condition_hash)
+        end
+
+        def param_content
+          if TIME_BASED_INTERVALS.include?(interval_type)
+            interval.public_send(interval_type).ago.to_datetime # rubocop:disable GitlabSecurity/PublicSend
+          else
+            interval.public_send(interval_type).ago.to_date # rubocop:disable GitlabSecurity/PublicSend
+          end
+        end
+
+        private
+
+        attr_reader :allowed_attributes, :attribute, :interval_condition, :interval_type, :interval
+
+        def validate_condition(condition)
+          ParamsValidator.new(filter_parameters, condition).validate!
+        end
+
+        def filter_parameters
+          [
+            {
+              name: :attribute,
+              type: String,
+              values: allowed_attributes
+            },
+            {
+              name: :condition,
+              type: String,
+              values: CONDITIONS
+            },
+            {
+              name: :interval_type,
+              type: String,
+              values: INTERVAL_TYPES
+            },
+            {
+              name: :interval,
+              type: Numeric
+            }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/policies/base_policy.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module Triage
+    module Policies
+      class BasePolicy
+        InvalidPolicyError = Class.new(StandardError)
+
+        attr_reader :type, :policy_spec, :resources, :network
+        attr_accessor :summary
+
+        def initialize(type, policy_spec, resources, network)
+          @type = type
+          @policy_spec = policy_spec
+          @resources = resources
+          @network = network
+        end
+
+        def validate!
+          raise InvalidPolicyError, 'Policies that comment_on_summary must include summarize action' if comment_on_summary? && !summarize?
+        end
+
+        def name
+          @name ||= (policy_spec[:name] || "#{type}-#{object_id}")
+        end
+
+        def source
+          case type
+          when 'epics'
+            'groups'
+          else
+            'projects'
+          end
+        end
+
+        def source_id_sym
+          case type
+          when 'epics'
+            :group_id
+          else
+            :project_id
+          end
+        end
+
+        def actions
+          @actions ||= policy_spec.fetch(:actions) { {} }
+        end
+
+        def summarize?
+          actions.key?(:summarize)
+        end
+
+        def comment_on_summary?
+          actions.key?(:comment_on_summary)
+        end
+
+        def comment?
+          # The actual keys are strings
+          (actions.keys.map(&:to_sym) - [:summarize, :comment_on_summary, :delete, :issue]).any?
+        end
+
+        def issue?
+          actions.key?(:issue)
+        end
+
+        def delete?
+          actions.key?(:delete) && actions[:delete]
+        end
+
+        def build_issue
+          raise NotImplementedError
+        end
+
+        def build_summary
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/policies/rule_policy.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'base_policy'
+require_relative '../entity_builders/issue_builder'
+require_relative '../entity_builders/summary_builder'
+
+module Gitlab
+  module Triage
+    module Policies
+      class RulePolicy < BasePolicy
+        # Build a summary from a single rule policy
+        def build_summary
+          action = actions.fetch(:summarize, {})
+
+          EntityBuilders::SummaryBuilder.new(
+            type: type,
+            policy_spec: policy_spec,
+            action: action,
+            resources: resources,
+            network: network)
+        end
+
+        def build_issue(resource)
+          action = actions.fetch(:issue, {})
+
+          EntityBuilders::IssueBuilder.new(
+            type: type,
+            policy_spec: policy_spec,
+            action: action,
+            resource: resource,
+            network: network)
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/policies/summary_policy.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'base_policy'
+require_relative '../entity_builders/summary_builder'
+
+module Gitlab
+  module Triage
+    module Policies
+      class SummaryPolicy < BasePolicy
+        # Build a summary from several rules policies
+        def build_summary
+          action = actions[:summarize]
+          issues = resources.map do |inner_policy_spec, inner_resources|
+            Policies::RulePolicy.new(
+              type, inner_policy_spec, inner_resources, network)
+              .build_summary
+          end
+
+          EntityBuilders::SummaryBuilder.new(
+            type: type,
+            action: action,
+            resources: issues.select(&:any_resources?),
+            network: network,
+            separator: "\n\n")
+        end
+      end
+    end
+  end
+end

data/lib/gitlab/triage/policies_resources/rule_resources.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Gitlab
+  module Triage
+    module PoliciesResources
+      RuleResources = Class.new(SimpleDelegator)
+    end
+  end
+end

data/lib/gitlab/triage/policies_resources/summary_resources.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Gitlab
+  module Triage
+    module PoliciesResources
+      SummaryResources = Class.new(SimpleDelegator)
+    end
+  end
+end