uffizzi_core 0.1.3 → 0.1.5

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

@@ -23,12 +23,13 @@ class UffizziCore::Controller::DeployContainers::ContainerSerializer < UffizziCo
     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}"
+    when UffizziCore::Repo::GithubContainerRegistry.name
+      registry_host = URI.parse(credential.registry_url).host
+      "#{registry_host}/#{credential.username}/#{object.image}"
     else
       object.image
     end
@@ -36,7 +37,7 @@ class UffizziCore::Controller::DeployContainers::ContainerSerializer < UffizziCo
 
   def tag
     case object.repo.type
-    when UffizziCore::Repo::Github.name
+    when UffizziCore::Repo::Github.name, UffizziCore::Repo::GithubContainerRegistry.name
       UffizziCore::RepoService.tag(object.repo)
     else
       object.tag

data/app/services/uffizzi_core/activity_item_service.rb

@@ -4,19 +4,6 @@ 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,
@@ -30,6 +17,22 @@ class UffizziCore::ActivityItemService
       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
@@ -61,11 +64,6 @@ class UffizziCore::ActivityItemService
 
       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)
@@ -73,14 +71,6 @@ class UffizziCore::ActivityItemService
 
     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)

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

@@ -148,32 +148,36 @@ class UffizziCore::ComposeFile::Builders::ContainerBuilderService
     memory_value
   end
 
-  def build_repo_attributes(container_data, image_data, build_data, credentials)
+  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)
+    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.github?(container_data)
-      UffizziCore::Repo::Github.name
-    elsif UffizziCore::ComposeFile::ContainerService.azure?(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
 
@@ -183,16 +187,9 @@ class UffizziCore::ComposeFile::Builders::ContainerBuilderService
     :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?
+    raise UffizziCore::ComposeFile::BuildError, I18n.t('compose.invalid_credential', value: scope) if credential.nil?
 
     docker_builder(repo_type).build_attributes(image_data)
   end
@@ -211,10 +208,6 @@ class UffizziCore::ComposeFile::Builders::ContainerBuilderService
     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

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

@@ -2,12 +2,6 @@
 
 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)
 
@@ -20,6 +14,12 @@ class UffizziCore::ComposeFile::ContainerService
       registry_url.present? && registry_url.include?('gcr.io')
     end
 
+    def amazon?(container)
+      registry_url = container.dig(:image, :registry_url)
+
+      registry_url.present? && registry_url.include?('amazonaws.com')
+    end
+
     def docker_hub?(container)
       registry_url = container.dig(:image, :registry_url)
       repository_url = container.dig(:build, :repository_url)
@@ -27,6 +27,12 @@ class UffizziCore::ComposeFile::ContainerService
       registry_url.nil? && repository_url.nil?
     end
 
+    def github_container_registry?(container)
+      registry_url = container.dig(:image, :registry_url)
+
+      registry_url.present? && registry_url.include?('ghcr.io')
+    end
+
     def has_secret?(container, secret)
       container['secret_variables'].any? { |container_secret| container_secret['name'] == secret['name'] }
     end
@@ -39,9 +45,7 @@ class UffizziCore::ComposeFile::ContainerService
     end
 
     def credential_for_container(container, credentials)
-      if UffizziCore::ComposeFile::ContainerService.github?(container)
-        detect_credential(credentials, :github)
-      elsif UffizziCore::ComposeFile::ContainerService.azure?(container)
+      if UffizziCore::ComposeFile::ContainerService.azure?(container)
         detect_credential(credentials, :azure)
       elsif UffizziCore::ComposeFile::ContainerService.docker_hub?(container)
         detect_credential(credentials, :docker_hub)

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

@@ -3,6 +3,7 @@
 class UffizziCore::ComposeFile::DependenciesService
   ENV_FILE_TYPE = 'env_file'
   CONFIG_TYPE = 'config'
+
   class << self
     def build_dependencies(compose_data, compose_path, dependencies_params)
       dependencies = compose_data[:containers].map do |container|

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

@@ -18,7 +18,7 @@ class UffizziCore::ComposeFile::ServicesOptionsService
 
     private
 
-    def prepare_service_data(service_name, service_data, global_configs_data, global_secrets_data, compose_payload)
+    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
@@ -27,7 +27,7 @@ class UffizziCore::ComposeFile::ServicesOptionsService
                                     when :image
                                       UffizziCore::ComposeFile::ServicesOptions::ImageService.parse(value)
                                     when :build
-                                      UffizziCore::ComposeFile::ServicesOptions::BuildService.parse(value, compose_payload)
+                                      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.not_implemented', option: :build)
                                     when :env_file
                                       UffizziCore::ComposeFile::ServicesOptions::EnvFileService.parse(value)
                                     when :environment

data/app/services/uffizzi_core/compose_file_service.rb

@@ -2,6 +2,58 @@
 
 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']
 
@@ -29,5 +81,101 @@ module UffizziCore::ComposeFileService
         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)
+      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

@@ -1,30 +1,15 @@
 # frozen_string_literal: true
 
 class UffizziCore::ContainerService
-  PRIVILEGED_PORT_MAX = 1024
-
   class << self
-    def should_build?(container)
-      container.repo_id && container.repo.github?
-    end
-
     def pod_name(container)
       return container.controller_name if container.controller_name.present?
 
-      formatted_name = if should_build?(container)
-        "#{UffizziCore::RepoService.image(container.repo)}-#{UffizziCore::RepoService.tag(container.repo)}"
-      else
-        container.image_name
-      end
-
+      formatted_name = container.image_name
       formatted_name.parameterize.gsub('_', '-')
     end
 
     def target_port_value(container)
