Merge branch '42643-persist-external-ip-of-ingress-controller-gke' into 'master'

Display ingress IP address in the Kubernetes page

See merge request gitlab-org/gitlab-ce!17052

10 files changed, 266 insertions, 14 deletions

diff --git a/spec/controllers/projects/clusters_controller_spec.rb b/spec/controllers/projects/clusters_controller_spec.rb
index 954fc79f57d..15ce418d0d6 100644
--- a/spec/controllers/projects/clusters_controller_spec.rb
+++ b/spec/controllers/projects/clusters_controller_spec.rb
@@ -91,6 +91,12 @@ describe Projects::ClustersController do
         expect(response).to have_gitlab_http_status(:ok)
         expect(response).to match_response_schema('cluster_status')
       end
+
+      it 'invokes schedule_status_update on each application' do
+        expect_any_instance_of(Clusters::Applications::Ingress).to receive(:schedule_status_update)
+
+        go
+      end
     end
 
     describe 'security' do
diff --git a/spec/features/projects/clusters/applications_spec.rb b/spec/features/projects/clusters/applications_spec.rb
index 8d1e10b7191..7b2c57aa652 100644
--- a/spec/features/projects/clusters/applications_spec.rb
+++ b/spec/features/projects/clusters/applications_spec.rb
@@ -22,7 +22,7 @@ feature 'Clusters Applications', :js do
       scenario 'user is unable to install applications' do
         page.within('.js-cluster-application-row-helm') do
           expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
-          expect(page.find(:css, '.js-cluster-application-install-button').text).to eq('Install')
+          expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Install')
         end
       end
     end
@@ -33,13 +33,13 @@ feature 'Clusters Applications', :js do
       scenario 'user can install applications' do
         page.within('.js-cluster-application-row-helm') do
           expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to be_nil
-          expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Install')
+          expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Install')
         end
       end
 
       context 'when user installs Helm' do
         before do
-          allow(ClusterInstallAppWorker).to receive(:perform_async).and_return(nil)
+          allow(ClusterInstallAppWorker).to receive(:perform_async)
 
           page.within('.js-cluster-application-row-helm') do
             page.find(:css, '.js-cluster-application-install-button').click
@@ -50,18 +50,18 @@ feature 'Clusters Applications', :js do
           page.within('.js-cluster-application-row-helm') do
             # FE sends request and gets the response, then the buttons is "Install"
             expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
-            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Install')
+            expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Install')
 
             Clusters::Cluster.last.application_helm.make_installing!
 
             # FE starts polling and update the buttons to "Installing"
             expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
-            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installing')
+            expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Installing')
 
             Clusters::Cluster.last.application_helm.make_installed!
 
             expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
-            expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installed')
+            expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Installed')
           end
 
           expect(page).to have_content('Helm Tiller was successfully installed on your Kubernetes cluster')
@@ -71,11 +71,14 @@ feature 'Clusters Applications', :js do
       context 'when user installs Ingress' do
         context 'when user installs application: Ingress' do
           before do
-            allow(ClusterInstallAppWorker).to receive(:perform_async).and_return(nil)
+            allow(ClusterInstallAppWorker).to receive(:perform_async)
+            allow(ClusterWaitForIngressIpAddressWorker).to receive(:perform_in)
+            allow(ClusterWaitForIngressIpAddressWorker).to receive(:perform_async)
 
             create(:clusters_applications_helm, :installed, cluster: cluster)
 
             page.within('.js-cluster-application-row-ingress') do
+              expect(page).to have_css('.js-cluster-application-install-button:not([disabled])')
               page.find(:css, '.js-cluster-application-install-button').click
             end
           end
@@ -83,19 +86,28 @@ feature 'Clusters Applications', :js do
           it 'he sees status transition' do
             page.within('.js-cluster-application-row-ingress') do
               # FE sends request and gets the response, then the buttons is "Install"
-              expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
-              expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Install')
+              expect(page).to have_css('.js-cluster-application-install-button[disabled]')
+              expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Install')
 
               Clusters::Cluster.last.application_ingress.make_installing!
 
               # FE starts polling and update the buttons to "Installing"
