gitlab_ci_yaml_processor.rb 6.3 KB
Newer Older
D
Douwe Maan 已提交
1 2 3 4 5 6 7
module Ci
  class GitlabCiYamlProcessor
    class ValidationError < StandardError;end

    DEFAULT_STAGES = %w(build test deploy)
    DEFAULT_STAGE = 'test'
    ALLOWED_YAML_KEYS = [:before_script, :image, :services, :types, :stages, :variables]
8
    ALLOWED_JOB_KEYS = [:tags, :script, :only, :except, :type, :image, :services, :allow_failure, :type, :stage, :when]
D
Douwe Maan 已提交
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

    attr_reader :before_script, :image, :services, :variables

    def initialize(config)
      @config = YAML.load(config)

      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] || {}
      @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 process?(only_params, except_params, ref, tag)
      return true if only_params.nil? && except_params.nil?

      if only_params
        return true if tag && only_params.include?("tags")
        return true if !tag && only_params.include?("branches")
        
        only_params.find do |pattern|
          match_ref?(pattern, ref)
        end
      else
        return false if tag && except_params.include?("tags")
        return false if !tag && except_params.include?("branches")

        except_params.each do |pattern|
          return false if match_ref?(pattern, ref)
        end
      end
    end

    def build_job(name, job)
      {
K
Kamil Trzcinski 已提交
88
        stage_idx: stages.index(job[:stage]),
D
Douwe Maan 已提交
89
        stage: job[:stage],
K
Kamil Trzcinski 已提交
90 91
        commands: "#{@before_script.join("\n")}\n#{normalize_script(job[:script])}",
        tag_list: job[:tags] || [],
D
Douwe Maan 已提交
92 93 94 95
        name: name,
        only: job[:only],
        except: job[:except],
        allow_failure: job[:allow_failure] || false,
96
        when: job[:when] || 'on_success',
D
Douwe Maan 已提交
97 98 99 100 101 102 103 104 105 106 107 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
        options: {
          image: job[:image] || @image,
          services: job[:services] || @services
        }.compact
      }
    end

    def match_ref?(pattern, ref)
      if pattern.first == "/" && pattern.last == "/"
        Regexp.new(pattern[1...-1]) =~ ref
      else
        pattern == ref
      end
    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

      @jobs.each do |name, job|
K
Kamil Trzcinski 已提交
142
        validate_job!(name, job)
D
Douwe Maan 已提交
143 144 145 146 147 148
      end

      true
    end

    def validate_job!(name, job)
K
Kamil Trzcinski 已提交
149 150 151 152
      if name.blank? || !validate_string(name)
        raise ValidationError, "job name should be non-empty string"
      end

D
Douwe Maan 已提交
153 154
      job.keys.each do |key|
        unless ALLOWED_JOB_KEYS.include? key
K
Kamil Trzcinski 已提交
155
          raise ValidationError, "#{name} job: unknown parameter #{key}"
D
Douwe Maan 已提交
156 157 158
        end
      end

K
Kamil Trzcinski 已提交
159 160
      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"
D
Douwe Maan 已提交
161 162 163 164
      end

      if job[:stage]
        unless job[:stage].is_a?(String) && job[:stage].in?(stages)
K
Kamil Trzcinski 已提交
165
          raise ValidationError, "#{name} job: stage parameter should be #{stages.join(", ")}"
D
Douwe Maan 已提交
166 167 168
        end
      end

K
Kamil Trzcinski 已提交
169 170
      if job[:image] && !validate_string(job[:image])
        raise ValidationError, "#{name} job: image should be a string"
D
Douwe Maan 已提交
171 172 173
      end

      if job[:services] && !validate_array_of_strings(job[:services])
K
Kamil Trzcinski 已提交
174
        raise ValidationError, "#{name} job: services should be an array of strings"
D
Douwe Maan 已提交
175 176 177
      end

      if job[:tags] && !validate_array_of_strings(job[:tags])
K
Kamil Trzcinski 已提交
178
        raise ValidationError, "#{name} job: tags parameter should be an array of strings"
D
Douwe Maan 已提交
179 180 181
      end

      if job[:only] && !validate_array_of_strings(job[:only])
K
Kamil Trzcinski 已提交
182
        raise ValidationError, "#{name} job: only parameter should be an array of strings"
D
Douwe Maan 已提交
183 184 185
      end

      if job[:except] && !validate_array_of_strings(job[:except])
K
Kamil Trzcinski 已提交
186
        raise ValidationError, "#{name} job: except parameter should be an array of strings"
D
Douwe Maan 已提交
187 188 189
      end

      if job[:allow_failure] && !job[:allow_failure].in?([true, false])
K
Kamil Trzcinski 已提交
190
        raise ValidationError, "#{name} job: allow_failure parameter should be an boolean"
D
Douwe Maan 已提交
191
      end
192 193

      if job[:when] && !job[:when].in?(%w(on_success on_failure always))
K
Kamil Trzcinski 已提交
194
        raise ValidationError, "#{name} job: when parameter should be on_success, on_failure or always"
195
      end
D
Douwe Maan 已提交
196 197 198 199 200
    end

    private

    def validate_array_of_strings(values)
K
Kamil Trzcinski 已提交
201
      values.is_a?(Array) && values.all? { |value| validate_string(value) }
D
Douwe Maan 已提交
202 203 204
    end

    def validate_variables(variables)
K
Kamil Trzcinski 已提交
205 206 207 208 209
      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)
D
Douwe Maan 已提交
210 211 212
    end
  end
end