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

    DEFAULT_STAGES = %w(build test deploy)
    DEFAULT_STAGE = 'test'
7
    ALLOWED_YAML_KEYS = [:before_script, :after_script, :image, :services, :types, :stages, :variables, :cache]
8 9
    ALLOWED_JOB_KEYS = [:tags, :script, :only, :except, :type, :image, :services,
                        :allow_failure, :type, :stage, :when, :artifacts, :cache,
10
                        :dependencies, :before_script, :after_script, :variables]
11

12
    attr_reader :before_script, :after_script, :image, :services, :path, :cache
13

14
    def initialize(config, path = nil)
15
      @config = YAML.safe_load(config, [Symbol], [], true)
16
      @path = path
17 18 19 20 21 22 23 24 25 26 27 28

      unless @config.is_a? Hash
        raise ValidationError, "YAML should be a hash"
      end

      @config = @config.deep_symbolize_keys

      initial_parsing

      validate!
    end

29 30
    def builds_for_stage_and_ref(stage, ref, tag = false, trigger_request = nil)
      builds.select{|build| build[:stage] == stage && process?(build[:only], build[:except], ref, tag, trigger_request)}
31 32 33 34 35 36 37 38 39 40 41 42
    end

    def builds
      @jobs.map do |name, job|
        build_job(name, job)
      end
    end

    def stages
      @stages || DEFAULT_STAGES
    end

43
    def global_variables
44 45 46 47
      @variables
    end

    def job_variables(name)
48 49 50 51
      job = @jobs[name.to_sym]
      return [] unless job

      job.fetch(:variables, [])
52 53
    end

54 55 56 57
    private

    def initial_parsing
      @before_script = @config[:before_script] || []
58
      @after_script = @config[:after_script]
59 60 61 62
      @image = @config[:image]
      @services = @config[:services]
      @stages = @config[:stages] || @config[:types]
      @variables = @config[:variables] || {}
63
      @cache = @config[:cache]
64 65 66 67 68 69 70 71 72 73 74 75 76
      @config.except!(*ALLOWED_YAML_KEYS)

      # anything that doesn't have script is considered as unknown
      @config.each do |name, param|
        raise ValidationError, "Unknown parameter: #{name}" unless param.is_a?(Hash) && param.has_key?(:script)
      end

      unless @config.values.any?{|job| job.is_a?(Hash)}
        raise ValidationError, "Please define at least one job"
      end

      @jobs = {}
      @config.each do |key, job|
77
        next if key.to_s.start_with?('.')
78 79 80 81 82 83 84
        stage = job[:stage] || job[:type] || DEFAULT_STAGE
        @jobs[key] = { stage: stage }.merge(job)
      end
    end

    def build_job(name, job)
      {
85
        stage_idx: stages.index(job[:stage]),
86
        stage: job[:stage],
87
        commands: [job[:before_script] || @before_script, job[:script]].flatten.join("\n"),
Kamil Trzcinski's avatar
Kamil Trzcinski committed
88
        tag_list: job[:tags] || [],
89 90 91 92
        name: name,
        only: job[:only],
        except: job[:except],
        allow_failure: job[:allow_failure] || false,
93
        when: job[:when] || 'on_success',
94 95
        options: {
          image: job[:image] || @image,
96
          services: job[:services] || @services,
97 98
          artifacts: job[:artifacts],
          cache: job[:cache] || @cache,
99
          dependencies: job[:dependencies],
100
          after_script: job[:after_script] || @after_script,
101 102 103 104 105
        }.compact
      }
    end

    def validate!
Kamil Trzcinski's avatar
Kamil Trzcinski committed
106 107 108 109 110 111 112 113 114 115 116 117
      validate_global!

      @jobs.each do |name, job|
        validate_job!(name, job)
      end

      true
    end

    private

    def validate_global!
118 119 120 121
      unless validate_array_of_strings(@before_script)
        raise ValidationError, "before_script should be an array of strings"
      end

122 123
      unless @after_script.nil? || validate_array_of_strings(@after_script)
        raise ValidationError, "after_script should be an array of strings"
124 125
      end

126 127 128 129 130 131 132 133 134 135 136 137 138
      unless @image.nil? || @image.is_a?(String)
        raise ValidationError, "image should be a string"
      end

      unless @services.nil? || validate_array_of_strings(@services)
        raise ValidationError, "services should be an array of strings"
      end

      unless @stages.nil? || validate_array_of_strings(@stages)
        raise ValidationError, "stages should be an array of strings"
      end

      unless @variables.nil? || validate_variables(@variables)
139
        raise ValidationError, "variables should be a map of key-value strings"
140 141
      end

Kamil Trzcinski's avatar
Kamil Trzcinski committed
142 143
      validate_global_cache! if @cache
    end
144

Kamil Trzcinski's avatar
Kamil Trzcinski committed
145 146 147
    def validate_global_cache!
      if @cache[:key] && !validate_string(@cache[:key])
        raise ValidationError, "cache:key parameter should be a string"
148 149
      end

Kamil Trzcinski's avatar
Kamil Trzcinski committed
150 151
      if @cache[:untracked] && !validate_boolean(@cache[:untracked])
        raise ValidationError, "cache:untracked parameter should be an boolean"
152 153
      end

Kamil Trzcinski's avatar
Kamil Trzcinski committed
154 155 156
      if @cache[:paths] && !validate_array_of_strings(@cache[:paths])
        raise ValidationError, "cache:paths parameter should be an array of strings"
      end
157 158 159
    end

    def validate_job!(name, job)
