gitlab_ci_yaml_processor.rb 11 KB
Newer Older
1 2
module Ci
  class GitlabCiYamlProcessor
3
    class ValidationError < StandardError; end
4

5
    include Gitlab::Ci::Config::Node::LegacyValidationHelpers
6

7
    DEFAULT_STAGE = 'test'
8
    ALLOWED_YAML_KEYS = [:before_script, :after_script, :image, :services, :types, :stages, :variables, :cache]
9 10
    ALLOWED_JOB_KEYS = [:tags, :script, :only, :except, :type, :image, :services,
                        :allow_failure, :type, :stage, :when, :artifacts, :cache,
11 12
                        :dependencies, :before_script, :after_script, :variables,
                        :environment]
13
    ALLOWED_CACHE_KEYS = [:key, :untracked, :paths]
14
    ALLOWED_ARTIFACTS_KEYS = [:name, :untracked, :paths, :when, :expire_in]
15

16
    attr_reader :path, :cache, :stages
17

18
    def initialize(config, path = nil)
19 20 21
      @ci_config = Gitlab::Ci::Config.new(config)
      @config = @ci_config.to_hash

22
      @path = path
23

24 25 26
      unless @ci_config.valid?
        raise ValidationError, @ci_config.errors.first
      end
27

28
      initial_parsing
29
      validate!
30
    rescue Gitlab::Ci::Config::Loader::FormatError => e
31
      raise ValidationError, e.message
32 33
    end

34 35 36
    def jobs_for_ref(ref, tag = false, trigger_request = nil)
      @jobs.select do |_, job|
        process?(job[:only], job[:except], ref, tag, trigger_request)
37
      end
38 39
    end

40 41 42
    def jobs_for_stage_and_ref(stage, ref, tag = false, trigger_request = nil)
      jobs_for_ref(ref, tag, trigger_request).select do |_, job|
        job[:stage] == stage
43 44 45
      end
    end

46 47 48 49
    def builds_for_ref(ref, tag = false, trigger_request = nil)
      jobs_for_ref(ref, tag, trigger_request).map do |name, job|
        build_job(name, job)
      end
50 51
    end

52 53 54 55 56
    def builds_for_stage_and_ref(stage, ref, tag = false, trigger_request = nil)
      jobs_for_stage_and_ref(stage, ref, tag, trigger_request).map do |name, job|
        build_job(name, job)
      end
    end
57

58 59 60 61
    def builds
      @jobs.map do |name, job|
        build_job(name, job)
      end
62 63
    end

64 65 66
    private

    def initial_parsing
67 68
      @before_script = @ci_config.before_script
      @image = @ci_config.image
69
      @after_script = @ci_config.after_script
70
      @services = @ci_config.services
71
      @variables = @ci_config.variables
72
      @stages = @ci_config.stages
73
      @cache = @ci_config.cache
74

75
      @jobs = {}
76

77
      @config.except!(*ALLOWED_YAML_KEYS)
Tomasz Maczukin's avatar
Tomasz Maczukin committed
78
      @config.each { |name, param| add_job(name, param) }
79

80
      raise ValidationError, "Please define at least one job" if @jobs.none?
81 82
    end

83 84 85 86 87 88 89
    def add_job(name, job)
      return if name.to_s.start_with?('.')

      raise ValidationError, "Unknown parameter: #{name}" unless job.is_a?(Hash) && job.has_key?(:script)

      stage = job[:stage] || job[:type] || DEFAULT_STAGE
      @jobs[name] = { stage: stage }.merge(job)
90 91
    end

92 93
    def build_job(name, job)
      {
94
        stage_idx: @stages.index(job[:stage]),
95
        stage: job[:stage],
96 97 98 99 100
        ##
        # Refactoring note:
        #  - before script behaves differently than after script
        #  - after script returns an array of commands
        #  - before script should be a concatenated command
101
        commands: [job[:before_script] || @before_script, job[:script]].flatten.compact.join("\n"),
Kamil Trzciński's avatar
Kamil Trzciński committed
102
        tag_list: job[:tags] || [],
103 104
        name: name,
        allow_failure: job[:allow_failure] || false,
105
        when: job[:when] || 'on_success',
106
        environment: job[:environment],
107
        yaml_variables: yaml_variables(name),
108 109
        options: {
          image: job[:image] || @image,
110
          services: job[:services] || @services,
111 112
          artifacts: job[:artifacts],
          cache: job[:cache] || @cache,
113
          dependencies: job[:dependencies],
114
          after_script: job[:after_script] || @after_script,
115 116 117 118
        }.compact
      }
    end

