yaml_processor.rb 5.42 KB
Newer Older
1
2
3
4
5
6
7
module Gitlab
  module Ci
    class YamlProcessor
      ValidationError = Class.new(StandardError)

      include Gitlab::Ci::Config::Entry::LegacyValidationHelpers

8
      attr_reader :cache, :stages, :jobs
9

10
11
      def initialize(config, opts = {})
        @ci_config = Gitlab::Ci::Config.new(config, opts)
12
13
14
15
16
17
18
        @config = @ci_config.to_hash

        unless @ci_config.valid?
          raise ValidationError, @ci_config.errors.first
        end

        initial_parsing
19
      rescue Gitlab::Ci::Config::ConfigError => e
20
21
22
23
24
25
26
27
28
29
        raise ValidationError, e.message
      end

      def builds
        @jobs.map do |name, _|
          build_attributes(name)
        end
      end

      def build_attributes(name)
30
        job = @jobs.fetch(name.to_sym, {})
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

        { stage_idx: @stages.index(job[:stage]),
          stage: job[:stage],
          commands: job[:commands],
          tag_list: job[:tags] || [],
          name: job[:name].to_s,
          allow_failure: job[:ignore],
          when: job[:when] || 'on_success',
          environment: job[:environment_name],
          coverage_regex: job[:coverage],
          yaml_variables: yaml_variables(name),
          options: {
            image: job[:image],
            services: job[:services],
            artifacts: job[:artifacts],
            cache: job[:cache],
            dependencies: job[:dependencies],
            before_script: job[:before_script],
            script: job[:script],
            after_script: job[:after_script],
            environment: job[:environment],
52
            retry: job[:retry],
53
            parallel: job[:parallel],
54
            instance: job[:instance],
Shinya Maeda's avatar
Shinya Maeda committed
55
            start_in: job[:start_in]
56
57
58
          }.compact }
      end

59
60
61
62
      def stage_builds_attributes(stage)
        @jobs.values
          .select { |job| job[:stage] == stage }
          .map { |job| build_attributes(job[:name]) }
63
64
      end

65
66
67
68
      def stages_attributes
        @stages.uniq.map do |stage|
          seeds = stage_builds_attributes(stage).map do |attributes|
            job = @jobs.fetch(attributes[:name].to_sym)
69

70
71
72
73
            attributes
              .merge(only: job.fetch(:only, {}))
              .merge(except: job.fetch(:except, {}))
          end
74

75
          { name: stage, index: @stages.index(stage), builds: seeds }
76
77
78
        end
      end

79
      def self.validation_message(content, opts = {})
80
81
82
        return 'Please provide content of .gitlab-ci.yml' if content.blank?

        begin
83
          Gitlab::Ci::YamlProcessor.new(content, opts)
84
          nil
85
        rescue ValidationError => e
86
87
          e.message
        end
88
89
      end

90
91
      private

92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
      def initial_parsing
        ##
        # Global config
        #
        @before_script = @ci_config.before_script
        @image = @ci_config.image
        @after_script = @ci_config.after_script
        @services = @ci_config.services
        @variables = @ci_config.variables
        @stages = @ci_config.stages
        @cache = @ci_config.cache

        ##
        # Jobs
        #
107
        @jobs = Ci::Config::Normalizer.normalize_jobs(@ci_config.jobs)
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

        @jobs.each do |name, job|
          # logical validation for job

          validate_job_stage!(name, job)
          validate_job_dependencies!(name, job)
          validate_job_environment!(name, job)
        end
      end

      def yaml_variables(name)
        variables = (@variables || {})
          .merge(job_variables(name))

        variables.map do |key, value|
          { key: key.to_s, value: value, public: true }
        end
      end

      def job_variables(name)
        job = @jobs[name.to_sym]
        return {} unless job

        job[:variables] || {}
      end

      def validate_job_stage!(name, job)
        return unless job[:stage]

        unless job[:stage].is_a?(String) && job[:stage].in?(@stages)
          raise ValidationError, "#{name} job: stage parameter should be #{@stages.join(", ")}"
        end
      end

      def validate_job_dependencies!(name, job)
        return unless job[:dependencies]

        stage_index = @stages.index(job[:stage])

        job[:dependencies].each do |dependency|
          raise ValidationError, "#{name} job: undefined dependency: #{dependency}" unless @jobs[dependency.to_sym]

          unless @stages.index(@jobs[dependency.to_sym][:stage]) < stage_index
            raise ValidationError, "#{name} job: dependency #{dependency} is not defined in prior stages"
          end
        end
      end

      def validate_job_environment!(name, job)
        return unless job[:environment]
        return unless job[:environment].is_a?(Hash)

        environment = job[:environment]
        validate_on_stop_job!(name, environment, environment[:on_stop])
      end

      def validate_on_stop_job!(name, environment, on_stop)
        return unless on_stop

        on_stop_job = @jobs[on_stop.to_sym]
        unless on_stop_job
          raise ValidationError, "#{name} job: on_stop job #{on_stop} is not defined"
        end

        unless on_stop_job[:environment]
          raise ValidationError, "#{name} job: on_stop job #{on_stop} does not have environment defined"
        end

        unless on_stop_job[:environment][:name] == environment[:name]
          raise ValidationError, "#{name} job: on_stop job #{on_stop} have different environment name"
        end

        unless on_stop_job[:environment][:action] == 'stop'
          raise ValidationError, "#{name} job: on_stop job #{on_stop} needs to have action stop defined"
        end
      end
    end
  end
end