160 161 162
      validate_job_name!(name)
      validate_job_keys!(name, job)
      validate_job_types!(name, job)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
163
      validate_job_script!(name, job)
164 165

      validate_job_stage!(name, job) if job[:stage]
166
      validate_job_variables!(name, job) if job[:variables]
167 168
      validate_job_cache!(name, job) if job[:cache]
      validate_job_artifacts!(name, job) if job[:artifacts]
169
      validate_job_dependencies!(name, job) if job[:dependencies]
170 171 172
    end

    def validate_job_name!(name)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
173 174 175
      if name.blank? || !validate_string(name)
        raise ValidationError, "job name should be non-empty string"
      end
176
    end
Kamil Trzcinski's avatar
Kamil Trzcinski committed
177

178
    def validate_job_keys!(name, job)
179 180
      job.keys.each do |key|
        unless ALLOWED_JOB_KEYS.include? key
Kamil Trzcinski's avatar
Kamil Trzcinski committed
181
          raise ValidationError, "#{name} job: unknown parameter #{key}"
182 183
        end
      end
184
    end
185

186
    def validate_job_types!(name, job)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
187 188
      if job[:image] && !validate_string(job[:image])
        raise ValidationError, "#{name} job: image should be a string"
189 190 191
      end

      if job[:services] && !validate_array_of_strings(job[:services])
Kamil Trzcinski's avatar
Kamil Trzcinski committed
192
        raise ValidationError, "#{name} job: services should be an array of strings"
193 194 195
      end

      if job[:tags] && !validate_array_of_strings(job[:tags])
Kamil Trzcinski's avatar
Kamil Trzcinski committed
196
        raise ValidationError, "#{name} job: tags parameter should be an array of strings"
197 198 199
      end

      if job[:only] && !validate_array_of_strings(job[:only])
Kamil Trzcinski's avatar
Kamil Trzcinski committed
200
        raise ValidationError, "#{name} job: only parameter should be an array of strings"
201 202 203
      end

      if job[:except] && !validate_array_of_strings(job[:except])
Kamil Trzcinski's avatar
Kamil Trzcinski committed
204
        raise ValidationError, "#{name} job: except parameter should be an array of strings"
205 206
      end

207 208
      if job[:allow_failure] && !validate_boolean(job[:allow_failure])
        raise ValidationError, "#{name} job: allow_failure parameter should be an boolean"
209 210
      end

211 212 213 214
      if job[:when] && !job[:when].in?(%w(on_success on_failure always))
        raise ValidationError, "#{name} job: when parameter should be on_success, on_failure or always"
      end
    end
215

Kamil Trzcinski's avatar
Kamil Trzcinski committed
216 217 218 219 220 221 222 223 224 225 226 227 228 229
    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

230 231 232
    def validate_job_stage!(name, job)
      unless job[:stage].is_a?(String) && job[:stage].in?(stages)
        raise ValidationError, "#{name} job: stage parameter should be #{stages.join(", ")}"
233
      end
234
    end
235

236
    def validate_job_variables!(name, job)
237
      unless validate_variables(job[:variables])
238
        raise ValidationError,
239
          "#{name} job: variables should be a map of key-value strings"
240 241 242
      end
    end

243
    def validate_job_cache!(name, job)
244 245 246 247
      if job[:cache][:key] && !validate_string(job[:cache][:key])
        raise ValidationError, "#{name} job: cache:key parameter should be a string"
      end

248 249
      if job[:cache][:untracked] && !validate_boolean(job[:cache][:untracked])
        raise ValidationError, "#{name} job: cache:untracked parameter should be an boolean"
250
      end
251

252 253
      if job[:cache][:paths] && !validate_array_of_strings(job[:cache][:paths])
        raise ValidationError, "#{name} job: cache:paths parameter should be an array of strings"
254
      end
255 256
    end

257
    def validate_job_artifacts!(name, job)
258 259 260 261
      if job[:artifacts][:name] && !validate_string(job[:artifacts][:name])
        raise ValidationError, "#{name} job: artifacts:name parameter should be a string"
      end

262 263 264 265 266 267 268 269
      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
    end
270

271 272 273 274 275 276 277 278
    def validate_job_dependencies!(name, job)
      if !validate_array_of_strings(job[:dependencies])
        raise ValidationError, "#{name} job: dependencies parameter should be an array of strings"
      end

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

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

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

287
    def validate_array_of_strings(values)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
288
      values.is_a?(Array) && values.all? { |value| validate_string(value) }
289 290 291
    end

    def validate_variables(variables)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
292 293 294 295 296
      variables.is_a?(Hash) && variables.all? { |key, value| validate_string(key) && validate_string(value) }
    end

    def validate_string(value)
      value.is_a?(String) || value.is_a?(Symbol)
297
    end
298

299 300 301 302
    def validate_boolean(value)
      value.in?([true, false])
    end

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

      if except_params.present?
309
        return false if matching?(except_params, ref, tag, trigger_request)
310 311 312 313 314
      end

      true
    end

315
    def matching?(patterns, ref, tag, trigger_request)
316
      patterns.any? do |pattern|
317
        match_ref?(pattern, ref, tag, trigger_request)
318 319 320
      end
    end

321
    def match_ref?(pattern, ref, tag, trigger_request)
322 323 324 325
      pattern, path = pattern.split('@', 2)
      return false if path && path != self.path
      return true if tag && pattern == 'tags'
      return true if !tag && pattern == 'branches'
326
      return true if trigger_request.present? && pattern == 'triggers'
327 328 329 330 331 332 333

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