summaryrefslogtreecommitdiff
path: root/app/services/clusters/applications/base_service.rb
blob: 14a454372874bf060cd0165653d0b18dc72d00d1 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# frozen_string_literal: true

module Clusters
  module Applications
    class BaseService
      InvalidApplicationError = Class.new(StandardError)

      attr_reader :cluster, :current_user, :params

      def initialize(cluster, user, params = {})
        @cluster = cluster
        @current_user = user
        @params = params.dup
      end

      def execute(request)
        instantiate_application.tap do |application|
          if application.has_attribute?(:hostname)
            application.hostname = params[:hostname]
          end

          if application.has_attribute?(:email)
            application.email = params[:email]
          end

          if application.respond_to?(:oauth_application)
            application.oauth_application = create_oauth_application(application, request)
          end

          worker = worker_class(application)

          application.make_scheduled!

          worker.perform_async(application.name, application.id)
        end
      end

      protected

      def worker_class(application)
        raise NotImplementedError
      end

      def builder
        raise NotImplementedError
      end

      def project_builders
        raise NotImplementedError
      end

      def instantiate_application
        raise_invalid_application_error if invalid_application?

        builder || raise(InvalidApplicationError, "invalid application: #{application_name}")
      end

      def raise_invalid_application_error
        raise(InvalidApplicationError, "invalid application: #{application_name}")
      end

      def invalid_application?
        unknown_application? || (!cluster.project_type? && project_only_application?)
      end

      def unknown_application?
        Clusters::Cluster::APPLICATIONS.keys.exclude?(application_name)
      end

      # These applications will need extra configuration to enable them to work
      # with groups of projects
      def project_only_application?
        Clusters::Cluster::PROJECT_ONLY_APPLICATIONS.include?(application_name)
      end

      def application_name
        params[:application]
      end

      def create_oauth_application(application, request)
        oauth_application_params = {
          name: params[:application],
          redirect_uri: application.callback_url,
          scopes: 'api read_user openid',
          owner: current_user
        }

        ::Applications::CreateService.new(current_user, oauth_application_params).execute(request)
      end
    end
  end
end