pact_broker 2.81.0 → 2.82.0

data/lib/pact_broker/config/basic_auth_configuration.rb

@@ -0,0 +1,38 @@
+require "pact_broker/config/runtime_configuration_logging_methods"
+require "pact_broker/string_refinements"
+
+module PactBroker
+  module Config
+    module RuntimeConfigurationBasicAuthMethods
+      using PactBroker::StringRefinements
+
+      def self.included(anyway_config)
+        anyway_config.class_eval do
+          attr_config(
+            basic_auth_enabled: false,
+            basic_auth_username: nil,
+            basic_auth_password: nil,
+            basic_auth_read_only_username: nil,
+            basic_auth_read_only_password: nil,
+            allow_public_read: false,
+            public_heartbeat: false
+          )
+
+          sensitive_values(:basic_auth_password, :basic_auth_read_only_password)
+
+          def basic_auth_credentials_provided?
+            basic_auth_username&.not_blank? && basic_auth_password&.not_blank?
+          end
+
+          def basic_auth_write_credentials
+            [basic_auth_username, basic_auth_password]
+          end
+
+          def basic_auth_read_credentials
+            [basic_auth_read_only_username, basic_auth_read_only_password]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/config/load.rb

@@ -9,12 +9,12 @@ module PactBroker
 
       include PactBroker::Logging
 
-      def self.call configuration
-        new(configuration).call
+      def self.call runtime_configuration
+        new(runtime_configuration).call
       end
 
-      def initialize configuration
-        @configuration = configuration
+      def initialize runtime_configuration
+        @runtime_configuration = runtime_configuration
       end
 
       def call
@@ -25,18 +25,29 @@ module PactBroker
 
       private
 
-      attr_reader :configuration
+      attr_reader :runtime_configuration
 
       def configuration_attribute_exists? setting
-        configuration.respond_to?("#{setting.name}=")
+        runtime_configuration.respond_to?("#{setting.name}=")
+      end
+
+      def unset_or_value_from_default? setting
+        setting_source(setting).nil? || setting_source(setting)[:type] == :defaults
+      end
+
+      def setting_source(setting)
+        runtime_configuration.to_source_trace.dig(setting.name, :source)
       end
 
       def set_value_on_configuration setting
-        if configuration_attribute_exists? setting
-          logger.debug("Loading #{setting.name} configuration from database.")
-          configuration.send("#{setting.name}=", setting.value_object)
+        if configuration_attribute_exists?(setting)
+          if unset_or_value_from_default?(setting)
+            runtime_configuration.send("#{setting.name}=", setting.value_object)
+          else
+            logger.debug("Ignoring #{setting.name} configuration from database, as it has been set by another source #{setting_source(setting)}")
+          end
         else
-          logger.warn("Could not load configuration setting \"#{setting.name}\" as there is no matching attribute on the Configuration class")
+          logger.warn("Could not load configuration setting \"#{setting.name}\" as there is no matching attribute on the #{runtime_configuration.class} class")
         end
       end
     end

data/lib/pact_broker/config/runtime_configuration.rb

