uffizzi-core 0.1.12

data/app/services/uffizzi_core/compose_file/builders/template_builder_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::Builders::TemplateBuilderService
+  attr_accessor :credentials, :project, :repositories
+
+  def initialize(credentials, project, repositories = [])
+    @credentials = credentials
+    @project = project
+    @repositories = repositories
+  end
+
+  def build_attributes(compose_data, compose_dependencies, source)
+    containers_data = compose_data[:containers]
+    ingress_data = compose_data[:ingress]
+    continuous_preview_global_data = compose_data[:continuous_preview]
+
+    containers_attributes = build_containers_attributes(
+      containers_data,
+      ingress_data,
+      continuous_preview_global_data,
+      compose_dependencies,
+    )
+
+    {
+      name: source,
+      payload: {
+        containers_attributes: containers_attributes,
+      },
+    }
+  end
+
+  private
+
+  def build_containers_attributes(containers_data, ingress_data, continuous_preview_global_data, compose_dependencies)
+    containers_data.map do |container_data|
+      container_attributes(container_data, ingress_data, continuous_preview_global_data, compose_dependencies)
+    end
+  end
+
+  def container_attributes(containers_data, ingress_data, continuous_preview_global_data, compose_dependencies)
+    builder = UffizziCore::ComposeFile::Builders::ContainerBuilderService.new(credentials, project, repositories)
+
+    builder.build_attributes(containers_data, ingress_data, continuous_preview_global_data, compose_dependencies)
+  end
+end

data/app/services/uffizzi_core/compose_file/builders/variables_builder_service.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::Builders::VariablesBuilderService
+  attr_accessor :project
+
+  require 'dotenv'
+
+  def initialize(project)
+    @project = project
+  end
+
+  def build_attributes(variables_data, dependencies)
+    variables = variables_data
+    variables_from_dependencies = variables_from_dependencies(dependencies)
+
+    variables + variables_from_dependencies
+  end
+
+  def build_secret_attributes(secrets)
+    project_secrets = project.secrets || []
+
+    secrets.uniq.map do |secret|
+      detected_secret = project_secrets.detect { |project_secret| project_secret['name'] == secret }
+      error_message = I18n.t('compose.project_secret_not_found', secret: secret)
+      raise UffizziCore::ComposeFile::SecretsError, error_message if detected_secret.nil?
+
+      build_variable(detected_secret['name'], detected_secret['value'])
+    end
+  end
+
+  private
+
+  def variables_from_dependencies(dependencies)
+    variables = dependencies.map do |dependency|
+      variables_data = parse_variables_from_dependency(dependency)
+
+      variables_data.map { |variable_data| build_variable(variable_data.first, variable_data.last) }
+    end
+
+    variables.flatten
+  end
+
+  def parse_variables_from_dependency(dependency)
+    content = dependency[:content]
+    return [] if content.blank?
+
+    variables_content = UffizziCore::ComposeFile::GithubDependenciesService.content(dependency)
+    parser = Dotenv::Parser.new(variables_content)
+    parser.call.to_a
+  end
+
+  def build_variable(name, value)
+    {
+      name: name,
+      value: value,
+    }
+  end
+end