-      should_find_unused_port = container.repo&.github? && UffizziCore::RepoService.needs_target_port?(container.repo) &&
-        container.public && container.port <= PRIVILEGED_PORT_MAX
-      return UffizziCore::DeploymentService.find_unused_port(container.deployment) if should_find_unused_port
-
       container.port
     end
 

data/app/services/uffizzi_core/controller_service.rb

@@ -25,7 +25,13 @@ module UffizziCore::ControllerService
     end
 
     def apply_credential(deployment, credential)
-      body = UffizziCore::Controller::CreateCredential::CredentialSerializer.new(credential).as_json
+      image = if credential.github_container_registry?
+        deployment.containers.by_repo_type(UffizziCore::Repo::GithubContainerRegistry.name).first&.image
+      end
+
+      options = { image: image }
+
+      body = UffizziCore::Controller::CreateCredential::CredentialSerializer.new(credential, options).as_json
       controller_client.apply_credential(deployment_id: deployment.id, body: body)
     end
 

data/app/services/uffizzi_core/credential_service.rb

@@ -6,8 +6,8 @@ module UffizziCore::CredentialService
       status = case credential.type
                when UffizziCore::Credential::DockerHub.name
                  UffizziCore::DockerHub::CredentialService.credential_correct?(credential)
-               when UffizziCore::Credential::Github.name
-                 UffizziCore::Github::CredentialService.credential_correct?(credential)
+               when UffizziCore::Credential::GithubContainerRegistry.name
+                 UffizziCore::GithubContainerRegistry::CredentialService.credential_correct?(credential)
                when UffizziCore::Credential::Azure.name
                  UffizziCore::Azure::CredentialService.credential_correct?(credential)
                when UffizziCore::Credential::Google.name

data/app/services/uffizzi_core/deployment_service.rb

@@ -29,6 +29,25 @@ module UffizziCore::DeploymentService
       deployment_form
     end
 
+    def update_from_compose(compose_file, project, user, deployment_id)
+      deployment_attributes = ActionController::Parameters.new(compose_file.template.payload)
+
+      deployment_form = UffizziCore::Api::Cli::V1::Deployment::UpdateForm.new(deployment_attributes)
+      deployment_form.assign_dependences!(project, user)
+      deployment_form.compose_file = compose_file
+
+      if deployment_form.valid?
+        deployment = UffizziCore::Deployment.find(deployment_id)
+        deployment.containers.destroy_all
+        deployment.compose_file.destroy if deployment.compose_file.kind.temporary?
+        deployment.update!(containers: deployment_form.containers, compose_file_id: compose_file.id)
+
+        return deployment
+      end
+
+      deployment_form
+    end
+
     def deploy_containers(deployment, repeated = false)
       if !repeated
         create_activity_items(deployment)
@@ -59,6 +78,14 @@ module UffizziCore::DeploymentService
       compose_file.destroy!
     end
 
+    def fail!(deployment)
+      deployment.fail!
+      compose_file = deployment.compose_file || deployment.template&.compose_file
+      return unless compose_file&.kind&.temporary?
+
+      compose_file.destroy!
+    end
+
     def build_subdomain(deployment)
       if deployment.continuous_preview_payload.present?
         continuous_preview_payload = deployment.continuous_preview_payload
@@ -224,12 +251,7 @@ module UffizziCore::DeploymentService
     def create_activity_items(deployment)
       deployment.active_containers.each do |container|
         repo = container.repo
-        activity_item = case repo.type
-                        when UffizziCore::Repo::Github.name
-                          UffizziCore::ActivityItemService.create_github_item!(repo, container)
-                        else
-                          UffizziCore::ActivityItemService.create_docker_item!(repo, container)
-        end
+        activity_item = UffizziCore::ActivityItemService.create_docker_item!(repo, container)
 
         create_default_activity_item_event(activity_item)
 
@@ -241,7 +263,6 @@ module UffizziCore::DeploymentService
     end
 
     def create_default_activity_item_event(activity_item)
-      activity_item.events.create(state: UffizziCore::Event.state.building) if activity_item.github?
       activity_item.events.create(state: UffizziCore::Event.state.deploying) if activity_item.docker?
     end
 

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

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

data/app/services/uffizzi_core/manage_activity_items_service.rb

@@ -42,21 +42,6 @@ class UffizziCore::ManageActivityItemsService
 
   def build_containers_replicas
     containers.map do |container|
-      repo = container.repo
-
-      if repo.github?
-        build = container.repo.builds.deployed.last
-
-        if build.nil? || build.building?
-          return [{ id: container.id,
-                    items: [{ name: container.image_name, status: UffizziCore::Event.state.building }] }]
-        end
-        if !build.successful?
-          return [{ id: container.id,
-                    items: [{ name: container.image_name, status: UffizziCore::Event.state.failed }] }]
-        end
-      end
-
       items = pods.map do |pod|
         {
           name: item_name(pod, container),
@@ -106,9 +91,7 @@ class UffizziCore::ManageActivityItemsService
     container_status(error, deployed)
   end
 
-  def building_container_status(container)
-    return UffizziCore::Event.state.building if container.repo.github?
-
+  def building_container_status(_container)
     UffizziCore::Event.state.deploying
   end
 
@@ -139,7 +122,9 @@ class UffizziCore::ManageActivityItemsService
     when :terminated
       UffizziCore::Event.state.failed
     when :waiting
-      return Event.state.failed if ['ErrImagePull', 'ImagePullBackOff', 'CrashLoopBackOff'].include?(reason)
+      return UffizziCore::Event.state.failed if ['CrashLoopBackOff'].include?(reason)
+
+      raise UffizziCore::Deployment::ImagePullError, @deployment.id if ['ErrImagePull', 'ImagePullBackOff'].include?(reason)
 
       UffizziCore::Event.state.deploying
     else