@@ -0,0 +1,188 @@
+require "anyway_config"
+require "pact_broker/config/runtime_configuration_logging_methods"
+require "pact_broker/config/runtime_configuration_database_methods"
+require "pact_broker/config/runtime_configuration_coercion_methods"
+require "pact_broker/version"
+require "pact_broker/config/basic_auth_configuration"
+require "pact_broker/string_refinements"
+require "pact_broker/hash_refinements"
+require "pact_broker/error"
+
+module PactBroker
+  module Config
+    class RuntimeConfiguration < Anyway::Config
+      using PactBroker::StringRefinements
+      using PactBroker::HashRefinements
+      include RuntimeConfigurationLoggingMethods
+      include RuntimeConfigurationCoercionMethods
+
+      include RuntimeConfigurationDatabaseMethods
+      include RuntimeConfigurationBasicAuthMethods
+
+      # logging attributes
+      attr_config(
+        log_dir: File.expand_path("./log"),
+        log_stream: :file,
+        log_level: :info,
+        log_format: nil,
+        warning_error_class_names: ["Sequel::ForeignKeyConstraintViolation"],
+        hide_pactflow_messages: false,
+        log_configuration_on_startup: true
+      )
+
+      on_load :validate_logging_attributes!
+
+      # webhook attributes
+      attr_config(
+        webhook_retry_schedule: [10, 60, 120, 300, 600, 1200], #10 sec, 1 min, 2 min, 5 min, 10 min, 20 min => 38 minutes
+        webhook_http_method_whitelist: ["POST"],
+        webhook_http_code_success: [200, 201, 202, 203, 204, 205, 206],
+        webhook_scheme_whitelist: ["https"],
+        webhook_host_whitelist: [],
+        disable_ssl_verification: false,
+        user_agent: "Pact Broker v#{PactBroker::VERSION}",
+      )
+
+      # resource attributes
+      attr_config(
+        port: 9292,
+        base_url: nil,
+        base_urls: [],
+        use_hal_browser: true,
+        enable_diagnostic_endpoints: true,
+        use_rack_protection: true,
+        badge_provider_mode: :redirect,
+        enable_public_badge_access: false,
+        shields_io_base_url: "https://img.shields.io",
+        use_case_sensitive_resource_names: true
+      )
+
+      # domain attributes
+      attr_config(
+        order_versions_by_date: true,
+        base_equality_only_on_content_that_affects_verification_results: true,
+        check_for_potential_duplicate_pacticipant_names: true,
+        create_deployed_versions_for_tags: true,
+        use_first_tag_as_branch: true,
+        use_first_tag_as_branch_time_limit: 10,
+        auto_detect_main_branch: true,
+        main_branch_candidates: ["develop", "main", "master"],
+        allow_dangerous_contract_modification: true,
+        semver_formats: ["%M.%m.%p%s%d", "%M.%m", "%M"],
+        seed_example_data: true,
+        features: []
+      )
+
+      def self.getter_and_setter_method_names
+        extra_methods = [
+          :warning_error_classes,
+          :database_configuration,
+          :basic_auth_credentials_provided?,
+          :basic_auth_write_credentials,
+          :basic_auth_read_credentials
+        ]
+        config_attributes + config_attributes.collect{ |k| "#{k}=".to_sym } + extra_methods  - [:base_url]
+      end
+
+      config_name :pact_broker
+
+      sensitive_values(:database_url, :database_password)
+
+      def log_level= log_level
+        super(log_level&.downcase&.to_sym)
+      end
+
+      def log_stream= log_stream
+        super(log_stream&.to_sym)
+      end
+
+      def log_format= log_format
+        super(log_format&.to_sym)
+      end
+
+      def custom_log_formatters= custom_log_formatters
+        super(custom_log_formatters&.symbolize_keys)
+      end
+
+      def base_url= base_url
+        super(value_to_string_array(base_url, "base_url"))
+      end
+
+      alias_method :original_base_url, :base_url
+
+      def base_url
+        raise NotImplementedError
+      end
+
+      def base_urls= base_urls
+        super(value_to_string_array(base_urls, "base_urls"))
+      end
+
+      def base_urls
+        (super + [*original_base_url]).uniq
+      end
+
+      def badge_provider_mode= badge_provider_mode
+        super(badge_provider_mode&.to_sym)
+      end
+
+      def warning_error_class_names= warning_error_class_names
+        super(value_to_string_array(warning_error_class_names, "warning_error_class_names"))
+      end
+
+      def semver_formats= semver_formats
+        super(value_to_string_array(semver_formats, "semver_formats"))
+      end
+
+      def webhook_retry_schedule= webhook_retry_schedule
+        super(value_to_integer_array(webhook_retry_schedule, "webhook_retry_schedule"))
+      end
+
+      def webhook_http_method_whitelist= webhook_http_method_whitelist
+        super(value_to_string_array(webhook_http_method_whitelist, "webhook_http_method_whitelist"))
+      end
+
+      def webhook_http_code_success= webhook_http_code_success
+        super(value_to_integer_array(webhook_http_code_success, "webhook_http_code_success"))
+      end
+
+      def webhook_scheme_whitelist= webhook_scheme_whitelist
+        super(value_to_string_array(webhook_scheme_whitelist, "webhook_scheme_whitelist"))
+      end
+
+      def webhook_host_whitelist= webhook_host_whitelist
+        super(value_to_string_array(webhook_host_whitelist, "webhook_host_whitelist"))
+      end
+
+      def features= features
+        super(value_to_string_array(features, "features").collect(&:downcase))
+      end
+
+      def warning_error_classes
+        warning_error_class_names.collect do | class_name |
+          begin
+            Object.const_get(class_name)
+          rescue NameError => e
+            puts("Class #{class_name} couldn't be loaded as a warning error class (#{e.class} - #{e.message}). Ignoring.")
+            nil
+          end
+        end.compact
+      end
+
+      def validate_logging_attributes!
+        valid_log_streams = [:file, :stdout]
+        unless valid_log_streams.include?(log_stream)
+          raise_validation_error("log_stream must be one of: #{valid_log_streams.join(", ")}")
+        end
+
+        if log_stream == :file && log_dir.blank?
+          raise_validation_error("Must specify log_dir if log_stream is set to file")
+        end
+      end
+
+      def raise_validation_error(msg)
+        raise PactBroker::ConfigurationError, msg
+      end
+    end
+  end
+end

