gitlab_ci_yaml_processor.rb 7.71 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 8
    ALLOWED_YAML_KEYS = [:before_script, :image, :services, :types, :stages, :variables, :cache]
    ALLOWED_JOB_KEYS = [:tags, :script, :only, :except, :type, :image, :services, :allow_failure, :type, :stage, :when, :artifacts, :cache]
9

10
    attr_reader :before_script, :image, :services, :variables, :path, :cache
11

12
    def initialize(config, path = nil)
13
      @config = YAML.load(config)
14
      @path = path
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

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

      @config = @config.deep_symbolize_keys

      initial_parsing

      validate!
    end

    def builds_for_stage_and_ref(stage, ref, tag = false)
      builds.select{|build| build[:stage] == stage && process?(build[:only], build[:except], ref, tag)}
    end

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

    def stages
      @stages || DEFAULT_STAGES
    end

    private

    def initial_parsing
      @before_script = @config[:before_script] || []
      @image = @config[:image]
      @services = @config[:services]
      @stages = @config[:stages] || @config[:types]
      @variables = @config[:variables] || {}
49
      @cache = @config[:cache]
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
      @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|
        stage = job[:stage] || job[:type] || DEFAULT_STAGE
        @jobs[key] = { stage: stage }.merge(job)
      end
    end

    def build_job(name, job)
      {
70
        stage_idx: stages.index(job[:stage]),
71
        stage: job[:stage],
Kamil Trzcinski's avatar
Kamil Trzcinski committed
72 73
        commands: "#{@before_script.join("\n")}\n#{normalize_script(job[:script])}",
        tag_list: job[:tags] || [],
74 75 76 77
        name: name,
        only: job[:only],
        except: job[:except],
        allow_failure: job[:allow_failure] || false,
78
        when: job[:when] || 'on_success',
79 80
        options: {
          image: job[:image] || @image,
81
          services: job[:services] || @services,
82 83
          artifacts: job[:artifacts],
          cache: job[:cache] || @cache,
84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
        }.compact
      }
    end

    def normalize_script(script)
      if script.is_a? Array
        script.join("\n")
      else
        script
      end
    end

    def validate!
      unless validate_array_of_strings(@before_script)
        raise ValidationError, "before_script should be an array of strings"
      end

      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)
        raise ValidationError, "variables should be a map of key-valued strings"
      end

117 118 119 120 121 122 123 124 125 126
      if @cache
        if @cache[:untracked] && !validate_boolean(@cache[:untracked])
          raise ValidationError, "cache:untracked parameter should be an boolean"
        end

        if @cache[:paths] && !validate_array_of_strings(@cache[:paths])
          raise ValidationError, "cache:paths parameter should be an array of strings"
        end
      end

127
      @jobs.each do |name, job|
Kamil Trzcinski's avatar
Kamil Trzcinski committed
128
        validate_job!(name, job)
129 130 131 132 133 134
      end

      true
    end

    def validate_job!(name, job)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
135 136 137 138
      if name.blank? || !validate_string(name)
        raise ValidationError, "job name should be non-empty string"
      end

139 140
      job.keys.each do |key|
        unless ALLOWED_JOB_KEYS.include? key
Kamil Trzcinski's avatar
Kamil Trzcinski committed
141
          raise ValidationError, "#{name} job: unknown parameter #{key}"
142 143 144
        end
      end

Kamil Trzcinski's avatar
Kamil Trzcinski committed
145 146
      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"
147 148 149 150
      end

      if job[:stage]
        unless job[:stage].is_a?(String) && job[:stage].in?(stages)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
151
          raise ValidationError, "#{name} job: stage parameter should be #{stages.join(", ")}"
152 153 154
        end
      end

Kamil Trzcinski's avatar
Kamil Trzcinski committed
155 156
      if job[:image] && !validate_string(job[:image])
        raise ValidationError, "#{name} job: image should be a string"
157 158 159
      end

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

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

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

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

175 176 177 178 179 180 181 182 183 184
      if job[:cache]
        if job[:cache][:untracked] && !validate_boolean(job[:cache][:untracked])
          raise ValidationError, "#{name} job: cache:untracked parameter should be an boolean"
        end

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

185 186 187 188 189 190 191 192
      if job[:artifacts]
        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
193 194
      end

195
      if job[:allow_failure] && !validate_boolean(job[:allow_failure])
Kamil Trzcinski's avatar
Kamil Trzcinski committed
196
        raise ValidationError, "#{name} job: allow_failure parameter should be an boolean"
197
      end
198 199

      if job[:when] && !job[:when].in?(%w(on_success on_failure always))
Kamil Trzcinski's avatar
Kamil Trzcinski committed
200
        raise ValidationError, "#{name} job: when parameter should be on_success, on_failure or always"
201
      end
202 203 204 205 206
    end

    private

    def validate_array_of_strings(values)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
207
      values.is_a?(Array) && values.all? { |value| validate_string(value) }
208 209 210
    end

    def validate_variables(variables)
Kamil Trzcinski's avatar
Kamil Trzcinski committed
211 212 213 214 215
      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)
216
    end
217

218 219 220 221
    def validate_boolean(value)
      value.in?([true, false])
    end

222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
    def process?(only_params, except_params, ref, tag)
      if only_params.present?
        return false unless matching?(only_params, ref, tag)
      end

      if except_params.present?
        return false if matching?(except_params, ref, tag)
      end

      true
    end

    def matching?(patterns, ref, tag)
      patterns.any? do |pattern|
        match_ref?(pattern, ref, tag)
      end
    end

    def match_ref?(pattern, ref, tag)
      pattern, path = pattern.split('@', 2)
      return false if path && path != self.path
      return true if tag && pattern == 'tags'
      return true if !tag && pattern == 'branches'

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