uffizzi-core 0.1.12

data/app/serializers/uffizzi_core/api/cli/v1/projects/secret_serializer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Projects::SecretSerializer < UffizziCore::BaseSerializer
+  attributes :name, :created_at, :updated_at
+end

data/app/serializers/uffizzi_core/api/cli/v1/short_project_serializer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::ShortProjectSerializer < UffizziCore::BaseSerializer
+  type :project
+
+  attributes :name, :slug
+end

data/app/serializers/uffizzi_core/api/cli/v1/user_serializer/account_serializer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::UserSerializer::AccountSerializer < UffizziCore::BaseSerializer
+  attributes :id, :state
+end

data/app/serializers/uffizzi_core/api/cli/v1/user_serializer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::UserSerializer < UffizziCore::BaseSerializer
+  type :user
+
+  has_many :accounts
+end

data/app/serializers/uffizzi_core/base_serializer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class UffizziCore::BaseSerializer < ActiveModel::Serializer
+  def anonymize(field)
+    '*' * field.length
+  end
+end

data/app/serializers/uffizzi_core/controller/apply_config_file/config_file_serializer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UffizziCore::Controller::ApplyConfigFile::ConfigFileSerializer < UffizziCore::BaseSerializer
+  attributes :id, :filename, :kind, :payload
+end

data/app/serializers/uffizzi_core/controller/create_credential/credential_serializer.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class UffizziCore::Controller::CreateCredential::CredentialSerializer < UffizziCore::BaseSerializer
+  attributes :id, :registry_url, :username, :password
+
+  def username
+    return 'AWS' if object.amazon?
+
+    object.username
+  end
+
+  def password
+    if object.amazon?
+      UffizziCore::Amazon::CredentialService.access_token(object)
+    else
+      object.password
+    end
+  end
+end

data/app/serializers/uffizzi_core/controller/create_deployment/deployment_serializer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UffizziCore::Controller::CreateDeployment::DeploymentSerializer < UffizziCore::BaseSerializer
+  attributes :kind
+end

data/app/serializers/uffizzi_core/controller/deploy_containers/container_serializer/container_config_file_serializer/config_file_serializer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/LineLength
+class UffizziCore::Controller::DeployContainers::ContainerSerializer::ContainerConfigFileSerializer::ConfigFileSerializer < UffizziCore::BaseSerializer
+  # rubocop:enable Metrics/LineLength
+
+  attributes :id, :filename, :kind, :payload
+end

data/app/serializers/uffizzi_core/controller/deploy_containers/container_serializer/container_config_file_serializer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class UffizziCore::Controller::DeployContainers::ContainerSerializer::ContainerConfigFileSerializer < UffizziCore::BaseSerializer
+  attributes :mount_path
+
+  belongs_to :config_file
+end

data/app/serializers/uffizzi_core/controller/deploy_containers/container_serializer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class UffizziCore::Controller::DeployContainers::ContainerSerializer < UffizziCore::BaseSerializer
+  attributes :id,
+             :kind,
+             :image,
+             :tag,
+             :variables,
+             :secret_variables,
+             :memory_limit,
+             :memory_request,
+             :entrypoint,
+             :command,
+             :port,
+             :target_port,
+             :public,
+             :controller_name,
+             :receive_incoming_requests,
+             :healthcheck
+
+  has_many :container_config_files
+
+  def image
+    repo = object.repo
+    credential = UffizziCore::RepoService.credential(repo)
+
+    case repo.type
+    when UffizziCore::Repo::Google.name, UffizziCore::Repo::Amazon.name, UffizziCore::Repo::Azure.name
+      registry_host = URI.parse(credential.registry_url).host
+
+      "#{registry_host}/#{object.image}"
+    when UffizziCore::Repo::GithubContainerRegistry.name
+      registry_host = URI.parse(credential.registry_url).host
+      "#{registry_host}/#{repo.namespace}/#{object.image}"
+    else
+      object.image
+    end
+  end
+
+  def tag
+    case object.repo.type
+    when UffizziCore::Repo::Github.name
+      UffizziCore::RepoService.tag(object.repo)
+    else
+      object.tag
+    end
+  end
+
+  def entrypoint
+    object.entrypoint.blank? ? nil : JSON.parse(object.entrypoint)
+  end
+
+  def command
+    object.command.blank? ? nil : JSON.parse(object.command)
+  end
+
+  def healthcheck
+    return {} if object.healthcheck.nil?
+
+    command = object.healthcheck['test']
+    new_command = if command.is_a?(Array)
+      items_to_remove = ['CMD', 'CMD-SHELL']
+      command.select { |item| items_to_remove.exclude?(item) }
+    elsif object.healthcheck['test'].is_a?(String)
+      command.split
+    end
+
+    object.healthcheck.merge(test: new_command)
+  end
+end