data/app/services/uffizzi_core/compose_file/config_files_service.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ConfigFilesService
+  def initialize(compose_file_form)
+    @compose_file_form = compose_file_form
+    @repository_id = compose_file_form.repository_id
+    @branch = compose_file_form.branch
+    @path = compose_file_form.path
+    @user = compose_file_form.added_by
+    @project = compose_file_form.project
+  end
+
+  def create_config_files(compose_dependencies)
+    configs_dependencies = UffizziCore::ComposeFile::GithubDependenciesService.configs_dependencies(compose_dependencies)
+    errors = []
+    configs_dependencies.each do |config_dependency|
+      errors = create_config_file(config_dependency)
+      errors << errors if errors
+    end
+
+    errors
+  end
+
+  private
+
+  def create_config_file(config_dependency)
+    source = UffizziCore::ComposeFile::GithubDependenciesService.build_source_path(@path, config_dependency[:path], @repository_id, @branch)
+    config_file = @project.config_files.find_or_initialize_by(source: source)
+    attributes = {
+      filename: UffizziCore::ComposeFile::GithubDependenciesService.filename(config_dependency),
+      payload: UffizziCore::ComposeFile::GithubDependenciesService.content(config_dependency),
+    }
+
+    config_file.assign_attributes(attributes)
+    config_file_form = build_config_file_form(config_file)
+    return config_file_form.errors if config_file_form.invalid?
+
+    config_file_form.save
+
+    nil
+  end
+
+  def build_config_file_form(config_file)
+    config_file_form = config_file.becomes(UffizziCore::Api::Cli::V1::ConfigFile::CreateForm)
+    config_file_form.project = @project
+    config_file_form.added_by = @user
+    config_file_form.compose_file = @compose_file_form
+    config_file_form.creation_source = UffizziCore::ConfigFile.creation_source.compose_file
+
+    config_file_form
+  end
+end

