@webex/webex-core 3.8.0-next.21 → 3.8.0-next.22

package/src/lib/services-v2/{index.js → index.ts}

@@ -20,4 +20,4 @@ export {default as ServiceInterceptorV2} from './interceptors/service';
 export {default as ServerErrorInterceptorV2} from './interceptors/server-error';
 export {default as HostMapInterceptorV2} from './interceptors/hostmap';
 export {default as ServiceCatalogV2} from './service-catalog';
-export {default as ServiceUrlV2} from './service-url';
+export {default as ServiceDetail} from './service-detail';

package/src/lib/services-v2/{service-catalog.js → service-catalog.ts}

@@ -3,7 +3,8 @@ import Url from 'url';
 import AmpState from 'ampersand-state';
 
 import {union} from 'lodash';
-import ServiceUrl from './service-url';
+import ServiceDetail from './service-detail';
+import {IServiceDetail} from './types';
 
 /* eslint-disable no-underscore-dangle */
 /**
@@ -56,13 +57,13 @@ const ServiceCatalog = AmpState.extend({
 
   /**
    * @private
-   * Search the service url array to locate a `ServiceUrl`
+   * Search the service url array to locate a `ServiceDetail`
    * class object based on its name.
    * @param {string} name
    * @param {string} [serviceGroup]
-   * @returns {ServiceUrl}
+   * @returns {IServiceDetail}
    */
