uffizzi-core 0.1.12

data/app/services/uffizzi_core/manage_activity_items_service.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+class UffizziCore::ManageActivityItemsService
+  attr_accessor :deployment, :containers, :pods, :namespace_data
+
+  def initialize(deployment)
+    @deployment = deployment
+    @containers = deployment.active_containers
+    @namespace_data = UffizziCore::ControllerService.fetch_namespace(deployment)
+    @pods = UffizziCore::ControllerService.fetch_pods(deployment)
+  end
+
+  def container_status_item(container)
+    container_status_items.detect { |container_statuses| container_statuses[:id] == container.id }
+  end
+
+  def container_status_items
+    network_connectivities = build_network_connectivities
+    containers_replicas = build_containers_replicas
+
+    build_container_status_items(network_connectivities, containers_replicas)
+  end
+
+  private
+
+  def build_network_connectivities
+    containers.with_public_access.map do |container|
+      { id: container.id, items: build_container_network_connectivity_items(container) }
+    end
+  end
+
+  def build_container_network_connectivity_items(container)
+    network_connectivities = container_network_connectivities(container)
+    return [] if network_connectivities.nil?
+
+    network_connectivities.map do |network_connectivity|
+      type, value = network_connectivity
+
+      { type: type, status: value.status }
+    end
+  end
+
+  def build_containers_replicas
+    containers.map do |container|
+      items = pods.map do |pod|
+        {
+          name: item_name(pod, container),
+          status: get_status(pod, container),
+        }
+      end
+
+      { id: container.id, items: items }
+    end
+  end
+
+  def build_container_status_items(network_connectivities, containers_replicas)
+    containers.map do |container|
+      network_connectivity = network_connectivities.detect { |item| item[:id] == container.id }
+      any_container_is_building = containers_replicas.any? do |container_replicas|
+        container_replicas[:items].any? do |item|
+          item[:status] == UffizziCore::Event.state.building
+        end
+      end
+      container_replicas = containers_replicas.detect { |item| item[:id] == container.id }
+
+      {
+        id: container.id,
+        status: build_container_status(container, network_connectivity, container_replicas, any_container_is_building),
+      }
+    end
+  end
+
+  def replicas_contains_status?(replicas, status)
+    replicas.any? { |replica| replica[:status] == status }
+  end
+
+  def build_container_status(container, network_connectivity, container_replicas, any_container_is_building)
+    return building_container_status(container) if any_container_is_building
+
+    error = replicas_contains_status?(container_replicas[:items], UffizziCore::Event.state.failed)
+    container_is_running = replicas_contains_status?(container_replicas[:items], UffizziCore::Event.state.deployed)
+    deployed = !error && container_is_running
+    return container_status(error, deployed) unless container.public?
+
+    network_connectivity[:items].each do |item|
+      status = item[:status].to_sym
+      error ||= status == :failed
+      deployed &&= status == :success
+    end
+
+    container_status(error, deployed)
+  end
+
+  def building_container_status(_container)
+    UffizziCore::Event.state.deploying
+  end
+
+  def container_status(error, deployed)
+    return UffizziCore::Event.state.failed if error
+    return UffizziCore::Event.state.deployed if deployed
+
+    UffizziCore::Event.state.deploying
+  end
+
+  def item_name(pod, container)
+    hash = pod.metadata.name.split('-').last
+    "#{container.image_name}-#{hash}"
+  end
+
+  def get_status(pod, container)
+    pod_container = pod_container(pod, container)
+
+    return UffizziCore::Event.state.deploying if pod_container.nil? || pod_container[:state].to_h.empty?
+
+    pod_container_status = pod_container[:state].keys.first
+    state = pod_container[:state][pod_container_status]
+    reason = state&.reason
+
+    Rails.logger.info("manage_activity_items get_status dep_id=#{container.deployment.id} pod_container_status: #{pod_container_status}")
+    Rails.logger.info("manage_activity_items get_status dep_id=#{container.deployment.id} state: #{state}")
+    ap(pod_container[:state])
+
+    case pod_container_status.to_sym
+    when :running
+      Rails.logger.info("manage_activity_items get_status dep_id=#{container.deployment.id} running")
+      UffizziCore::Event.state.deployed
+    when :terminated
+      Rails.logger.info("manage_activity_items get_status dep_id=#{container.deployment.id} terminated")
+      UffizziCore::Event.state.failed
+    when :waiting
+      Rails.logger.info("manage_activity_items get_status dep_id=#{container.deployment.id} waiting")
+      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
+      Rails.logger.info("manage_activity_items get_status dep_id=#{container.deployment.id} else")
+      UffizziCore::Event.state.deploying
+    end
+  end
+
+  def pod_container(pod, container)
+    pod_name = UffizziCore::ContainerService.pod_name(container)
+
+    pod&.status&.container_statuses&.detect { |cs| cs.name.include?(pod_name) }
+  end
+
+  def container_network_connectivities(container)
+    network_connectivity = Hashie::Mash.new(JSON.parse(deployment_network_connectivity))
+    containers_network_connectivity = network_connectivity&.containers
+
+    containers_network_connectivity[container.id.to_s] if !containers_network_connectivity.nil?
+  end
+
+  def deployment_network_connectivity
+    namespace_data&.metadata&.annotations&.network_connectivity || '{}'
+  end
+end

