uffizzi-core 0.1.12

data/app/forms/uffizzi_core/api/cli/v1/deployment/create_form.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Deployment::CreateForm < UffizziCore::Deployment
+  include UffizziCore::ApplicationForm
+
+  permit :creation_source,
+         containers_attributes: [
+           :image,
+           :service_name,
+           :tag,
+           :port,
+           :public,
+           :memory_limit,
+           :memory_request,
+           :entrypoint,
+           :command,
+           :receive_incoming_requests,
+           :continuously_deploy,
+           { healthcheck: {} },
+           { variables: [:name, :value],
+             secret_variables: [:name, :value],
+             repo_attributes: [
+               :namespace,
+               :name,
+               :slug,
+               :type,
+               :description,
+               :is_private,
+               :repository_id,
+               :branch,
+               :kind,
+               :dockerfile_path,
+               :dockerfile_context_path,
+               :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,
+               :delete_preview_after,
+               { args: [:name, :value] },
+             ],
+             container_config_files_attributes: [
+               :config_file_id,
+               :mount_path,
+             ] },
+         ]
+
+  validate :check_all_containers_have_unique_ports
+  validate :check_exists_ingress_container
+  validate :check_max_memory_limit
+  validate :check_max_memory_request
+
+  def assign_dependences!(project, user)
+    self.project = project
+
+    self.containers = containers.map do |container|
+      container.repo.project = project if !container.repo.nil?
+
+      container
+    end
+
+    self.deployed_by = user
+
+    self
+  end
+
+  private
+
+  def check_all_containers_have_unique_ports
+    active_containers = containers.select(&:active?)
+
+    errors.add(:containers, :duplicate_ports) unless UffizziCore::DeploymentService.all_containers_have_unique_ports?(active_containers)
+  end
+
+  def check_exists_ingress_container
+    active_containers = containers.select(&:active?)
+
+    errors.add(:containers, :incorrect_ingress_container) unless UffizziCore::DeploymentService.ingress_container?(active_containers)
+  end
+
+  def check_max_memory_limit
+    return if UffizziCore::DeploymentService.valid_containers_memory_limit?(self)
+
+    errors.add(:containers, :max_memory_limit_error, max: project.account.container_memory_limit)
+  end
+
+  def check_max_memory_request
+    return if UffizziCore::DeploymentService.valid_containers_memory_request?(self)
+
+    errors.add(:containers, :max_memory_request_error, max: project.account.container_memory_limit)
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/deployment/update_form.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Deployment::UpdateForm < UffizziCore::Deployment
+  include UffizziCore::ApplicationForm
+
+  permit containers_attributes: [
+    :image,
+    :name,
+    :tag,
+    :port,
+    :public,
+    :memory_limit,
+    :memory_request,
+    :entrypoint,
+    :command,
+    :receive_incoming_requests,
+    :continuously_deploy,
+    { variables: [:name, :value],
+      secret_variables: [:name, :value],
+      repo_attributes: [
+        :namespace,
+        :name,
+        :slug,
+        :type,
+        :description,
+        :is_private,
+        :repository_id,
+        :branch,
+        :kind,
+        :dockerfile_path,
+        :dockerfile_context_path,
+        :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,
+        :delete_preview_after,
+        { args: [:name, :value] },
+      ],
+      container_config_files_attributes: [
+        :config_file_id,
+        :mount_path,
+      ] },
+  ]
+
+  validate :check_all_containers_have_unique_ports
+  validate :check_exists_ingress_container
+  validate :check_max_memory_limit
+  validate :check_max_memory_request
+
+  def assign_dependences!(project, user)
+    self.project = project
+
+    self.containers = containers.map do |container|
+      container.repo.project = project if !container.repo.nil?
+
+      container
+    end
+
+    self.deployed_by = user
+
+    self
+  end
+
+  private
+
+  def check_all_containers_have_unique_ports
+    active_containers = containers.select(&:active?)
+
+    errors.add(:containers, :duplicate_ports) unless UffizziCore::DeploymentService.all_containers_have_unique_ports?(active_containers)
+  end
+
+  def check_exists_ingress_container
+    active_containers = containers.select(&:active?)
+
+    errors.add(:containers, :incorrect_ingress_container) unless UffizziCore::DeploymentService.ingress_container?(active_containers)
+  end
+
+  def check_max_memory_limit
+    return if UffizziCore::DeploymentService.valid_containers_memory_limit?(self)
+
+    errors.add(:containers, :max_memory_limit_error, max: project.account.container_memory_limit)
+  end
+
+  def check_max_memory_request
+    return if UffizziCore::DeploymentService.valid_containers_memory_request?(self)
+
+    errors.add(:containers, :max_memory_request_error, max: project.account.container_memory_limit)
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/project/create_form.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Project::CreateForm < UffizziCore::Project
+  include UffizziCore::ApplicationForm
+
+  permit :name, :slug, :description
+end

