Merge branch 'move-all-configs-to-global-ee' into 'master'

Introduce default: for gitlab-ci.yml

See merge request gitlab-org/gitlab-ee!14091

changelogs/unreleased/move-all-configs-to-global.yml

+---
+title: 'Introduce default: for gitlab-ci.yml'
+merge_request:
+author:
+type: added

ee/lib/ee/gitlab/ci/config/entry/bridge.rb

@@ -50,6 +50,16 @@ module EE
             helpers(*ALLOWED_KEYS)
             attributes(*ALLOWED_KEYS)
 
+            def self.matching?(name, config)
+              ::Feature.enabled?(:cross_project_pipeline_triggers, default_enabled: true) &&
+                !name.to_s.start_with?('.') &&
+                config.is_a?(Hash) && config.key?(:trigger)
+            end
+
+            def self.visible?
+              true
+            end
+
             def name
               @metadata[:name]
             end

ee/lib/ee/gitlab/ci/config/entry/jobs.rb

@@ -6,28 +6,19 @@ module EE
       module Config
         module Entry
           module Jobs
-            extend ::Gitlab::Utils::Override
+            extend ActiveSupport::Concern
 
-            override :node_type
-            def node_type(name)
-              if hidden?(name)
-                ::Gitlab::Ci::Config::Entry::Hidden
-              elsif bridge?(name)
-                ::EE::Gitlab::Ci::Config::Entry::Bridge
-              else
-                ::Gitlab::Ci::Config::Entry::Job
-              end
+            prepended do
+              EE_TYPES = const_get(:TYPES) + [::EE::Gitlab::Ci::Config::Entry::Bridge]
             end
 
-            def bridge?(name)
-              config.fetch(name).yield_self do |value|
-                value.is_a?(Hash) && value.key?(:trigger) &&
-                  cross_project_triggers_enabled?
-              end
-            end
+            class_methods do
+              extend ::Gitlab::Utils::Override
 
-            def cross_project_triggers_enabled?
-              ::Feature.enabled?(:cross_project_pipeline_triggers, default_enabled: true)
+              override :all_types
+              def all_types
+                EE_TYPES
+              end
             end
           end
         end

ee/spec/lib/ee/gitlab/ci/config/entry/bridge_spec.rb

@@ -2,105 +2,145 @@ require 'fast_spec_helper'
 require_dependency 'active_model'
 
 describe EE::Gitlab::Ci::Config::Entry::Bridge do
-  subject { described_class.new(config, name: :my_trigger) }
+  describe '.matching?' do
+    subject { described_class.matching?(name, config) }
 
-  before do
-    subject.compose!
-  end
-
-  context 'when trigger config is a non-empty string' do
-    let(:config) { { trigger: 'some/project' } }
+    context 'when config is not a hash' do
+      let(:name) { :my_trigger }
+      let(:config) { 'string' }
 
-    describe '#valid?' do
-      it { is_expected.to be_valid }
+      it { is_expected.to be_falsey }
     end
 
-    describe '#value' do
-      it 'is returns a bridge job configuration' do
-        expect(subject.value).to eq(name: :my_trigger,
-                                    trigger: { project: 'some/project' },
-                                    ignore: false,
-                                    stage: 'test',
-                                    only: { refs: %w[branches tags] })
+    context 'when config is a regular job' do
+      let(:name) { :my_trigger }
+      let(:config) do
+        { script: 'ls -al' }
       end
-    end
-  end
 
-  context 'when bridge trigger is a hash' do
-    let(:config) do
-      { trigger: { project: 'some/project', branch: 'feature' } }
+      it { is_expected.to be_falsey }
     end
 
-    describe '#valid?' do
-      it { is_expected.to be_valid }
+    context 'when config is a bridge job' do
+      let(:name) { :my_trigger }
+      let(:config) do
+        { trigger: 'other-project' }
+      end
+
+      it { is_expected.to be_truthy }
     end
 
-    describe '#value' do
-      it 'is returns a bridge job configuration hash' do
-        expect(subject.value).to eq(name: :my_trigger,
-                                    trigger: { project: 'some/project',
-                                               branch: 'feature' },
-                                    ignore: false,
-                                    stage: 'test',
-                                    only: { refs: %w[branches tags] })
+    context 'when config is a hidden job' do
+      let(:name) { '.my_trigger' }
+      let(:config) do
+        { trigger: 'other-project' }
       end
+
+      it { is_expected.to be_falsey }
     end
   end
 
-  context 'when bridge configuration contains all supported keys' do
-    let(:config) do
-      { trigger: { project: 'some/project', branch: 'feature' },
-        when: 'always',
-        extends: '.some-key',
-        stage: 'deploy',
-        only: { variables: %w[$SOMEVARIABLE] },
-        except: { refs: %w[feature] },
-        variables: { VARIABLE: '123' } }
+  describe '.new' do
+    subject { described_class.new(config, name: :my_trigger) }
+
+    before do
+      subject.compose!
     end
 
-    it { is_expected.to be_valid }
-  end
+    context 'when trigger config is a non-empty string' do
+      let(:config) { { trigger: 'some/project' } }
 
-  context 'when trigger config is nil' do
-    let(:config) { { trigger: nil } }
+      describe '#valid?' do
+        it { is_expected.to be_valid }
+      end
 
-    describe '#valid?' do
-      it { is_expected.not_to be_valid }
+      describe '#value' do
+        it 'is returns a bridge job configuration' do
+          expect(subject.value).to eq(name: :my_trigger,
+                                      trigger: { project: 'some/project' },
+                                      ignore: false,
+                                      stage: 'test',
+                                      only: { refs: %w[branches tags] })
+        end
+      end
     end
 
