uffizzi_core 0.1.3

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::TemplateService
+  def initialize(github_form, project, user)
+    @project = project
+    @user = user
+    @compose_dependencies = github_form.compose_dependencies
+    @compose_data = github_form.compose_data
+    @compose_repositories = github_form.compose_repositories
+  end
+
+  def create_template(compose_file_form)
+    compose_file_template_form = build_compose_file_template_form(compose_file_form)
+    return compose_file_template_form.errors if compose_file_template_form.invalid?
+
+    template_form = build_template_form(compose_file_form, compose_file_template_form)
+    return template_form.errors if template_form.invalid?
+
+    template_form.save
+
+    nil
+  end
+
+  private
+
+  def build_compose_file_template_form(compose_file_form)
+    credentials = @project.account.credentials
+    compose_file_template_form = UffizziCore::Api::Cli::V1::ComposeFile::TemplateForm.new
+    compose_file_template_form.compose_data = @compose_data
+    compose_file_template_form.source = compose_file_form.source
+    compose_file_template_form.credentials = credentials
+    compose_file_template_form.project = @project
+    compose_file_template_form.user = @user
+    compose_file_template_form.compose_dependencies = @compose_dependencies
+    compose_file_template_form.compose_repositories = @compose_repositories
+    compose_file_template_form.assign_template_attributes!
+
+    compose_file_template_form
+  end
+
+  def build_template_form(compose_file_form, compose_file_template_form)
+    attributes = compose_file_template_form.template_attributes
+    source = compose_file_template_form.source
+    template = compose_file_form.template
+    template = @project.templates.find_or_initialize_by(name: source) if !template.present?
+    template.assign_attributes(attributes)
+    template_form = template.becomes(UffizziCore::Api::Cli::V1::Template::CreateForm)
+    template_form.project = @project
+    template_form.added_by = @user
+    template_form.compose_file = compose_file_form
+    template_form.creation_source = UffizziCore::Template.creation_source.compose_file
+
+    template_form
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class UffizziCore::ComposeFile::UpdateService
+  def initialize(user, project)
+    @user = user
+    @project = project
+  end
+
+  def update(compose_file, params)
+    compose_file_form = compose_file.becomes(ComposeFile::UpdateForm)
+    compose_file_form.assign_attributes(params)
+    credential = compose_file_form.project.account.credentials.github.last
+    compose_file_github_form = ComposeFileService.create_compose_file_github_form(compose_file_form, credential)
+
+    if compose_file_github_form.invalid?
+      if compose_file_github_form.compose_content_data.present?
+        compose_file_form.content = compose_file_github_form.compose_content_data[:content]
+      end
+
+      return [compose_file_form, compose_file_github_form.errors]
+    end
+
+    compose_file_depedencies = compose_file_github_form.compose_dependencies
+    compose_file_form.payload['dependencies'] = ComposeFileService.prepare_compose_file_dependencies(compose_file_depedencies)
+    compose_file_form.content = compose_file_github_form.compose_content_data[:content]
+
+    ComposeFileService.persist!(compose_file_form, compose_file_github_form)
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module UffizziCore::ComposeFile::VariablesService
+  def parse_variable_from_string(str)
+    variable_parts = str.split('=', 2)
+
+    parse_variable_from_array(variable_parts)
+  end
+
+  def parse_variable_from_array(arr)
+    name = arr.first.to_s
+    value = arr.last.to_s
+
+    build_variable(name, value)
+  end
+
+  def build_variable(name, value)
+    raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.no_variable_name', name: name, value: value) if name.blank?
+
+    {
+      name: name,
+      value: value,
+    }
+  end
+end

data/app/services/uffizzi_core/compose_file_service.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module UffizziCore::ComposeFileService
+  class << self
+    def has_secret?(compose_file, secret)
+      containers = compose_file.template.payload['containers_attributes']
+
+      containers.any? { |container| UffizziCore::ComposeFile::ContainerService.has_secret?(container, secret) }
+    end
+
+    def update_secret!(compose_file, secret)
+      compose_file.template.payload['containers_attributes'].map do |container|
+        if UffizziCore::ComposeFile::ContainerService.has_secret?(container, secret)
+          container = UffizziCore::ComposeFile::ContainerService.update_secret(container, secret)
+        end
+
+        container
+      end
+
+      compose_file.template.save!
+
+      compose_file
+    end
+
+    def secrets_valid?(compose_file, secrets)
+      secret_names = secrets.pluck('name')
+
+      compose_file.template.payload['containers_attributes'].all? do |container|
+        container['secret_variables'].all? { |secret| secret_names.include?(secret['name']) }
+      end
+    end
+  end
+end

data/app/services/uffizzi_core/container_service.rb