data/app/services/uffizzi_core/project_service.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module UffizziCore::ProjectService
+  class << self
+    def update_compose_secrets(project)
+      compose_file = project.compose_file
+      return if compose_file&.template.nil?
+
+      project.secrets.each do |secret|
+        if UffizziCore::ComposeFileService.has_secret?(compose_file, secret)
+          UffizziCore::ComposeFileService.update_secret!(compose_file, secret)
+        end
+      end
+
+      return unless UffizziCore::ComposeFileService.secrets_valid?(compose_file, project.secrets)
+
+      secrets_error_key = UffizziCore::ComposeFile::ErrorsService::SECRETS_ERROR_KEY
+      return unless UffizziCore::ComposeFile::ErrorsService.has_error?(compose_file, secrets_error_key)
+
+      UffizziCore::ComposeFile::ErrorsService.reset_error!(compose_file, secrets_error_key)
+      compose_file.set_valid! unless UffizziCore::ComposeFile::ErrorsService.has_errors?(compose_file)
+    end
+
+    def update_compose_secret_errors(project, secret)
+      compose_file = project.compose_file
+      return if compose_file.nil?
+      return unless UffizziCore::ComposeFileService.has_secret?(compose_file, secret)
+
+      error_message = I18n.t('compose.project_secret_not_found', secret: secret['name'])
+      error = { UffizziCore::ComposeFile::ErrorsService::SECRETS_ERROR_KEY => [error_message] }
+
+      existing_errors = compose_file.payload['errors'].presence || {}
+      new_errors = existing_errors.merge(error)
+
+      UffizziCore::ComposeFile::ErrorsService.update_compose_errors!(compose_file, new_errors, compose_file.content)
+    end
+
+    def add_users_to_project!(project, current_user)
+      user_projects = []
+
+      current_user.organizational_account.memberships.where(role: UffizziCore::Membership.role.admin).map do |membership|
+        user_projects << { project: project, user: membership.user, role: UffizziCore::UserProject.role.admin }
+      end
+
+      UffizziCore::UserProject.create!(user_projects)
+    end
+  end
+end

data/app/services/uffizzi_core/repo_service.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module UffizziCore::RepoService
+  class << self
+    def needs_target_port?(repo)
+      return false if repo.nil?
+
+      !repo.dockerfile?
+    end
+
+    def credential(repo)
+      credentials = repo.project.account.credentials
+
+      case repo.type
+      when UffizziCore::Repo::GithubContainerRegistry.name
+        credentials.github_container_registry.first
+      when UffizziCore::Repo::DockerHub.name
+        credentials.docker_hub.first
+      when UffizziCore::Repo::Azure.name
+        credentials.azure.first
+      when UffizziCore::Repo::Google.name
+        credentials.google.first
+      when UffizziCore::Repo::Amazon.name
+        credentials.amazon.first
+      end
+    end
+
+    def image_name(repo)
+      "e#{repo.container.deployment_id}r#{repo.id}-#{Digest::SHA256.hexdigest("#{self.class}:#{repo.branch}:
+      #{repo.project_id}:#{repo.id}")[0, 10]}"
+    end
+
+    def tag(repo)
+      repo&.builds&.deployed&.last&.commit || 'latest'
+    end
+
+    def image(repo)
+      repo_credential = credential(repo)
+
+      "#{repo_credential.registry_url}/#{image_name(repo)}"
+    end
+  end
+end

