uffizzi_core 0.1.3 → 0.1.5

data/app/services/uffizzi_core/cli/compose_file_service.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-class UffizziCore::Cli::ComposeFileService
-  class << self
-    def create(params, kind)
-      compose_file_form = create_compose_form(params, kind)
-
-      process_compose_file(compose_file_form, params)
-    end
-
-    def update(compose_file, params)
-      compose_file_form = create_update_compose_form(compose_file, params)
-
-      process_compose_file(compose_file_form, params)
-    end
-
-    def parse(compose_content, compose_payload = {})
-      compose_data = load_compose_data(compose_content)
-      check_config_options_format(compose_data)
-      configs_data = UffizziCore::ComposeFile::ConfigsOptionsService.parse(compose_data['configs'])
-      secrets_data = UffizziCore::ComposeFile::SecretsOptionsService.parse(compose_data['secrets'])
-      containers_data = UffizziCore::ComposeFile::ServicesOptionsService.parse(compose_data['services'], configs_data, secrets_data,
-                                                                               compose_payload)
-
-      continuous_preview_option = UffizziCore::ComposeFile::ConfigOptionService.continuous_preview_option(compose_data)
-      continuous_preview_data = UffizziCore::ComposeFile::ContinuousPreviewOptionsService.parse(continuous_preview_option)
-
-      ingress_option = UffizziCore::ComposeFile::ConfigOptionService.ingress_option(compose_data)
-      ingress_data = UffizziCore::ComposeFile::IngressOptionsService.parse(ingress_option, compose_data['services'])
-
-      {
-        containers: containers_data,
-        ingress: ingress_data,
-        continuous_preview: continuous_preview_data,
-      }
-    end
-
-    def load_repositories(compose_data, credential)
-      containers = github_containers(compose_data)
-      return [] if containers.empty?
-
-      search_query = 'fork:true '
-      search_query += containers.reduce('') do |query, container|
-        query += "repo:#{credential.username}/#{container[:build][:repository_name]} "
-        query
-      end
-
-      UffizziCore::Github::CredentialService.search_repositories(credential, search_query)
-    end
-
-    def check_github_branches(compose_data, repositories, credential)
-      containers = github_containers_with_branches(compose_data)
-      return [] if containers.empty?
-
-      containers.map do |container|
-        repository = repositories.detect { |item| item[:clone_url].to_s.start_with?(container[:build][:repository_url]) }
-        error_message = I18n.t('compose.repository_not_found', repository_url: container[:build][:repository_url])
-        raise UffizziCore::ComposeFile::NotFoundError, error_message if repository.nil?
-
-        branch = begin
-          UffizziCore::Github::CredentialService.branch(credential, repository[:id], container[:build][:branch])
-        rescue Octokit::NotFound
-          nil
-        end
-
-        error_message = I18n.t('compose.invalid_branch', branch: container[:build][:branch],
-                                                         repository_url: container[:build][:repository_url])
-        raise UffizziCore::ComposeFile::NotFoundError, error_message if branch.nil?
-      end
-    end
-
-    def build_template_attributes(compose_data, source, credentials, project, compose_dependencies = [], compose_repositories = [])
-      builder = UffizziCore::ComposeFile::Builders::TemplateBuilderService.new(credentials, project, compose_repositories)
-
-      builder.build_attributes(compose_data, compose_dependencies, source)
-    end
-
-    def containers_credentials(compose_data, credentials)
-      containers = compose_data[:containers]
-      detected_credentials = containers.map do |container|
-        UffizziCore::ComposeFile::ContainerService.credential_for_container(container, credentials)
-      end
-
-      result = []
-      detected_credentials.compact
-        .group_by { |credential| credential[:id] }
-        .each_pair { |_id, value| result << value.first }
-      result
-    end
-
-    private
-
-    def process_compose_file(compose_file_form, params)
-      credential = compose_file_form.project.account.credentials.github.last
-      cli_form = create_cli_form(compose_file_form.content, credential)
-      return [compose_file_form, cli_form.errors] if cli_form.invalid?
-
-      dependencies = params[:dependencies].to_a
-      compose_data = cli_form.compose_data
-      compose_dependencies = build_compose_dependecies(compose_data, compose_file_form.path, dependencies)
-      cli_form.compose_dependencies = compose_dependencies
-
-      persist!(compose_file_form, cli_form)
-    end
-
-    def create_compose_form(params, kind)
-      compose_file_params = params[:compose_file_params]
-      compose_file_form = UffizziCore::Api::Cli::V1::ComposeFile::CreateForm.new(compose_file_params)
-      compose_file_form.project = params[:project]
-      compose_file_form.added_by = params[:user]
-      compose_file_form.content = compose_file_params[:content]
-      compose_file_form.kind = kind
-      payload_dependencies = prepare_compose_file_dependencies(params[:dependencies])
-      compose_file_form.payload['dependencies'] = payload_dependencies
-
-      compose_file_form
-    end
-
-    def create_update_compose_form(compose_file, params)
-      compose_file_form = compose_file.becomes(UffizziCore::Api::Cli::V1::ComposeFile::UpdateForm)
-      compose_file_params = params[:compose_file_params]
-      compose_file_form.assign_attributes(compose_file_params)
-      payload_dependencies = prepare_compose_file_dependencies(params[:dependencies])
-      compose_file_form.payload['dependencies'] = payload_dependencies
-
-      compose_file_form
-    end
-
-    def create_cli_form(content, credential)
-      cli_form = UffizziCore::Api::Cli::V1::ComposeFile::CliForm.new
-      cli_form.content = content
-      cli_form.credential = credential
-
-      cli_form
-    end
-
-    def build_compose_dependecies(compose_data, compose_path, dependencies)
-      return [] if dependencies.empty?
-
-      UffizziCore::ComposeFile::DependenciesService.build_dependencies(compose_data, compose_path, dependencies)
-    end
-
-    def prepare_compose_file_dependencies(compose_dependencies)
-      compose_dependencies.map do |dependency|
-        {
-          path: dependency[:path],
-        }
-      end
-    end
-
-    def persist!(compose_file_form, cli_form)
-      errors = []
-      ActiveRecord::Base.transaction do
-        if !compose_file_form.save
-          errors = compose_file_form.errors
-          raise ActiveRecord::Rollback
-        end
-
-        config_files_service = UffizziCore::ComposeFile::ConfigFilesService.new(compose_file_form)
-        errors = config_files_service.create_config_files(cli_form.compose_dependencies)
-        raise ActiveRecord::Rollback if errors.present?
-
-        project = compose_file_form.project
-        user = compose_file_form.added_by
-        template_service = UffizziCore::ComposeFile::TemplateService.new(cli_form, project, user)
-        errors = template_service.create_template(compose_file_form)
-
-        raise ActiveRecord::Rollback if errors.present?
-      end
-      [compose_file_form, errors]
-    end
-
-    def load_compose_data(compose_content)
-      begin
-        compose_data = YAML.safe_load(compose_content)
-      rescue Psych::SyntaxError
-        raise UffizziCore::ComposeFile::ParseError, 'Invalid compose file'
-      end
-
-      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.unsupported_file') if compose_data.nil?
-
-      compose_data
-    end
-
-    def check_config_options_format(compose_data)
-      options = UffizziCore::ComposeFile::ConfigOptionService.config_options(compose_data)
-
-      options.each do |option|
-        next if UffizziCore::ComposeFile::ConfigOptionService.valid_option_format?(option)
-
-        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_config_option', value: option)
-      end
-    end
-
-    def github_containers(compose_data)
-      compose_data[:containers].select { |container| UffizziCore::ComposeFile::ContainerService.github?(container) }
-    end
-
-    def github_containers_with_branches(compose_data)
-      github_containers(compose_data).reject { |container| container[:build][:branch].nil? }
-    end
-  end
-end

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

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-class UffizziCore::ComposeFile::Builders::GithubRepoBuilderService
-  attr_accessor :repositories
-
-  def initialize(repositories)
-    @repositories = repositories
-  end
-
-  def build_attributes(build_data)
-    repository_data = repository(build_data[:repository_name])
-
-    {
-      kind: repository_kind(build_data),
-      name: build_data[:repository_name],
-      slug: build_data[:repository_name],
-      type: UffizziCore::Repo::Github.name,
-      branch: branch(build_data, repository_data),
-      namespace: build_data[:account_name],
-      is_private: nil,
-      description: repository_data[:description],
-      repository_id: repository_data[:id],
-      dockerfile_path: build_data[:dockerfile],
-      dockerfile_context_path: build_data[:dockerfile_context_path],
-      args: args(build_data),
-    }
-  end
-
-  private
-
-  def branch(build_data, repository_data)
-    build_data[:branch] || repository_data[:default_branch]
-  end
-
-  def repository(name)
-    repo = repositories.detect { |repository| repository.name.downcase == name.downcase }
-
-    raise UffizziCore::ComposeFile::BuildError, I18n.t('compose.repo_not_found', name: name) if repo.nil?
-
-    repo
-  end
-
-  def repository_kind(build_data)
-    if build_data[:dockerfile].present?
-      UffizziCore::Repo.kind.dockerfile
-    else
-      UffizziCore::Repo.kind.barestatic
-    end
-  end
-
-  def args(build_data)
-    build_data[:args].map do |arg|
-      {
-        name: arg[:name],
-        value: arg[:value],
-      }
-    end
-  end
-end

