uffizzi_core 0.1.3

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Projects::DeploymentSerializer < UffizziCore::BaseSerializer
+  type :deployment
+
+  attributes :id,
+             :kind,
+             :project_id,
+             :created_at,
+             :updated_at,
+             :state,
+             :preview_url,
+             :tag,
+             :branch,
+             :commit,
+             :image_id,
+             :ingress_container_ready,
+             :ingress_container_state,
+             :creation_source
+
+  has_many :containers
+
+  belongs_to :deployed_by
+
+  def deployed_by
+    object.deployed_by
+  end
+
+  def containers
+    object.containers.active
+  end
+
+  def preview_url
+    UffizziCore::DeploymentService.build_preview_url(object)
+  end
+
+  def tag
+    object.ingress_container&.tag
+  end
+
+  def branch
+    object.ingress_container&.repo&.branch
+  end
+
+  def commit
+    object.ingress_container&.repo&.builds&.deployed&.last&.commit.to_s.slice(0..5)
+  end
+
+  def image_id
+    object.ingress_container&.repo&.name
+  end
+
+  def ingress_container_ready
+    !!object.ingress_container&.activity_items&.last&.events&.last&.deployed?
+  end
+
+  def ingress_container_state
+    last_event = object.ingress_container&.activity_items&.last&.events&.last
+
+    case last_event&.state
+    when UffizziCore::Event.state.deployed
+      :deployed
+    when UffizziCore::Event.state.failed, UffizziCore::Event.state.timeout, UffizziCore::Event.state.cancelled
+      :failed
+    else
+      state_from_activity_items
+    end
+  end
+
+  def state_from_activity_items
+    activity_items_count = object.ingress_container&.activity_items&.count
+    activity_items_count.to_i > 1 ? :updating : :pending
+  end
+end

data/app/serializers/uffizzi_core/api/cli/v1/projects/deployments/activity_item_serializer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Projects::Deployments::ActivityItemSerializer < UffizziCore::BaseSerializer
+  type :activity_item
+
+  attributes :id, :namespace, :name, :tag, :type, :branch, :commit, :commit_message, :state, :created_at,
+             :updated_at, :build_id, :data, :container_id, :digest
+
+  def type
+    return :github if object.type == UffizziCore::ActivityItem::Github.name
+    return :docker if object.type == UffizziCore::ActivityItem::Docker.name
+    return :memory_limit if object.type == UffizziCore::ActivityItem::MemoryLimit.name
+
+    nil
+  end
+
+  def commit
+    object.commit.to_s.slice(0..6)
+  end
+
+  def state
+    object.events.order_by_id.last&.state
+  end
+end

data/app/serializers/uffizzi_core/api/cli/v1/projects/deployments/container_serializer/container_config_file_serializer/config_file_serializer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Projects::Deployments::ContainerSerializer::ContainerConfigFileSerializer::ConfigFileSerializer <
+  UffizziCore::BaseSerializer
+  attributes :id, :filename, :kind, :payload
+end

data/app/serializers/uffizzi_core/api/cli/v1/projects/deployments/container_serializer/container_config_file_serializer.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Projects::Deployments::ContainerSerializer::ContainerConfigFileSerializer < UffizziCore::BaseSerializer
+  attributes :id, :mount_path
+
+  belongs_to :config_file
+end

data/app/serializers/uffizzi_core/api/cli/v1/projects/deployments/container_serializer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Projects::Deployments::ContainerSerializer < UffizziCore::BaseSerializer
+  attributes :id, :name, :memory_limit, :memory_request, :continuously_deploy, :variables, :secret_variables
+
+  has_many :container_config_files
+
+  type :container
+
+  def name
+    image_name = object.image.split('/').pop
+    commit = object&.repo&.builds&.deployed&.last&.commit
+    container_name = "#{image_name}:#{object.tag}"
+
+    if !commit.nil?
+      short_commit_hash = commit.slice(0..5)
+      container_name = "#{container_name}@#{short_commit_hash}"
+    end
+
+    container_name
+  end
+
+  def secret_variables
+    return unless object.secret_variables.present?
+
+    object.secret_variables.map do |var|
+      { name: var['name'], value: anonymize(var['value']) }
+    end
+  end
+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/create_credential/credential_serializer.rb