data/lib/pact_broker/config/runtime_configuration_coercion_methods.rb

@@ -0,0 +1,41 @@
+require "pact_broker/config/space_delimited_string_list"
+require "pact_broker/config/space_delimited_integer_list"
+
+module PactBroker
+  module Config
+    module RuntimeConfigurationCoercionMethods
+      def value_to_string_array value, property_name
+        if value.is_a?(String)
+          PactBroker::Config::SpaceDelimitedStringList.parse(value)
+        elsif value.is_a?(Array)
+          # parse structured values to possible regexp
+          [*value].flat_map do | val |
+            if val.is_a?(String)
+              PactBroker::Config::SpaceDelimitedStringList.parse(val)
+            else
+              [val]
+            end
+          end
+        elsif value
+          raise ConfigurationError.new("Pact Broker configuration property `#{property_name}` must be a space delimited String or an Array. Got: #{value.inspect}")
+        end
+      end
+
+      private :value_to_string_array
+
+      def value_to_integer_array value, property_name
+        if value.is_a?(String)
+          PactBroker::Config::SpaceDelimitedIntegerList.parse(value)
+        elsif value.is_a?(Array)
+          value.collect { |v| v.to_i }
+        elsif value.is_a?(Integer)
+          [value]
+        elsif value
+          raise ConfigurationError.new("Pact Broker configuration property `#{property_name}` must be a space delimited String or an Array of Integers. Got: #{value.inspect}")
+        end
+      end
+
+      private :value_to_integer_array
+    end
+  end
+end

data/lib/pact_broker/config/runtime_configuration_database_methods.rb