data/app/services/uffizzi_core/response_service.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module UffizziCore::ResponseService
+  def meta(collection)
+    {
+      total_count: collection.total_count,
+      current_page: collection.current_page,
+      per_page: collection.limit_value,
+      count: collection.to_a.count,
+      total_pages: collection.total_pages,
+    }
+  end
+end

data/app/services/uffizzi_core/starter_template_service.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+class UffizziCore::StarterTemplateService
+  class << self
+    def create(project, user)
+      voting_app_config_file = create_config_file(project, user)
+      create_containers(project, user, voting_app_config_file)
+    end
+
+    private
+
+    def create_config_file(project, user)
+      starter_template_config_file = config_file_attributes
+
+      starter_template_config_file_params = ActionController::Parameters.new(starter_template_config_file)
+
+      starter_template_config_file_form = UffizziCore::Api::Cli::V1::ConfigFile::CreateForm.new(starter_template_config_file_params)
+      starter_template_config_file_form.project = project
+      starter_template_config_file_form.added_by = user
+      starter_template_config_file_form.creation_source = UffizziCore::ConfigFile.creation_source.system
+      starter_template_config_file_form.save
+
+      starter_template_config_file_form
+    end
+
+    def create_containers(project, user, voting_app_config_file)
+      starter_template_containers = {
+        name: 'Voting App (from base images)',
+        payload: {
+          containers_attributes: containers_attributes(voting_app_config_file),
+        },
+      }
+
+      starter_template = ActionController::Parameters.new(starter_template_containers)
+
+      starter_template_form = UffizziCore::Api::Cli::V1::Template::CreateForm.new(starter_template)
+      starter_template_form.creation_source = UffizziCore::Template.creation_source.system
+      starter_template_form.added_by = user
+      starter_template_form.project = project
+      starter_template_form.save
+    end
+
+    def containers_attributes(voting_app_config_file)
+      [
+        postgres_container_attributes,
+        nginx_container_attributes(voting_app_config_file),
+        redis_container_attributes,
+        example_worker_container_attributes,
+        example_result_container_attributes,
+        example_vote_container_attributes,
+      ]
+    end
+
+    def postgres_container_attributes
+      {
+        image: 'library/postgres',
+        tag: '9.6',
+        port: nil,
+        public: false,
+        memory_limit: 250,
+        memory_request: 250,
+        receive_incoming_requests: false,
+        continuously_deploy: 'disabled',
+        secret_variables: nil,
+        variables: [
+          {
+            name: 'POSTGRES_USER',
+            value: 'postgres',
+          },
+          {
+            name: 'POSTGRES_PASSWORD',
+            value: 'postgres',
+          },
+        ],
+        repo_attributes: repo_attributes('library/postgres'),
+        container_config_files_attributes: [],
+      }
+    end
+
+    def nginx_container_attributes(voting_app_config_file)
+      {
+        image: 'library/nginx',
+        tag: 'latest',
+        port: 8080,
+        public: true,
+        memory_limit: 125,
+        memory_request: 125,
+        receive_incoming_requests: true,
+        continuously_deploy: 'disabled',
+        secret_variables: nil,
+        variables: nil,
+        repo_attributes: repo_attributes('library/nginx'),
+        container_config_files_attributes: [{
+          config_file_id: voting_app_config_file.id,
+          mount_path: '/etc/nginx/conf.d/',
+        }],
+      }
+    end
+
+    def redis_container_attributes
+      {
+        image: 'library/redis',
+        tag: 'latest',
+        port: nil,
+        public: false,
+        memory_limit: 125,
+        memory_request: 125,
+        receive_incoming_requests: false,
+        continuously_deploy: 'disabled',
+        secret_variables: nil,
+        variables: nil,
+        repo_attributes: repo_attributes('library/redis'),
+        container_config_files_attributes: [],
+      }
+    end
+
+    def example_worker_container_attributes
+      {
+        image: 'uffizzicloud/example-worker',
+        tag: 'latest',
+        port: nil,
+        public: false,
+        memory_limit: 250,
+        memory_request: 250,
+        receive_incoming_requests: false,
+        continuously_deploy: 'disabled',
+        secret_variables: nil,
+        variables: nil,
+        repo_attributes: repo_attributes('uffizzicloud/example-worker'),
+        container_config_files_attributes: [],
+      }
+    end
+
+    def example_result_container_attributes
+      {
+        image: 'uffizzicloud/example-result',
+        tag: 'latest',
+        port: nil,
+        public: false,
+        memory_limit: 125,
+        memory_request: 125,
+        receive_incoming_requests: false,
+        continuously_deploy: 'disabled',
+        secret_variables: nil,
+        variables: nil,
+        repo_attributes: repo_attributes('uffizzicloud/example-result'),
+        container_config_files_attributes: [],
+      }
+    end
+
+    def example_vote_container_attributes
+      {
+        image: 'uffizzicloud/example-vote',
+        tag: 'latest',
+        port: nil,
+        public: false,
+        memory_limit: 250,
+        memory_request: 250,
+        receive_incoming_requests: false,
+        continuously_deploy: 'disabled',
+        secret_variables: nil,
+        variables: nil,
+        repo_attributes: repo_attributes('uffizzicloud/example-vote'),
+        container_config_files_attributes: [],
+      }
+    end
+
+    def config_file_attributes
+      {
+        filename: 'vote.conf',
+        kind: 'config_map',
+        payload: "server {
+               listen       8080;
+               server_name  example.com;
+               location / {
+                 proxy_pass      http://127.0.0.1:80/;
+               }
+               location /vote/ {
+                 proxy_pass      http://127.0.0.1:8888/;
+               }
+            }",
+      }
+    end
+
+    def repo_attributes(image)
+      namespace, name = image.split('/')
+      {
+        namespace: namespace,
+        name: name,
+        slug: name,
+        type: 'UffizziCore::Repo::DockerHub',
+        description: '',
+        is_private: false,
+        repository_id: nil,
+        branch: '',
+        kind: nil,
+      }
+    end
+  end
+end