-    describe '#errors' do
-      it 'is returns an error about empty trigger config' do
-        expect(subject.errors.first).to match /can't be blank/
+    context 'when bridge trigger is a hash' do
+      let(:config) do
+        { trigger: { project: 'some/project', branch: 'feature' } }
+      end
+
+      describe '#valid?' do
+        it { is_expected.to be_valid }
+      end
+
+      describe '#value' do
+        it 'is returns a bridge job configuration hash' do
+          expect(subject.value).to eq(name: :my_trigger,
+                                      trigger: { project: 'some/project',
+                                                branch: 'feature' },
+                                      ignore: false,
+                                      stage: 'test',
+                                      only: { refs: %w[branches tags] })
+        end
       end
     end
-  end
 
-  context 'when bridge config contains unknown keys' do
-    let(:config) { { unknown: 123 } }
+    context 'when bridge configuration contains all supported keys' do
+      let(:config) do
+        { trigger: { project: 'some/project', branch: 'feature' },
+          when: 'always',
+          extends: '.some-key',
+          stage: 'deploy',
+          only: { variables: %w[$SOMEVARIABLE] },
+          except: { refs: %w[feature] },
+          variables: { VARIABLE: '123' } }
+      end
 
-    describe '#valid?' do
-      it { is_expected.not_to be_valid }
+      it { is_expected.to be_valid }
     end
 
-    describe '#errors' do
-      it 'is returns an error about unknown config key' do
-        expect(subject.errors.first)
-          .to match /config contains unknown keys: unknown/
+    context 'when trigger config is nil' do
+      let(:config) { { trigger: nil } }
+
+      describe '#valid?' do
+        it { is_expected.not_to be_valid }
+      end
+
+      describe '#errors' do
+        it 'is returns an error about empty trigger config' do
+          expect(subject.errors.first).to match /can't be blank/
+        end
       end
     end
-  end
 
-  context 'when bridge config contains build-specific attributes' do
-    let(:config) { { script: 'something' } }
+    context 'when bridge config contains unknown keys' do
+      let(:config) { { unknown: 123 } }
+
+      describe '#valid?' do
+        it { is_expected.not_to be_valid }
+      end
 
-    describe '#valid?' do
-      it { is_expected.not_to be_valid }
+      describe '#errors' do
+        it 'is returns an error about unknown config key' do
+          expect(subject.errors.first)
+            .to match /config contains unknown keys: unknown/
+        end
+      end
     end
 
-    describe '#errors' do
-      it 'returns an error message' do
-        expect(subject.errors.first)
-          .to match /contains unknown keys: script/
+    context 'when bridge config contains build-specific attributes' do
+      let(:config) { { script: 'something' } }
+
+      describe '#valid?' do
+        it { is_expected.not_to be_valid }
+      end
+
+      describe '#errors' do
+        it 'returns an error message' do
+          expect(subject.errors.first)
+            .to match /contains unknown keys: script/
+        end
       end
     end
   end

ee/spec/lib/gitlab/ci/config/entry/jobs_spec.rb

 require 'spec_helper'
 
 describe Gitlab::Ci::Config::Entry::Jobs do
-  subject do
-    described_class.new(
-      {
-        '.hidden_job'.to_sym => { script: 'something' },
-        '.hidden_bridge'.to_sym => { trigger: 'my/project' },
-        regular_job: { script: 'something' },
-        my_trigger: { trigger: 'my/project' }
-      }
-    )
+  let(:config) do
+    {
+      '.hidden_job'.to_sym => { script: 'something' },
+      '.hidden_bridge'.to_sym => { trigger: 'my/project' },
+      regular_job: { script: 'something' },
+      my_trigger: { trigger: 'my/project' }
+    }
   end
 
-  context 'when cross-project pipeline triggers are enabled' do
-    before do
-      stub_feature_flags(cross_project_pipeline_triggers: true)
+  describe '.all_types' do
+    subject { described_class.all_types }
 
-      subject.compose!
-    end
-
-    describe '#node_type' do
-      it 'correctly identifies hidden jobs' do
-        expect(subject.node_type(:'.hidden_job'))
-          .to eq ::Gitlab::Ci::Config::Entry::Hidden
-      end
+    it { is_expected.to include(::EE::Gitlab::Ci::Config::Entry::Bridge) }
+  end
 
-      it 'correctly identifies hidden bridge jobs' do
-        expect(subject.node_type(:'.hidden_bridge'))
-          .to eq ::Gitlab::Ci::Config::Entry::Hidden
-      end
+  describe '.find_type' do
+    using RSpec::Parameterized::TableSyntax
 
-      it 'correctly identifies regular jobs' do
-        expect(subject.node_type(:regular_job))
-          .to eq ::Gitlab::Ci::Config::Entry::Job
-      end
+    subject { described_class.find_type(name, config[name]) }
 
-      it 'correctly identifies cross-project triggers' do
-        expect(subject.node_type(:my_trigger))
-          .to eq ::EE::Gitlab::Ci::Config::Entry::Bridge
+    context 'when cross-project pipeline triggers are enabled' do
+      before do
+        stub_feature_flags(cross_project_pipeline_triggers: true)
       end
-    end
 
-    describe '#bridge?' do
-      it 'returns true when a job is a trigger' do
-        expect(subject.bridge?(:my_trigger)).to be true
+      where(:name, :type) do
+        :'.hidden_job'    | ::Gitlab::Ci::Config::Entry::Hidden
+        :'.hidden_bridge' | ::Gitlab::Ci::Config::Entry::Hidden
+        :regular_job      | ::Gitlab::Ci::Config::Entry::Job
+        :my_trigger       | ::EE::Gitlab::Ci::Config::Entry::Bridge
       end
 
-      it 'returns false when a job is not a trigger' do
-        expect(subject.bridge?(:regular_job)).to be false
+      with_them do
+        it { is_expected.to eq(type) }
       end
     end
 
-    describe '#hidden?' do
-      it 'does not claim that a bridge job is hidden' do
-        expect(subject.hidden?(:my_trigger)).to be false
+    context 'when cross-project pipeline triggers are disabled' do
+      before do
+        stub_feature_flags(cross_project_pipeline_triggers: false)
       end
-    end
 