data/app/forms/uffizzi_core/api/cli/v1/project/update_form.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Project::UpdateForm < UffizziCore::Project
+  include UffizziCore::ApplicationForm
+
+  permit :name, :slug, :description
+
+  validates :name, presence: true, uniqueness: { scope: :account }
+  validates :slug, presence: true, uniqueness: true
+end

data/app/forms/uffizzi_core/api/cli/v1/secret/bulk_assign_form.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Secret::BulkAssignForm
+  include UffizziCore::ApplicationFormWithoutActiveRecord
+  MAX_SECRET_KEY_LENGTH = 256
+
+  attribute :secrets, Array
+  validate :check_duplicates
+  validate :check_length
+
+  def assign_secrets(new_secrets)
+    return if new_secrets.blank?
+
+    new_secrets.each do |new_secret|
+      secret = UffizziCore::Secret.new(name: new_secret['name'], value: new_secret['value'])
+      secrets.append(secret)
+    end
+  end
+
+  private
+
+  def check_duplicates
+    duplicates = []
+    groupped_secrets = secrets.group_by { |secret| secret['name'] }
+    groupped_secrets.each_pair do |key, value|
+      duplicates << key if value.size > 1
+    end
+
+    error_message = I18n.t('secrets.duplicates_exists', secrets: duplicates.join(', '))
+    errors.add(:secrets, error_message) if duplicates.present?
+  end
+
+  def check_length
+    secrets_with_invalid_key_length = secrets.select { |secret| secret['name'].length > MAX_SECRET_KEY_LENGTH }
+
+    error_message = I18n.t('secrets.invalid_key_length')
+    errors.add(:secrets, error_message) if secrets_with_invalid_key_length.present?
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/session_create_form.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::SessionCreateForm
+  include UffizziCore::ApplicationFormWithoutActiveRecord
+
+  attribute :email, String
+  attribute :password, String
+
+  validates :email, :password, presence: true
+  validate :check_authenticate, if: :email
+
+  def user
+    @user ||= UffizziCore::User.active.by_email(email).first
+  end
+
+  def check_authenticate
+    return unless wrong_email_or_password?
+
+    errors.add(:password, 'Email or password is incorrect.')
+  end
+
+  private
+
+  def wrong_email_or_password?
+    return true if user.nil?
+
+    !user.authenticate(password)
+  end
+end

data/app/forms/uffizzi_core/api/cli/v1/template/create_form.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+class UffizziCore::Api::Cli::V1::Template::CreateForm < UffizziCore::Template
+  include UffizziCore::ApplicationForm
+
+  permit :name,
+         payload: {
+           containers_attributes: [
+             :image,
+             :tag,
+             :port,
+             :public,
+             :memory_limit,
+             :memory_request,
+             :entrypoint,
+             :command,
+             :receive_incoming_requests,
+             :continuously_deploy,
+             :service_name,
+             { variables: [:name, :value],
+               secret_variables: [:name, :value],
+               repo_attributes: [
+                 :namespace,
+                 :name,
+                 :slug,
+                 :type,
+                 :description,
+                 :repository_id,
+                 :is_private,
+                 :branch,
+                 :kind,
+                 :dockerfile_path,
+                 :dockerfile_context_path,
+                 :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,
+                 :delete_preview_after,
+                 { args: [:name, :value] },
+               ],
+               container_config_files_attributes: [
+                 :config_file_id,
+                 :mount_path,
+               ] },
+           ],
+         }
+
+  validate :check_max_memory_limit
+  validate :check_max_memory_request
+
+  private
+
+  def check_max_memory_limit
+    return if UffizziCore::TemplateService.valid_containers_memory_limit?(self)
+
+    errors.add(:payload, :max_memory_limit_error, max: project.account.container_memory_limit)
+  end
+
+  def check_max_memory_request
+    return if UffizziCore::TemplateService.valid_containers_memory_request?(self)
+
+    errors.add(:payload, :max_memory_request_error, max: project.account.container_memory_limit)
+  end
+end

data/app/forms/uffizzi_core/application_form.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module UffizziCore::ApplicationForm
+  extend ActiveSupport::Concern
+
+  include UffizziCore::MassAssignmentControlConcern
+
+  class_methods do
+    delegate :model_name, :name, to: :superclass
+  end
+end