@@ -0,0 +1,17 @@
+# 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
+    return UffizziCore::Amazon::CredentialService.access_token(object) if object.amazon?
+
+    object.password
+  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.rb

@@ -0,0 +1,53 @@
+# 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
+
+  has_many :container_config_files
+
+  def image
+    credential = UffizziCore::RepoService.credential(object.repo)
+
+    case object.repo.type
+    when UffizziCore::Repo::Github.name
+      UffizziCore::RepoService.image(object.repo)
+    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}"
+    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
+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,98 @@
+# frozen_string_literal: true
+
+class UffizziCore::ActivityItemService
+  COMPLETED_STATES = ['deployed', 'failed', 'cancelled'].freeze
+
+  class << self
+    def create_github_item!(repo, container)
+      activity_item_attributes = {
+        namespace: repo.namespace,
+        name: repo.name,
+        container: container,
+        deployment_id: container.deployment_id,
+        branch: repo.branch,
+        type: UffizziCore::ActivityItem::Github.name,
+      }
+
+      create_item!(activity_item_attributes)
+    end
+
+    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 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
+
+      update_build_data(activity_item) if activity_item.github?
+
+      if status == UffizziCore::Event.state.deployed && UffizziCore::DeploymentService.pull_request_payload_present?(deployment)
+        UffizziCore::Deployment::SendGithubPreviewMessageJob.perform_async(deployment.id)
+      end
+      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 update_build_data(activity_item)
+      build = activity_item.container.repo.builds.deployed.last
+
+      return if !build.present? || !activity_item.build_id.nil?
+
+      activity_item.update(build_id: build.id, commit: build.commit, commit_message: build.message)
+    end
+
+    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/cli/compose_file_service.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+class UffizziCore::Cli::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 load_repositories(compose_data, credential)
+      containers = github_containers(compose_data)
+      return [] if containers.empty?
+
+      search_query = 'fork:true '
+      search_query += containers.reduce('') do |query, container|
+        query += "repo:#{credential.username}/#{container[:build][:repository_name]} "
+        query
+      end
+
+      UffizziCore::Github::CredentialService.search_repositories(credential, search_query)
+    end
+
+    def check_github_branches(compose_data, repositories, credential)
+      containers = github_containers_with_branches(compose_data)
+      return [] if containers.empty?
+
+      containers.map do |container|
+        repository = repositories.detect { |item| item[:clone_url].to_s.start_with?(container[:build][:repository_url]) }
+        error_message = I18n.t('compose.repository_not_found', repository_url: container[:build][:repository_url])
+        raise UffizziCore::ComposeFile::NotFoundError, error_message if repository.nil?
+
+        branch = begin
+          UffizziCore::Github::CredentialService.branch(credential, repository[:id], container[:build][:branch])
+        rescue Octokit::NotFound
+          nil
+        end
+
+        error_message = I18n.t('compose.invalid_branch', branch: container[:build][:branch],
+                                                         repository_url: container[:build][:repository_url])
+        raise UffizziCore::ComposeFile::NotFoundError, error_message if branch.nil?
+      end
+    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
+
+    private
+
+    def process_compose_file(compose_file_form, params)
+      credential = compose_file_form.project.account.credentials.github.last
+      cli_form = create_cli_form(compose_file_form.content, credential)
+      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 create_cli_form(content, credential)
+      cli_form = UffizziCore::Api::Cli::V1::ComposeFile::CliForm.new
+      cli_form.content = content
+      cli_form.credential = credential
+
+      cli_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)
+      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
+
+    def github_containers(compose_data)
+      compose_data[:containers].select { |container| UffizziCore::ComposeFile::ContainerService.github?(container) }
+    end
+
+    def github_containers_with_branches(compose_data)
+      github_containers(compose_data).reject { |container| container[:build][:branch].nil? }
+    end
+  end
+end