-    describe '#valid?' do
-      it { is_expected.to be_valid }
-    end
+      where(:name, :type) do
+        :'.hidden_job'    | ::Gitlab::Ci::Config::Entry::Hidden
+        :'.hidden_bridge' | ::Gitlab::Ci::Config::Entry::Hidden
+        :regular_job      | ::Gitlab::Ci::Config::Entry::Job
+        :my_trigger       | nil
+      end
 
-    describe '#value' do
-      it 'returns a correct hash representing all jobs' do
-        expect(subject.value).to eq(
-          my_trigger: {
-            name: :my_trigger,
-            trigger: { project: 'my/project' },
-            stage: 'test',
-            only: { refs: %w[branches tags] },
-            ignore: false
-          },
-          regular_job: {
-            script: %w[something],
-            name: :regular_job,
-            stage: 'test',
-            only: { refs: %w[branches tags] },
-            ignore: false
-          })
+      with_them do
+        it { is_expected.to eq(type) }
       end
     end
   end
 
-  context 'when cross-project pipeline triggers are disabled' do
-    before do
-      stub_feature_flags(cross_project_pipeline_triggers: false)
-
-      subject.compose!
+  describe '.new' do
+    subject do
+      described_class.new(config)
     end
 
-    describe '#node_type' do
-      it 'correctly identifies hidden jobs' do
-        expect(subject.node_type(:'.hidden_job'))
-          .to eq ::Gitlab::Ci::Config::Entry::Hidden
+    context 'when cross-project pipeline triggers are enabled' do
+      before do
+        stub_feature_flags(cross_project_pipeline_triggers: true)
+
+        subject.compose!
       end
 
-      it 'correctly identifies regular jobs' do
-        expect(subject.node_type(:regular_job))
-          .to eq ::Gitlab::Ci::Config::Entry::Job
+      describe '#valid?' do
+        it { is_expected.to be_valid }
       end
 
-      it 'does not identify trigger job as a bridge job' do
-        expect(subject.node_type(:my_trigger))
-          .to eq ::Gitlab::Ci::Config::Entry::Job
+      describe '#value' do
+        it 'returns a correct hash representing all jobs' do
+          expect(subject.value).to eq(
+            my_trigger: {
+              name: :my_trigger,
+              trigger: { project: 'my/project' },
+              stage: 'test',
+              only: { refs: %w[branches tags] },
+              ignore: false
+            },
+            regular_job: {
+              script: %w[something],
+              name: :regular_job,
+              stage: 'test',
+              only: { refs: %w[branches tags] },
+              variables: {},
+              ignore: false
+            })
+        end
       end
     end
 
-    describe '#bridge?' do
-      it 'returns false even when a job is a trigger' do
-        expect(subject.bridge?(:my_trigger)).to be false
-      end
+    context 'when cross-project pipeline triggers are disabled' do
+      before do
+        stub_feature_flags(cross_project_pipeline_triggers: false)
 
-      it 'returns false when a job is not a trigger' do
-        expect(subject.bridge?(:regular_job)).to be false
+        subject.compose!
       end
-    end
 
-    describe '#valid?' do
-      it { is_expected.not_to be_valid }
+      describe '#valid?' do
+        it { is_expected.not_to be_valid }
+      end
     end
   end
 end

lib/gitlab/ci/config.rb

@@ -14,23 +14,25 @@ module Gitlab
         External::Processor::IncludeError
       ].freeze
 
+      attr_reader :root
+
       def initialize(config, project: nil, sha: nil, user: nil)
         @config = Config::Extendable
           .new(build_config(config, project: project, sha: sha, user: user))
           .to_hash
 
-        @global = Entry::Global.new(@config)
-        @global.compose!
+        @root = Entry::Root.new(@config)
+        @root.compose!
       rescue *rescue_errors => e
         raise Config::ConfigError, e.message
       end
 
       def valid?
-        @global.valid?
+        @root.valid?
       end
 
       def errors
-        @global.errors
+        @root.errors
       end
 
       def to_hash
@@ -40,36 +42,16 @@ module Gitlab
       ##
       # Temporary method that should be removed after refactoring
       #
-      def before_script
-        @global.before_script_value
-      end
-
-      def image
-        @global.image_value
-      end
-
-      def services
-        @global.services_value
-      end
-
-      def after_script
-        @global.after_script_value
-      end
-
       def variables
-        @global.variables_value
+        root.variables_value
       end
 
       def stages
-        @global.stages_value
-      end
-
-      def cache
-        @global.cache_value
+        root.stages_value
       end
 
       def jobs
-        @global.jobs_value
+        root.jobs_value
       end
 
       private

lib/gitlab/ci/config/entry/default.rb

+# frozen_string_literal: true
+
+module Gitlab
+  module Ci
+    class Config
+      module Entry
+        ##
+        # This class represents a default entry
+        # Entry containing default values for all jobs
+        # defined in configuration file.
+        #
+        class Default < ::Gitlab::Config::Entry::Node
+          include ::Gitlab::Config::Entry::Configurable
+
+          DuplicateError = Class.new(Gitlab::Config::Loader::FormatError)
+
+          ALLOWED_KEYS = %i[before_script image services
+                            after_script cache].freeze
+
+          validations do
+            validates :config, allowed_keys: ALLOWED_KEYS
+          end
+
+          entry :before_script, Entry::Script,
+            description: 'Script that will be executed before each job.',
+            inherit: true
+
+          entry :image, Entry::Image,
+            description: 'Docker image that will be used to execute jobs.',
+            inherit: true
+
+          entry :services, Entry::Services,
+            description: 'Docker images that will be linked to the container.',
+            inherit: true
+
+          entry :after_script, Entry::Script,
+            description: 'Script that will be executed after each job.',
+            inherit: true
+
+          entry :cache, Entry::Cache,
+            description: 'Configure caching between build jobs.',
+            inherit: true
+
+          helpers :before_script, :image, :services, :after_script, :cache
+
+          def compose!(deps = nil)
+            super(self)
+
+            inherit!(deps)
+          end
+
+          private
+
+          def inherit!(deps)
+            return unless deps
+
+            self.class.nodes.each do |key, factory|
+              next unless factory.inheritable?
+
+              root_entry = deps[key]
+              next unless root_entry.specified?
+
+              if self[key].specified?
+                raise DuplicateError, "#{key} is defined in top-level and `default:` entry"
+              end
+
+              @entries[key] = root_entry
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/gitlab/ci/config/entry/hidden.rb

