feat: Adapt verifyServerUrl for new asynchronous Parse Server start-up states (#8366)

BREAKING CHANGE: The method `ParseServer.verifyServerUrl` now returns a promise instead of a callback.

Author: dblythy

spec/ParseServer.spec.js

@@ -29,27 +29,20 @@ describe('Server Url Checks', () => {
     server.close(done);
   });
 
-  it('validate good server url', done => {
+  it('validate good server url', async () => {
     Parse.serverURL = 'http://localhost:13376';
-    ParseServer.verifyServerUrl(async result => {
-      if (!result) {
-        done.fail('Did not pass valid url');
-      }
-      await reconfigureServer();
-      done();
-    });
+    const response = await ParseServer.verifyServerUrl();
+    expect(response).toBeTrue();
   });
 
-  it('mark bad server url', done => {
+  it('mark bad server url', async () => {
     spyOn(console, 'warn').and.callFake(() => {});
     Parse.serverURL = 'notavalidurl';
-    ParseServer.verifyServerUrl(async result => {
-      if (result) {
-        done.fail('Did not mark invalid url');
-      }
-      await reconfigureServer();
-      done();
-    });
+    const response = await ParseServer.verifyServerUrl();
+    expect(response).not.toBeTrue();
+    expect(console.warn).toHaveBeenCalledWith(
+      `\nWARNING, Unable to connect to 'notavalidurl' as the URL is invalid. Cloud code and push notifications may be unavailable!\n`
+    );
   });
 
   xit('handleShutdown, close connection', done => {

spec/index.spec.js

@@ -546,6 +546,12 @@ describe('server', () => {
     const health = await request({
       url: 'http://localhost:12701/parse/health',
     }).catch(e => e);
+    spyOn(console, 'warn').and.callFake(() => {});
+    const verify = await ParseServer.default.verifyServerUrl();
+    expect(verify).not.toBeTrue();
+    expect(console.warn).toHaveBeenCalledWith(
+      `\nWARNING, Unable to connect to 'http://localhost:12701/parse'. Cloud code and push notifications may be unavailable!\n`
+    );
     expect(health.data.status).toBe('initialized');
     expect(health.status).toBe(503);
     await new Promise(resolve => server.close(resolve));
@@ -573,6 +579,8 @@ describe('server', () => {
     expect(health.data.status).toBe('starting');
     expect(health.status).toBe(503);
     expect(health.headers['retry-after']).toBe('1');
+    const response = await ParseServer.default.verifyServerUrl();
+    expect(response).toBeTrue();
     await startingPromise;
     await new Promise(resolve => server.close(resolve));
   });

src/ParseServer.js

@@ -392,30 +392,45 @@ class ParseServer {
     return server;
   }
 
-  static verifyServerUrl(callback) {
+  static async verifyServerUrl() {
     // perform a health check on the serverURL value
     if (Parse.serverURL) {
+      const isValidHttpUrl = string => {
+        let url;
+        try {
+          url = new URL(string);
+        } catch (_) {
+          return false;
+        }
+        return url.protocol === 'http:' || url.protocol === 'https:';
+      };
+      const url = `${Parse.serverURL.replace(/\/$/, '')}/health`;
+      if (!isValidHttpUrl(url)) {
+        console.warn(
+          `\nWARNING, Unable to connect to '${Parse.serverURL}' as the URL is invalid.` +
+            ` Cloud code and push notifications may be unavailable!\n`
+        );
+        return;
+      }
       const request = require('./request');
-      request({ url: Parse.serverURL.replace(/\/$/, '') + '/health' })
-        .catch(response => response)
-        .then(response => {
-          const json = response.data || null;
-          if (response.status !== 200 || !json || (json && json.status !== 'ok')) {
-            /* eslint-disable no-console */
-            console.warn(
-              `\nWARNING, Unable to connect to '${Parse.serverURL}'.` +
-                ` Cloud code and push notifications may be unavailable!\n`
-            );
-            /* eslint-enable no-console */
-            if (callback) {
-              callback(false);
-            }
-          } else {
-            if (callback) {
-              callback(true);
-            }
-          }
-        });
+      const response = await request({ url }).catch(response => response);
+      const json = response.data || null;
+      console.log(response.status, { json });
+      const retry = response.headers['retry-after'];
+      if (retry) {
+        await new Promise(resolve => setTimeout(resolve, retry * 1000));
+        return this.verifyServerUrl();
+      }
+      if (response.status !== 200 || json?.status !== 'ok') {
+        /* eslint-disable no-console */
+        console.warn(
+          `\nWARNING, Unable to connect to '${Parse.serverURL}'.` +
+            ` Cloud code and push notifications may be unavailable!\n`
+        );
+        /* eslint-enable no-console */
+        return;
+      }
+      return true;
     }
   }
 }