[savedObjects] fix error handling when Kibana index is missing

src/server/saved_objects/client/__tests__/saved_objects_client.js

@@ -291,7 +291,9 @@ describe('SavedObjectsClient', () => {
 
   describe('#delete', () => {
     it('throws notFound when ES is unable to find the document',  async () => {
-      callAdminCluster.returns(Promise.resolve({ found: false }));
+      callAdminCluster.returns(Promise.resolve({
+        result: 'not_found'
+      }));
 
       try {
         await savedObjectsClient.delete('index-pattern', 'logstash-*');
@@ -303,7 +305,9 @@ describe('SavedObjectsClient', () => {
     });
 
     it('passes the parameters to callAdminCluster', async () => {
-      callAdminCluster.returns({});
+      callAdminCluster.returns({
+        result: 'deleted'
+      });
       await savedObjectsClient.delete('index-pattern', 'logstash-*');
 
       expect(callAdminCluster.calledOnce).to.be(true);
@@ -314,7 +318,8 @@ describe('SavedObjectsClient', () => {
         type: 'doc',
         id: 'index-pattern:logstash-*',
         refresh: 'wait_for',
-        index: '.kibana-test'
+        index: '.kibana-test',
+        ignore: [404],
       });
     });
   });
@@ -562,6 +567,7 @@ describe('SavedObjectsClient', () => {
         body: {
           doc: { updated_at: mockTimestamp, 'index-pattern': { title: 'Testing' } }
         },
+        ignore: [404],
         refresh: 'wait_for',
         index: '.kibana-test'
       });

src/server/saved_objects/client/saved_objects_client.js

@@ -144,11 +144,25 @@ export class SavedObjectsClient {
       id: this._generateEsId(type, id),
       type: this._type,
       refresh: 'wait_for',
+      ignore: [404],
     });
 
-    if (response.found === false) {
+    const deleted = response.result === 'deleted';
+    if (deleted) {
+      return {};
+    }
+
+    // 404 might be because document is missing or index is missing,
+    // don't leak that implementation detail to the user
+    const docNotFound = response.result === 'not_found';
+    const indexNotFound = response.error && response.error.type === 'index_not_found_exception';
+    if (docNotFound || indexNotFound) {
       throw errors.decorateNotFoundError(Boom.notFound());
     }
+
+    throw new Error(
+      `Unexpected Elasticsearch DELETE response: ${JSON.stringify({ type, id, response, })}`
+    );
   }
 
   /**
@@ -188,6 +202,7 @@ export class SavedObjectsClient {
       size: perPage,
       from: perPage * (page - 1),
       _source: includedFields(type, fields),
+      ignore: [404],
       body: {
         version: true,
         ...getSearchDsl(this._mappings, {
@@ -202,6 +217,17 @@ export class SavedObjectsClient {
 
     const response = await this._withKibanaIndex('search', esOptions);
 
+    if (response.status === 404) {
+      // 404 is only possible here if the index is missing, which
+      // is an implementation detail we don't want to leak
+      return {
+        page,
+        per_page: perPage,
+        total: 0,
+        saved_objects: []
+      };
+    }
+
     return {
       page,
       per_page: perPage,
@@ -249,13 +275,14 @@ export class SavedObjectsClient {
       saved_objects: response.docs.map((doc, i) => {
         const { id, type } = objects[i];
 
-        if (doc.found === false) {
+        if (!doc.found) {
           return {
             id,
             type,
             error: { statusCode: 404, message: 'Not found' }
           };
         }
+
         const time = doc._source.updated_at;
         return {
           id,
@@ -279,7 +306,16 @@ export class SavedObjectsClient {
     const response = await this._withKibanaIndex('get', {
       id: this._generateEsId(type, id),
       type: this._type,
+      ignore: [404]
     });
+
+    const docNotFound = response.found === false;
+    const indexNotFound = response.status === 404;
+    if (docNotFound || indexNotFound) {
+      // don't leak implementation details about why there was a 404
+      throw errors.decorateNotFoundError(Boom.notFound());
+    }
+
     const { updated_at: updatedAt } = response._source;
 
     return {
@@ -307,6 +343,7 @@ export class SavedObjectsClient {
       type: this._type,
       version: options.version,
       refresh: 'wait_for',
+      ignore: [404],
       body: {
         doc: {
           updated_at: time,
@@ -315,6 +352,11 @@ export class SavedObjectsClient {
       },
     });
 
+    if (response.status === 404) {
+      // don't leak implementation details about why there was a 404
+      throw errors.decorateNotFoundError(Boom.notFound());
+    }
+
     return {
       id,
       type,

src/ui/ui_settings/routes/__tests__/lib/assert.js

@@ -10,7 +10,6 @@ export function assertDocMissingResponse({ result }) {
   assertSinonMatch(result, {
     statusCode: 404,
     error: 'Not Found',
-    message: sinon.match('document_missing_exception')
-      .and(sinon.match('document missing'))
+    message: 'Not Found'
   });
 }

tasks/config/run.js

@@ -55,6 +55,7 @@ module.exports = function (grunt) {
         ...stdDevArgs,
         '--optimize.enabled=false',
         '--elasticsearch.url=' + esTestConfig.getUrl(),
+        '--elasticsearch.healthCheck.delay=360000',
         '--server.port=' + kibanaTestServerUrlParts.port,
         '--server.xsrf.disableProtection=true',
         ...kbnServerFlags,

test/api_integration/apis/index.js

@@ -1,6 +1,7 @@
 export default function ({ loadTestFile }) {
   describe('apis', () => {
     loadTestFile(require.resolve('./index_patterns'));
+    loadTestFile(require.resolve('./saved_objects'));
     loadTestFile(require.resolve('./scripts'));
     loadTestFile(require.resolve('./search'));
     loadTestFile(require.resolve('./suggestions'));

test/api_integration/apis/saved_objects/bulk_get.js

@@ -0,0 +1,122 @@
+import expect from 'expect.js';
+
+export default function ({ getService }) {
+  const supertest = getService('supertest');
+  const es = getService('es');
+  const esArchiver = getService('esArchiver');
+
+  const BULK_REQUESTS = [
+    {
+      type: 'visualization',
+      id: 'dd7caf20-9efd-11e7-acb3-3dab96693fab',
+    },
+    {
+      type: 'dashboard',
+      id: 'does not exist',
+    },
+    {
+      type: 'config',
+      id: '7.0.0-alpha1',
+    },
+  ];
+
+  describe('bulk_get', () => {
+    describe('with kibana index', () => {
+      before(() => esArchiver.load('saved_objects/basic'));
+      after(() => esArchiver.unload('saved_objects/basic'));
+
+      it('should return 200 with individual responses', async () => (
+        await supertest
+          .post(`/api/saved_objects/bulk_get`)
+          .send(BULK_REQUESTS)
+          .expect(200)
+          .then(resp => {
+            expect(resp.body).to.eql({
+              saved_objects: [
+                {
+                  id: 'dd7caf20-9efd-11e7-acb3-3dab96693fab',
+                  type: 'visualization',
+                  updated_at: '2017-09-21T18:51:23.794Z',
+                  version: resp.body.saved_objects[0].version,
+                  attributes: {
+                    title: 'Count of requests',
+                    description: '',
+                    version: 1,
+                    // cheat for some of the more complex attributes
+                    visState: resp.body.saved_objects[0].attributes.visState,
+                    uiStateJSON: resp.body.saved_objects[0].attributes.uiStateJSON,
+                    kibanaSavedObjectMeta: resp.body.saved_objects[0].attributes.kibanaSavedObjectMeta
+                  }
+                },
+                {
+                  id: 'does not exist',
+                  type: 'dashboard',
+                  error: {
+                    statusCode: 404,
+                    message: 'Not found'
+                  }
+                },
+                {
+                  id: '7.0.0-alpha1',
+                  type: 'config',
+                  updated_at: '2017-09-21T18:49:16.302Z',
+                  version: resp.body.saved_objects[2].version,
+                  attributes: {
+                    buildNum: 8467,
+                    defaultIndex: '91200a00-9efd-11e7-acb3-3dab96693fab'
+                  }
+                }
+              ]
+            });
+          })
+      ));
+    });
+
+    describe('without kibana index', () => {
+      before(async () => (
+        // just in case the kibana server has recreated it
+        await es.indices.delete({
+          index: '.kibana',
+          ignore: [404],
+        })
+      ));
+
+      it('should return 200 with individual responses', async () => (
+        await supertest
+          .post('/api/saved_objects/bulk_get')
+          .send(BULK_REQUESTS)
+          .expect(200)
+          .then(resp => {
+            expect(resp.body).to.eql({
+              saved_objects: [
+                {
+                  id: 'dd7caf20-9efd-11e7-acb3-3dab96693fab',
+                  type: 'visualization',
+                  error: {
+                    statusCode: 404,
+                    message: 'Not found'
+                  }
+                },
+                {
+                  id: 'does not exist',
+                  type: 'dashboard',
+                  error: {
+                    statusCode: 404,
+                    message: 'Not found'
+                  }
+                },
+                {
+                  id: '7.0.0-alpha1',
+                  type: 'config',
+                  error: {
+                    statusCode: 404,
+                    message: 'Not found'
+                  }
+                }
+              ]
+            });
+          })
+      ));
+    });
+  });
+}

test/api_integration/apis/saved_objects/create.js

@@ -0,0 +1,86 @@
+import expect from 'expect.js';
+
+export default function ({ getService }) {
+  const supertest = getService('supertest');
+  const es = getService('es');
+  const esArchiver = getService('esArchiver');
+
+  async function sendAndValidateCreate() {
+    await supertest
+      .post(`/api/saved_objects/visualization`)
+      .send({
+        attributes: {
+          title: 'My favorite vis'
+        }
+      })
+      .expect(200)
+      .then(resp => {
+        // loose uuid validation
+        expect(resp.body).to.have.property('id').match(/^[0-9a-f-]{36}$/);
+
+        // loose ISO8601 UTC time with milliseconds validation
+        expect(resp.body).to.have.property('updated_at').match(/^[\d-]{10}T[\d:\.]{12}Z$/);
+
+        expect(resp.body).to.eql({
+          id: resp.body.id,
+          type: 'visualization',
+          updated_at: resp.body.updated_at,
+          version: 1,
+          attributes: {
+            title: 'My favorite vis'
+          }
+        });
+      });
+  }
+
+  describe('create', () => {
+    describe('with kibana index', () => {
+      before(() => esArchiver.load('saved_objects/basic'));
+      after(() => esArchiver.unload('saved_objects/basic'));
+      it('should return 200', sendAndValidateCreate);
+    });
+
+    describe('without kibana index', () => {
+      before(async () => (
+        // just in case the kibana server has recreated it
+        await es.indices.delete({
+          index: '.kibana',
+          ignore: [404],
+        })
+      ));
+
+      after(async () => (
+        // make sure to delete the invalid kibana index
+        await es.indices.delete({ index: '.kibana' })
+      ));
+
+      it('should return 200 and create invalid kibana index', async () => {
+        // just in case the kibana server has recreated it
+        await es.indices.delete({
+          index: '.kibana',
+          ignore: [404],
+        });
+
+        await sendAndValidateCreate();
+
+        const index = await es.indices.get({
+          index: '.kibana'
+        });
+
+        const { mappings } = index['.kibana'];
+        expect(mappings).to.have.keys('doc');
+        expect(mappings.doc.properties).to.have.keys([
+          'type',
+          'updated_at',
+          'visualization'
+        ]);
+        expect(mappings.doc.properties).to.not.have.keys([
+          'config',
+          'dashboard',
+          'index-pattern',
+          'search'
+        ]);
+      });
+    });
+  });
+}