@@ -14,6 +14,14 @@ module Gitlab
             validates :config, presence: true
           end
 
+          def self.matching?(name, config)
+            name.to_s.start_with?('.')
+          end
+
+          def self.visible?
+            false
+          end
+
           def relevant?
             false
           end

lib/gitlab/ci/config/entry/job.rb

@@ -42,7 +42,8 @@ module Gitlab
           end
 
           entry :before_script, Entry::Script,
-            description: 'Global before script overridden in this job.'
+            description: 'Global before script overridden in this job.',
+            inherit: true
 
           entry :script, Entry::Commands,
             description: 'Commands that will be executed in this job.'
@@ -54,16 +55,20 @@ module Gitlab
             description: 'Deprecated: stage this job will be executed into.'
 
           entry :after_script, Entry::Script,
-            description: 'Commands that will be executed when finishing job.'
+            description: 'Commands that will be executed when finishing job.',
+            inherit: true
 
           entry :cache, Entry::Cache,
-            description: 'Cache definition for this job.'
+            description: 'Cache definition for this job.',
+            inherit: true
 
           entry :image, Entry::Image,
-            description: 'Image that will be used to execute this job.'
+            description: 'Image that will be used to execute this job.',
+            inherit: true
 
           entry :services, Entry::Services,
-            description: 'Services that will be used to execute this job.'
+            description: 'Services that will be used to execute this job.',
+            inherit: true
 
           entry :only, Entry::Policy,
             description: 'Refs policy this job will be executed for.',
@@ -95,6 +100,15 @@ module Gitlab
           attributes :script, :tags, :allow_failure, :when, :dependencies,
                      :retry, :parallel, :extends, :start_in
 
+          def self.matching?(name, config)
+            !name.to_s.start_with?('.') &&
+              config.is_a?(Hash) && config.key?(:script)
+          end
+
+          def self.visible?
+            true
+          end
+
           def compose!(deps = nil)
             super do
               if type_defined? && !stage_defined?
@@ -129,15 +143,19 @@ module Gitlab
 
           private
 
+          # We inherit config entries from `default:`
+          # if the entry has the `inherit: true` flag set
           def inherit!(deps)
             return unless deps
 
-            self.class.nodes.each_key do |key|
-              global_entry = deps[key]
+            self.class.nodes.each do |key, factory|
+              next unless factory.inheritable?
+
+              default_entry = deps.default[key]
               job_entry = self[key]
 
-              if global_entry.specified? && !job_entry.specified?
-                @entries[key] = global_entry
+              if default_entry.specified? && !job_entry.specified?
+                @entries[key] = default_entry
               end
             end
           end
@@ -152,7 +170,7 @@ module Gitlab
               cache: cache_value,
               only: only_value,
               except: except_value,
-              variables: variables_defined? ? variables_value : nil,
+              variables: variables_defined? ? variables_value : {},
               environment: environment_defined? ? environment_value : nil,
               environment_name: environment_defined? ? environment_value[:name] : nil,
               coverage: coverage_defined? ? coverage_value : nil,

lib/gitlab/ci/config/entry/jobs.rb

@@ -14,29 +14,48 @@ module Gitlab
             validates :config, type: Hash
 
             validate do
+              unless has_valid_jobs?
+                errors.add(:config, 'should contain valid jobs')
+              end
+
               unless has_visible_job?
                 errors.add(:config, 'should contain at least one visible job')
               end
             end
 
+            def has_valid_jobs?
+              config.all? do |name, value|
+                Jobs.find_type(name, value)
+              end
+            end
+
             def has_visible_job?
-              config.any? { |name, _| !hidden?(name) }
+              config.any? do |name, value|
+                Jobs.find_type(name, value)&.visible?
+              end
             end
           end
 
-          def hidden?(name)
-            name.to_s.start_with?('.')
+          TYPES = [Entry::Hidden, Entry::Job].freeze
+
+          private_constant :TYPES
+
+          def self.all_types
+            TYPES
           end
 
-          def node_type(name)
-            hidden?(name) ? Entry::Hidden : Entry::Job
+          def self.find_type(name, config)
+            self.all_types.find do |type|
+              type.matching?(name, config)
+            end
           end
 
           # rubocop: disable CodeReuse/ActiveRecord
           def compose!(deps = nil)
             super do
               @config.each do |name, config|
-                node = node_type(name)
+                node = self.class.find_type(name, config)
+                next unless node
 
                 factory = ::Gitlab::Config::Entry::Factory.new(node)
                   .value(config || {})

lib/gitlab/ci/config/entry/global.rb → lib/gitlab/ci/config/entry/root.rb

@@ -8,52 +8,107 @@ module Gitlab
         # This class represents a global entry - root Entry for entire
         # GitLab CI Configuration file.
         #
-        class Global < ::Gitlab::Config::Entry::Node
+        class Root < ::Gitlab::Config::Entry::Node
           include ::Gitlab::Config::Entry::Configurable
 
-          entry :before_script, Entry::Script,
-            description: 'Script that will be executed before each job.'
+          ALLOWED_KEYS = %i[default include before_script image services
+                            after_script variables stages types cache].freeze
 
-          entry :image, Entry::Image,
-            description: 'Docker image that will be used to execute jobs.'
+          validations do
+            validates :config, allowed_keys: ALLOWED_KEYS
+          end
+
+          # reserved:
+          #   defines whether the node name is reserved
+          #   the reserved name cannot be used a job name
+          #   reserved should not be used as it will make
+          #   breaking change to `.gitlab-ci.yml`
+
+          entry :default, Entry::Default,
+            description: 'Default configuration for all jobs.',
+            default: {}
 
           entry :include, Entry::Includes,