-              expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
-              expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installing')
+              expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Installing')
+              expect(page).to have_css('.js-cluster-application-install-button[disabled]')
 
+              # The application becomes installed but we keep waiting for external IP address
               Clusters::Cluster.last.application_ingress.make_installed!
 
-              expect(page.find(:css, '.js-cluster-application-install-button')['disabled']).to eq('true')
-              expect(page.find(:css, '.js-cluster-application-install-button')).to have_content('Installed')
+              expect(page).to have_css('.js-cluster-application-install-button', exact_text: 'Installed')
+              expect(page).to have_css('.js-cluster-application-install-button[disabled]')
+              expect(page).to have_selector('.js-no-ip-message')
+              expect(page.find('.js-ip-address').value).to eq('?')
+
+              # We receive the external IP address and display
+              Clusters::Cluster.last.application_ingress.update!(external_ip: '192.168.1.100')
+
+              expect(page).not_to have_selector('.js-no-ip-message')
+              expect(page.find('.js-ip-address').value).to eq('192.168.1.100')
             end
 
             expect(page).to have_content('Ingress was successfully installed on your Kubernetes cluster')
diff --git a/spec/fixtures/api/schemas/cluster_status.json b/spec/fixtures/api/schemas/cluster_status.json
index 489d563be2b..d27c12e43f2 100644
--- a/spec/fixtures/api/schemas/cluster_status.json
+++ b/spec/fixtures/api/schemas/cluster_status.json
@@ -30,7 +30,8 @@
             ]
           }
         },
-        "status_reason": { "type": ["string", "null"] }
+        "status_reason": { "type": ["string", "null"] },
+        "external_ip": { "type": ["string", "null"] }
       },
       "required" : [ "name", "status" ]
     }
diff --git a/spec/javascripts/clusters/components/applications_spec.js b/spec/javascripts/clusters/components/applications_spec.js
index 15832c38f25..dfb4cc1b9b1 100644
--- a/spec/javascripts/clusters/components/applications_spec.js
+++ b/spec/javascripts/clusters/components/applications_spec.js
@@ -44,4 +44,71 @@ describe('Applications', () => {
     });
     /* */
   });
+
+  describe('Ingress application', () => {
+    describe('when installed', () => {
+      describe('with ip address', () => {
+        it('renders ip address with a clipboard button', () => {
+          vm = mountComponent(Applications, {
+            applications: {
+              ingress: {
+                title: 'Ingress',
+                status: 'installed',
+                externalIp: '0.0.0.0',
+              },
+              helm: { title: 'Helm Tiller' },
+              runner: { title: 'GitLab Runner' },
+              prometheus: { title: 'Prometheus' },
+            },
+          });
+
+          expect(
+            vm.$el.querySelector('.js-ip-address').value,
+          ).toEqual('0.0.0.0');
+
+          expect(
+            vm.$el.querySelector('.js-clipboard-btn').getAttribute('data-clipboard-text'),
+          ).toEqual('0.0.0.0');
+        });
+      });
+
+      describe('without ip address', () => {
+        it('renders an input text with a question mark and an alert text', () => {
+          vm = mountComponent(Applications, {
+            applications: {
+              ingress: {
+                title: 'Ingress',
+                status: 'installed',
+              },
+              helm: { title: 'Helm Tiller' },
+              runner: { title: 'GitLab Runner' },
+              prometheus: { title: 'Prometheus' },
+            },
+          });
+
+          expect(
+            vm.$el.querySelector('.js-ip-address').value,
+          ).toEqual('?');
+
+          expect(vm.$el.querySelector('.js-no-ip-message')).not.toBe(null);
+        });
+      });
+    });
+
+    describe('before installing', () => {
+      it('does not render the IP address', () => {
+        vm = mountComponent(Applications, {
+          applications: {
+            helm: { title: 'Helm Tiller' },
+            ingress: { title: 'Ingress' },
+            runner: { title: 'GitLab Runner' },
+            prometheus: { title: 'Prometheus' },
+          },
+        });
+
+        expect(vm.$el.textContent).not.toContain('Ingress IP Address');
+        expect(vm.$el.querySelector('.js-ip-address')).toBe(null);
+      });
+    });
+  });
 });