@@ -0,0 +1,57 @@
+# 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.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
+
+    def defines_env?(container, name)
+      return false if container.variables.nil?
+
+      container.variables.select { |v| v['name'].downcase.to_sym == name.to_sym }.any?
+    end
+
+    def continuously_deploy_enabled?(container)
+      container.aasm(:continuously_deploy).current_state == UffizziCore::Container::STATE_ENABLED
+    end
+
+    def valid_memory_limit?(container)
+      max_memory_limit = container.deployment.project.account.container_memory_limit
+      container_memory_limit = container.memory_limit
+      return true if max_memory_limit.nil? || container_memory_limit.nil?
+
+      container_memory_limit <= max_memory_limit
+    end
+
+    def valid_memory_request?(container)
+      max_memory_limit = container.deployment.project.account.container_memory_limit
+      container_memory_request = container.memory_request
+      return true if max_memory_limit.nil? || container_memory_request.nil?
+
+      container_memory_request <= max_memory_limit
+    end
+  end
+end

data/app/services/uffizzi_core/controller_service.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module UffizziCore::ControllerService
+  class << self
+    def apply_config_file(deployment, config_file)
+      body = {
+        config_file: UffizziCore::Controller::ApplyConfigFile::ConfigFileSerializer.new(config_file).as_json,
+      }
+
+      controller_client.apply_config_file(deployment_id: deployment.id, config_file_id: config_file.id, body: body)
+    end
+
+    def create_deployment(deployment)
+      body = UffizziCore::Controller::CreateDeployment::DeploymentSerializer.new(deployment).as_json
+      controller_client.create_deployment(deployment_id: deployment.id, body: body)
+    end
+
+    def update_deployment(deployment)
+      body = UffizziCore::Controller::UpdateDeployment::DeploymentSerializer.new(deployment).as_json
+      controller_client.update_deployment(deployment_id: deployment.id, body: body)
+    end
+
+    def delete_deployment(deployment_id)
+      controller_client.delete_deployment(deployment_id: deployment_id)
+    end
+
+    def apply_credential(deployment, credential)
+      body = UffizziCore::Controller::CreateCredential::CredentialSerializer.new(credential).as_json
+      controller_client.apply_credential(deployment_id: deployment.id, body: body)
+    end
+
+    def delete_credential(deployment, credential)
+      controller_client.delete_credential(deployment_id: deployment.id, credential_id: credential.id)
+    end
+
+    def deploy_containers(deployment, containers)
+      containers = containers.map do |container|
+        UffizziCore::Controller::DeployContainers::ContainerSerializer.new(container).as_json(include: '**')
+      end
+      credentials = deployment.credentials.deployable.map do |credential|
+        UffizziCore::Controller::DeployContainers::CredentialSerializer.new(credential).as_json
+      end
+
+      body = {
+        containers: containers,
+        credentials: credentials,
+        deployment_url: UffizziCore::DeploymentService.build_preview_url(deployment),
+      }
+
+      controller_client.deploy_containers(deployment_id: deployment.id, body: body)
+    end
+
+    def deployment_exists?(deployment)
+      controller_client.deployment(deployment_id: deployment.id).code == 200
+    end
+
+    def fetch_deployment_events(deployment)
+      request_events(deployment) || []
+    end
+
+    def fetch_pods(deployment)
+      pods = controller_client.deployment_containers(deployment_id: deployment.id).result || []
+      pods.filter { |pod| pod.metadata.name.start_with?(Settings.controller.namespace_prefix) }
+    end
+
+    def fetch_namespace(deployment)
+      controller_client.deployment(deployment_id: deployment.id).result || nil
+    end
+
+    private
+
+    def request_events(deployment)
+      controller_client.deployment_containers_events(deployment_id: deployment.id)
+    end
+
+    def controller_client
+      UffizziCore::ControllerClient.new
+    end
+  end
+end

data/app/services/uffizzi_core/credential_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module UffizziCore::CredentialService
+  class << self
+    def correct_credentials?(credential)
+      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::Azure.name
+                 UffizziCore::Azure::CredentialService.credential_correct?(credential)
+               when UffizziCore::Credential::Google.name
+                 UffizziCore::Google::CredentialService.credential_correct?(credential)
+               when UffizziCore::Credential::Amazon.name
+                 UffizziCore::Amazon::CredentialService.credential_correct?(credential)
+               else
+                 false
+      end
+
+      if credential.persisted? && credential.active? && !status
+        Rails.logger.warn("broken credentials, credential_correct? credential_id=#{credential.id}")
+        credential.unauthorize!
+      end
+
+      status
+    end
+
+    def update_expired_credentials
+      currect_date = DateTime.now
+      credentials = UffizziCore::Credential::Amazon.active.where('updated_at < ?', currect_date - 10.hours)
+
+      credentials.each do |credential|
+        deployments = UffizziCore::Deployment.where(project_id: credential.account.projects.select(:id)).with_amazon_repos
+
+        deployments.each do |deployment|
+          UffizziCore::Deployment::CreateCredentialJob.perform_async(deployment.id, credential.id)
+        end
+
+        credential.update(updated_at: currect_date)
+      end
+    end
+  end
+end