-                description: 'List of external YAML files to include.'
+            description: 'List of external YAML files to include.',
+            reserved: true
+
+          entry :before_script, Entry::Script,
+            description: 'Script that will be executed before each job.',
+            reserved: true
+
+          entry :image, Entry::Image,
+            description: 'Docker image that will be used to execute jobs.',
+            reserved: true
 
           entry :services, Entry::Services,
-            description: 'Docker images that will be linked to the container.'
+            description: 'Docker images that will be linked to the container.',
+            reserved: true
 
           entry :after_script, Entry::Script,
-            description: 'Script that will be executed after each job.'
+            description: 'Script that will be executed after each job.',
+            reserved: true
 
           entry :variables, Entry::Variables,
-            description: 'Environment variables that will be used.'
+            description: 'Environment variables that will be used.',
+            reserved: true
 
           entry :stages, Entry::Stages,
-            description: 'Configuration of stages for this pipeline.'
+            description: 'Configuration of stages for this pipeline.',
+            reserved: true
 
           entry :types, Entry::Stages,
-            description: 'Deprecated: stages for this pipeline.'
+            description: 'Deprecated: stages for this pipeline.',
+            reserved: true
 
           entry :cache, Entry::Cache,
-            description: 'Configure caching between build jobs.'
+            description: 'Configure caching between build jobs.',
+            reserved: true
+
+          helpers :default, :jobs, :stages, :types, :variables
+
+          delegate :before_script_value,
+                   :image_value,
+                   :services_value,
+                   :after_script_value,
+                   :cache_value, to: :default
 
-          helpers :before_script, :image, :services, :after_script,
-                  :variables, :stages, :types, :cache, :jobs
+          attr_reader :jobs_config
+
+          class << self
+            include ::Gitlab::Utils::StrongMemoize
+
+            def reserved_nodes_names
+              strong_memoize(:reserved_nodes_names) do
+                self.nodes.select do |_, node|
+                  node.reserved?
+                end.keys
+              end
+            end
+          end
+
+          def initialize(config, **metadata)
+            super do
+              filter_jobs!
+            end
+          end
 
           def compose!(_deps = nil)
             super(self) do
-              compose_jobs!
               compose_deprecated_entries!
+              compose_jobs!
             end
           end
 
+          def default
+            self[:default]
+          end
+
           private
 
           # rubocop: disable CodeReuse/ActiveRecord
           def compose_jobs!
             factory = ::Gitlab::Config::Entry::Factory.new(Entry::Jobs)
-              .value(@config.except(*self.class.nodes.keys))
+              .value(jobs_config)
               .with(key: :jobs, parent: self,
                     description: 'Jobs definition for this pipeline')
 
@@ -72,6 +127,18 @@ module Gitlab
 
             @entries.delete(:types)
           end
+
+          def filter_jobs!
+            return unless @config.is_a?(Hash)
+
+            @jobs_config = @config
+              .except(*self.class.reserved_nodes_names)  # rubocop: disable CodeReuse/ActiveRecord
+              .select do |name, config|
+              Entry::Jobs.find_type(name, config).present?
+            end
+
+            @config = @config.except(*@jobs_config.keys) # rubocop: disable CodeReuse/ActiveRecord
+          end
         end
       end
     end

lib/gitlab/ci/yaml_processor.rb

@@ -7,7 +7,7 @@ module Gitlab
 
       include Gitlab::Config::Entry::LegacyValidationHelpers
 
-      attr_reader :cache, :stages, :jobs
+      attr_reader :stages, :jobs
 
       def initialize(config, opts = {})
         @ci_config = Gitlab::Ci::Config.new(config, **opts)
@@ -95,13 +95,8 @@ module Gitlab
         ##
         # 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

lib/gitlab/config/entry/configurable.rb

@@ -58,13 +58,21 @@ module Gitlab
             Hash[(@nodes || {}).map { |key, factory| [key, factory.dup] }]
           end
 
+          def reserved_node_names
+            self.nodes.select do |_, node|
+              node.reserved?
+            end.keys
+          end
+
           private
 
           # rubocop: disable CodeReuse/ActiveRecord
-          def entry(key, entry, metadata)
+          def entry(key, entry, description: nil, default: nil, inherit: nil, reserved: nil)
             factory = ::Gitlab::Config::Entry::Factory.new(entry)
-              .with(description: metadata[:description])
-              .with(default: metadata[:default])
+              .with(description: description)
+              .with(default: default)
+              .with(inherit: inherit)
+              .with(reserved: reserved)
 
             (@nodes ||= {}).merge!(key.to_sym => factory)
           end

lib/gitlab/config/entry/factory.rb

@@ -30,6 +30,18 @@ module Gitlab
           self
         end
 
+        def description
+          @attributes[:description]
+        end
+
+        def inheritable?
+          @attributes[:inherit]
+        end
+
+        def reserved?
+          @attributes[:reserved]
+        end
+
         def create!
           raise InvalidFactory unless defined?(@value)
 

spec/controllers/projects/ci/lints_controller_spec.rb

@@ -107,7 +107,7 @@ describe Projects::Ci::LintsController do
       end
 
       it 'assigns errors' do
-        expect(assigns[:error]).to eq('jobs:rubocop config contains unknown keys: scriptt')
+        expect(assigns[:error]).to eq('root config contains unknown keys: rubocop')
       end
     end
 

spec/lib/gitlab/ci/config/entry/default_spec.rb