data/app/forms/uffizzi_core/application_form_without_active_record.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module UffizziCore::ApplicationFormWithoutActiveRecord
+  extend ActiveSupport::Concern
+
+  included do
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    include ActiveModel::Serialization
+    include ActiveModel::Validations::Callbacks
+    include ::Virtus.model
+  end
+
+  def persisted?
+    false
+  end
+end

data/app/forms/uffizzi_core/mass_assignment_control_concern.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module UffizziCore::MassAssignmentControlConcern
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def permit(*args)
+      @_args = args
+    end
+
+    def _args
+      @_args
+    end
+  end
+
+  def assign_attributes(attrs = ActionController::Parameters.new)
+    attrs = ActionController::Parameters.new if attrs.nil?
+
+    new_attrs = attrs.permit(*self.class._args)
+    super(new_attrs)
+  end
+end

data/app/helpers/uffizzi_core/application_helper.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module UffizziCore
+  module ApplicationHelper
+  end
+end

data/app/jobs/uffizzi_core/account/create_credential_job.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class UffizziCore::Account::CreateCredentialJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :accounts, retry: 5
+
+  def perform(id)
+    credential = UffizziCore::Credential.find(id)
+    UffizziCore::AccountService.create_credential(credential)
+  end
+end

data/app/jobs/uffizzi_core/activity_item/docker/update_digest_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class UffizziCore::ActivityItem::Docker::UpdateDigestJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: 5
+
+  def perform(id)
+    activity_item = UffizziCore::ActivityItem.find(id)
+
+    UffizziCore::ActivityItemService.update_docker_digest!(activity_item)
+  end
+end

data/app/jobs/uffizzi_core/application_job.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module UffizziCore
+  class ApplicationJob
+    include Sidekiq::Worker
+  end
+end

data/app/jobs/uffizzi_core/config_file/apply_job.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class UffizziCore::ConfigFile::ApplyJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :config_files, retry: Settings.controller.resource_create_retry_count
+
+  sidekiq_retry_in do |count, exception|
+    case exception
+    when UffizziCore::ControllerService::DeploymentNotFoundError
+      Rails.logger.info("DEPLOYMENT_PROCESS ApplyJob retry deployment_id=#{exception.deployment_id} count=#{count}")
+      Settings.controller.resource_create_retry_time
+    end
+  end
+
+  def perform(deployment_id, config_file_id)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment_id} Apply ConfigFile(config_file_id:#{config_file_id})")
+
+    deployment = UffizziCore::Deployment.find(deployment_id)
+    config_file = UffizziCore::ConfigFile.find(config_file_id)
+    if deployment.disabled?
+      Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment.id} deployment was disabled stop config file applying")
+      return
+    end
+
+    unless UffizziCore::ControllerService.deployment_exists?(deployment)
+      raise UffizziCore::ControllerService::DeploymentNotFoundError,
+            deployment_id
+    end
+
+    UffizziCore::ControllerService.apply_config_file(deployment, config_file)
+  end
+end

data/app/jobs/uffizzi_core/credential/docker_hub/create_webhook_job.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class UffizziCore::Credential::DockerHub::CreateWebhookJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :accounts, retry: 5
+
+  def perform(credential_id, image, deployment_id = nil)
+    if deployment_id.present?
+      Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment_id} DockerHub CreateWebhooksJob")
+    end
+
+    credential = UffizziCore::Credential.find(credential_id)
+
+    UffizziCore::DockerHubService.create_webhook(credential, image)
+  end
+end

data/app/jobs/uffizzi_core/deployment/create_credential_job.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::CreateCredentialJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: Settings.controller.resource_create_retry_count
+
+  sidekiq_retry_in do |count, exception|
+    case exception
+    when UffizziCore::DeploymentNotFoundError
+      Rails.logger.info("DEPLOYMENT_PROCESS CreateCredentialJob retry deployment_id=#{exception.deployment_id} count=#{count}")
+      Settings.controller.resource_create_retry_time
+    end
+  end
+
+  def perform(deployment_id, credential_id)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment_id} CreateCredentialJob(cred_id:#{credential_id})")
+
+    deployment = UffizziCore::Deployment.find(deployment_id)
+    credential = UffizziCore::Credential.find(credential_id)
+
+    if deployment.disabled?
+      Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment.id} deployment was disabled stop creating credential")
+      return
+    end
+
+    unless UffizziCore::ControllerService.deployment_exists?(deployment)
+      raise UffizziCore::DeploymentNotFoundError,
+            deployment_id
+    end
+
+    UffizziCore::ControllerService.apply_credential(deployment, credential)
+  end
+end