data/app/services/uffizzi_core/compose_file/config_option_service.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ConfigOptionService
+  class << self
+    def valid_option_format?(option)
+      if option.is_a?(TrueClass) || option.is_a?(FalseClass)
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.boolean_option', value: option)
+      end
+
+      option.match(/^[a-zA-Z_][a-zA-Z0-9._\-]+$/).present?
+    end
+
+    def config_options(compose_data)
+      compose_data.each_with_object([]) do |(key, value), keys|
+        if compose_data.equal?(value)
+          raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.infinite_recursion', key: key)
+        end
+
+        keys << key
+        keys.concat(config_options(value)) if value.is_a?(Hash)
+      end
+    end
+
+    def prepare_file_path_value(file_path)
+      pathname = Pathname.new(file_path)
+
+      pathname.cleanpath.to_s.strip.delete_prefix('/')
+    end
+
+    def ingress_option(compose_data)
+      compose_data.dig('x-uffizzi', 'ingress').presence || compose_data['x-uffizzi-ingress'].presence
+    end
+
+    def continuous_preview_option(compose_data)
+      compose_data.dig('x-uffizzi', 'continuous_preview').presence ||
+        compose_data.dig('x-uffizzi', 'continuous_previews').presence ||
+        compose_data['x-uffizzi-continuous-preview'].presence ||
+        compose_data['x-uffizzi-continuous-previews'].presence
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/configs_options_service.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ConfigsOptionsService
+  class << self
+    def parse(configs_data)
+      return [] if configs_data.nil?
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :configs) unless configs_data.is_a?(Hash)
+
+      configs = []
+      configs_data.each_pair do |config_name, config_data|
+        if config_data['file'].blank?
+          raise UffizziCore::ComposeFile::ParseError,
+                I18n.t('compose.config_file_option_empty', config_name: config_name)
+        end
+
+        configs << {
+          config_name: config_name,
+          config_file: config_data['file'],
+        }
+      end
+
+      configs
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/container_service.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ContainerService
+  class << self
+    def azure?(container)
+      registry_url = container.dig(:image, :registry_url)
+
+      registry_url.present? && registry_url.include?('azurecr.io')
+    end
+
+    def google?(container)
+      registry_url = container.dig(:image, :registry_url)
+
+      registry_url.present? && registry_url.include?('gcr.io')
+    end
+
+    def amazon?(container)
+      registry_url = container.dig(:image, :registry_url)
+
+      registry_url.present? && registry_url.include?('amazonaws.com')
+    end
+
+    def docker_hub?(container)
+      registry_url = container.dig(:image, :registry_url)
+      repository_url = container.dig(:build, :repository_url)
+
+      registry_url.nil? && repository_url.nil?
+    end
+
+    def github_container_registry?(container)
+      registry_url = container.dig(:image, :registry_url)
+
+      registry_url.present? && registry_url.include?('ghcr.io')
+    end
+
+    def has_secret?(container, secret)
+      container['secret_variables'].any? { |container_secret| container_secret['name'] == secret['name'] }
+    end
+
+    def update_secret(container, secret)
+      secret_index = container['secret_variables'].find_index { |container_secret| container_secret['name'] == secret['name'] }
+      container['secret_variables'][secret_index] = secret
+
+      container
+    end
+
+    def credential_for_container(container, credentials)
+      if UffizziCore::ComposeFile::ContainerService.azure?(container)
+        detect_credential(credentials, :azure)
+      elsif UffizziCore::ComposeFile::ContainerService.docker_hub?(container)
+        detect_credential(credentials, :docker_hub)
+      elsif UffizziCore::ComposeFile::ContainerService.google?(container)
+        detect_credential(credentials, :google)
+      end
+    end
+
+    def detect_credential(credentials, type)
+      credential = credentials.detect do |item|
+        item.send("#{type}?")
+      end
+
+      error_message = "Invalid credential: #{type}"
+      raise UffizziCore::ComposeFile::CredentialError.new(error_message) if credential.nil?
+
+      credential
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/continuous_preview_options_service.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ContinuousPreviewOptionsService
+  class << self
+    def parse(continuous_preview_data)
+      return {} if continuous_preview_data.nil?
+
+      {
+        deploy_preview_when_pull_request_is_opened: trigger_value(continuous_preview_data, 'deploy_preview_when_pull_request_is_opened'),
+        delete_preview_when_pull_request_is_closed: trigger_value(continuous_preview_data, 'delete_preview_when_pull_request_is_closed'),
+        deploy_preview_when_image_tag_is_created: trigger_value(continuous_preview_data, 'deploy_preview_when_image_tag_is_created'),
+        delete_preview_when_image_tag_is_updated: trigger_value(continuous_preview_data, 'delete_preview_when_image_tag_is_updated'),
+        delete_preview_after: delete_preview_after_value(continuous_preview_data['delete_preview_after']),
+        share_to_github: trigger_value(continuous_preview_data, 'share_to_github'),
+      }
+    end
+
+    private
+
+    def trigger_value(continuous_preview_data, field)
+      value = continuous_preview_data[field]
+      return nil if value.nil?
+      return value if value.in?([true, false])
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_bool_value', field: field, value: value)
+    end
+
+    def delete_preview_after_value(value)
+      return {} if value.blank?
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_string', option: :delete_preview_after) unless value.is_a?(String)
+
+      hours, postfix = value.scan(/^([0-9]+)([a-zA-Z])$/).flatten
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_integer', option: :delete_preview_after) if hours.nil?
+
+      formatted_hours = hours.to_i
+      if formatted_hours < Settings.compose.delete_after_min_value
+        raise UffizziCore::ComposeFile::ParseError,
+              I18n.t('compose.invalid_delete_after_min', value: Settings.compose.delete_after_min_value)
+      end
+
+      if formatted_hours > Settings.compose.delete_after_max_value
+        raise UffizziCore::ComposeFile::ParseError,
+              I18n.t('compose.invalid_delete_after_max', value: Settings.compose.delete_after_max_value)
+      end
+
+      if postfix.nil? || !Settings.compose.delete_after_postfixes.include?(postfix.downcase)
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_delete_after_postfix')
+      end
+
+      {
+        value: formatted_hours,
+        postfix: postfix.downcase,
+      }
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/dependencies_service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::DependenciesService
+  ENV_FILE_TYPE = 'env_file'
+  CONFIG_TYPE = 'config'
+
+  class << self
+    def build_dependencies(compose_data, compose_path, dependencies_params)
+      dependencies = compose_data[:containers].map do |container|
+        env_file_dependencies = build_env_files_dependencies(container, compose_path, dependencies_params)
+        configs_dependencies = build_configs_dependencies(container, compose_path, dependencies_params)
+
+        env_file_dependencies + configs_dependencies
+      end
+
+      dependencies.compact.flatten
+    end
+
+    def build_env_files_dependencies(container, compose_path, dependencies_params)
+      env_files = container[:env_file]
+      return [] unless env_files.present?
+
+      env_files.map do |path|
+        dependency = dependencies_params.detect { |item| item[:path] == path }
+        source = build_source_path(compose_path, path)
+
+        base_file_params(dependency, container).merge(source: source, type: ENV_FILE_TYPE)
+      end
+    end
+
+    def build_configs_dependencies(container, compose_path, dependencies_params)
+      configs = container[:configs]
+      return [] unless configs.present?
+
+      configs.map do |config|
+        dependency = dependencies_params.detect { |item| item[:path] == config[:source] }
+        source = build_source_path(compose_path, dependency[:path])
+
+        base_file_params(dependency, container).merge(source: source, type: CONFIG_TYPE)
+      end
+    end
+
+    def base_file_params(dependency, container)
+      {
+        content: dependency[:content],
+        path: dependency[:path],
+        container_name: container[:container_name],
+      }
+    end
+
+    def build_source_path(compose_path, dependency_path)
+      prepared_compose_path = Pathname.new(compose_path).basename.to_s
+      "#{prepared_compose_path}/#{dependency_path}"
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/errors_service.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ErrorsService
+  SECRETS_ERROR_KEY = 'secret_variables'
+  class << self
+    def has_error?(compose_file, error_code)
+      error = compose_file.payload.dig('errors', error_code)
+
+      error.present?
+    end
+
+    def has_errors?(compose_file)
+      compose_file.payload['errors'].present?
+    end
+
+    def update_compose_errors!(compose_file, errors, invalid_content)
+      compose_file.payload['errors'] = errors
+      compose_file.set_invalid if compose_file.valid_file?
+      compose_file.content = invalid_content
+
+      compose_file.save!
+
+      compose_file
+    end
+
+    def reset_compose_errors!(compose_file)
+      compose_file.payload['errors'] = nil
+      compose_file.set_valid
+
+      compose_file.save!
+
+      compose_file
+    end
+
+    def reset_error!(compose_file, error_code)
+      errors = compose_file.payload['errors']
+      return if errors.nil?
+
+      new_errors = errors.except(error_code)
+      compose_file.payload['errors'] = new_errors
+      compose_file.save!
+
+      compose_file
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/github_dependencies_service.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::GithubDependenciesService
+  ENV_FILE_TYPE = 'env_file'
+  CONFIG_TYPE = 'config'
+
+  class << self
+    def filename(dependency)
+      pathname = Pathname.new(dependency[:path])
+
+      pathname.basename.to_s
+    end
+
+    def content(dependency)
+      Base64.decode64(dependency[:content])
+    end
+
+    def env_file_dependencies_for_container(dependencies, container_name)
+      dependencies.select { |dependency| dependency[:type] == ENV_FILE_TYPE && dependency[:container_name] == container_name }
+    end
+
+    def configs_dependencies_for_container(dependencies, container_name)
+      configs_dependencies(dependencies).select { |dependency| dependency[:container_name] == container_name }
+    end
+
+    def configs_dependencies(dependencies)
+      dependencies.select { |dependency| dependency[:type] == CONFIG_TYPE }
+    end
+
+    def build_source_path(compose_path, dependency_path, repository_id, branch)
+      prepared_compose_path = Pathname.new(compose_path).basename.to_s
+      base_source = "#{prepared_compose_path}/#{dependency_path}"
+      return base_source if repository_id.blank?
+
+      "#{repository_id}/#{branch}/#{base_source}"
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/ingress_options_service.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::IngressOptionsService
+  class << self
+    def parse(ingress_data, services_data)
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.no_ingress') if ingress_data.nil?
+
+      container_name = container_name(ingress_data, services_data)
+      port = port(ingress_data)
+
+      {
+        container_name: container_name,
+        port: port,
+      }
+    end
+
+    private
+
+    def container_name(ingress_data, services_data)
+      container_name = ingress_data['service']
+
+      if container_name.nil?
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.ingress_service_not_found')
+      end
+
+      unless services_data.keys.include?(container_name)
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_ingress_service', value: container_name)
+      end
+
+      container_name
+    end
+
+    def port(ingress_data)
+      port = ingress_data['port']
+
+      if port.nil?
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.ingress_port_not_specified')
+      end
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_integer', option: :port) unless port.is_a?(Integer)
+
+      port_min = Settings.compose.port_min_value
+      port_max = Settings.compose.port_max_value
+      if port < port_min || port > port_max
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.port_out_of_range', port_min: port_min, port_max: port_max)
+      end
+
+      port
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/parsers/services/healthcheck_parser_service.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::Parsers::Services::HealthcheckParserService
+  REQUIRED_START_COMMANDS = ['NONE', 'CMD', 'CMD-SHELL'].freeze
+
+  class << self
+    def parse(healthcheck_data)
+      return {} if healthcheck_data.blank?
+
+      command = parse_command(healthcheck_data)
+
+      {
+        test: command,
+        interval: parse_time(healthcheck_data['interval']),
+        timeout: parse_time(healthcheck_data['timeout']),
+        retries: parse_retries(healthcheck_data['retries']),
+        start_period: parse_time(healthcheck_data['start_period']),
+        disable: parse_disable_option(healthcheck_data['disable'], command),
+      }
+    end
+
+    private
+
+    def parse_command(healthcheck_data)
+      command = healthcheck_data['test']
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.string_or_array_error', option: :test) if command.nil?
+
+      case command
+      when Array
+        start_command = command.first
+        raise UffizziCore::ComposeFile::ParseError unless REQUIRED_START_COMMANDS.include?(start_command)
+
+        command
+      when String
+        command
+      else
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :test)
+      end
+    end
+
+    def parse_retries(value)
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_integer', option: :retries) unless value.is_a?(Integer)
+    end
+
+    def parse_time(value)
+      tokens = {
+        's' => 1,
+        'm' => 60,
+        'h' => (60 * 60),
+        'd' => (60 * 60 * 24),
+      }
+
+      time_parts = value.scan(/(\d+)(\w)/).compact
+
+      time_parts.reduce(0) do |acc, part|
+        amount, measure = part
+        acc += amount.to_i * tokens[measure]
+
+        acc
+      rescue StandardError
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_time_interval')
+      end
+    end
+
+    def parse_disable_option(value, command)
+      return true if command.is_a?(Array) && command.first == 'NONE'
+      return false if value.nil?
+      return value if value.in?([true, false])
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_bool_value', field: 'disable', value: value)
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/secrets_options_service.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::SecretsOptionsService
+  class << self
+    def parse(secrets_data)
+      return [] if secrets_data.nil?
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :secrets) unless secrets_data.is_a?(Hash)
+
+      secrets = []
+      secrets_data.each_pair do |secret_name, secret_data|
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.secret_name_blank', option: secret_name) if secret_data['name'].blank?
+
+        if secret_data['external'] != true
+          raise UffizziCore::ComposeFile::ParseError,
+                I18n.t('compose.secret_external', secret: secret_name)
+        end
+
+        secrets << {
+          secret_name: secret_name,
+          secret_variable: secret_data['name'],
+        }
+      end
+
+      secrets
+    end
+  end
+end

data/app/services/uffizzi_core/compose_file/services_options/command_service.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::CommandService
+  class << self
+    def parse(command_data)
+      return nil if command_data.blank?
+
+      case command_data
+      when String
+        [command_data]
+      when Array
+        command_data
+      else
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :command)
+      end
+    end
+  end
+end