+require 'spec_helper'
+
+describe Gitlab::Ci::Config::Entry::Default do
+  let(:entry) { described_class.new(config) }
+
+  describe '.nodes' do
+    it 'returns a hash' do
+      expect(described_class.nodes).to be_a(Hash)
+    end
+
+    context 'when filtering all the entry/node names' do
+      it 'contains the expected node names' do
+        expect(described_class.nodes.keys)
+          .to match_array(%i[before_script image services
+                             after_script cache])
+      end
+    end
+  end
+
+  describe 'validations' do
+    before do
+      entry.compose!
+    end
+
+    context 'when default entry value is correct' do
+      let(:config) { { before_script: ['rspec'] } }
+
+      describe '#valid?' do
+        it 'is valid' do
+          expect(entry).to be_valid
+        end
+      end
+    end
+
+    context 'when default entry is empty' do
+      let(:config) { {} }
+
+      describe '#valid' do
+        it 'is valid' do
+          expect(entry).to be_valid
+        end
+      end
+    end
+
+    context 'when default entry is not correct' do
+      context 'incorrect config value type' do
+        let(:config) { ['incorrect'] }
+
+        describe '#errors' do
+          it 'reports error about a config type' do
+            expect(entry.errors)
+              .to include 'default config should be a hash'
+          end
+        end
+      end
+
+      context 'when unknown keys detected' do
+        let(:config) { { unknown: true } }
+
+        describe '#valid' do
+          it 'is not valid' do
+            expect(entry).not_to be_valid
+          end
+        end
+      end
+    end
+  end
+
+  describe '#compose!' do
+    let(:specified) do
+      double('specified', 'specified?' => true, value: 'specified')
+    end
+
+    let(:unspecified) { double('unspecified', 'specified?' => false) }
+    let(:deps) { double('deps', '[]' => unspecified) }
+
+    context 'when default entry inherits configuration from root' do
+      let(:config) do
+        { image: 'some_image' }
+      end
+
+      before do
+        allow(deps).to receive('[]').with(:image).and_return(specified)
+      end
+
+      it 'raises error' do
+        expect { entry.compose!(deps) }.to raise_error(
+          Gitlab::Ci::Config::Entry::Default::DuplicateError)
+      end
+    end
+
+    context 'when default entry inherits a non-defined configuration from root' do
+      let(:config) do
+        { image: 'some_image' }
+      end
+
+      before do
+        allow(deps).to receive('[]').with(:after_script).and_return(specified)
+
+        entry.compose!(deps)
+      end
+
+      it 'inherits non-defined configuration entries' do
+        expect(entry[:image].value).to eq(name: 'some_image')
+        expect(entry[:after_script].value).to eq('specified')
+      end
+    end
+  end
+end

spec/lib/gitlab/ci/config/entry/hidden_spec.rb

 require 'spec_helper'
 
 describe Gitlab::Ci::Config::Entry::Hidden do
-  let(:entry) { described_class.new(config) }
+  describe '.matching?' do
+    subject { described_class.matching?(name, {}) }
 
-  describe 'validations' do
-    context 'when entry config value is correct' do
-      let(:config) { [:some, :array] }
+    context 'when name starts with dot' do
+      let(:name) { '.hidden_job' }
 
-      describe '#value' do
-        it 'returns key value' do
-          expect(entry.value).to eq [:some, :array]
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when name does not start with dot' do
+      let(:name) { 'rspec' }
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
+  describe '.new' do
+    let(:entry) { described_class.new(config) }
+
+    describe 'validations' do
+      context 'when entry config value is correct' do
+        let(:config) { [:some, :array] }
+
+        describe '#value' do
+          it 'returns key value' do
+            expect(entry.value).to eq [:some, :array]
+          end
         end
-      end
 
-      describe '#valid?' do
-        it 'is valid' do
-          expect(entry).to be_valid
+        describe '#valid?' do
+          it 'is valid' do
+            expect(entry).to be_valid
+          end
         end
       end
-    end
 
-    context 'when entry value is not correct' do
-      context 'when config is empty' do
-        let(:config) { {} }
+      context 'when entry value is not correct' do
+        context 'when config is empty' do
+          let(:config) { {} }
 
-        describe '#valid' do
-          it 'is invalid' do
-            expect(entry).not_to be_valid
+          describe '#valid' do
+            it 'is invalid' do
+              expect(entry).not_to be_valid
+            end
           end
         end
       end
     end
-  end
 
-  describe '#leaf?' do
-    it 'is a leaf' do
-      expect(entry).to be_leaf
+    describe '#leaf?' do
+      it 'is a leaf' do
+        expect(entry).to be_leaf
+      end
     end
-  end
 
-  describe '#relevant?' do
-    it 'is not a relevant entry' do
-      expect(entry).not_to be_relevant
+    describe '#relevant?' do
+      it 'is not a relevant entry' do
+        expect(entry).not_to be_relevant
+      end
     end
   end
 end

spec/lib/gitlab/ci/config/entry/job_spec.rb

@@ -17,6 +17,44 @@ describe Gitlab::Ci::Config::Entry::Job do
     end
   end
 
+  describe '.matching?' do
+    subject { described_class.matching?(name, config) }
+
+    context 'when config is not a hash' do
+      let(:name) { :rspec }
+      let(:config) { 'string' }
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when config is a regular job' do
+      let(:name) { :rspec }
+      let(:config) do
+        { script: 'ls -al' }
+      end
+
+      it { is_expected.to be_truthy }
+    end
+
+    context 'when config is a bridge job' do
+      let(:name) { :rspec }
+      let(:config) do
+        { trigger: 'other-project' }
+      end
+
+      it { is_expected.to be_falsey }
+    end
+
+    context 'when config is a hidden job' do
+      let(:name) { '.rspec' }
+      let(:config) do
+        { script: 'ls -al' }
+      end
+
+      it { is_expected.to be_falsey }
+    end
+  end
+
   describe 'validations' do
     before do
       entry.compose!
@@ -235,15 +273,15 @@ describe Gitlab::Ci::Config::Entry::Job do
   end
 
   describe '#compose!' do
-    let(:unspecified) { double('unspecified', 'specified?' => false) }
-
     let(:specified) do
       double('specified', 'specified?' => true, value: 'specified')
     end
 
