uffizzi_core 0.1.3

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::Builders::ConfigFilesBuilderService
+  attr_accessor :project
+
+  def initialize(project)
+    @project = project
+  end
+
+  def build_attributes(config_files_data, dependencies)
+    return [] if config_files_data.empty?
+
+    config_file_sources = dependencies.pluck(:source)
+    config_files = project.config_files.with_creation_source(UffizziCore::ConfigFile.creation_source.compose_file)
+      .by_source(config_file_sources)
+
+    config_files_data.map do |config_file_data|
+      detected_dependency = dependencies.detect { |dependency| dependency[:path] == config_file_data[:source] }
+      detected_config_file = config_files.detect { |config_file| config_file.source == detected_dependency[:source] }
+
+      if detected_config_file.nil?
+        raise UffizziCore::ComposeFile::BuildError, I18n.t('compose.config_file_not_found', name: config_file_data[:source])
+      end
+
+      {
+        mount_path: config_file_data[:target],
+        config_file_id: detected_config_file.id,
+      }
+    end
+  end
+end

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

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::Builders::ContainerBuilderService
+  attr_accessor :credentials, :project, :repositories
+
+  def initialize(credentials, project, repositories = [])
+    @credentials = credentials
+    @project = project
+    @repositories = repositories
+  end
+
+  def build_attributes(container_data, ingress_data, continuous_preview_global_data, compose_dependencies)
+    image_data = container_data[:image] || {}
+    build_data = container_data[:build] || {}
+    environment = container_data[:environment] || []
+    deploy_data = container_data[:deploy] || {}
+    configs_data = container_data[:configs] || []
+    secrets = container_data[:secrets] || []
+    container_name = container_data[:container_name]
+    continuous_preview_container_data = container_data[:'x-uffizzi-continuous-preview'] || container_data[:'x-uffizzi-continuous-previews']
+
+    env_file_dependencies = UffizziCore::ComposeFile::GithubDependenciesService.env_file_dependencies_for_container(compose_dependencies,
+                                                                                                                    container_name)
+    configs_dependencies = UffizziCore::ComposeFile::GithubDependenciesService.configs_dependencies_for_container(compose_dependencies,
+                                                                                                                  container_name)
+
+    is_ingress = ingress_container?(container_name, ingress_data)
+    repo_attributes = build_repo_attributes(container_data, image_data, build_data, credentials)
+
+    repo_attributes = set_continuous_preview_attributes_to_repo(repo_attributes, continuous_preview_global_data.to_h,
+                                                                continuous_preview_container_data.to_h)
+
+    {
+      tag: tag(image_data, repo_attributes),
+      port: port(container_name, ingress_data),
+      image: image(container_data, image_data, build_data),
+      public: is_ingress,
+      entrypoint: entrypoint(container_data),
+      command: command(container_data),
+      variables: variables(environment, env_file_dependencies),
+      secret_variables: secret_variables(secrets),
+      memory_limit: memory(deploy_data),
+      memory_request: memory(deploy_data),
+      repo_attributes: repo_attributes,
+      continuously_deploy: continuously_deploy(deploy_data),
+      receive_incoming_requests: is_ingress,
+      container_config_files_attributes: config_files(configs_data, configs_dependencies),
+      name: container_name,
+    }
+  end
+
+  private
+
+  def set_continuous_preview_attributes_to_repo(repo_attributes, global_data, container_data)
+    condition_attributes = [
+      :deploy_preview_when_pull_request_is_opened,
+      :delete_preview_when_pull_request_is_closed,
+      :deploy_preview_when_image_tag_is_created,
+      :delete_preview_when_image_tag_is_updated,
+      :share_to_github,
+    ]
+
+    condition_attributes.each do |attribute|
+      repo_attributes[attribute] = select_continuous_preview_attribute(global_data[attribute], container_data[attribute], false)
+    end
+    repo_attributes[:delete_preview_after] =
+      select_continuous_preview_attribute(global_data.dig(:delete_preview_after, :value),
+                                          container_data.dig(:delete_preview_after, :value), nil)
+
+    repo_attributes
+  end
+
+  def select_continuous_preview_attribute(global_attribute, local_attribute, default_attribute)
+    return local_attribute if !local_attribute.nil?
+    return global_attribute if !global_attribute.nil?
+
+    default_attribute
+  end
+
+  def tag(image_data, repo_attributes)
+    image_data[:tag] || repo_attributes[:branch]
+  end
+
+  def port(container_name, ingress)
+    return nil unless ingress_container?(container_name, ingress)
+
+    ingress[:port]
+  end
+
+  def image(container_data, image_data, build_data)
+    if image_data.present?
+      image_name(container_data, image_data)
+    else
+      "#{build_data[:account_name]}/#{build_data[:repository_name]}"
+    end
+  end
+
+  def image_name(container_data, image_data)
+    if image_data[:registry_url].present? && !UffizziCore::ComposeFile::ContainerService.google?(container_data)
+      image_data[:name]
+    else
+      "#{image_data[:namespace]}/#{image_data[:name]}"
+    end
+  end
+
+  def ingress_container?(container_name, ingress)
+    ingress[:container_name] == container_name
+  end
+
+  def entrypoint(container_data)
+    entrypoint = container_data[:entrypoint]
+
+    entrypoint.present? ? entrypoint.to_s : nil
+  end
+
+  def command(container_data)
+    command = container_data[:command]
+
+    command.present? ? command.to_s : nil
+  end
+
+  def command_args(command_data)
+    return nil if command_data[:command_args].blank?
+
+    command_data[:command_args].to_s
+  end
+
+  def memory(deploy_data)
+    memory = deploy_data[:memory]
+    return Settings.compose.default_memory if memory.nil?
+
+    memory_value = case memory[:postfix]
+                   when 'b'
+                     memory[:value] / 1_000_000
+                   when 'k'
+                     memory[:value] / 1000
+                   when 'm'
+                     memory[:value]
+                   when 'g'
+                     memory[:value] * 1000
+    end
+
+    unless Settings.compose.memory_values.include?(memory_value)
+      raise UffizziCore::ComposeFile::BuildError,
+            I18n.t('compose.invalid_memory')
+    end
+
+    memory_value
+  end
+
+  def build_repo_attributes(container_data, image_data, build_data, credentials)
+    repo_type = repo_type(container_data)
+
+    case repo_type
+    when UffizziCore::Repo::Github.name
+      build_github_repo_attributes(build_data, credentials)
+    when UffizziCore::Repo::DockerHub.name
+      build_docker_repo_attributes(image_data, credentials, :docker_hub, UffizziCore::Repo::DockerHub.name)
+    when UffizziCore::Repo::Azure.name
+      build_docker_repo_attributes(image_data, credentials, :azure, UffizziCore::Repo::Azure.name)
+    when UffizziCore::Repo::Google.name
+      build_docker_repo_attributes(image_data, credentials, :google, UffizziCore::Repo::Google.name)
+    else
+      raise UffizziCore::ComposeFile::BuildError, I18n.t('compose.invalid_repo_type')
+    end
+  end
+
+  def repo_type(container_data)
+    if UffizziCore::ComposeFile::ContainerService.github?(container_data)
+      UffizziCore::Repo::Github.name
+    elsif UffizziCore::ComposeFile::ContainerService.azure?(container_data)
+      UffizziCore::Repo::Azure.name
+    elsif UffizziCore::ComposeFile::ContainerService.docker_hub?(container_data)
+      UffizziCore::Repo::DockerHub.name
+    elsif UffizziCore::ComposeFile::ContainerService.google?(container_data)
+      UffizziCore::Repo::Google.name
+    end
+  end
+
+  def continuously_deploy(deploy_data)
+    return :disabled if deploy_data[:auto] == false
+
+    :enabled
+  end
+
+  def build_github_repo_attributes(build_data, credentials)
+    credential = credentials.github.first
+    raise UffizziCore::ComposeFile::BuildError, 'Invalid credential: GitHub' if credential.nil?
+
+    github_builder.build_attributes(build_data)
+  end
+
+  def build_docker_repo_attributes(image_data, credentials, scope, repo_type)
+    credential = credentials.send(scope).first
+    raise UffizziCore::ComposeFile::BuildError, 'Invalid credential: Docker' if credential.nil?
+
+    docker_builder(repo_type).build_attributes(image_data)
+  end
+
+  def variables(variables_data, dependencies)
+    variables_builder.build_attributes(variables_data, dependencies)
+  end
+
+  def secret_variables(secrets)
+    variables_builder.build_secret_attributes(secrets)
+  end
+
+  def config_files(config_files_data, dependencies)
+    builder = UffizziCore::ComposeFile::Builders::ConfigFilesBuilderService.new(project)
+
+    builder.build_attributes(config_files_data, dependencies)
+  end
+
+  def github_builder
+    @github_builder ||= UffizziCore::ComposeFile::Builders::GithubRepoBuilderService.new(repositories)
+  end
+
+  def docker_builder(type)
+    @docker_builder ||= UffizziCore::ComposeFile::Builders::DockerRepoBuilderService.new(type)
+  end
+
+  def variables_builder
+    @variables_builder ||= UffizziCore::ComposeFile::Builders::VariablesBuilderService.new(project)
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::Builders::DockerRepoBuilderService
+  attr_accessor :type
+
+  def initialize(type)
+    @type = type
+  end
+
+  def build_attributes(image_data)
+    {
+      kind: nil,
+      name: image_data[:name],
+      slug: image_data[:name],
+      type: type,
+      branch: nil,
+      namespace: image_data[:namespace],
+      is_private: nil, # TODO: detect
+      description: '',
+      repository_id: nil,
+      dockerfile_path: '',
+      dockerfile_context_path: nil,
+    }
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::Builders::GithubRepoBuilderService
+  attr_accessor :repositories
+
+  def initialize(repositories)
+    @repositories = repositories
+  end
+
+  def build_attributes(build_data)
+    repository_data = repository(build_data[:repository_name])
+
+    {
+      kind: repository_kind(build_data),
+      name: build_data[:repository_name],
+      slug: build_data[:repository_name],
+      type: UffizziCore::Repo::Github.name,
+      branch: branch(build_data, repository_data),
+      namespace: build_data[:account_name],
+      is_private: nil,
+      description: repository_data[:description],
+      repository_id: repository_data[:id],
+      dockerfile_path: build_data[:dockerfile],
+      dockerfile_context_path: build_data[:dockerfile_context_path],
+      args: args(build_data),
+    }
+  end
+
+  private
+
+  def branch(build_data, repository_data)
+    build_data[:branch] || repository_data[:default_branch]
+  end
+
+  def repository(name)
+    repo = repositories.detect { |repository| repository.name.downcase == name.downcase }
+
+    raise UffizziCore::ComposeFile::BuildError, I18n.t('compose.repo_not_found', name: name) if repo.nil?
+
+    repo
+  end
+
+  def repository_kind(build_data)
+    if build_data[:dockerfile].present?
+      UffizziCore::Repo.kind.dockerfile
+    else
+      UffizziCore::Repo.kind.barestatic
+    end
+  end
+
+  def args(build_data)
+    build_data[:args].map do |arg|
+      {
+        name: arg[:name],
+        value: arg[:value],
+      }
+    end
+  end
+end

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,37 @@
+# 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|
+        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,64 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::ContainerService
+  class << self
+    def github?(container)
+      repository_url = container.dig(:build, :repository_url)
+
+      repository_url.present? && repository_url.include?('github.com')
+    end
+
+    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 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 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.github?(container)
+        detect_credential(credentials, :github)
+      elsif 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