data/app/services/uffizzi_core/template_service.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class UffizziCore::TemplateService
+  class << self
+    def valid_containers_memory_limit?(template)
+      containers_attributes = template.payload['containers_attributes']
+      container_memory_limit = template.project.account.container_memory_limit
+      return true if container_memory_limit.nil?
+
+      containers_attributes.all? { |container| container['memory_limit'].to_i <= container_memory_limit }
+    end
+
+    def valid_containers_memory_request?(template)
+      containers_attributes = template.payload['containers_attributes']
+      container_memory_limit = template.project.account.container_memory_limit
+      return true if container_memory_limit.nil?
+
+      containers_attributes.all? { |container| container['memory_request'].to_i <= container_memory_limit }
+    end
+  end
+end

data/app/services/uffizzi_core/token_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module UffizziCore::TokenService
+  class << self
+    def encode(payload)
+      JWT.encode(payload, Settings.rails.secret_key_base, 'HS256')
+    end
+
+    def decode(token)
+      JWT.decode(token, Settings.rails.secret_key_base, true, algorithm: 'HS256')
+    rescue JWT::DecodeError
+      nil
+    end
+
+    def generate
+      SecureRandom.hex
+    end
+  end
+end

data/app/services/uffizzi_core/user_access_service.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class UffizziCore::UserAccessService
+  attr_accessor :user_access_module
+
+  delegate :admin_access_to_account?, :developer_access_to_account?, :viewer_access_to_account?,
+           :admin_or_developer_access_to_account?, :any_access_to_account?, :admin_access_to_project?,
+           :developer_access_to_project?, :viewer_access_to_project?, :admin_or_developer_access_to_project?,
+           :any_access_to_project?, :global_admin?, to: :@user_access_module
+
+  def initialize(user_access_module)
+    @user_access_module = user_access_module
+  end
+end