data/app/services/uffizzi_core/compose_file/services_options/build_service.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-class UffizziCore::ComposeFile::ServicesOptions::BuildService
-  extend UffizziCore::ComposeFile::VariablesService
-
-  class << self
-    def parse(build_data, compose_payload)
-      return {} if build_data.blank?
-
-      args = parse_args(build_data)
-
-      repository_url, branch, dockerfile_context_path = parse_context(build_data, compose_payload)
-      repository_parts = repository_url.split('/').last(2)
-      account_name = repository_parts.first
-      repository_name = repository_parts.last
-      dockerfile = build_data['dockerfile'].blank? ? ::Settings.compose.dockerfile_default_path : build_data['dockerfile']
-
-      {
-        repository_url: repository_url,
-        account_name: account_name,
-        repository_name: repository_name,
-        branch: branch,
-        dockerfile: dockerfile,
-        dockerfile_context_path: dockerfile_context_path,
-        args: args,
-      }
-    end
-
-    private
-
-    def parse_args(build_data)
-      args = build_data['args']
-      return [] if args.nil?
-
-      case args
-      when Array
-        args.map { |arg| parse_variable_from_string(arg) }
-      when Hash
-        args.to_a.map { |arg| parse_variable_from_array(arg) }
-      else
-        raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_type', option: :args)
-      end
-    end
-
-    def parse_context(build_data, compose_payload)
-      if build_data.is_a?(String)
-        parse_context_from_inline_syntax(build_data, compose_payload)
-      else
-        parse_context_from_long_syntax(build_data, compose_payload)
-      end
-    end
-
-    def parse_repository_url_fragment(fragment)
-      branch, dockerfile_context_path = fragment.split(':')
-
-      [branch, dockerfile_context_path]
-    end
-
-    def valid_url?(url)
-      URI(url).host.present? && URI(url).host =~ /\w+\.\w+/ && URI(url).path.present?
-    end
-
-    def parse_context_from_inline_syntax(context, compose_payload)
-      if compose_payload[:repository_url].blank?
-        raise UffizziCore::ComposeFile::ParseError,
-              I18n.t('compose.build_context_unknown_repository')
-      end
-
-      repository_url = compose_payload[:repository_url]
-      branch = compose_payload[:branch]
-      dockerfile_context_path = UffizziCore::ComposeFile::ConfigOptionService.prepare_file_path_value(context)
-
-      [repository_url, branch, dockerfile_context_path]
-    end
-
-    def parse_context_from_long_syntax(build_data, compose_payload)
-      context = build_data['context']
-      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.build_context_no_specified') if context.blank?
-
-      if valid_url?(context)
-        uri = URI(context)
-        repository_url = "#{uri.scheme}://#{uri.host}#{uri.path}"
-        branch, dockerfile_context_path = parse_repository_url_fragment(uri.fragment.to_s)
-      else
-        repository_url, branch, dockerfile_context_path = parse_context_from_inline_syntax(context, compose_payload)
-      end
-
-      raise UffizziCore::ComposeFile::ParseError, I18n.t('compose.invalid_context', value: context) if repository_url.blank?
-
-      [repository_url, branch, dockerfile_context_path]
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# 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/github/app_service.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-class UffizziCore::Github::AppService
-  class << self
-    def create_preview_message_into_pull_request(deployment)
-      project = deployment.project
-      credential = project.credentials.github.last
-      return if credential.nil?
-
-      pull_request_payload = deployment.continuous_preview_payload['pull_request']
-      installation_id = credential.provider_ref
-      message = UffizziCore::Github::MessageService.build_preview_message(deployment)
-
-      create_comment(installation_id, pull_request_payload['repository_full_name'], pull_request_payload['id'], message)
-    end
-
-    private
-
-    def create_comment(installation_id, repository, issue_id, message)
-      access_token = create_installation_access_token(installation_id)
-
-      installation_client = UffizziCore::Github::InstallationClient.new(access_token)
-
-      installation_client.add_comment(repository, issue_id, message)
-    end
-
-    def create_installation_access_token(installation_id)
-      access_token_response = app_client.create_app_installation_access_token(installation_id)
-      access_token_response[:token]
-    end
-
-    def app_client
-      UffizziCore::Github::AppClient.new(generate_jwt_token)
-    end
-
-    def generate_jwt_token
-      rsa_armor = '-----'
-      parts = Settings.github.private_key.split(rsa_armor)
-      parts[2].gsub!(/\s/, "\n")
-      private_key = OpenSSL::PKey::RSA.new(parts.join(rsa_armor))
-
-      payload = {}.tap do |opts|
-        opts[:iat] = Time.now.to_i
-        opts[:exp] = opts[:iat] + 60
-        opts[:iss] = Settings.github.app_id
-      end
-
-      JWT.encode(payload, private_key, 'RS256')
-    end
-  end
-end

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

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-class UffizziCore::Github::CredentialService
-  class << self
-    def repository_contains_file?(credential, repository_id, branch, path)
-      client(credential).contents?(repository_id, ref: branch, path: path)
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, repository_contains_file? credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    def credential_correct?(credential)
-      valid_installation?(credential)
-    rescue Octokit::Unauthorized
-      false
-    end
-
-    def search_repositories(credential, search_query)
-      result = client(credential).search_repositories(search_query)
-
-      result[:items]
-    rescue Octokit::UnprocessableEntity
-      []
-    end
-
-    def repositories(credential, query = '', page = 1)
-      repo_attributes = {
-        sort: :updated,
-        page: page,
-      }
-
-      repos = client(credential).installation_repositories(credential.provider_ref, repo_attributes)
-      filter_repos(repos, query)
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, repositories credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    def branches(credential, repository_id)
-      client(credential).branches(repository_id)
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, branches credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    def branch(credential, repository_id, branch)
-      client(credential).branch(repository_id, branch)
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, branch credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    def commit(credential, repository_id, commit_sha)
-      commit = client(credential).commit(repository_id, commit_sha)
-
-      {
-        message: commit[:message],
-        committer: commit[:committer][:name],
-        commit: commit_sha,
-      }
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, commit credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    def contents(credential, repository_id, options)
-      client(credential).contents(repository_id, options)
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, contents credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    def repo(credential, repository_id)
-      client(credential).repo(repository_id)
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, repo credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    def repo_url(credential, repository_id)
-      repo = repo(credential, repository_id)
-      repo[:clone_url].split(%r{https://}).last
-    end
-
-    def file_content(credential, repository_id, branch, file_path)
-      file = contents(credential, repository_id, ref: branch, path: file_path)
-      Base64.decode64(file[:content])
-    rescue Octokit::Unauthorized
-      Rails.logger.warn("broken credentials, file_content credential_id=#{credential.id}")
-      credential.unauthorize! unless credential.unauthorized?
-      raise
-    end
-
-    private
-
-    def client(credential)
-      UffizziCore::Github::UserClient.new(credential.password)
-    end
-
-    def valid_installation?(credential)
-      user_installations = client(credential).user_installations
-
-      installation = user_installations.detect do |user_installation|
-        user_installation[:id].to_s == credential.provider_ref
-      end
-
-      installation.present?
-    end
-
-    def filter_repos(repos, query)
-      return repos if query.blank?
-
-      prepared_query = query.downcase
-      repos.select { |repo| repo.full_name.downcase.include?(prepared_query) || repo.description&.downcase&.include?(prepared_query) }
-    end
-  end
-end

data/app/services/uffizzi_core/github/message_service.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class UffizziCore::Github::MessageService
-  class << self
-    def build_preview_message(deployment)
-      preview_url = UffizziCore::DeploymentService.build_preview_url(deployment)
-      deployment_url = UffizziCore::DeploymentService.build_deployment_url(deployment)
-
-      "**This branch has been deployed using Uffizzi.**
-
-      Preview URL:
-      https://#{preview_url}
-
-      View deployment details here:
-      https://#{deployment_url}
-
-      This is an automated comment. To turn off commenting, visit uffizzi.com."
-    end
-  end
-end

data/app/services/uffizzi_core/github_service.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-class UffizziCore::GithubService
-  class << self
-    def send_preview_message(deployment)
-      image = deployment.continuous_preview_payload['pull_request']['repository_full_name']
-      containers = deployment.containers.where(image: image)
-      repo = UffizziCore::Repo.find_by(id: containers.select(:repo_id))
-
-      preview_message_is_enabled = !!repo.share_to_github
-
-      return if !preview_message_is_enabled
-
-      continuous_preview_payload = deployment.continuous_preview_payload
-      pull_request_payload = continuous_preview_payload['pull_request']
-      new_preview_message = UffizziCore::Github::MessageService.build_preview_message(deployment)
-
-      return if new_preview_message == pull_request_payload['message']
-
-      pull_request_payload['message'] = new_preview_message
-      continuous_preview_payload['pull_request'] = pull_request_payload
-
-      deployment.update(continuous_preview_payload: continuous_preview_payload)
-
-      UffizziCore::Github::AppService.create_preview_message_into_pull_request(deployment)
-    end
-  end
-end

data/app/services/uffizzi_core/user_access_service.rb

@@ -1,14 +0,0 @@
-# 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