Add latest changes from gitlab-org/gitlab@master

4 files changed, 169 insertions, 48 deletions

diff --git a/spec/lib/gitlab/email/receiver_spec.rb b/spec/lib/gitlab/email/receiver_spec.rb
index 43c73242f5f..018219e5647 100644
--- a/spec/lib/gitlab/email/receiver_spec.rb
+++ b/spec/lib/gitlab/email/receiver_spec.rb
@@ -5,22 +5,27 @@ require 'spec_helper'
 describe Gitlab::Email::Receiver do
   include_context :email_shared_context
 
-  context "when the email contains a valid email address in a Delivered-To header" do
-    let(:email_raw) { fixture_file('emails/forwarded_new_issue.eml') }
+  context 'when the email contains a valid email address in a header' do
     let(:handler) { double(:handler) }
 
     before do
-      stub_incoming_email_setting(enabled: true, address: "incoming+%{key}@appmail.adventuretime.ooo")
-
       allow(handler).to receive(:execute)
       allow(handler).to receive(:metrics_params)
       allow(handler).to receive(:metrics_event)
+
+      stub_incoming_email_setting(enabled: true, address: "incoming+%{key}@appmail.example.com")
+    end
+
+    context 'when in a Delivered-To header' do
+      let(:email_raw) { fixture_file('emails/forwarded_new_issue.eml') }
+
+      it_behaves_like 'correctly finds the mail key'
     end
 
-    it "finds the mail key" do
-      expect(Gitlab::Email::Handler).to receive(:for).with(an_instance_of(Mail::Message), 'gitlabhq/gitlabhq+auth_token').and_return(handler)
+    context 'when in an Envelope-To header' do
+      let(:email_raw) { fixture_file('emails/envelope_to_header.eml') }
 
-      receiver.execute
+      it_behaves_like 'correctly finds the mail key'
     end
   end
 
diff --git a/spec/lib/gitlab/gitaly_client_spec.rb b/spec/lib/gitlab/gitaly_client_spec.rb
index 0d9719a5663..ebf56c0ae66 100644
--- a/spec/lib/gitlab/gitaly_client_spec.rb
+++ b/spec/lib/gitlab/gitaly_client_spec.rb
@@ -229,6 +229,59 @@ describe Gitlab::GitalyClient do
         end
       end
     end
+
+    context 'deadlines', :request_store do
+      let(:request_deadline) { real_time + 10.0 }
+
+      before do
+        allow(Gitlab::RequestContext.instance).to receive(:request_deadline).and_return(request_deadline)
+      end
+
+      it 'includes the deadline information' do
+        kword_args = described_class.request_kwargs('default', timeout: 2)
+
+        expect(kword_args[:deadline])
+          .to be_within(1).of(real_time + 2)
+        expect(kword_args[:metadata][:deadline_type]).to eq("regular")
+      end
+
+      it 'limits the deadline do the request deadline if that is closer', :aggregate_failures do
+        kword_args = described_class.request_kwargs('default', timeout: 15)
+
+        expect(kword_args[:deadline]).to eq(request_deadline)
+        expect(kword_args[:metadata][:deadline_type]).to eq("limited")
+      end
+
+      it 'does not limit calls in sidekiq' do
+        expect(Sidekiq).to receive(:server?).and_return(true)
+
+        kword_args = described_class.request_kwargs('default', timeout: 6.hours.to_i)
+
+        expect(kword_args[:deadline]).to be_within(1).of(real_time + 6.hours.to_i)
+        expect(kword_args[:metadata][:deadline_type]).to be_nil
+      end
+
+      it 'does not limit calls in sidekiq when allowed unlimited' do
+        expect(Sidekiq).to receive(:server?).and_return(true)
+
+        kword_args = described_class.request_kwargs('default', timeout: 0)
+
+        expect(kword_args[:deadline]).to be_nil
+        expect(kword_args[:metadata][:deadline_type]).to be_nil
+      end
+
+      it 'includes only the deadline specified by the timeout when there was no deadline' do
+        allow(Gitlab::RequestContext.instance).to receive(:request_deadline).and_return(nil)
+        kword_args = described_class.request_kwargs('default', timeout: 6.hours.to_i)
+
+        expect(kword_args[:deadline]).to be_within(1).of(Gitlab::Metrics::System.real_time + 6.hours.to_i)
+        expect(kword_args[:metadata][:deadline_type]).to be_nil
+      end
+
+      def real_time
+        Gitlab::Metrics::System.real_time
+      end
+    end
   end
 
   describe 'enforce_gitaly_request_limits?' do