119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
    def yaml_variables(name)
      variables = global_variables.merge(job_variables(name))
      variables.map do |key, value|
        { key: key, value: value, public: true }
      end
    end

    def global_variables
      @variables || {}
    end

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

      job[:variables] || {}
    end

137
    def validate!
Kamil Trzciński's avatar
Kamil Trzciński committed
138 139 140 141 142 143 144
      @jobs.each do |name, job|
        validate_job!(name, job)
      end

      true
    end

145
    def validate_job!(name, job)
146 147 148
      validate_job_name!(name)
      validate_job_keys!(name, job)
      validate_job_types!(name, job)
Kamil Trzciński's avatar
Kamil Trzciński committed
149
      validate_job_script!(name, job)
150 151

      validate_job_stage!(name, job) if job[:stage]
152
      validate_job_variables!(name, job) if job[:variables]
153 154
      validate_job_cache!(name, job) if job[:cache]
      validate_job_artifacts!(name, job) if job[:artifacts]
155
      validate_job_dependencies!(name, job) if job[:dependencies]
156 157 158
    end

    def validate_job_name!(name)
159 160 161
      if name.blank? || !validate_string(name)
        raise ValidationError, "job name should be non-empty string"
      end
162
    end
163

164
    def validate_job_keys!(name, job)
165 166
      job.keys.each do |key|
        unless ALLOWED_JOB_KEYS.include? key
167
          raise ValidationError, "#{name} job: unknown parameter #{key}"
168 169
        end
      end
170
    end
171

172
    def validate_job_types!(name, job)
173 174
      if job[:image] && !validate_string(job[:image])
        raise ValidationError, "#{name} job: image should be a string"
175 176 177
      end

      if job[:services] && !validate_array_of_strings(job[:services])
178
        raise ValidationError, "#{name} job: services should be an array of strings"
179 180 181
      end

      if job[:tags] && !validate_array_of_strings(job[:tags])
182
        raise ValidationError, "#{name} job: tags parameter should be an array of strings"
183 184
      end

185 186
      if job[:only] && !validate_array_of_strings_or_regexps(job[:only])
        raise ValidationError, "#{name} job: only parameter should be an array of strings or regexps"
187 188
      end

189 190
      if job[:except] && !validate_array_of_strings_or_regexps(job[:except])
        raise ValidationError, "#{name} job: except parameter should be an array of strings or regexps"
191 192
      end

193 194
      if job[:allow_failure] && !validate_boolean(job[:allow_failure])
        raise ValidationError, "#{name} job: allow_failure parameter should be an boolean"
195 196
      end

Kamil Trzciński's avatar
Kamil Trzciński committed
197
      if job[:when] && !job[:when].in?(%w[on_success on_failure always])
198 199
        raise ValidationError, "#{name} job: when parameter should be on_success, on_failure or always"
      end
200

201 202
      if job[:environment] && !validate_environment(job[:environment])
        raise ValidationError, "#{name} job: environment parameter #{Gitlab::Regex.environment_name_regex_message}"
203
      end
204
    end
205

Kamil Trzciński's avatar
Kamil Trzciński committed
206 207 208 209 210 211 212 213 214 215 216 217 218 219
    def validate_job_script!(name, job)
      if !validate_string(job[:script]) && !validate_array_of_strings(job[:script])
        raise ValidationError, "#{name} job: script should be a string or an array of a strings"
      end

      if job[:before_script] && !validate_array_of_strings(job[:before_script])
        raise ValidationError, "#{name} job: before_script should be an array of strings"
      end

      if job[:after_script] && !validate_array_of_strings(job[:after_script])
        raise ValidationError, "#{name} job: after_script should be an array of strings"
      end
    end