diff --git a/spec/javascripts/clusters/services/mock_data.js b/spec/javascripts/clusters/services/mock_data.js
index 253b3c45243..6ae7a792329 100644
--- a/spec/javascripts/clusters/services/mock_data.js
+++ b/spec/javascripts/clusters/services/mock_data.js
@@ -18,6 +18,7 @@ const CLUSTERS_MOCK_DATA = {
           name: 'ingress',
           status: APPLICATION_ERROR,
           status_reason: 'Cannot connect',
+          external_ip: null,
         }, {
           name: 'runner',
           status: APPLICATION_INSTALLING,
diff --git a/spec/javascripts/clusters/stores/clusters_store_spec.js b/spec/javascripts/clusters/stores/clusters_store_spec.js
index 726a4ed30de..8028faf2f02 100644
--- a/spec/javascripts/clusters/stores/clusters_store_spec.js
+++ b/spec/javascripts/clusters/stores/clusters_store_spec.js
@@ -75,6 +75,7 @@ describe('Clusters Store', () => {
             statusReason: mockResponseData.applications[1].status_reason,
             requestStatus: null,
             requestReason: null,
+            externalIp: null,
           },
           runner: {
             title: 'GitLab Runner',
diff --git a/spec/models/clusters/applications/ingress_spec.rb b/spec/models/clusters/applications/ingress_spec.rb
index 619c088b0bf..a34f4ff2b48 100644
--- a/spec/models/clusters/applications/ingress_spec.rb
+++ b/spec/models/clusters/applications/ingress_spec.rb
@@ -4,5 +4,52 @@ describe Clusters::Applications::Ingress do
   it { is_expected.to belong_to(:cluster) }
   it { is_expected.to validate_presence_of(:cluster) }
 
+  before do
+    allow(ClusterWaitForIngressIpAddressWorker).to receive(:perform_in)
+    allow(ClusterWaitForIngressIpAddressWorker).to receive(:perform_async)
+  end
+
   include_examples 'cluster application specs', described_class
+
+  describe '#make_installed!' do
+    before do
+      application.make_installed!
+    end
+
+    let(:application) { create(:clusters_applications_ingress, :installing) }
+
+    it 'schedules a ClusterWaitForIngressIpAddressWorker' do
+      expect(ClusterWaitForIngressIpAddressWorker).to have_received(:perform_in)
+        .with(Clusters::Applications::Ingress::FETCH_IP_ADDRESS_DELAY, 'ingress', application.id)
+    end
+  end
+
+  describe '#schedule_status_update' do
+    let(:application) { create(:clusters_applications_ingress, :installed) }
+
+    before do
+      application.schedule_status_update
+    end
+
+    it 'schedules a ClusterWaitForIngressIpAddressWorker' do
+      expect(ClusterWaitForIngressIpAddressWorker).to have_received(:perform_async)
+        .with('ingress', application.id)
+    end
+
+    context 'when the application is not installed' do
+      let(:application) { create(:clusters_applications_ingress, :installing) }
+
+      it 'does not schedule a ClusterWaitForIngressIpAddressWorker' do
+        expect(ClusterWaitForIngressIpAddressWorker).not_to have_received(:perform_async)
+      end
+    end
+
+    context 'when there is already an external_ip' do
+      let(:application) { create(:clusters_applications_ingress, :installed, external_ip: '111.222.222.111') }
+
+      it 'does not schedule a ClusterWaitForIngressIpAddressWorker' do
+        expect(ClusterWaitForIngressIpAddressWorker).not_to have_received(:perform_in)
+      end
+    end
+  end
 end
diff --git a/spec/serializers/cluster_application_entity_spec.rb b/spec/serializers/cluster_application_entity_spec.rb
index b5a55b4ef6e..852b6af9f7f 100644
--- a/spec/serializers/cluster_application_entity_spec.rb
+++ b/spec/serializers/cluster_application_entity_spec.rb
@@ -26,5 +26,19 @@ describe ClusterApplicationEntity do
         expect(subject[:status_reason]).to eq(application.status_reason)
       end
     end
+
+    context 'for ingress application' do
+      let(:application) do
+        build(
+          :clusters_applications_ingress,
+          :installed,
+          external_ip: '111.222.111.222'
+        )
+      end
+
+      it 'includes external_ip' do
+        expect(subject[:external_ip]).to eq('111.222.111.222')
+      end
+    end
   end
 end
diff --git a/spec/services/clusters/applications/check_ingress_ip_address_service_spec.rb b/spec/services/clusters/applications/check_ingress_ip_address_service_spec.rb
new file mode 100644
index 00000000000..bf038595a4d
--- /dev/null
+++ b/spec/services/clusters/applications/check_ingress_ip_address_service_spec.rb
@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Clusters::Applications::CheckIngressIpAddressService do
+  let(:application) { create(:clusters_applications_ingress, :installed) }
+  let(:service) { described_class.new(application) }
+  let(:kubeclient) { double(::Kubeclient::Client, get_service: kube_service) }
+  let(:ingress) { [{ ip: '111.222.111.222' }] }
+  let(:exclusive_lease) { instance_double(Gitlab::ExclusiveLease, try_obtain: true) }
+
+  let(:kube_service) do
+    ::Kubeclient::Resource.new(
+      {
+          status: {
+              loadBalancer: {
+                  ingress: ingress
+              }
+          }
+      }
+    )
+  end
+
+  subject { service.execute }
+
+  before do
+    allow(application.cluster).to receive(:kubeclient).and_return(kubeclient)
+    allow(Gitlab::ExclusiveLease)
+      .to receive(:new)
+      .with("check_ingress_ip_address_service:#{application.id}", timeout: 15.seconds.to_i)
+      .and_return(exclusive_lease)
+  end
+
+  describe '#execute' do
+    context 'when the ingress ip address is available' do
+      it 'updates the external_ip for the app' do
+        subject
+
+        expect(application.external_ip).to eq('111.222.111.222')
+      end
+    end
+
+    context 'when the ingress ip address is not available' do
+      let(:ingress) { nil }
+
+      it 'does not error' do
+        subject
+      end
+    end
+
+    context 'when the exclusive lease cannot be obtained' do
+      before do
+        allow(exclusive_lease)
+          .to receive(:try_obtain)
+          .and_return(false)
+      end
+
+      it 'does not call kubeclient' do
+        subject
+
+        expect(kubeclient).not_to have_received(:get_service)
+      end
+    end
+
+    context 'when there is already an external_ip' do
+      let(:application) { create(:clusters_applications_ingress, :installed, external_ip: '001.111.002.111') }
+
+      it 'does not call kubeclient' do
+        subject
+
+        expect(kubeclient).not_to have_received(:get_service)
+      end
+    end
+  end
+end
diff --git a/spec/workers/cluster_wait_for_ingress_ip_address_worker_spec.rb b/spec/workers/cluster_wait_for_ingress_ip_address_worker_spec.rb
new file mode 100644
index 00000000000..2e2e9afd25a
--- /dev/null
+++ b/spec/workers/cluster_wait_for_ingress_ip_address_worker_spec.rb
@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ClusterWaitForIngressIpAddressWorker do
+  describe '#perform' do
+    let(:service) { instance_double(Clusters::Applications::CheckIngressIpAddressService, execute: true) }
+    let(:application) { instance_double(Clusters::Applications::Ingress) }
+    let(:worker) { described_class.new }
+
+    before do
+      allow(worker)
+        .to receive(:find_application)
+        .with('ingress', 117)
+        .and_yield(application)
+
+      allow(Clusters::Applications::CheckIngressIpAddressService)
+        .to receive(:new)
+        .with(application)
+        .and_return(service)
+
+      allow(described_class)
+        .to receive(:perform_in)
+    end
+
+    it 'finds the application and calls CheckIngressIpAddressService#execute' do
+      worker.perform('ingress', 117)
+
+      expect(service).to have_received(:execute)
+    end
+  end
+end