data/app/services/uffizzi_core/user_generator_service.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+class UffizziCore::UserGeneratorService
+  DEFAULT_USER_EMAIL = 'user@example.com'
+  DEFAULT_PROJECT_NAME = 'default'
+  DEFAULT_ACCOUNT_NAME = 'default'
+
+  class << self
+    def safe_generate(email, password, project_name)
+      generate(email, password, project_name)
+    rescue StandardError => e
+      puts e.message
+    end
+
+    def generate(email, password, project_name)
+      user_attributes = build_user_attributes(email, password)
+      project_attributes = build_project_attributes(project_name)
+
+      ActiveRecord::Base.transaction do
+        user = UffizziCore::User.create!(user_attributes)
+
+        account_attributes = build_account_attributes(user)
+        account = UffizziCore::Account.create!(account_attributes)
+        user.memberships.create!(account: account, role: UffizziCore::Membership.role.admin)
+        project = account.projects.create!(project_attributes)
+        project.user_projects.create!(user: user, role: UffizziCore::UserProject.role.admin)
+      end
+    end
+
+    private
+
+    def build_user_attributes(email, password)
+      user_attributes = {
+        state: UffizziCore::User::STATE_ACTIVE,
+        creation_source: UffizziCore::User.creation_source.system,
+      }
+
+      if email.present?
+        user_attributes[:email] = email
+      elsif IO::console.present?
+        IO::console.write("Enter User Email (default: #{DEFAULT_USER_EMAIL}): ")
+        user_attributes[:email] = IO::console.gets.strip.presence || DEFAULT_USER_EMAIL
+      end
+
+      user_attributes[:password] = if password.present?
+        password
+      elsif IO::console.present?
+        IO::console.getpass('Enter Password: ')
+      end
+
+      user_attributes
+    end
+
+    def build_project_attributes(project_name)
+      project_attributes = {
+        state: UffizziCore::Project::STATE_ACTIVE,
+      }
+      if project_name.present?
+        project_attributes[:name] = project_name
+      elsif IO::console.present?
+        IO::console.write("Enter Project Name (default: #{DEFAULT_PROJECT_NAME}): ")
+        project_attributes[:name] = IO::console.gets.strip.presence || DEFAULT_PROJECT_NAME
+      else
+        project_attributes[:name] = DEFAULT_PROJECT_NAME
+      end
+
+      project_attributes[:slug] = prepare_project_slug(project_attributes[:name])
+      project_attributes
+    end
+
+    def build_account_attributes(user)
+      {
+        owner: user,
+        name: DEFAULT_ACCOUNT_NAME,
+        state: UffizziCore::Account::STATE_ACTIVE,
+        kind: UffizziCore::Account.kind.organizational,
+      }
+    end
+
+    def prepare_project_slug(project_name)
+      project_name.downcase.gsub(/[^A-Za-z0-9]/, '-')
+    end
+  end
+end

data/app/utils/uffizzi_core/converters.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module UffizziCore::Converters
+  class << self
+    include ActionView::Helpers::NumberHelper
+
+    def deep_lower_camelize_keys(object)
+      case object
+      when Array
+        object.map do |element|
+          element.deep_transform_keys { |key| key.to_s.camelize(:lower) }
+        end
+      when Hash
+        object.deep_transform_keys { |key| key.to_s.camelize(:lower) }
+      else
+        object
+      end
+    end
+
+    def deep_underscore_keys(object)
+      case object
+      when Array
+        object.map do |element|
+          element.deep_transform_keys { |key| key.to_s.underscore }
+        end
+      when Hash
+        object.deep_transform_keys { |key| key.to_s.underscore }
+      else
+        object
+      end
+    end
+  end
+end

data/app/validators/uffizzi_core/email_validator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class UffizziCore::EmailValidator < ActiveModel::EachValidator
+  EMAIL_REGEXP = /\A([^@\s<>]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i.freeze
+
+  def validate_each(record, attribute, value)
+    record.errors.add(attribute, (options[:message] || :invalid)) unless value&.match?(EMAIL_REGEXP)
+  end
+end

data/app/validators/uffizzi_core/environment_variable_list_validator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class UffizziCore::EnvironmentVariableListValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, variables)
+    record.errors.add(attribute, :invalid) if variables.class != Array || !valid_variables?(variables)
+  end
+
+  def valid_variables?(variables)
+    variables.each do |variable|
+      return false if variable.class != Hash || !variable.key?('name') || variable['name'].nil? || !variable.key?('value')
+    end
+
+    true
+  end
+end

data/app/validators/uffizzi_core/image_command_args_validator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class UffizziCore::ImageCommandArgsValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, command_args)
+    record.errors.add(attribute, :invalid) if !command_args.nil? && !valid_command_args?(command_args)
+  end
+
+  def valid_command_args?(raw_command_args)
+    return true if raw_command_args.empty?
+
+    begin
+      command_args = JSON.parse(raw_command_args)
+    rescue JSON::ParserError
+      return false
+    end
+
+    return false if command_args.class != Array || command_args.empty?
+
+    command_args.all? { |item| item.instance_of?(String) }
+  end
+end