uffizzi_core 0.1.3

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

@@ -0,0 +1,55 @@
+# 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,49 @@
+# 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)
+
+      if port < Settings.compose.port_min_value || port > Settings.compose.port_max_value
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_port')
+      end
+
+      port
+    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/build_service.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::BuildService
+  extend UffizziCore::ComposeFile::VariablesService
+
+  class << self
+    def parse(build_data, compose_payload)
+      return {} if build_data.blank?
+
+      args = parse_args(build_data)
+
+      repository_url, branch, dockerfile_context_path = parse_context(build_data, compose_payload)
+      repository_parts = repository_url.split('/').last(2)
+      account_name = repository_parts.first
+      repository_name = repository_parts.last
+      dockerfile = build_data['dockerfile'].blank? ? ::Settings.compose.dockerfile_default_path : build_data['dockerfile']
+
+      {
+        repository_url: repository_url,
+        account_name: account_name,
+        repository_name: repository_name,
+        branch: branch,
+        dockerfile: dockerfile,
+        dockerfile_context_path: dockerfile_context_path,
+        args: args,
+      }
+    end
+
+    private
+
+    def parse_args(build_data)
+      args = build_data['args']
+      return [] if args.nil?
+
+      case args
+      when Array
+        args.map { |arg| parse_variable_from_string(arg) }
+      when Hash
+        args.to_a.map { |arg| parse_variable_from_array(arg) }
+      else
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :args)
+      end
+    end
+
+    def parse_context(build_data, compose_payload)
+      if build_data.is_a?(String)
+        parse_context_from_inline_syntax(build_data, compose_payload)
+      else
+        parse_context_from_long_syntax(build_data, compose_payload)
+      end
+    end
+
+    def parse_repository_url_fragment(fragment)
+      branch, dockerfile_context_path = fragment.split(':')
+
+      [branch, dockerfile_context_path]
+    end
+
+    def valid_url?(url)
+      URI(url).host.present? && URI(url).host =~ /\w+\.\w+/ && URI(url).path.present?
+    end
+
+    def parse_context_from_inline_syntax(context, compose_payload)
+      if compose_payload[:repository_url].blank?
+        raise UffizziCore::ComposeFile::ParseError,
+              I18n.t('compose.build_context_unknown_repository')
+      end
+
+      repository_url = compose_payload[:repository_url]
+      branch = compose_payload[:branch]
+      dockerfile_context_path = UffizziCore::ComposeFile::ConfigOptionService.prepare_file_path_value(context)
+
+      [repository_url, branch, dockerfile_context_path]
+    end
+
+    def parse_context_from_long_syntax(build_data, compose_payload)
+      context = build_data['context']
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.build_context_no_specified') if context.blank?
+
+      if valid_url?(context)
+        uri = URI(context)
+        repository_url = "#{uri.scheme}://#{uri.host}#{uri.path}"
+        branch, dockerfile_context_path = parse_repository_url_fragment(uri.fragment.to_s)
+      else
+        repository_url, branch, dockerfile_context_path = parse_context_from_inline_syntax(context, compose_payload)
+      end
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_context', value: context) if repository_url.blank?
+
+      [repository_url, branch, dockerfile_context_path]
+    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

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::ConfigsService
+  class << self
+    def parse(configs, global_configs_data)
+      return [] if configs.nil?
+
+      configs.map do |config|
+        config_data = case config
+                      when String
+                        process_short_syntax(config, global_configs_data)
+                      when Hash
+                        process_long_syntax(config, global_configs_data)
+                      else
+                        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :configs)
+        end
+
+        config_data
+      end
+    end
+
+    private
+
+    def process_short_syntax(config_name, global_configs_data)
+      global_config = find_global_config!(config_name, global_configs_data)
+
+      {
+        source: UffizziCore::ComposeFile::ConfigOptionService.prepare_file_path_value(global_config[:config_file]),
+        target: global_config[:config_file],
+      }
+    end
+
+    def process_long_syntax(config_data, global_configs_data)
+      global_config = find_global_config!(config_data['source'], global_configs_data)
+      target = config_data['target'].blank? ? global_config[:config_file] : config_data['target']
+
+      {
+        source: UffizziCore::ComposeFile::ConfigOptionService.prepare_file_path_value(global_config[:config_file]),
+        target: target,
+      }
+    end
+
+    def find_global_config!(config_name, global_configs_data)
+      detected_config = global_configs_data.detect { |global_config_data| global_config_data[:config_name] == config_name }
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.global_config_not_found', config: config_name) if detected_config.nil?
+
+      detected_config
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::DeployService
+  class << self
+    def parse(deploy_data)
+      return {} if deploy_data.blank?
+
+      auto = prepare_deploy_auto(deploy_data)
+      memory = prepare_memory(deploy_data)
+
+      {
+        auto: auto,
+        memory: memory,
+      }
+    end
+
+    private
+
+    def prepare_deploy_auto(deploy_data)
+      auto = deploy_data['x-uffizzi-auto-deploy-updates']
+      return auto if auto.nil? || auto.in?([true, false])
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_bool_value', field: :auto, value: auto)
+    end
+
+    def prepare_memory(deploy_data)
+      memory = deploy_data.dig('resources', 'limits', 'memory')
+      return nil if memory.blank?
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_memory_type', value: memory) unless memory.is_a?(String)
+
+      value, postfix = memory.scan(/^([0-9]+)([a-zA-Z]+)$/).flatten
+
+      if postfix.nil? || !Settings.compose.memory_postfixes.include?(postfix.downcase)
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_memory_postfix', value: memory)
+      end
+
+      {
+        value: value.to_i,
+        postfix: postfix.downcase,
+      }
+    end
+  end
+end

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

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

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::EnvFileService
+  class << self
+    def parse(env_file)
+      env_files = case env_file
+                  when String
+                    [prepare_file_path(env_file)]
+                  when Array
+                    env_file.map { |env_file_path| prepare_file_path(env_file_path) }
+                  else
+                    raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :env_file)
+      end
+
+      check_duplicates(env_files)
+
+      env_files
+    end
+
+    private
+
+    def prepare_file_path(env_file_path)
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.empty_env_file') if env_file_path.blank?
+
+      UffizziCore::ComposeFile::ConfigOptionService.prepare_file_path_value(env_file_path)
+    end
+
+    def check_duplicates(env_files)
+      return if env_files.uniq.length == env_files.length
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.env_file_duplicates', values: env_files)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::EnvironmentService
+  extend UffizziCore::ComposeFile::VariablesService
+
+  class << self
+    def parse(environment)
+      return [] if environment.blank?
+
+      case environment
+      when Array
+        environment.map { |variable| parse_variable_from_string(variable) }
+      when Hash
+        environment.to_a.map { |variable| parse_variable_from_array(variable) }
+      else
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :environment)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::ImageService
+  class << self
+    def parse(image)
+      return {} if image.blank?
+
+      image_parts = image.downcase.split(':')
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_image_value', value: image) if image_parts.count > 2
+
+      image_name, tag = image_parts
+      tag = Settings.compose.default_tag if tag.blank?
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_image_value', value: image) if image_name.blank?
+
+      if valid_image_url?(image_name)
+        url, namespace, name = parse_image_url(image_name)
+      else
+        namespace, name = parse_docker_hub_image(image_name)
+      end
+
+      {
+        registry_url: url,
+        namespace: namespace,
+        name: name,
+        tag: tag,
+      }
+    end
+
+    private
+
+    def valid_image_url?(image_name)
+      url = prepare_image_url(image_name)
+
+      URI(url).host.present? && URI(url).host =~ /\w+\.\w+/ && URI(url).path.present?
+    end
+
+    def prepare_image_url(image_name)
+      if image_name.start_with?('https://')
+        image_name
+      else
+        "https://#{image_name}"
+      end
+    end
+
+    def parse_image_url(image_name)
+      prepared_url = prepare_image_url(image_name)
+
+      uri = URI(prepared_url)
+      url = uri.host
+      path = uri.path.delete_suffix('/').delete_prefix('/')
+
+      namespace, name = parse_image_path(path)
+
+      [url, namespace, name]
+    end
+
+    def parse_image_path(path)
+      path_parts = path.split('/', 2)
+
+      if path_parts.count == 1
+        namespace = nil
+        name = path_parts.first
+      else
+        namespace = path_parts.first
+        name = path_parts.last
+      end
+
+      [namespace, name]
+    end
+
+    def parse_docker_hub_image(image_name)
+      if contains_account_name?(image_name)
+        namespace = image_name.split('/').first
+        name = image_name.split('/', 2).last.delete_suffix('/')
+      else
+        namespace = Settings.docker_hub.public_namespace
+        name = image_name
+      end
+
+      [namespace, name]
+    end
+
+    def contains_account_name?(image_name)
+      image_name_parts = image_name.split('/')
+
+      image_name_parts.count > 1
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptions::SecretsService
+  class << self
+    def parse(secrets, global_secrets_data)
+      return [] if secrets.nil?
+
+      secrets.map do |secret|
+        variable_name = if secret.is_a?(String)
+          process_short_syntax(secret, global_secrets_data)
+        else
+          raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :secrets)
+        end
+
+        variable_name
+      end
+    end
+
+    private
+
+    def process_short_syntax(secret_name, global_secrets_data)
+      global_secret = find_global_secret!(secret_name, global_secrets_data)
+
+      global_secret[:secret_variable]
+    end
+
+    def find_global_secret!(secret_name, global_secrets_data)
+      detected_secret = global_secrets_data.detect { |global_secret_data| global_secret_data[:secret_name] == secret_name }
+      error_message = I18n.t('compose.global_secret_not_found', secret: secret_name)
+      raise UffizziCore::ComposeFile::ParseError, error_message if detected_secret.nil?
+
+      detected_secret
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ServicesOptionsService
+  class << self
+    def parse(services, global_configs_data, global_secrets_data, compose_payload)
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.no_services') if services.nil? || services.keys.empty?
+
+      services.keys.map do |service|
+        service_data = prepare_service_data(service, services.fetch(service), global_configs_data, global_secrets_data, compose_payload)
+
+        if service_data[:image].blank? && service_data[:build].blank?
+          raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.image_build_no_specified', value: service)
+        end
+
+        service_data
+      end
+    end
+
+    private
+
+    def prepare_service_data(service_name, service_data, global_configs_data, global_secrets_data, compose_payload)
+      options_data = {}
+      service_data.each_pair do |key, value|
+        service_key = key.to_sym
+
+        options_data[service_key] = case service_key
+                                    when :image
+                                      UffizziCore::ComposeFile::ServicesOptions::ImageService.parse(value)
+                                    when :build
+                                      UffizziCore::ComposeFile::ServicesOptions::BuildService.parse(value, compose_payload)
+                                    when :env_file
+                                      UffizziCore::ComposeFile::ServicesOptions::EnvFileService.parse(value)
+                                    when :environment
+                                      UffizziCore::ComposeFile::ServicesOptions::EnvironmentService.parse(value)
+                                    when :configs
+                                      UffizziCore::ComposeFile::ServicesOptions::ConfigsService.parse(value, global_configs_data)
+                                    when :secrets
+                                      UffizziCore::ComposeFile::ServicesOptions::SecretsService.parse(value, global_secrets_data)
+                                    when :deploy
+                                      UffizziCore::ComposeFile::ServicesOptions::DeployService.parse(value)
+                                    when :entrypoint
+                                      UffizziCore::ComposeFile::ServicesOptions::EntrypointService.parse(value)
+                                    when :command
+                                      UffizziCore::ComposeFile::ServicesOptions::CommandService.parse(value)
+                                    when :'x-uffizzi-continuous-preview', :'x-uffizzi-continuous-previews'
+                                      UffizziCore::ComposeFile::ContinuousPreviewOptionsService.parse(value)
+        end
+      end
+
+      options_data[:container_name] = service_name
+
+      options_data
+    end
+  end
+end