gitlab-cloud-connector 0.1.0 → 0.1.1

data/lib/gitlab/cloud_connector/unit_primitives.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../utils/parse_helper'
-
-module Gitlab
-  module CloudConnector
-    class UnitPrimitives
-      include ::Utils::ParseHelper
-
-      attr_reader :path
-      attr_reader :attributes
-
-      VALID_UNIT_PRIMITIVE_NAME = %r{^#{/[a-z0-9]+/}(#{'_'} #{/[a-z0-9]+/})*$}x
-      BACKEND_SERVICE_MATCHER = %r{\/backend_services\/(\w+)\/unit_primitives\/(?:\w+)\.yml}
-
-      PARAMS = %i[
-        name
-        description
-        backend_service
-        cut_off_date
-        introduced_by_url
-        unit_primitive_issue_url
-        milestone
-        group
-        feature_category
-        maturity
-        min_gitlab_version
-        min_gitlab_version_for_free_access
-        min_gitlab_version
-        min_backend_version
-        delivered_by
-        bundled_with
-        gitlab_realms
-      ].freeze
-
-      BACKEND_SERVICES = %i[
-        ai_gateway
-      ]
-
-      InvalidUnitPrimitiveError = Class.new(Exception)
-
-      PARAMS.each do |param|
-        define_method(param) do
-          ## parse time or create version
-          attributes[param]
-        end
-      end
-
-      BACKEND_SERVICES.each do |backend_service, _|
-        define_method("#{backend_service}?") do
-          attributes[:backend_service].to_sym == backend_service
-        end
-      end
-
-      alias :add_ons :bundled_with
-
-      def initialize(path, **opts)
-        @path = path
-        @attributes = {}
-
-        PARAMS.each do |param|
-          if param.end_with?('version')
-            @attributes[param] = parse_version(opts[param]) if opts[param]
-          elsif param.end_with?('date')
-            @attributes[param] = parse_time(opts[param]).utc if opts[param]
-          else
-            @attributes[param] = opts[param]
-          end
-        end
-
-        # read backend_service from the path
-        @attributes[:backend_service] = BACKEND_SERVICE_MATCHER.match(path.to_s)[1]
-      end
-
-      def key
-        name.to_sym
-      end
-
-      def validate!
-        unless name.present?
-          raise InvalidUnitPrimitiveError, "Unit primitive is missing name"
-        end
-
-        if backend_service.empty?
-          raise InvalidUnitPrimitiveError, "Unit primitive '#{name}' is missing `backend_service`. Ensure to update #{path}"
-        end
-
-        unless BACKEND_SERVICES.include?(backend_service.to_sym)
-          raise InvalidUnitPrimitiveError, "Unit primitive '#{name}' backend service '#{backend_service}' is invalid."
-        end
-
-        if delivered_by.empty?
-          raise InvalidUnitPrimitiveError, "Unit primitive '#{name}' is missing 'delivered_by'. If unit primitive is delivered as a stand-alone feature, set unit_primitive name."
-        end
-
-        if bundled_with.empty?
-          raise InvalidUnitPrimitiveError, "Unit primitive '#{name}' is missing 'bundled_with'."
-        end
-
-        if feature_category.empty?
-          raise InvalidUnitPrimitiveError, "Unit primitive '#{name}' is missing 'feature_category'."
-        end
-
-        unless VALID_UNIT_PRIMITIVE_NAME =~ name
-          raise InvalidUnitPrimitiveError, "Unit primitive '#{name}' is invalid"
-        end
-
-        if File.basename(path, ".yml") != name
-          raise InvalidUnitPrimitiveError, "Unit primitive '#{name}' has an invalid path: '#{path}'. Ensure to update #{path}"
-        end
-      end
-
-      def to_h
-        attributes
-      end
-
-      class << self
-        def paths
-          @paths ||= [File.join(CloudConnector.root, 'config', 'cloud_connector', 'backend_services', '**', 'unit_primitives', '*.yml')]
-        end
-
-        def definitions
-          # We lazily load all definitions
-          @definitions ||= load_all!
-        end
-
-        def get(key)
-          definitions[key.to_sym]
-        end
-
-        def reload!
-          @definitions = load_all!
-        end
-
-        def has_definition?(key)
-          definitions.has_key?(key.to_sym)
-        end
-
-        def register_hot_reloader!
-          return unless Rails.env.development? || Rails.env.test?
-          # Reload feature flags on change of this file or any `.yml`
-          file_watcher = Rails.configuration.file_watcher.new(reload_files, reload_directories) do
-            reload!
-          end
-
-          Rails.application.reloaders << file_watcher
-          Rails.application.reloader.to_run { file_watcher.execute_if_updated }
-
-          file_watcher
-        end
-
-        def load_all!
-          paths.each_with_object({}) do |glob_path, definitions|
-            load_all_from_path!(definitions, glob_path)
-          end
-        end
-
-        def load_from_file(path)
-          definition = File.read(path)
-          definition = YAML.safe_load(definition, aliases: true)
-          definition.deep_symbolize_keys!
-
-          self.new(path, **definition).tap(&:validate!)
-        rescue StandardError => e
-          raise InvalidUnitPrimitiveError, "Invalid definition for `#{path}`: #{e.message}"
-        end
-
-        def load_all_from_path!(definitions, glob_path)
-          Dir.glob(glob_path).each do |path|
-            definition = load_from_file(path)
-
-            if previous = definitions[definition.key]
-              raise InvalidUnitPrimitiveError, "Feature flag '#{definition.key}' is already defined in '#{previous.path}'"
-            end
-
-            definitions[definition.key] = definition
-          end
-        end
-
-        def reload_files
-          []
-        end
-
-        def reload_directories
-          paths.each_with_object({}) do |path, result|
-            path = File.dirname(path)
-            Dir.glob(path).each do |matching_dir|
-              result[matching_dir] = 'yml'
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/gitlab/cloud_connector.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'cloud_connector/configuration'
-require_relative 'cloud_connector/token_issuer'
-require_relative 'cloud_connector/deliverable'
-require_relative 'cloud_connector/delivered_by'
-require_relative 'cloud_connector/backend_service'
-require_relative '../utils/strong_memoize'
-
-module Gitlab
-  module CloudConnector
-    extend Deliverable
-    extend TokenIssuer
-    extend ::Utils::StrongMemoize
-    Time.zone = 'UTC'
-
-    VERSION = "0.1.0"
-
-    class << self
-
-      alias :instance_access_token :access_token
-      delegate :token_issuer, :token_expires_in, :token_subject, :gitlab_realm, :gitlab_version, to: :configuration
-
-      def root
-        File.expand_path '../../..', __FILE__
-      end
-
-      def configure
-        yield configuration
-      end
-
-      def configuration
-        strong_memoize(:configuration) do
-          Configuration.new
-        end
-      end
-
-      def unit_primitives
-        strong_memoize(:unit_primitives) do
-           unit_primitives = Gitlab::CloudConnector::UnitPrimitives.definitions
-           unit_primitives.transform_values{ |up| configuration.purchasable_decorator_class.new(up) }
-        end
-      end
-
-      def backend_services
-        strong_memoize(:backend_services) do
-          unit_primitives.values.group_by(&:backend_service).map do |name, unit_primitives|
-            BackendService.new(name.to_sym, unit_primitives.index_by(&:key))
-          end.index_by(&:name)
-        end
-      end
-
-      def feature_categories
-        strong_memoize(:feature_categories) do
-          unit_primitives.values.map(&:feature_category).uniq
-        end
-      end
-
-      def bundled_with
-        strong_memoize(:bundled_with) do
-          unit_primitives.values.flat_map(&:bundled_with).uniq
-        end
-      end
-
-      alias :add_ons :bundled_with
-    end
-  end
-end

data/lib/gitlab/popen.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'fileutils'
-require 'open3'
-
-module Gitlab
-  module Popen
-    extend self
-
-    Result = Struct.new(:cmd, :stdout, :stderr, :status, :duration)
-
-    # Returns [stdout + stderr, status]
-    # status is either the exit code or the signal that killed the process
-    def popen(cmd, path = nil, vars = {}, &block)
-      result = popen_with_detail(cmd, path, vars, &block)
-
-      # Process#waitpid returns Process::Status, which holds a 16-bit value.
-      # The higher-order 8 bits hold the exit() code (`exitstatus`).
-      # The lower-order bits holds whether the process was terminated.
-      # If the process didn't exit normally, `exitstatus` will be `nil`,
-      # but we still want a non-zero code, even if the value is
-      # platform-dependent.
-      status = result.status&.exitstatus || result.status.to_i
-
-      ["#{result.stdout}#{result.stderr}", status]
-    end
-
-    # Returns Result
-    def popen_with_detail(cmd, path = nil, vars = {})
-      unless cmd.is_a?(Array)
-        raise "System commands must be given as an array of strings"
-      end
-
-      if cmd.one? && cmd.first.match?(/\s/)
-        raise "System commands must be split into an array of space-separated values"
-      end
-
-      path ||= Dir.pwd
-      vars['PWD'] = path
-      options = { chdir: path }
-
-      unless File.directory?(path)
-        FileUtils.mkdir_p(path)
-      end
-
-      cmd_stdout = ''
-      cmd_stderr = ''
-      cmd_status = nil
-      start = Time.now
-
-      Open3.popen3(vars, *cmd, options) do |stdin, stdout, stderr, wait_thr|
-        # stderr and stdout pipes can block if stderr/stdout aren't drained: https://bugs.ruby-lang.org/issues/9082
-        # Mimic what Ruby does with capture3: https://github.com/ruby/ruby/blob/1ec544695fa02d714180ef9c34e755027b6a2103/lib/open3.rb#L257-L273
-        out_reader = Thread.new { stdout.read }
-        err_reader = Thread.new { stderr.read }
-
-        yield(stdin) if block_given?
-        stdin.close
-
-        cmd_stdout = out_reader.value
-        cmd_stderr = err_reader.value
-        cmd_status = wait_thr.value
-      end
-
-      Result.new(cmd, cmd_stdout, cmd_stderr, cmd_status, Time.now - start)
-    end
-  end
-end

data/lib/utils/parse_helper.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Utils
-  module ParseHelper
-    VERSION_REGEX = /\A(\d+\.\d+)/
-    def parse_time(time)
-      Time.zone.parse(time).utc if time
-    end
-
-    def parse_version(version)
-      version = VERSION_REGEX.match(version.to_s).to_s
-      Gem::Version.new(version)
-    end
-  end
-end

data/lib/utils/strong_memoize.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-module Utils
-  module StrongMemoize
-    # Instead of writing patterns like this:
-    #
-    #     def trigger_from_token
-    #       return @trigger if defined?(@trigger)
-    #
-    #       @trigger = Ci::Trigger.find_by_token(params[:token].to_s)
-    #     end
-    #
-    # We could write it like:
-    #
-    #     include Utils::StrongMemoize
-    #
-    #     def trigger_from_token
-    #       Ci::Trigger.find_by_token(params[:token].to_s)
-    #     end
-    #     strong_memoize_attr :trigger_from_token
-    #
-    #     def enabled?
-    #       Feature.enabled?(:some_feature)
-    #     end
-    #     strong_memoize_attr :enabled?
-    #
-    def strong_memoize(name)
-      key = ivar(name)
-
-      if instance_variable_defined?(key)
-        instance_variable_get(key)
-      else
-        instance_variable_set(key, yield)
-      end
-    end
-
-    # Works the same way as "strong_memoize" but takes
-    # a second argument - expire_in. This allows invalidate
-    # the data after specified number of seconds
-    def strong_memoize_with_expiration(name, expire_in)
-      key = ivar(name)
-      expiration_key = "#{key}_expired_at"
-
-      if instance_variable_defined?(expiration_key)
-        expire_at = instance_variable_get(expiration_key)
-        clear_memoization(name) if Time.current > expire_at
-      end
-
-      if instance_variable_defined?(key)
-        instance_variable_get(key)
-      else
-        value = instance_variable_set(key, yield)
-        instance_variable_set(expiration_key, Time.current + expire_in)
-        value
-      end
-    end
-
-    def strong_memoize_with(name, *args)
-      container = strong_memoize(name) { {} }
-
-      if container.key?(args)
-        container[args]
-      else
-        container[args] = yield
-      end
-    end
-
-    def strong_memoized?(name)
-      key = ivar(StrongMemoize.normalize_key(name))
-      instance_variable_defined?(key)
-    end
-
-    def clear_memoization(name)
-      key = ivar(StrongMemoize.normalize_key(name))
-      remove_instance_variable(key) if instance_variable_defined?(key)
-    end
-
-    module StrongMemoizeClassMethods
-      def strong_memoize_attr(method_name)
-        member_name = StrongMemoize.normalize_key(method_name)
-
-        StrongMemoize.send(:do_strong_memoize, self, method_name, member_name) # rubocop:disable GitlabSecurity/PublicSend
-      end
-    end
-
-    def self.included(base)
-      base.singleton_class.prepend(StrongMemoizeClassMethods)
-    end
-
-    private
-
-    # Convert `"name"`/`:name` into `:@name`
-    #
-    # Depending on a type ensure that there's a single memory allocation
-    def ivar(name)
-      case name
-      when Symbol
-        name.to_s.prepend("@").to_sym
-      when String
-        :"@#{name}"
-      else
-        raise ArgumentError, "Invalid type of '#{name}'"
-      end
-    end
-
-    class << self
-      def normalize_key(key)
-        return key unless key.end_with?('!', '?')
-
-        # Replace invalid chars like `!` and `?` with allowed Unicode codeparts.
-        key.to_s.tr('!?', "\uFF01\uFF1F")
-      end
-
-      private
-
-      def do_strong_memoize(klass, method_name, member_name)
-        method = klass.instance_method(method_name)
-
-        unless method.arity == 0
-          raise <<~ERROR
-              Using `strong_memoize_attr` on methods with parameters is not supported.
-
-              Use `strong_memoize_with` instead.
-              See https://docs.gitlab.com/ee/development/utilities.html#strongmemoize
-          ERROR
-        end
-
-        # Methods defined within a class method are already public by default, so we don't need to
-        # explicitly make them public.
-        scope = %i[private protected].find do |scope|
-          klass.send(:"#{scope}_instance_methods") # rubocop:disable GitlabSecurity/PublicSend
-            .include? method_name
-        end
-
-        klass.define_method(method_name) do |&block|
-          strong_memoize(member_name) do
-            method.bind_call(self, &block)
-          end
-        end
-
-        klass.send(scope, method_name) if scope # rubocop:disable GitlabSecurity/PublicSend
-      end
-    end
-  end
-end