data/app/serializers/uffizzi_core/controller/deploy_containers/credential_serializer.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class UffizziCore::Controller::DeployContainers::CredentialSerializer < UffizziCore::BaseSerializer
+  attributes :id
+end

data/app/services/uffizzi_core/account_service.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class UffizziCore::AccountService
+  class << self
+    def create_credential(credential)
+      credential.account.projects.active.each do |project|
+        project.deployments.active.each do |deployment|
+          UffizziCore::Deployment::CreateCredentialJob.perform_async(deployment.id, credential.id)
+        end
+      end
+    end
+
+    def delete_credential(credential)
+      credential.account.projects.active.each do |project|
+        project.deployments.active.each do |deployment|
+          UffizziCore::Deployment::DeleteCredentialJob.perform_async(deployment.id, credential.id)
+        end
+      end
+    end
+  end
+end

data/app/services/uffizzi_core/activity_item_service.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+class UffizziCore::ActivityItemService
+  COMPLETED_STATES = ['deployed', 'failed', 'cancelled'].freeze
+
+  class << self
+    def create_docker_item!(repo, container)
+      activity_item_attributes = {
+        namespace: repo.namespace,
+        name: repo.name,
+        container: container,
+        deployment_id: container.deployment_id,
+        type: UffizziCore::ActivityItem::Docker.name,
+        tag: container.tag,
+      }
+
+      create_item!(activity_item_attributes)
+    end
+
+    def disable_deployment!(activity_item)
+      deployment = activity_item.container.deployment
+
+      activity_item.events.create(state: UffizziCore::Event.state.failed)
+
+      UffizziCore::DeploymentService.disable!(deployment)
+    end
+
+    def fail_deployment!(activity_item)
+      deployment = activity_item.container.deployment
+
+      activity_item.events.create(state: UffizziCore::Event.state.failed)
+
+      UffizziCore::DeploymentService.fail!(deployment)
+    end
+
+    def update_docker_digest!(activity_item)
+      container = activity_item.container
+      repo = container.repo
+      credential = UffizziCore::RepoService.credential(repo)
+
+      digest = case repo.type
+               when UffizziCore::Repo::DockerHub.name
+                 UffizziCore::DockerHubService.digest(credential, activity_item.image, activity_item.tag)
+               when UffizziCore::Repo::Azure.name
+                 UffizziCore::AzureService.digest(credential, activity_item.image, activity_item.tag)
+               when UffizziCore::Repo::Google.name
+                 UffizziCore::GoogleService.digest(credential, activity_item.image, activity_item.tag)
+               when UffizziCore::Repo::Amazon.name
+                 UffizziCore::AmazonService.digest(credential, activity_item.image, activity_item.tag)
+      end
+
+      activity_item.update!(digest: digest)
+
+      activity_item
+    end
+
+    def manage_deploy_activity_item(activity_item)
+      container = activity_item.container
+      deployment = container.deployment
+      service = UffizziCore::ManageActivityItemsService.new(deployment)
+      container_status_item = service.container_status_item(container)
+      status = container_status_item[:status]
+      last_event = activity_item.events.order_by_id.last
+
+      activity_item.events.create(state: status) if last_event&.state != status
+
+      return unless [UffizziCore::Event.state.building, UffizziCore::Event.state.deploying].include?(status)
+
+      UffizziCore::Deployment::ManageDeployActivityItemJob.perform_in(5.seconds, activity_item.id)
+    end
+
+    private
+
+    def create_item!(activity_item_attributes)
+      activity_item = UffizziCore::ActivityItem.find_by(activity_item_attributes)
+      return activity_item unless completed?(activity_item)
+
+      UffizziCore::ActivityItem.create!(activity_item_attributes)
+    end
+
+    def completed?(activity_item)
+      return true if activity_item.nil?
+
+      last_event = activity_item.events.last
+      COMPLETED_STATES.include?(last_event.state)
+    end
+  end
+end