data/app/jobs/uffizzi_core/deployment/create_credentials_job.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::CreateCredentialsJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: 5
+
+  def perform(deployment_id)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment_id} CreateCredentialsJob")
+
+    deployment = UffizziCore::Deployment.find(deployment_id)
+
+    credentials = deployment.project.account.credentials.deployable
+
+    credentials.each do |credential|
+      UffizziCore::Deployment::CreateCredentialJob.perform_async(deployment.id, credential.id)
+    end
+  end
+end

data/app/jobs/uffizzi_core/deployment/create_job.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::CreateJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: 5
+
+  def perform(id)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{id} CreateJob")
+
+    deployment = UffizziCore::Deployment.find(id)
+
+    UffizziCore::ControllerService.create_deployment(deployment)
+
+    UffizziCore::Deployment::CreateCredentialsJob.perform_async(deployment.id)
+  end
+end

data/app/jobs/uffizzi_core/deployment/create_webhooks_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::CreateWebhooksJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: 5
+
+  def perform(id)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{id} CreateWebhooksJob")
+
+    deployment = UffizziCore::Deployment.find(id)
+
+    UffizziCore::DeploymentService.create_webhooks(deployment)
+  end
+end

data/app/jobs/uffizzi_core/deployment/delete_credential_job.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::DeleteCredentialJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: 5
+
+  def perform(deployment_id, credential_id)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment_id} DeleteCredentialJob(cred_id:#{credential_id})")
+
+    deployment = UffizziCore::Deployment.find(deployment_id)
+    credential = UffizziCore::Credential.find(credential_id)
+    UffizziCore::ControllerService.delete_credential(deployment, credential)
+  end
+end

data/app/jobs/uffizzi_core/deployment/delete_job.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::DeleteJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: 5
+
+  def perform(id)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{id} DeleteJob")
+
+    UffizziCore::ControllerService.delete_deployment(id)
+  end
+end

data/app/jobs/uffizzi_core/deployment/deploy_containers_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::DeployContainersJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: Settings.controller.resource_create_retry_count
+
+  sidekiq_retry_in do |count, exception|
+    case exception
+    when UffizziCore::DeploymentNotFoundError
+      Rails.logger.info("DEPLOYMENT_PROCESS DeployContainersJob retry deployment_id=#{exception.deployment_id} count=#{count}")
+      Settings.controller.resource_create_retry_time
+    end
+  end
+
+  def perform(id, repeated = false)
+    Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{id} DeployContainersJob")
+
+    deployment = UffizziCore::Deployment.find(id)
+    if deployment.disabled?
+      Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment.id} deployment was disabled stop deploying")
+      return
+    end
+
+    raise UffizziCore::DeploymentNotFoundError, id unless UffizziCore::ControllerService.deployment_exists?(deployment)
+
+    UffizziCore::DeploymentService.deploy_containers(deployment, repeated)
+  end
+end

data/app/jobs/uffizzi_core/deployment/manage_deploy_activity_item_job.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class UffizziCore::Deployment::ManageDeployActivityItemJob < UffizziCore::ApplicationJob
+  sidekiq_options queue: :deployments, retry: 3
+
+  sidekiq_retry_in do |count, exception|
+    case exception
+    when UffizziCore::Deployment::ImagePullError
+      Rails.logger.info("DEPLOYMENT_PROCESS ManageDeployActivityItemJob retry deployment_id=#{exception.deployment_id} count=#{count}")
+      15.seconds
+    end
+  end
+
+  sidekiq_retries_exhausted do |msg, exception|
+    case exception
+    when UffizziCore::Deployment::ImagePullError
+      Rails.logger.info("DEPLOYMENT_PROCESS ManageDeployActivityItemJob exhausted #{msg.inspect} #{exception.inspect}")
+
+      activity_item_id = msg['args'].first
+      activity_item = UffizziCore::ActivityItem.find(activity_item_id)
+      UffizziCore::ActivityItemService.fail_deployment!(activity_item)
+    end
+  end
+
+  def perform(activity_item_id)
+    activity_item = UffizziCore::ActivityItem.find(activity_item_id)
+    container = activity_item.container
+
+    if container.disabled?
+      logger_message = "DEPLOYMENT_PROCESS deployment_id=#{container.deployment_id} activity_item_id=#{activity_item.id}
+      deployment was disabled stop monitoring"
+      Rails.logger.info(logger_message)
+      return
+    end
+
+    UffizziCore::ActivityItemService.manage_deploy_activity_item(activity_item)
+  end
+end