diff --git a/spec/lib/gitlab/middleware/request_context_spec.rb b/spec/lib/gitlab/middleware/request_context_spec.rb
new file mode 100644
index 00000000000..1ed06a97c1e
--- /dev/null
+++ b/spec/lib/gitlab/middleware/request_context_spec.rb
@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require 'fast_spec_helper'
+require 'rack'
+require 'request_store'
+require_relative '../../../support/helpers/next_instance_of'
+
+describe Gitlab::Middleware::RequestContext do
+  include NextInstanceOf
+
+  let(:app) { -> (env) {} }
+  let(:env) { {} }
+
+  around do |example|
+    RequestStore.begin!
+    example.run
+    RequestStore.end!
+    RequestStore.clear!
+  end
+
+  describe '#call' do
+    context 'setting the client ip' do
+      subject { Gitlab::RequestContext.instance.client_ip }
+
+      context 'with X-Forwarded-For headers' do
+        let(:load_balancer_ip) { '1.2.3.4' }
+        let(:headers) do
+          {
+            'HTTP_X_FORWARDED_FOR' => "#{load_balancer_ip}, 127.0.0.1",
+            'REMOTE_ADDR' => '127.0.0.1'
+          }
+        end
+
+        let(:env) { Rack::MockRequest.env_for("/").merge(headers) }
+
+        it 'returns the load balancer IP' do
+          endpoint = proc do
+            [200, {}, ["Hello"]]
+          end
+
+          described_class.new(endpoint).call(env)
+
+          expect(subject).to eq(load_balancer_ip)
+        end
+      end
+
+      context 'request' do
+        let(:ip) { '192.168.1.11' }
+
+        before do
+          allow_next_instance_of(Rack::Request) do |instance|
+            allow(instance).to receive(:ip).and_return(ip)
+          end
+          described_class.new(app).call(env)
+        end
+
+        it { is_expected.to eq(ip) }
+      end
+
+      context 'before RequestContext middleware run' do
+        it { is_expected.to be_nil }
+      end
+    end
+  end
+
+  context 'setting the thread cpu time' do
+    it 'sets the `start_thread_cpu_time`' do
+      expect { described_class.new(app).call(env) }
+        .to change { Gitlab::RequestContext.instance.start_thread_cpu_time }.from(nil).to(Float)
+    end
+  end
+
+  context 'setting the request start time' do
+    it 'sets the `request_start_time`' do
+      expect { described_class.new(app).call(env) }
+        .to change { Gitlab::RequestContext.instance.request_start_time }.from(nil).to(Float)
+    end
+  end
+end
diff --git a/spec/lib/gitlab/request_context_spec.rb b/spec/lib/gitlab/request_context_spec.rb
index 87b8029de2e..1290071549d 100644
--- a/spec/lib/gitlab/request_context_spec.rb
+++ b/spec/lib/gitlab/request_context_spec.rb
@@ -2,59 +2,44 @@
 
 require 'spec_helper'
 
-describe Gitlab::RequestContext do
-  describe '#client_ip' do
-    subject { described_class.client_ip }
+describe Gitlab::RequestContext, :request_store do
+  subject { described_class.instance }
 
-    let(:app) { -> (env) {} }
-    let(:env) { Hash.new }
+  it { is_expected.to have_attributes(client_ip: nil, start_thread_cpu_time: nil, request_start_time: nil) }
 
-    context 'with X-Forwarded-For headers', :request_store do
-      let(:load_balancer_ip) { '1.2.3.4' }
-      let(:headers) do
-        {
-          'HTTP_X_FORWARDED_FOR' => "#{load_balancer_ip}, 127.0.0.1",
-          'REMOTE_ADDR' => '127.0.0.1'
-        }
-      end
+  describe '#request_deadline' do
+    let(:request_start_time) { 1575982156.206008 }
 
-      let(:env) { Rack::MockRequest.env_for("/").merge(headers) }
+    it "sets the time to #{Settings.gitlab.max_request_duration_seconds} seconds in the future" do
+      allow(subject).to receive(:request_start_time).and_return(request_start_time)
 
-      it 'returns the load balancer IP' do
-        client_ip = nil
-
-        endpoint = proc do
-          client_ip = Gitlab::SafeRequestStore[:client_ip]
-          [200, {}, ["Hello"]]
-        end
+      expect(subject.request_deadline).to eq(1575982156.206008 + Settings.gitlab.max_request_duration_seconds)
+      expect(subject.request_deadline).to be_a(Float)
+    end
 
-        described_class.new(endpoint).call(env)
+    it 'returns nil if there is no start time' do
+      allow(subject).to receive(:request_start_time).and_return(nil)
 
-        expect(client_ip).to eq(load_balancer_ip)
-      end
+      expect(subject.request_deadline).to be_nil
     end
+  end
 
-    context 'when RequestStore::Middleware is used' do
-      around do |example|
-        RequestStore::Middleware.new(-> (env) { example.run }).call({})
-      end
+  describe '#ensure_request_deadline_not_exceeded!' do
+    it 'does not raise an error when there was no deadline' do
+      expect(subject).to receive(:request_deadline).and_return(nil)
+      expect { subject.ensure_deadline_not_exceeded! }.not_to raise_error
+    end
 
-      context 'request' do
-        let(:ip) { '192.168.1.11' }
+    it 'does not raise an error if the deadline is in the future' do
+      allow(subject).to receive(:request_deadline).and_return(Gitlab::Metrics::System.real_time + 10)
 
-        before do
-          allow_next_instance_of(Rack::Request) do |instance|
-            allow(instance).to receive(:ip).and_return(ip)
-          end
-          described_class.new(app).call(env)
-        end
+      expect { subject.ensure_deadline_not_exceeded! }.not_to raise_error
+    end
 
-        it { is_expected.to eq(ip) }
-      end
+    it 'raises an error when the deadline is in the past' do
+      allow(subject).to receive(:request_deadline).and_return(Gitlab::Metrics::System.real_time - 10)
 
-      context 'before RequestContext middleware run' do
-        it { is_expected.to be_nil }
-      end
+      expect { subject.ensure_deadline_not_exceeded! }.to raise_error(described_class::RequestDeadlineExceeded)
     end
   end
 end