data/app/services/uffizzi_core/amazon/credential_service.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class UffizziCore::Amazon::CredentialService
+  class << self
+    def credential_correct?(credential)
+      access_token(credential).present?
+    end
+
+    def access_token(credential)
+      response = client(credential).authorization_token
+      base64_data = response.authorization_data[0].authorization_token
+      token_string = Base64.decode64(base64_data)
+      token_items = token_string.split(':')
+      token_items.pop
+    rescue Aws::ECR::Errors::UnrecognizedClientException, Aws::ECR::Errors::InvalidSignatureException
+      ''
+    end
+
+    private
+
+    def client(credential)
+      region = UffizziCore::AmazonService.get_region_from_registry_url(credential.registry_url)
+
+      UffizziCore::AmazonRegistryClient.new(
+        region: region,
+        access_key_id: credential.username,
+        secret_access_key: credential.password,
+      )
+    end
+  end
+end

data/app/services/uffizzi_core/amazon_service.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class UffizziCore::AmazonService
+  class << self
+    def digest(credential, image, tag)
+      response = client(credential).batch_get_image(image: image, tag: tag)
+      response.images[0].image_id.image_digest
+    rescue StandardError
+      nil
+    end
+
+    def get_region_from_registry_url(url)
+      parsed_url = URI.parse(url)
+      host = parsed_url.host
+      parsed_host = host.split('.')
+      parsed_host[3]
+    end
+
+    def process_webhook(event, event_data)
+      case event
+      when 'PUSH'
+        source = UffizziCore::Repo::Amazon.name
+        image = event_data['repository-name']
+        tag = event_data['image-tag']
+
+        UffizziCore::ContinuouslyDeployService.run_docker_registry_process(source, image, tag)
+        UffizziCore::ContinuousPreviewService.run_docker_registry_process(source, image, tag)
+      else
+        Rails.logger.warn("Amazon #{event} event doesn't support")
+      end
+    end
+
+    private
+
+    def client(credential)
+      region = get_region_from_registry_url(credential.registry_url)
+
+      UffizziCore::AmazonRegistryClient.new(
+        region: region,
+        access_key_id: credential.username,
+        secret_access_key: credential.password,
+      )
+    end
+  end
+end

data/app/services/uffizzi_core/azure/credential_service.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class UffizziCore::Azure::CredentialService
+  class << self
+    def credential_correct?(credential)
+      client(credential).authentificated?
+    rescue URI::InvalidURIError, Faraday::ConnectionFailed
+      false
+    end
+
+    private
+
+    def client(credential)
+      UffizziCore::AzureRegistryClient.new(registry_url: credential.registry_url, username: credential.username,
+                                           password: credential.password)
+    end
+  end
+end

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,222 @@
+# 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]
+    healthcheck_data = container_data[:healthcheck] || {}
+
+    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 = repo_attributes(container_data, continuous_preview_global_data)
+
+    {
+      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),
+      service_name: container_name,
+    }
+  end
+
+  private
+
+  def repo_attributes(container_data, continuous_preview_global_data)
+    repo_attributes = build_repo_attributes(container_data)
+    continuous_preview_container_data = container_data[:'x-uffizzi-continuous-preview'] || container_data[:'x-uffizzi-continuous-previews']
+
+    set_continuous_preview_attributes_to_repo(repo_attributes, continuous_preview_global_data.to_h, continuous_preview_container_data.to_h)
+  end
+
+  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)
+    repo_type = repo_type(container_data)
+    image_data = container_data[:image]
+
+    case repo_type
+    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)
+    when UffizziCore::Repo::GithubContainerRegistry.name
+      build_docker_repo_attributes(image_data, credentials, :github_container_registry, UffizziCore::Repo::GithubContainerRegistry.name)
+    when UffizziCore::Repo::Amazon.name
+      build_docker_repo_attributes(image_data, credentials, :amazon, UffizziCore::Repo::Amazon.name)
+    else
+      raise UffizziCore::ComposeFile::BuildError, I18n.t('compose.invalid_repo_type')
+    end
+  end
+
+  def repo_type(container_data)
+    if 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
+    elsif UffizziCore::ComposeFile::ContainerService.github_container_registry?(container_data)
+      UffizziCore::Repo::GithubContainerRegistry.name
+    elsif UffizziCore::ComposeFile::ContainerService.amazon?(container_data)
+      UffizziCore::Repo::Amazon.name
+    end
+  end
+
+  def continuously_deploy(deploy_data)
+    return :disabled if deploy_data[:auto] == false
+
+    :enabled
+  end
+
+  def build_docker_repo_attributes(image_data, credentials, scope, repo_type)
+    credential = credentials.send(scope).first
+    raise UffizziCore::ComposeFile::BuildError, I18n.t('compose.invalid_credential', value: scope) 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 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