220
    def validate_job_stage!(name, job)
221 222
      unless job[:stage].is_a?(String) && job[:stage].in?(@stages)
        raise ValidationError, "#{name} job: stage parameter should be #{@stages.join(", ")}"
223
      end
224
    end
225

226
    def validate_job_variables!(name, job)
227
      unless validate_variables(job[:variables])
228
        raise ValidationError,
229
          "#{name} job: variables should be a map of key-value strings"
230 231 232
      end
    end

233
    def validate_job_cache!(name, job)
234 235 236 237 238 239
      job[:cache].keys.each do |key|
        unless ALLOWED_CACHE_KEYS.include? key
          raise ValidationError, "#{name} job: cache unknown parameter #{key}"
        end
      end

240 241 242 243
      if job[:cache][:key] && !validate_string(job[:cache][:key])
        raise ValidationError, "#{name} job: cache:key parameter should be a string"
      end

244 245
      if job[:cache][:untracked] && !validate_boolean(job[:cache][:untracked])
        raise ValidationError, "#{name} job: cache:untracked parameter should be an boolean"
246
      end
247

248 249
      if job[:cache][:paths] && !validate_array_of_strings(job[:cache][:paths])
        raise ValidationError, "#{name} job: cache:paths parameter should be an array of strings"
250
      end
251 252
    end

253
    def validate_job_artifacts!(name, job)
254 255 256 257 258 259
      job[:artifacts].keys.each do |key|
        unless ALLOWED_ARTIFACTS_KEYS.include? key
          raise ValidationError, "#{name} job: artifacts unknown parameter #{key}"
        end
      end

260 261 262 263
      if job[:artifacts][:name] && !validate_string(job[:artifacts][:name])
        raise ValidationError, "#{name} job: artifacts:name parameter should be a string"
      end

264 265 266 267 268 269 270
      if job[:artifacts][:untracked] && !validate_boolean(job[:artifacts][:untracked])
        raise ValidationError, "#{name} job: artifacts:untracked parameter should be an boolean"
      end

      if job[:artifacts][:paths] && !validate_array_of_strings(job[:artifacts][:paths])
        raise ValidationError, "#{name} job: artifacts:paths parameter should be an array of strings"
      end
271

Kamil Trzciński's avatar
Kamil Trzciński committed
272
      if job[:artifacts][:when] && !job[:artifacts][:when].in?(%w[on_success on_failure always])
273 274
        raise ValidationError, "#{name} job: artifacts:when parameter should be on_success, on_failure or always"
      end
275 276 277 278

      if job[:artifacts][:expire_in] && !validate_duration(job[:artifacts][:expire_in])
        raise ValidationError, "#{name} job: artifacts:expire_in parameter should be a duration"
      end
279
    end
280

281
    def validate_job_dependencies!(name, job)
282
      unless validate_array_of_strings(job[:dependencies])
283 284 285
        raise ValidationError, "#{name} job: dependencies parameter should be an array of strings"
      end

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

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

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

297
    def process?(only_params, except_params, ref, tag, trigger_request)
298
      if only_params.present?
299
        return false unless matching?(only_params, ref, tag, trigger_request)
300 301 302
      end

      if except_params.present?
303
        return false if matching?(except_params, ref, tag, trigger_request)
304 305 306 307 308
      end

      true
    end

309
    def matching?(patterns, ref, tag, trigger_request)
310
      patterns.any? do |pattern|
311
        match_ref?(pattern, ref, tag, trigger_request)
312 313 314
      end
    end

315
    def match_ref?(pattern, ref, tag, trigger_request)
316 317 318 319
      pattern, path = pattern.split('@', 2)
      return false if path && path != self.path
      return true if tag && pattern == 'tags'
      return true if !tag && pattern == 'branches'
320
      return true if trigger_request.present? && pattern == 'triggers'
321 322 323 324 325 326 327

      if pattern.first == "/" && pattern.last == "/"
        Regexp.new(pattern[1...-1]) =~ ref
      else
        pattern == ref
      end
    end
328
  end
329
end