uffizzi-core 0.1.12

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,57 @@
+# 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
+                                      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.not_implemented', option: :build)
+                                    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 :healthcheck
+                                      UffizziCore::ComposeFile::Parsers::Services::HealthcheckParserService.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

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::TemplateService
+  def initialize(cli_form, project, user)
+    @project = project
+    @user = user
+    @compose_dependencies = cli_form.compose_dependencies
+    @compose_data = cli_form.compose_data
+    @compose_repositories = cli_form.compose_repositories
+  end
+
+  def create_template(compose_file_form)
+    compose_file_template_form = build_compose_file_template_form(compose_file_form)
+    return compose_file_template_form.errors if compose_file_template_form.invalid?
+
+    template_form = build_template_form(compose_file_form, compose_file_template_form)
+    return template_form.errors if template_form.invalid?
+
+    template_form.save
+
+    nil
+  end
+
+  private
+
+  def build_compose_file_template_form(compose_file_form)
+    credentials = @project.account.credentials
+    compose_file_template_form = UffizziCore::Api::Cli::V1::ComposeFile::TemplateForm.new
+    compose_file_template_form.compose_data = @compose_data
+    compose_file_template_form.source = compose_file_form.source
+    compose_file_template_form.credentials = credentials
+    compose_file_template_form.project = @project
+    compose_file_template_form.user = @user
+    compose_file_template_form.compose_dependencies = @compose_dependencies
+    compose_file_template_form.compose_repositories = @compose_repositories
+    compose_file_template_form.assign_template_attributes!
+
+    compose_file_template_form
+  end
+
+  def build_template_form(compose_file_form, compose_file_template_form)
+    attributes = compose_file_template_form.template_attributes
+    source = compose_file_template_form.source
+    template = compose_file_form.template
+    template = @project.templates.find_or_initialize_by(name: source) if !template.present?
+    template.assign_attributes(attributes)
+    template_form = template.becomes(UffizziCore::Api::Cli::V1::Template::CreateForm)
+    template_form.project = @project
+    template_form.added_by = @user
+    template_form.compose_file = compose_file_form
+    template_form.creation_source = UffizziCore::Template.creation_source.compose_file
+
+    template_form
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module UffizziCore::ComposeFile::VariablesService
+  def parse_variable_from_string(str)
+    variable_parts = str.split('=', 2)
+
+    parse_variable_from_array(variable_parts)
+  end
+
+  def parse_variable_from_array(arr)
+    name = arr.first.to_s
+    value = arr.last.to_s
+
+    build_variable(name, value)
+  end
+
+  def build_variable(name, value)
+    raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.no_variable_name', name: name, value: value) if name.blank?
+
+    {
+      name: name,
+      value: value,
+    }
+  end
+end