@@ -0,0 +1,119 @@
+module PactBroker
+  module Config
+    module RuntimeConfigurationDatabaseMethods
+
+      # rubocop: disable Metrics/MethodLength
+      # rubocop: disable Metrics/CyclomaticComplexity
+      def self.included(anyway_config)
+        anyway_config.class_eval do
+
+          attr_config(
+            database_adapter: "postgres",
+            database_username: nil,
+            database_password: nil,
+            database_name: nil,
+            database_host: nil,
+            database_port: nil,
+            database_url: nil,
+            database_sslmode: nil,
+            sql_log_level: :debug,
+            sql_log_warn_duration: 5,
+            database_max_connections: nil,
+            database_pool_timeout: 5,
+            database_connect_max_retries: 0,
+            auto_migrate_db: true,
+            auto_migrate_db_data: true,
+            allow_missing_migration_files: true,
+            validate_database_connection_config: true,
+            database_statement_timeout: 15,
+            metrics_sql_statement_timeout: 30,
+            database_connection_validation_timeout: -1
+          )
+
+          def database_configuration
+            database_credentials
+              .merge(
+                encoding: "utf8",
+                sslmode: database_sslmode,
+                sql_log_level: sql_log_level,
+                log_warn_duration: sql_log_warn_duration,
+                max_connections: database_max_connections,
+                pool_timeout: database_pool_timeout,
+                driver_options: driver_options,
+                connect_max_retries: database_connect_max_retries,
+                connection_validation_timeout: database_connection_validation_timeout
+              ).compact
+          end
+
+          def database_connect_max_retries= database_connect_max_retries
+            super(database_connect_max_retries&.to_i)
+          end
+
+          def sql_log_level= sql_log_level
+            super(sql_log_level&.downcase&.to_sym)
+          end
+
+          def sql_log_warn_duration= sql_log_warn_duration
+            super(sql_log_warn_duration&.to_f)
+          end
+
+          def database_port= database_port
+            super(database_port&.to_i)
+          end
+
+          def metrics_sql_statement_timeout= metrics_sql_statement_timeout
+            super(metrics_sql_statement_timeout&.to_i)
+          end
+
+          def postgres?
+            database_credentials[:adapter] == "postgres"
+          end
+          private :postgres?
+
+          def driver_options
+            if postgres?
+              { options: "-c statement_timeout=#{database_statement_timeout}s" }
+            end
+          end
+          private :driver_options
+
+          def database_credentials
+            if database_url
+              database_configuration_from_url
+            else
+              database_configuration_from_parts
+            end
+          end
+          private :database_credentials
+
+          def database_configuration_from_parts
+            {
+              adapter: database_adapter,
+              user: database_username,
+              password: database_password,
+              host: database_host,
+              database: database_name,
+              database_port: database_port
+            }.compact
+          end
+          private :database_credentials
+
+          def database_configuration_from_url
+            uri = URI(database_url)
+            {
+              adapter: uri.scheme,
+              user: uri.user,
+              password: uri.password,
+              host: uri.host,
+              database: uri.path.sub(/^\//, ""),
+              port: uri.port&.to_i,
+            }.compact
+          end
+          private :database_configuration_from_url
+        end
+      end
+      # rubocop: enable Metrics/MethodLength
+      # rubocop: enable Metrics/CyclomaticComplexity
+    end
+  end
+end

data/lib/pact_broker/config/runtime_configuration_logging_methods.rb

@@ -0,0 +1,61 @@
+require "uri"
+
+module PactBroker
+  module Config
+    module RuntimeConfigurationLoggingMethods
+      module ClassMethods
+        def sensitive_values(*values)
+          @sensitive_values ||= []
+          if values
+            @sensitive_values.concat([*values])
+          else
+            @sensitive_values
+          end
+        end
+
+        def sensitive_value?(value)
+          sensitive_values.any? { |key| key == value || key == value.to_sym || key.kind_of?(Regexp) && key =~ value }
+        end
+      end
+
+      module InstanceMethods
+        def log_configuration(logger)
+          to_source_trace.sort_by { |key, _| key }.each { |key, value| log_config_inner(key, value, logger) }
+        end
+
+        def log_config_inner(key, value, logger)
+          if !value.has_key? :value
+            value.sort_by { |inner_key, _| inner_key }.each { |inner_key, inner_value| log_config_inner("#{key}.#{inner_key}", inner_value, logger) }
+          elsif self.class.sensitive_value?(key)
+            logger.info "#{key}=#{redact(key, value[:value])} source=#{value[:source]}"
+          else
+            logger.info "#{key}=#{value[:value]} source=#{value[:source]}"
+          end
+        end
+        private :log_config_inner
+
+        def redact name, value
+          if value && name.to_s.end_with?("_url")
+            begin
+              uri = URI(value)
+              uri.password = "*****"
+              uri.to_s
+            rescue StandardError
+              "*****"
+            end
+          elsif !value.nil?
+            "*****"
+          else
+            nil
+          end
+        end
+        private :redact
+      end
+
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+  end
+end