-    let(:deps) { double('deps', '[]' => unspecified) }
+    let(:unspecified) { double('unspecified', 'specified?' => false) }
+    let(:default) { double('default', '[]' => unspecified) }
+    let(:deps) { double('deps', 'default' => default, '[]' => unspecified) }
 
-    context 'when job config overrides global config' do
+    context 'when job config overrides default config' do
       before do
         entry.compose!(deps)
       end
@@ -252,21 +290,22 @@ describe Gitlab::Ci::Config::Entry::Job do
         { script: 'rspec', image: 'some_image', cache: { key: 'test' } }
       end
 
-      it 'overrides global config' do
+      it 'overrides default config' do
         expect(entry[:image].value).to eq(name: 'some_image')
         expect(entry[:cache].value).to eq(key: 'test', policy: 'pull-push')
       end
     end
 
-    context 'when job config does not override global config' do
+    context 'when job config does not override default config' do
       before do
-        allow(deps).to receive('[]').with(:image).and_return(specified)
+        allow(default).to receive('[]').with(:image).and_return(specified)
+
         entry.compose!(deps)
       end
 
       let(:config) { { script: 'ls', cache: { key: 'test' } } }
 
-      it 'uses config from global entry' do
+      it 'uses config from default entry' do
         expect(entry[:image].value).to eq 'specified'
         expect(entry[:cache].value).to eq(key: 'test', policy: 'pull-push')
       end
@@ -298,7 +337,8 @@ describe Gitlab::Ci::Config::Entry::Job do
                    stage: 'test',
                    ignore: false,
                    after_script: %w[cleanup],
-                   only: { refs: %w[branches tags] })
+                   only: { refs: %w[branches tags] },
+                   variables: {})
         end
       end
     end

spec/lib/gitlab/ci/config/entry/jobs_spec.rb

@@ -3,6 +3,37 @@ require 'spec_helper'
 describe Gitlab::Ci::Config::Entry::Jobs do
   let(:entry) { described_class.new(config) }
 
+  describe '.all_types' do
+    subject { described_class.all_types }
+
+    it { is_expected.to include(::Gitlab::Ci::Config::Entry::Hidden) }
+    it { is_expected.to include(::Gitlab::Ci::Config::Entry::Job) }
+  end
+
+  describe '.find_type' do
+    using RSpec::Parameterized::TableSyntax
+
+    let(:config) do
+      {
+        '.hidden_job'.to_sym => { script: 'something' },
+        regular_job: { script: 'something' },
+        invalid_job: 'text'
+      }
+    end
+
+    where(:name, :type) do
+      :'.hidden_job'    | ::Gitlab::Ci::Config::Entry::Hidden
+      :regular_job      | ::Gitlab::Ci::Config::Entry::Job
+      :invalid_job      | nil
+    end
+
+    subject { described_class.find_type(name, config[name]) }
+
+    with_them do
+      it { is_expected.to eq(type) }
+    end
+  end
+
   describe 'validations' do
     before do
       entry.compose!
@@ -29,11 +60,11 @@ describe Gitlab::Ci::Config::Entry::Jobs do
           end
         end
 
-        context 'when job is unspecified' do
+        context 'when job is invalid' do
           let(:config) { { rspec: nil } }
 
           it 'reports error' do
-            expect(entry.errors).to include "rspec config can't be blank"
+            expect(entry.errors).to include "jobs config should contain valid jobs"
           end
         end
 
@@ -49,46 +80,50 @@ describe Gitlab::Ci::Config::Entry::Jobs do
     end
   end
 
-  context 'when valid job entries composed' do
-    before do
-      entry.compose!
-    end
+  describe '.compose!' do
+    context 'when valid job entries composed' do
+      before do
+        entry.compose!
+      end
 
-    let(:config) do
-      { rspec: { script: 'rspec' },
-        spinach: { script: 'spinach' },
-        '.hidden'.to_sym => {} }
-    end
+      let(:config) do
+        { rspec: { script: 'rspec' },
+          spinach: { script: 'spinach' },
+          '.hidden'.to_sym => {} }
+      end
 
-    describe '#value' do
-      it 'returns key value' do
-        expect(entry.value).to eq(
-          rspec: { name: :rspec,
-                   script: %w[rspec],
-                   ignore: false,
-                   stage: 'test',
-                   only: { refs: %w[branches tags] } },
-          spinach: { name: :spinach,
-                     script: %w[spinach],
-                     ignore: false,
-                     stage: 'test',
-                     only: { refs: %w[branches tags] } })
+      describe '#value' do
+        it 'returns key value' do
+          expect(entry.value).to eq(
+            rspec: { name: :rspec,
+                    script: %w[rspec],
+                    ignore: false,
+                    stage: 'test',
+                    only: { refs: %w[branches tags] },
+                    variables: {} },
+            spinach: { name: :spinach,
+                      script: %w[spinach],
+                      ignore: false,
+                      stage: 'test',
+                      only: { refs: %w[branches tags] },
+                      variables: {} })
+        end
       end
-    end
 
-    describe '#descendants' do
-      it 'creates valid descendant nodes' do
-        expect(entry.descendants.count).to eq 3
-        expect(entry.descendants.first(2))
-          .to all(be_an_instance_of(Gitlab::Ci::Config::Entry::Job))
-        expect(entry.descendants.last)
-          .to be_an_instance_of(Gitlab::Ci::Config::Entry::Hidden)
+      describe '#descendants' do
+        it 'creates valid descendant nodes' do
+          expect(entry.descendants.count).to eq 3
+          expect(entry.descendants.first(2))
+            .to all(be_an_instance_of(Gitlab::Ci::Config::Entry::Job))
+          expect(entry.descendants.last)
+            .to be_an_instance_of(Gitlab::Ci::Config::Entry::Hidden)
+        end
       end
-    end
 