data/app/services/uffizzi_core/compose_file_service.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module UffizziCore::ComposeFileService
+  class << self
+    def create(params, kind)
+      compose_file_form = create_compose_form(params, kind)
+
+      process_compose_file(compose_file_form, params)
+    end
+
+    def update(compose_file, params)
+      compose_file_form = create_update_compose_form(compose_file, params)
+
+      process_compose_file(compose_file_form, params)
+    end
+
+    def parse(compose_content, compose_payload = {})
+      compose_data = load_compose_data(compose_content)
+      check_config_options_format(compose_data)
+      configs_data = UffizziCore::ComposeFile::ConfigsOptionsService.parse(compose_data['configs'])
+      secrets_data = UffizziCore::ComposeFile::SecretsOptionsService.parse(compose_data['secrets'])
+      containers_data = UffizziCore::ComposeFile::ServicesOptionsService.parse(compose_data['services'], configs_data, secrets_data,
+                                                                               compose_payload)
+
+      continuous_preview_option = UffizziCore::ComposeFile::ConfigOptionService.continuous_preview_option(compose_data)
+      continuous_preview_data = UffizziCore::ComposeFile::ContinuousPreviewOptionsService.parse(continuous_preview_option)
+
+      ingress_option = UffizziCore::ComposeFile::ConfigOptionService.ingress_option(compose_data)
+      ingress_data = UffizziCore::ComposeFile::IngressOptionsService.parse(ingress_option, compose_data['services'])
+
+      {
+        containers: containers_data,
+        ingress: ingress_data,
+        continuous_preview: continuous_preview_data,
+      }
+    end
+
+    def build_template_attributes(compose_data, source, credentials, project, compose_dependencies = [], compose_repositories = [])
+      builder = UffizziCore::ComposeFile::Builders::TemplateBuilderService.new(credentials, project, compose_repositories)
+
+      builder.build_attributes(compose_data, compose_dependencies, source)
+    end
+
+    def containers_credentials(compose_data, credentials)
+      containers = compose_data[:containers]
+      detected_credentials = containers.map do |container|
+        UffizziCore::ComposeFile::ContainerService.credential_for_container(container, credentials)
+      end
+
+      result = []
+      detected_credentials.compact
+        .group_by { |credential| credential[:id] }
+        .each_pair { |_id, value| result << value.first }
+      result
+    end
+
+    def has_secret?(compose_file, secret)
+      containers = compose_file.template.payload['containers_attributes']
+
+      containers.any? { |container| UffizziCore::ComposeFile::ContainerService.has_secret?(container, secret) }
+    end
+
+    def update_secret!(compose_file, secret)
+      compose_file.template.payload['containers_attributes'].map do |container|
+        if UffizziCore::ComposeFile::ContainerService.has_secret?(container, secret)
+          container = UffizziCore::ComposeFile::ContainerService.update_secret(container, secret)
+        end
+
+        container
+      end
+
+      compose_file.template.save!
+
+      compose_file
+    end
+
+    def secrets_valid?(compose_file, secrets)
+      secret_names = secrets.pluck('name')
+
+      compose_file.template.payload['containers_attributes'].all? do |container|
+        container['secret_variables'].all? { |secret| secret_names.include?(secret['name']) }
+      end
+    end
+
+    private
+
+    def process_compose_file(compose_file_form, params)
+      cli_form = UffizziCore::Api::Cli::V1::ComposeFile::CliForm.new
+      cli_form.content = compose_file_form.content
+      return [compose_file_form, cli_form.errors] if cli_form.invalid?
+
+      dependencies = params[:dependencies].to_a
+      compose_data = cli_form.compose_data
+      compose_dependencies = build_compose_dependecies(compose_data, compose_file_form.path, dependencies)
+      cli_form.compose_dependencies = compose_dependencies
+
+      persist!(compose_file_form, cli_form)
+    end
+
+    def create_compose_form(params, kind)
+      compose_file_params = params[:compose_file_params]
+      compose_file_form = UffizziCore::Api::Cli::V1::ComposeFile::CreateForm.new(compose_file_params)
+      compose_file_form.project = params[:project]
+      compose_file_form.added_by = params[:user]
+      compose_file_form.content = compose_file_params[:content]
+      compose_file_form.kind = kind
+      payload_dependencies = prepare_compose_file_dependencies(params[:dependencies])
+      compose_file_form.payload['dependencies'] = payload_dependencies
+
+      compose_file_form
+    end
+
+    def create_update_compose_form(compose_file, params)
+      compose_file_form = compose_file.becomes(UffizziCore::Api::Cli::V1::ComposeFile::UpdateForm)
+      compose_file_params = params[:compose_file_params]
+      compose_file_form.assign_attributes(compose_file_params)
+      payload_dependencies = prepare_compose_file_dependencies(params[:dependencies])
+      compose_file_form.payload['dependencies'] = payload_dependencies
+
+      compose_file_form
+    end
+
+    def build_compose_dependecies(compose_data, compose_path, dependencies)
+      return [] if dependencies.empty?
+
+      UffizziCore::ComposeFile::DependenciesService.build_dependencies(compose_data, compose_path, dependencies)
+    end
+
+    def prepare_compose_file_dependencies(compose_dependencies)
+      compose_dependencies.map do |dependency|
+        {
+          path: dependency[:path],
+        }
+      end
+    end
+
+    def persist!(compose_file_form, cli_form)
+      errors = []
+      ActiveRecord::Base.transaction do
+        if !compose_file_form.save
+          errors = compose_file_form.errors
+          raise ActiveRecord::Rollback
+        end
+
+        config_files_service = UffizziCore::ComposeFile::ConfigFilesService.new(compose_file_form)
+        errors = config_files_service.create_config_files(cli_form.compose_dependencies)
+        raise ActiveRecord::Rollback if errors.present?
+
+        project = compose_file_form.project
+        user = compose_file_form.added_by
+        template_service = UffizziCore::ComposeFile::TemplateService.new(cli_form, project, user)
+        errors = template_service.create_template(compose_file_form)
+
+        raise ActiveRecord::Rollback if errors.present?
+      end
+      [compose_file_form, errors]
+    end
+
+    def load_compose_data(compose_content)
+      begin
+        compose_data = YAML.safe_load(compose_content, aliases: true)
+      rescue Psych::SyntaxError
+        raise UffizziCore::ComposeFile::ParseError, 'Invalid compose file'
+      end
+
+      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.unsupported_file') if compose_data.nil?
+
+      compose_data
+    end
+
+    def check_config_options_format(compose_data)
+      options = UffizziCore::ComposeFile::ConfigOptionService.config_options(compose_data)
+
+      options.each do |option|
+        next if UffizziCore::ComposeFile::ConfigOptionService.valid_option_format?(option)
+
+        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_config_option', value: option)
+      end
+    end
+  end
+end

data/app/services/uffizzi_core/container_service.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+class UffizziCore::ContainerService
+  class << self
+    def pod_name(container)
+      return container.controller_name if container.controller_name.present?
+
+      formatted_name = container.image_name
+      formatted_name.parameterize.gsub('_', '-')
+    end
+
+    def target_port_value(container)
+      container.port
+    end
+
+    def defines_env?(container, name)
+      return false if container.variables.nil?
+
+      container.variables.select { |v| v['name'].downcase.to_sym == name.to_sym }.any?
+    end
+
+    def continuously_deploy_enabled?(container)
+      container.aasm(:continuously_deploy).current_state == UffizziCore::Container::STATE_ENABLED
+    end
+
+    def valid_memory_limit?(container)
+      max_memory_limit = container.deployment.project.account.container_memory_limit
+      container_memory_limit = container.memory_limit
+      return true if max_memory_limit.nil? || container_memory_limit.nil?
+
+      container_memory_limit <= max_memory_limit
+    end
+
+    def valid_memory_request?(container)
+      max_memory_limit = container.deployment.project.account.container_memory_limit
+      container_memory_request = container.memory_request
+      return true if max_memory_limit.nil? || container_memory_request.nil?
+
+      container_memory_request <= max_memory_limit
+    end
+  end
+end