data/app/services/uffizzi_core/deployment_service.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+module UffizziCore::DeploymentService
+  MIN_TARGET_PORT_RANGE = 37_000
+  MAX_TARGET_PORT_RANGE = 39_999
+
+  DEPLOYMENT_PROCESS_STATUSES = {
+    building: :building,
+    deploying: :deploying,
+    failed: :failed,
+  }.freeze
+
+  class << self
+    def create_from_compose(compose_file, project, user)
+      deployment_attributes = ActionController::Parameters.new(compose_file.template.payload)
+
+      deployment_form = UffizziCore::Api::Cli::V1::Deployment::CreateForm.new(deployment_attributes)
+      deployment_form.assign_dependences!(project, user)
+      deployment_form.compose_file = compose_file
+      deployment_form.creation_source = UffizziCore::Deployment.creation_source.compose_file_manual
+
+      if deployment_form.save
+        update_subdomain!(deployment_form)
+
+        UffizziCore::Deployment::CreateJob.perform_async(deployment_form.id)
+        UffizziCore::Deployment::CreateWebhooksJob.perform_async(deployment_form.id)
+      end
+
+      deployment_form
+    end
+
+    def deploy_containers(deployment, repeated = false)
+      if !repeated
+        create_activity_items(deployment)
+        update_controller_container_names(deployment)
+      end
+
+      case deployment_process_status(deployment)
+      when DEPLOYMENT_PROCESS_STATUSES[:building]
+        Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment.id} repeat deploy_containers")
+        UffizziCore::Deployment::DeployContainersJob.perform_in(1.minute, deployment.id, true)
+      when DEPLOYMENT_PROCESS_STATUSES[:deploying]
+        Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment.id} start deploying into controller")
+
+        containers = deployment.active_containers
+        containers = add_default_deployment_variables!(containers)
+
+        UffizziCore::ControllerService.deploy_containers(deployment, containers)
+      else
+        Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment.id} deployment has builds errors, stopping")
+      end
+    end
+
+    def disable!(deployment)
+      deployment.disable!
+      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
+
+        return build_pull_request_subdomain(deployment) if continuous_preview_payload['pull_request'].present?
+        return build_docker_continuous_preview_subdomain(deployment) if continuous_preview_payload['docker'].present?
+      end
+
+      build_default_subdomain(deployment)
+    end
+
+    def build_pull_request_subdomain(deployment)
+      project = deployment.project
+      continuous_preview_payload = deployment.continuous_preview_payload
+      pull_request_payload = continuous_preview_payload['pull_request']
+      repo_name = pull_request_payload['repository_full_name'].split('/').last
+      deployment_name = name(deployment)
+
+      "pr#{pull_request_payload['id']}-#{deployment_name}.#{repo_name}.#{project.slug}"
+    end
+
+    def build_docker_continuous_preview_subdomain(deployment)
+      project = deployment.project
+      continuous_preview_payload = deployment.continuous_preview_payload
+      docker_payload = continuous_preview_payload['docker']
+      repo_name = docker_payload['image'].split('/').last.gsub('_', '-')
+      image_tag = docker_payload['tag'].gsub('_', '-')
+      deployment_name = name(deployment)
+
+      "#{image_tag}-#{deployment_name}.#{repo_name}.#{project.slug}"
+    end
+
+    def build_default_subdomain(deployment)
+      deployment_name = name(deployment)
+      slug = deployment.project.slug.to_s
+      "#{deployment_name}.#{slug}"
+    end
+
+    def build_preview_url(deployment)
+      "#{deployment.subdomain}.#{Settings.app.managed_dns_zone}"
+    end
+
+    def build_deployment_url(deployment)
+      "#{Settings.app.managed_dns_zone}/projects/#{deployment.project_id}/deployments"
+    end
+
+    def all_containers_have_unique_ports?(containers)
+      ports = containers.map(&:port).compact
+      containers.empty? || ports.size == ports.uniq.size
+    end
+
+    def valid_containers_memory_limit?(deployment)
+      containers = deployment.containers
+      container_memory_limit = deployment.project.account.container_memory_limit
+      return true if container_memory_limit.nil?
+
+      containers.all? { |container| container.memory_limit <= container_memory_limit }
+    end
+
+    def valid_containers_memory_request?(deployment)
+      containers = deployment.containers
+      container_memory_limit = deployment.project.account.container_memory_limit
+      return true if container_memory_limit.nil?
+
+      containers.all? { |container| container.memory_request <= container_memory_limit }
+    end
+
+    def ingress_container?(containers)
+      containers.empty? || containers.map(&:receive_incoming_requests).count(true) == 1
+    end
+
+    def find_unused_port(deployment)
+      selected_port = nil
+
+      Timeout.timeout(20) do
+        loop do
+          selected_port = rand(MIN_TARGET_PORT_RANGE..MAX_TARGET_PORT_RANGE)
+
+          break if !deployment.containers.exists?(target_port: selected_port)
+        end
+      end
+
+      selected_port
+    end
+
+    def setup_ingress_container(deployment, ingress_container, port)
+      old_deployment_subdomain = deployment.subdomain
+
+      containers = deployment.containers.active
+
+      UffizziCore::Container.transaction do
+        containers.update_all(receive_incoming_requests: false, port: nil, public: false)
+        containers.find(ingress_container.id).update!(port: port, public: true, receive_incoming_requests: true)
+      end
+
+      deployment.reload
+
+      new_deployment_subdomain = build_subdomain(deployment)
+
+      if new_deployment_subdomain != old_deployment_subdomain
+        deployment.update(subdomain: new_deployment_subdomain)
+      end
+
+      UffizziCore::Deployment::DeployContainersJob.perform_async(deployment.id)
+    end
+
+    def name(deployment)
+      "deployment-#{deployment.id}"
+    end
+
+    def update_subdomain!(deployment)
+      deployment.subdomain = build_subdomain(deployment)
+
+      deployment.save!
+    end
+
+    def create_webhooks(deployment)
+      credential = deployment.project.account.credentials.docker_hub.active.first
+
+      if !deployment.containers.with_docker_hub_repo.exists? || !credential.present?
+        Rails.logger.info("DEPLOYMENT_PROCESS deployment_id=#{deployment.id} create_webhooks no dockerhub containers or credential")
+        return
+      end
+
+      accounts = UffizziCore::DockerHubService.accounts(credential)
+
+      deployment.containers.with_docker_hub_repo.find_each do |container|
+        if !accounts.include?(container.repo.namespace)
+          logger_message = "DEPLOYMENT_PROCESS deployment_id=#{deployment.id} no namespace(#{container.repo.namespace})
+          in accounts(#{accounts.inspect})"
+          Rails.logger.info(logger_message)
+          next
+        end
+
+        UffizziCore::Credential::DockerHub::CreateWebhookJob.perform_async(credential.id, container.image, deployment.id)
+      end
+    end
+
+    def pull_request_payload_present?(deployment)
+      deployment.continuous_preview_payload.present? && deployment.continuous_preview_payload['pull_request'].present?
+    end
+
+    def failed?(deployment)
+      deployment_status = deployment_process_status(deployment)
+
+      deployment_status == DEPLOYMENT_PROCESS_STATUSES[:failed]
+    end
+
+    private
+
+    def deployment_process_status(deployment)
+      containers = deployment.active_containers
+      activity_items = containers.map { |container| container.activity_items.order_by_id.last }
+      events = activity_items.map { |activity_item| activity_item.events.order_by_id.last&.state }
+      events = events.flatten.uniq
+
+      return DEPLOYMENT_PROCESS_STATUSES[:failed] if events.include?(UffizziCore::Event.state.failed)
+      return DEPLOYMENT_PROCESS_STATUSES[:building] if events.include?(UffizziCore::Event.state.building)
+
+      DEPLOYMENT_PROCESS_STATUSES[:deploying]
+    end
+
+    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
+
+        create_default_activity_item_event(activity_item)
+
+        if UffizziCore::RepoService.credential(repo).present? && activity_item.docker?
+          UffizziCore::ActivityItem::Docker::UpdateDigestJob.perform_async(activity_item.id)
+        end
+        UffizziCore::Deployment::ManageDeployActivityItemJob.perform_in(5.seconds, activity_item.id)
+      end
+    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
+
+    def update_controller_container_names(deployment)
+      deployment.active_containers.each do |container|
+        next if container.controller_name.present?
+
+        controller_name = generate_controller_container_name(container)
+        container.update!(controller_name: controller_name)
+      end
+    end
+
+    def generate_controller_container_name(container)
+      Digest::SHA256.hexdigest("#{container.id}:#{container.image}")[0, 10]
+    end
+
+    def add_default_deployment_variables!(containers)
+      containers.each do |container|
+        envs = []
+        if container.port.present? && !UffizziCore::ContainerService.defines_env?(container, 'PORT')
+          envs.push('name' => 'PORT', 'value' => container.target_port.to_s)
+        end
+
+        container.variables = [] if container.variables.nil?
+
+        container.variables.push(*envs)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class UffizziCore::DockerHub::CredentialService
+  class << self
+    def credential_correct?(credential)
+      client(credential).authentificated?
+    end
+
+    private
+
+    def client(credential)
+      UffizziCore::DockerHubClient.new(credential)
+    end
+  end
+end