-    describe '#value' do
-      it 'returns value of visible jobs only' do
-        expect(entry.value.keys).to eq [:rspec, :spinach]
+      describe '#value' do
+        it 'returns value of visible jobs only' do
+          expect(entry.value.keys).to eq [:rspec, :spinach]
+        end
       end
     end
   end

spec/lib/gitlab/ci/pipeline/chain/validate/config_spec.rb

@@ -77,7 +77,14 @@ describe Gitlab::Ci::Pipeline::Chain::Validate::Config do
   end
 
   context 'when pipeline contains configuration validation errors' do
-    let(:config) { { rspec: {} } }
+    let(:config) do
+      {
+        rspec: {
+          before_script: 10,
+          script: 'ls -al'
+        }
+      }
+    end
 
     let(:pipeline) do
       build(:ci_pipeline, project: project, config: config)
@@ -85,7 +92,7 @@ describe Gitlab::Ci::Pipeline::Chain::Validate::Config do
 
     it 'appends configuration validation errors to pipeline errors' do
       expect(pipeline.errors.to_a)
-        .to include "jobs:rspec config can't be blank"
+        .to include "jobs:rspec:before_script config should be an array of strings"
     end
 
     it 'breaks the chain' do

spec/lib/gitlab/ci/yaml_processor_spec.rb

@@ -265,6 +265,19 @@ module Gitlab
             end
           end
 
+          context "in default context" do
+            let(:config) do
+              {
+                default: { before_script: ["global script"] },
+                test: { script: ["script"] }
+              }
+            end
+
+            it "return commands with scripts concencaced" do
+              expect(subject[:options][:before_script]).to eq(["global script"])
+            end
+          end
+
           context "overwritten in local context" do
             let(:config) do
               {
@@ -305,6 +318,19 @@ module Gitlab
             end
           end
 
+          context "in default context" do
+            let(:config) do
+              {
+                after_script: ["after_script"],
+                test: { script: ["script"] }
+              }
+            end
+
+            it "return after_script in options" do
+              expect(subject[:options][:after_script]).to eq(["after_script"])
+            end
+          end
+
           context "overwritten in local context" do
             let(:config) do
               {
@@ -774,6 +800,28 @@ module Gitlab
           )
         end
 
+        it "returns cache when defined in default context" do
+          config = YAML.dump(
+            {
+              default: {
+                cache: { paths: ["logs/", "binaries/"], untracked: true, key: 'key' }
+              },
+              rspec: {
+                script: "rspec"
+              }
+            })
+
+          config_processor = Gitlab::Ci::YamlProcessor.new(config)
+
+          expect(config_processor.stage_builds_attributes("test").size).to eq(1)
+          expect(config_processor.stage_builds_attributes("test").first[:options][:cache]).to eq(
+            paths: ["logs/", "binaries/"],
+            untracked: true,
+            key: 'key',
+            policy: 'pull-push'
+          )
+        end
+
         it "returns cache when defined in a job" do
           config = YAML.dump({
                                rspec: {
@@ -1271,7 +1319,7 @@ module Gitlab
           config = YAML.dump({ extra: "bundle update" })
           expect do
             Gitlab::Ci::YamlProcessor.new(config)
-          end.to raise_error(Gitlab::Ci::YamlProcessor::ValidationError, "jobs:extra config should be a hash")
+          end.to raise_error(Gitlab::Ci::YamlProcessor::ValidationError, "root config contains unknown keys: extra")
         end
 
         it "returns errors if services configuration is not correct" do

spec/lib/gitlab/config/entry/configurable_spec.rb

@@ -34,18 +34,25 @@ describe Gitlab::Config::Entry::Configurable do
 
     before do
       entry.class_exec(entry_class) do |entry_class|
-        entry :object, entry_class, description: 'test object'
+        entry :object, entry_class,
+          description: 'test object',
+          inherit: true,
+          reserved: true
       end
     end
 
     describe '.nodes' do
       it 'has valid nodes' do
-        expect(entry.nodes).to include :object
+        expect(entry.nodes).to include(:object)
       end
 
       it 'creates a node factory' do
-        expect(entry.nodes[:object])
-          .to be_an_instance_of Gitlab::Config::Entry::Factory
+        factory = entry.nodes[:object]
+
+        expect(factory).to be_an_instance_of(Gitlab::Config::Entry::Factory)
+        expect(factory.description).to eq('test object')
+        expect(factory.inheritable?).to eq(true)
+        expect(factory.reserved?).to eq(true)
       end
 
       it 'returns a duplicated factory object' do
@@ -55,5 +62,17 @@ describe Gitlab::Config::Entry::Configurable do
         expect(first_factory).not_to be_equal(second_factory)
       end
     end
+
+    describe '.reserved_node_names' do
+      before do
+        entry.class_exec(entry_class) do |entry_class|
+          entry :not_reserved, entry_class
+        end
+      end
+
+      it 'returns all nodes with reserved: true' do
+        expect(entry.reserved_node_names).to contain_exactly(:object)
+      end
+    end
   end
 end

spec/lib/gitlab/config/entry/factory_spec.rb

@@ -23,17 +23,36 @@ describe Gitlab::Config::Entry::Factory do
       end
 
       context 'when setting description' do
-        it 'creates entry with description' do
-          entry = factory
+        before do
+          factory
             .value(%w(ls pwd))
             .with(description: 'test description')
-            .create!
+        end
+
+        it 'configures description' do
+          expect(factory.description).to eq 'test description'
+        end
+
+        it 'creates entry with description' do
+          entry = factory.create!
 
           expect(entry.value).to eq %w(ls pwd)
           expect(entry.description).to eq 'test description'
         end
       end
 
+      context 'when setting inherit' do
+        before do
+          factory
+            .value(%w(ls pwd))
+            .with(inherit: true)
+        end
+
+        it 'makes object inheritable' do
+          expect(factory.inheritable?).to eq true
+        end
+      end
+
       context 'when setting key' do
         it 'creates entry with custom key' do
           entry = factory