-  _getUrl(name, serviceGroup) {
+  _getUrl(name: string, serviceGroup: string): IServiceDetail | undefined {
     const serviceUrls =
       typeof serviceGroup === 'string'
         ? this.serviceGroups[serviceGroup] || []
@@ -74,16 +75,16 @@ const ServiceCatalog = AmpState.extend({
             ...this.serviceGroups.discovery,
           ];
 
-    return serviceUrls.find((serviceUrl) => serviceUrl.name === name);
+    return serviceUrls.find((serviceUrl: IServiceDetail) => serviceUrl.serviceName === name);
   },
 
   /**
    * @private
-   * Generate an array of `ServiceUrl`s that is organized from highest auth
+   * Generate an array of `ServiceDetail`s that is organized from highest auth
    * level to lowest auth level.
-   * @returns {Array<ServiceUrl>} - array of `ServiceUrl`s
+   * @returns {Array<IServiceDetail>} - array of `ServiceDetail`s
    */
-  _listServiceUrls() {
+  _listServiceUrls(): Array<IServiceDetail> {
     return [
       ...this.serviceGroups.override,
       ...this.serviceGroups.postauth,
@@ -95,39 +96,37 @@ const ServiceCatalog = AmpState.extend({
 
   /**
    * @private
-   * Safely load one or more `ServiceUrl`s into this `Services` instance.
+   * Safely load one or more `ServiceDetail`s into this `Services` instance.
    * @param {string} serviceGroup
-   * @param  {Array<ServiceUrl>} services
+   * @param  {Array<IServiceDetail>} services
    * @returns {Services}
    */
-  _loadServiceUrls(serviceGroup, services) {
+  _loadServiceUrls(serviceGroup: string, services: Array<IServiceDetail>): void {
     // declare namespaces outside of loop
-    let existingService;
+    let existingService: IServiceDetail | undefined;
 
     services.forEach((service) => {
-      existingService = this._getUrl(service.name, serviceGroup);
+      existingService = this._getUrl(service.serviceName, serviceGroup);
 
       if (!existingService) {
         this.serviceGroups[serviceGroup].push(service);
       }
     });
-
-    return this;
   },
 
   /**
    * @private
-   * Safely unload one or more `ServiceUrl`s into this `Services` instance
+   * Safely unload one or more `ServiceDetail`s into this `Services` instance
    * @param {string} serviceGroup
-   * @param  {Array<ServiceUrl>} services
+   * @param  {Array<IServiceDetail>} services
    * @returns {Services}
    */
-  _unloadServiceUrls(serviceGroup, services) {
+  _unloadServiceUrls(serviceGroup: string, services: Array<IServiceDetail>): void {
     // declare namespaces outside of loop
-    let existingService;
+    let existingService: IServiceDetail | undefined;
 
     services.forEach((service) => {
-      existingService = this._getUrl(service.name, serviceGroup);
+      existingService = this._getUrl(service.serviceName, serviceGroup);
 
       if (existingService) {
         this.serviceGroups[serviceGroup].splice(
@@ -136,8 +135,6 @@ const ServiceCatalog = AmpState.extend({
         );
       }
     });
-
-    return this;
   },
 
   /**
@@ -145,7 +142,7 @@ const ServiceCatalog = AmpState.extend({
    *
    * @returns {void}
    */
-  clean() {
+  clean(): void {
     this.serviceGroups.preauth.length = 0;
     this.serviceGroups.signin.length = 0;
     this.serviceGroups.postauth.length = 0;
@@ -160,7 +157,7 @@ const ServiceCatalog = AmpState.extend({
    * @param {string} url - Must be parsable by `Url`
    * @returns {string} - ClusterId of a given url
    */
-  findClusterId(url) {
+  findClusterId(url: string): string | undefined {
     const incomingUrlObj = Url.parse(url);
     let serviceUrlObj;
 
@@ -205,7 +202,7 @@ const ServiceCatalog = AmpState.extend({
    * @returns {string} service.name
    * @returns {string} service.url
    */
-  findServiceFromClusterId({clusterId, priorityHost = true, serviceGroup} = {}) {
+  findServiceFromClusterId({clusterId, priorityHost = true, serviceGroup}) {
     const serviceUrls =
       typeof serviceGroup === 'string'
         ? this.serviceGroups[serviceGroup] || []
@@ -234,9 +231,9 @@ const ServiceCatalog = AmpState.extend({
   /**
    * Find a service based on the provided url.
    * @param {string} url - Must be parsable by `Url`
-   * @returns {serviceUrl} - ServiceUrl assocated with provided url
+   * @returns {IServiceDetail} - ServiceDetail assocated with provided url
    */
-  findServiceUrlFromUrl(url) {
+  findServiceUrlFromUrl(url: string): IServiceDetail | undefined {
     const serviceUrls = [
       ...this.serviceGroups.discovery,
       ...this.serviceGroups.preauth,
@@ -273,7 +270,7 @@ const ServiceCatalog = AmpState.extend({
    * @param {string} url - The url to match the allowed domains against.
    * @returns {string} - The matching allowed domain.
    */
-  findAllowedDomain(url) {
+  findAllowedDomain(url: string): string {
     const urlObj = Url.parse(url);
 
     if (!urlObj.host) {
@@ -290,7 +287,7 @@ const ServiceCatalog = AmpState.extend({
    * @param {string} serviceGroup
    * @returns {string}
    */
-  get(name, priorityHost, serviceGroup) {
+  get(name: string, priorityHost: boolean, serviceGroup: string): string | undefined {
     const serviceUrl = this._getUrl(name, serviceGroup);
 
     return serviceUrl ? serviceUrl.get(priorityHost) : undefined;
@@ -301,7 +298,7 @@ const ServiceCatalog = AmpState.extend({
    *
    * @returns {Array<string>} - the current allowed domains list.
    */
-  getAllowedDomains() {
+  getAllowedDomains(): Array<string> {
     return [...this.allowedDomains];
   },
 
@@ -338,17 +335,17 @@ const ServiceCatalog = AmpState.extend({
   /**
    * Mark a priority host service url as failed.
    * This will mark the host associated with the
-   * `ServiceUrl` to be removed from the its
+   * `ServiceDetail` to be removed from the its
    * respective host array, and then return the next
-   * viable host from the `ServiceUrls` host array,
-   * or the `ServiceUrls` default url if no other priority
+   * viable host from the `ServiceDetail` host array,
+   * or the `ServiceDetail` default url if no other priority
    * hosts are available, or if `noPriorityHosts` is set to
    * `true`.
    * @param {string} url
    * @param {boolean} noPriorityHosts
    * @returns {string}
    */
-  markFailedUrl(url, noPriorityHosts) {
+  markFailedUrl(url: string, noPriorityHosts = false): string | undefined {
     const serviceUrl = this._getUrl(
       Object.keys(this.list()).find((key) => this._getUrl(key).failHost(url))
     );
@@ -366,7 +363,7 @@ const ServiceCatalog = AmpState.extend({
    * @param {Array<string>} allowedDomains - allowed domains to be assigned.
    * @returns {void}
    */
-  setAllowedDomains(allowedDomains) {
+  setAllowedDomains(allowedDomains: Array<string>): void {
     this.allowedDomains = [...allowedDomains];
   },
 
@@ -375,37 +372,36 @@ const ServiceCatalog = AmpState.extend({
    * @param {Array<string>} newAllowedDomains - new allowed domains to add to existing set of allowed domains
    * @returns {void}
    */
-  addAllowedDomains(newAllowedDomains) {
+  addAllowedDomains(newAllowedDomains: Array<string>): void {
     this.allowedDomains = union(this.allowedDomains, newAllowedDomains);
   },
 
   /**
-   * Update the current list of `ServiceUrl`s against a provided
+   * Update the current list of `ServiceDetail`s against a provided
    * service hostmap.
    * @emits ServiceCatalog#preauthorized
    * @emits ServiceCatalog#postauthorized
    * @param {string} serviceGroup
    * @param {object} serviceHostmap
-   * @returns {Services}
+   * @returns {void}
    */
-  updateServiceUrls(serviceGroup, serviceHostmap) {
+  updateServiceUrls(serviceGroup: string, serviceHostmap: Array<IServiceDetail>): void {
     const currentServiceUrls = this.serviceGroups[serviceGroup];
 
     const unusedUrls = currentServiceUrls.filter((serviceUrl) =>
-      serviceHostmap.every((item) => item.name !== serviceUrl.name)
+      serviceHostmap.every((item) => item.serviceName !== serviceUrl.serviceName)
     );
 
     this._unloadServiceUrls(serviceGroup, unusedUrls);
 
     serviceHostmap.forEach((serviceObj) => {
-      const service = this._getUrl(serviceObj.name, serviceGroup);
+      const service = this._getUrl(serviceObj.serviceName, serviceGroup);
 
       if (service) {
-        service.defaultUrl = serviceObj.defaultUrl;
-        service.hosts = serviceObj.hosts || [];
+        service.serviceUrls = serviceObj.serviceUrls || [];
       } else {
         this._loadServiceUrls(serviceGroup, [
-          new ServiceUrl({
+          new ServiceDetail({
             ...serviceObj,
           }),
         ]);
@@ -414,8 +410,6 @@ const ServiceCatalog = AmpState.extend({
 
     this.status[serviceGroup].ready = true;
     this.trigger(serviceGroup);
-
-    return this;
   },
 
   /**
@@ -426,7 +420,7 @@ const ServiceCatalog = AmpState.extend({
    * @returns {Promise<void>}
    */
   waitForCatalog(serviceGroup, timeout) {
-    return new Promise((resolve, reject) => {
+    return new Promise<void>((resolve, reject) => {
       if (this.status[serviceGroup].ready) {
         resolve();
       }

package/src/lib/services-v2/service-detail.ts

@@ -0,0 +1,97 @@
+import AmpState from 'ampersand-state';
+import {ServiceUrl} from './types';
+
+/**
+ * @class
+ */
+const ServiceDetail = AmpState.extend({
+  namespace: 'ServiceDetail',
+
+  props: {
+    serviceUrls: ['array', false, () => []],
+    serviceName: ['string', true, undefined],
+    id: ['string', true, undefined],
+  },
+
+  /**
+   * Generate a host url based on the host
+   * uri provided.
+   * @param {ServiceUrl} serviceUrl
+   * @returns {string}
+   */
+  _generateHostUrl(serviceUrl: ServiceUrl): string {
+    const url = new URL(serviceUrl.baseUrl);
+
+    // setting url.hostname will not apply during Url.format(), set host via
+    // a string literal instead.
+    url.host = `${serviceUrl.host}${url.port ? `:${url.port}` : ''}`;
+
+    return url.href;
+  },
+
+  /**
+   * Get the current host url with the highest priority. This will only return a URL with a filtered host that has the
+   * `homeCluster` value set to `true`.
+   * @returns {string} - The priority host url.
+   */
+  _getPriorityHostUrl(): string {
+    // format of catalog ensures that array is sorted by highest priority
+    let priorityServiceUrl = this._searchForValidPriorityHost();
+
+    if (!priorityServiceUrl) {
+      this.serviceUrls = this.serviceUrls.map((serviceUrl) => {
+        serviceUrl.failed = false;
+
+        return serviceUrl;
+      });
+
+      priorityServiceUrl = this._searchForValidPriorityHost();
+    }
+
+    return priorityServiceUrl ? this._generateHostUrl(priorityServiceUrl) : '';
+  },
+
+  /**
+   * Searches for a valid service URL with a priority greater than 0 that has not failed.
+   * @returns {ServiceUrl | undefined} - The first valid service URL found, or undefined if none exist.
+   */
+  _searchForValidPriorityHost(): ServiceUrl | undefined {
+    return this.serviceUrls.find((serviceUrl) => serviceUrl.priority > 0 && !serviceUrl.failed);
+  },
+
+  /**
+   * Attempt to mark a host from this `ServiceDetail` as failed and return true
+   * if the provided url has a host that could be successfully marked as failed.
+   *
+   * @param {string} url
+   * @returns {boolean}
+   */
+  failHost(url: string): boolean {
+    const failedUrl = new URL(url);
+
+    const foundHost = this.serviceUrls.find((serviceUrl) => serviceUrl.host === failedUrl.host);
+
+    if (foundHost) {
+      foundHost.failed = true;
+    }
+
+    return foundHost !== undefined;
+  },
+
+  /**
+   * Generate a url using the host with the
+   * highest priority via host rendering.
+   *
+   * @returns {string} - The full service url.
+   */
+  get(): string {
+    // return empty string to indicate that no service url is available
+    if (!this.serviceUrls || this.serviceUrls.length === 0) {
+      return '';
+    }
+
+    return this._getPriorityHostUrl();
+  },
+});
+
+export default ServiceDetail;

package/src/lib/services-v2/services-v2.js

@@ -189,7 +189,7 @@ const Services = WebexPlugin.extend({
       forceRefresh,
     })
       .then((serviceHostMap) => {
-        catalog.updateServiceUrls(serviceGroup, serviceHostMap);
+        catalog.updateServiceGroups(serviceGroup, serviceHostMap);
         this.updateCredentialsConfig();
         catalog.status[serviceGroup].collecting = false;
       })
@@ -455,7 +455,7 @@ const Services = WebexPlugin.extend({
 
     const serviceHostMap = this._formatReceivedHostmap(hostMap);
 
-    return catalog.updateServiceUrls(serviceGroup, serviceHostMap);
+    return catalog.updateServiceGroups(serviceGroup, serviceHostMap);
   },
 
   /**
@@ -662,6 +662,28 @@ const Services = WebexPlugin.extend({
     return uri;
   },
 
+  /**
+   * Formats a host map entry for use in service catalog.
+   *
+   * @param {Object} entry - The host map entry to format.
+   * @param {string} entry.serviceName - i.e. conversation, identity, etc.
+   * @param {string} entry.id - The unique identifier for the service, usually clusterId.
+   * @param {Array<IServiceDetail>} entry.serviceUrls - The group to which the service belongs.
+   * @returns {Object} - The formatted host map entry.
+   */
+  _formatHostMapEntry({id, serviceName, serviceUrls}) {
+    const formattedServiceUrls = serviceUrls.map((serviceUrl) => ({
+      host: new URL(serviceUrl.baseUrl).host,
+      ...serviceUrl,
+    }));
+
+    return {
+      id,
+      serviceName,
+      serviceUrls: formattedServiceUrls,
+    };
+  },
+
   /**
    * @private
    * Organize a received hostmap from a service
@@ -670,18 +692,7 @@ const Services = WebexPlugin.extend({
    * @returns {object}
    */
   _formatReceivedHostmap({services, activeServices}) {
-    const formattedHostmap = services.map(({id, serviceName, serviceUrls}) => {
-      const formattedServiceUrls = serviceUrls.map((serviceUrl) => ({
-        host: new URL(serviceUrl.baseUrl).host,
-        ...serviceUrl,
-      }));
-
-      return {
-        id,
-        serviceName,
-        serviceUrls: formattedServiceUrls,
-      };
-    });
+    const formattedHostmap = services.map((service) => this._formatHostMapEntry(service));
     this._updateActiveServices(activeServices);
     this._updateServices(services);
 
@@ -850,24 +861,30 @@ const Services = WebexPlugin.extend({
       // Check for discovery services.
       if (services.discovery) {
         // Format the discovery configuration into an injectable array.
-        const formattedDiscoveryServices = Object.keys(services.discovery).map((key) => ({
-          name: key,
-          defaultUrl: services.discovery[key],
-        }));
+        const formattedDiscoveryServices = Object.keys(services.discovery).map((key) =>
+          this._formatHostMapEntry({
+            id: key,
+            serviceName: key,
+            serviceUrls: [{baseUrl: services.discovery[key], priority: 1}],
+          })
+        );
 
         // Inject formatted discovery services into services catalog.
-        catalog.updateServiceUrls('discovery', formattedDiscoveryServices);
+        catalog.updateServiceGroups('discovery', formattedDiscoveryServices);
       }
 
       if (services.override) {
         // Format the override configuration into an injectable array.
-        const formattedOverrideServices = Object.keys(services.override).map((key) => ({
-          name: key,
-          defaultUrl: services.override[key],
-        }));
+        const formattedOverrideServices = Object.keys(services.override).map((key) =>
+          this._formatHostMapEntry({
+            id: key,
+            serviceName: key,
+            serviceUrls: [{baseUrl: services.override[key], priority: 1}],
+          })
+        );
 
         // Inject formatted override services into services catalog.
-        catalog.updateServiceUrls('override', formattedOverrideServices);
+        catalog.updateServiceGroups('override', formattedOverrideServices);
       }
 
       // if not fedramp, append on the commercialAllowedDomains

package/src/lib/services-v2/types.ts

@@ -0,0 +1,12 @@
+export type ServiceUrl = {
+  baseUrl: string;
+  host: string;
+  priority: number;
+  failed?: boolean;
+};
+
+export interface IServiceDetail {
+  id: string;
+  serviceName: string;
+  serviceUrls: Array<ServiceUrl>;
+}

package/test/fixtures/host-catalog-v2.js

@@ -120,23 +120,25 @@ export const serviceHostmapV2 = {
   format: 'U2Cv2',
 };
 
+export const formattedServiceHostmapEntryConv = {
+  id: 'urn:TEAM:us-east-2_a:conversation',
+  serviceName: 'conversation',
+  serviceUrls: [
+    {
+      baseUrl: 'https://prod-achm-message.svc.webex.com/conversation/api/v1',
+      host: 'prod-achm-message.svc.webex.com',
+      priority: 1,
+    },
+    {
+      baseUrl: 'https://conv-a.wbx2.com/conversation/api/v1',
+      host: 'conv-a.wbx2.com',
+      priority: 2,
+    },
+  ],
+};
+
 export const formattedServiceHostmapV2 = [
-  {
-    id: 'urn:TEAM:us-east-2_a:conversation',
-    serviceName: 'conversation',
-    serviceUrls: [
-      {
-        baseUrl: 'https://prod-achm-message.svc.webex.com/conversation/api/v1',
-        host: 'prod-achm-message.svc.webex.com',
-        priority: 1,
-      },
-      {
-        baseUrl: 'https://conv-a.wbx2.com/conversation/api/v1',
-        host: 'conv-a.wbx2.com',
-        priority: 2,
-      },
-    ],
-  },
+  formattedServiceHostmapEntryConv,
   {
     id: 'urn:TEAM:me-central-1_d:conversation',
     serviceName: 'conversation',

package/test/unit/spec/services-v2/service-detail.ts

@@ -0,0 +1,147 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {assert} from '@webex/test-helper-chai';
+import MockWebex from '@webex/test-helper-mock-webex';
+import {ServicesV2, ServiceDetail} from '@webex/webex-core';
+import {formattedServiceHostmapEntryConv} from '../../../fixtures/host-catalog-v2';
+
+describe('webex-core', () => {
+  describe('ServiceDetail', () => {
+    let webex;
+    let serviceDetail;
+    let template;
+
+    beforeEach(() => {
+      webex = new MockWebex();
+      new ServicesV2(undefined, {parent: webex});
+
+      template = formattedServiceHostmapEntryConv;
+
+      serviceDetail = new ServiceDetail({...template});
+    });
+
+    describe('#namespace', () => {
+      it('is accurate to plugin name', () => {
+        assert.equal(serviceDetail.namespace, 'ServiceDetail');
+      });
+    });
+
+    describe('#serviceName', () => {
+      it('is valid value', () => {
+        assert.typeOf(serviceDetail.serviceName, 'string');
+        assert.equal(serviceDetail.serviceName, 'conversation');
+      });
+    });
+
+    describe('#serviceUrls', () => {
+      it('is valid value', () => {
+        assert.typeOf(serviceDetail.serviceUrls, 'array');
+      });
+
+      it('contains all appended hosts on construction', () => {
+        template.serviceUrls.forEach((serviceUrl) => {
+          assert.include([...serviceDetail.serviceUrls], serviceUrl);
+        });
+      });
+    });
+
+    describe('#id', () => {
+      it('is valid value', () => {
+        assert.typeOf(serviceDetail.id, 'string');
+        assert.equal(serviceDetail.id, 'urn:TEAM:us-east-2_a:conversation');
+      });
+    });
+
+    describe('#_generateHostUrl()', () => {
+      it('returns a string', () => {
+        serviceDetail.serviceUrls.forEach((serviceUrl) => {
+          assert.typeOf(serviceDetail._generateHostUrl(serviceUrl), 'string');
+        });
+      });
+
+      it('replaces the host of a pass in url', () => {
+        serviceDetail.serviceUrls.forEach((serviceUrl) => {
+          assert.equal(
+            serviceDetail._generateHostUrl(serviceUrl),
+            `https://${serviceUrl.host}/conversation/api/v1`
+          );
+        });
+      });
+    });
+
+    describe('#_getPriorityHostUrl()', () => {
+      it('validates that the retrieved high priority host matches the manually retrieved high priority host', () => {
+        assert.equal(
+          serviceDetail._getPriorityHostUrl(),
+          serviceDetail._generateHostUrl(template.serviceUrls[0])
+        );
+      });
+
+      it('should pick most priority non failed host', () => {
+        serviceDetail.serviceUrls[0].failed = true;
+
+        assert.isTrue(serviceDetail.serviceUrls[0].failed);
+
+        const priorityHost = serviceDetail._getPriorityHostUrl();
+        assert.equal(priorityHost, serviceDetail.serviceUrls[1].baseUrl);
+      });
+
+      it('should reset the hosts when all have failed', () => {
+        serviceDetail.serviceUrls.forEach((serviceUrl) => {
+          /* eslint-disable-next-line no-param-reassign */
+          serviceUrl.failed = true;
+        });
+
+        assert.isTrue(serviceDetail.serviceUrls.every((serviceUrl) => serviceUrl.failed));
+
+        const priorityHost = serviceDetail._getPriorityHostUrl();
+
+        assert.equal(priorityHost, serviceDetail.serviceUrls[0].baseUrl);
+        assert.isTrue(serviceDetail.serviceUrls.every((serviceUrl) => !serviceUrl.failed));
+      });
+      it('should return empty string if no available hosts', () => {
+        serviceDetail.serviceUrls = [{priority: -1}];
+
+        const priorityHost = serviceDetail.get();
+
+        assert.equal(priorityHost, '');
+      });
+    });
+
+    describe('#get', () => {
+      it('should return empty string if no hosts are available', () => {
+        serviceDetail.serviceUrls = [];
+
+        const priorityHost = serviceDetail.get();
+
+        assert.equal(priorityHost, '');
+      });
+    });
+
+    describe('#failHost()', () => {
+      it('marks a host as failed', () => {
+        serviceDetail.failHost(serviceDetail.serviceUrls[0].baseUrl);
+
+        const removedHost = serviceDetail.serviceUrls.find(
+          (currentHost) => currentHost.host === serviceDetail.serviceUrls[0].host
+        );
+
+        assert.isTrue(removedHost.failed);
+      });
+
+      it('returns true if hostUrl was found', () => {
+        const removedHostResult = serviceDetail.failHost(serviceDetail.serviceUrls[0].baseUrl);
+
+        assert.isTrue(removedHostResult);
+      });
+
+      it('returns false if hostUrl was not found', () => {
+        const removedHostResult = serviceDetail.failHost('https://someurl.com/api/vq');
+
+        assert.isFalse(removedHostResult);
+      });
+    });
+  });
+});