@webex/webex-core 3.8.0 → 3.8.1-next.10

package/src/lib/{services/interceptors → interceptors}/server-error.js

@@ -3,7 +3,7 @@
  */
 
 import {Interceptor} from '@webex/http-core';
-import WebexHttpError from '../../webex-http-error';
+import WebexHttpError from '../webex-http-error';
 /**
  * Changes server url when it fails
  */

package/src/lib/services/index.js

@@ -3,10 +3,9 @@
  */
 import {registerInternalPlugin} from '../../webex-core';
 
-import * as constants from './constants';
 import Services from './services';
-import ServerErrorInterceptor from './interceptors/server-error';
-import ServiceInterceptor from './interceptors/service';
+import ServerErrorInterceptor from '../interceptors/server-error';
+import ServiceInterceptor from '../interceptors/service';
 
 registerInternalPlugin('services', Services, {
   interceptors: {
@@ -15,10 +14,6 @@ registerInternalPlugin('services', Services, {
   },
 });
 
-export {constants};
-export {default as ServiceInterceptor} from './interceptors/service';
-export {default as ServerErrorInterceptor} from './interceptors/server-error';
-export {default as HostMapInterceptor} from './interceptors/hostmap';
 export {default as Services} from './services';
 export {default as ServiceCatalog} from './service-catalog';
 export {default as ServiceRegistry} from './service-registry';

package/src/lib/services/service-host.js

@@ -1,6 +1,6 @@
 import Url from 'url';
 
-import {SERVICE_CATALOGS} from './constants';
+import {SERVICE_CATALOGS} from '../constants';
 
 /**
  * The parameter transfer object for {@link ServiceHost#constructor}.

package/src/lib/services/service-registry.js

@@ -1,4 +1,4 @@
-import {SERVICE_CATALOGS, SERVICE_CATALOGS_ENUM_TYPES} from './constants';
+import {SERVICE_CATALOGS, SERVICE_CATALOGS_ENUM_TYPES} from '../constants';
 import ServiceHost from './service-host';
 
 /**

package/src/lib/services/service-state.js

@@ -1,4 +1,4 @@
-import {SERVICE_CATALOGS} from './constants';
+import {SERVICE_CATALOGS} from '../constants';
 
 /**
  * The state of a specific catalog to be used by {@link ServiceState}.

package/src/lib/services/services.js

@@ -3,12 +3,12 @@ import sha256 from 'crypto-js/sha256';
 import {union, forEach} from 'lodash';
 import WebexPlugin from '../webex-plugin';
 
-import METRICS from './metrics';
+import METRICS from '../metrics';
 import ServiceCatalog from './service-catalog';
 import ServiceRegistry from './service-registry';
 import ServiceState from './service-state';
 import fedRampServices from './service-fed-ramp';
-import {COMMERCIAL_ALLOWED_DOMAINS} from './constants';
+import {COMMERCIAL_ALLOWED_DOMAINS} from '../constants';
 
 const trailingSlashes = /(?:^\/)|(?:\/$)/;
 

package/src/lib/services-v2/README.md

@@ -0,0 +1,3 @@
+[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+
+> Services plugin update for WG4 DNSSec enabled users, this module is a work in progress. Please use at your own risk! This service will be updated many times to enable this feature. Continue to use /services.

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

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+export {default as ServicesV2} from './services-v2';
+export {default as ServiceCatalogV2} from './service-catalog';
+export {default as ServiceDetail} from './service-detail';

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

@@ -0,0 +1,4 @@
+// Metrics for service catalog
+export default {
+  JS_SDK_SERVICE_NOT_FOUND: 'JS_SDK_SERVICE_NOT_FOUND',
+};

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

@@ -0,0 +1,361 @@
+import AmpState from 'ampersand-state';
+
+import {union} from 'lodash';
+import ServiceDetail from './service-detail';
+import {IServiceDetail, ServiceGroup} from './types';
+
+/**
+ * @class
+ */
+const ServiceCatalog = AmpState.extend({
+  namespace: 'ServiceCatalog',
+
+  props: {
+    serviceGroups: [
+      'object',
+      true,
+      () => ({
+        discovery: [],
+        override: [],
+        preauth: [],
+        postauth: [],
+        signin: [],
+      }),
+    ],
+    status: [
+      'object',
+      true,
+      () => ({
+        discovery: {
+          ready: false,
+          collecting: false,
+        },
+        override: {
+          ready: false,
+          collecting: false,
+        },
+        preauth: {
+          ready: false,
+          collecting: false,
+        },
+        postauth: {
+          ready: false,
+          collecting: false,
+        },
+        signin: {
+          ready: false,
+          collecting: false,
+        },
+      }),
+    ],
+    isReady: ['boolean', false, false],
+    allowedDomains: ['array', false, () => []],
+  },
+
+  /**
+   * @private
+   * Get all service details for a given service group or return all details if no group is specified.
+   * @param {ServiceGroup} serviceGroup - The name of the service group to retrieve details for.
+   * @returns {Array<IServiceDetail>} - An array of service details.
+   */
+  _getAllServiceDetails(serviceGroup?: ServiceGroup): Array<IServiceDetail> {
+    const serviceDetails =
+      typeof serviceGroup === 'string'
+        ? this.serviceGroups[serviceGroup] || []
+        : [
+            ...this.serviceGroups.override,
+            ...this.serviceGroups.postauth,
+            ...this.serviceGroups.signin,
+            ...this.serviceGroups.preauth,
+            ...this.serviceGroups.discovery,
+          ];
+
+    return serviceDetails;
+  },
+
+  /**
+   * @private
+   * Search the service details array to locate a `ServiceDetails`
+   * class object based on its id.
+   * @param {string} clusterId
+   * @param {ServiceGroup} [serviceGroup]
+   * @returns {IServiceDetail}
+   */
+  _getServiceDetail(clusterId: string, serviceGroup?: ServiceGroup): IServiceDetail | undefined {
+    const serviceDetails = this._getAllServiceDetails(serviceGroup);
+
+    return serviceDetails.find((serviceDetail: IServiceDetail) => serviceDetail.id === clusterId);
+  },
+
+  /**
+   * @private
+   * Safely load one or more `ServiceDetail`s into this `ServiceCatalog` instance.
+   * @param {ServiceGroup} serviceGroup
+   * @param  {Array<ServiceDetail>} serviceDetails
+   * @returns {void}
+   */
+  _loadServiceDetails(serviceGroup: ServiceGroup, serviceDetails: Array<IServiceDetail>): void {
+    // declare namespaces outside of loop
+    let existingService: IServiceDetail | undefined;
+
+    serviceDetails.forEach((service) => {
+      existingService = this._getServiceDetail(service.id, serviceGroup);
+
+      if (!existingService) {
+        this.serviceGroups[serviceGroup].push(service);
+      }
+    });
+  },
+
+  /**
+   * @private
+   * Safely unload one or more `ServiceDetail`s into this `Services` instance
+   * @param {ServiceGroup} serviceGroup
+   * @param  {Array<ServiceDetail>} serviceDetails
+   * @returns {void}
+   */
+  _unloadServiceDetails(serviceGroup: ServiceGroup, serviceDetails: Array<IServiceDetail>): void {
+    // declare namespaces outside of loop
+    let existingService: IServiceDetail | undefined;
+
+    serviceDetails.forEach((service) => {
+      existingService = this._getServiceDetail(service.id, serviceGroup);
+
+      if (existingService) {
+        this.serviceGroups[serviceGroup].splice(
+          this.serviceGroups[serviceGroup].indexOf(existingService),
+          1
+        );
+      }
+    });
+  },
+
+  /**
+   * Clear all collected catalog data and reset catalog status.
+   *
+   * @returns {void}
+   */
+  clean(): void {
+    this.serviceGroups.preauth.length = 0;
+    this.serviceGroups.signin.length = 0;
+    this.serviceGroups.postauth.length = 0;
+    this.status.preauth = {ready: false};
+    this.status.signin = {ready: false};
+    this.status.postauth = {ready: false};
+  },
+
+  /**
+   * Search over all service groups to find a cluster id based
+   * on a given url.
+   * @param {string} url - Must be parsable by `Url`
+   * @returns {string | undefined} - ClusterId of a given url
+   */
+  findClusterId(url: string): string | undefined {
+    try {
+      const incomingUrlObj = new URL(url);
+      const allServiceDetails = this._getAllServiceDetails();
+
+      return allServiceDetails.find((serviceDetail: IServiceDetail) =>
+        serviceDetail.serviceUrls.find(({host}) => host === incomingUrlObj.host)
+      )?.id;
+    } catch {
+      // If the URL is invalid or can't be found, return undefined
+      return undefined;
+    }
+  },
+
+  /**
+   * Search over all service groups and return a service value from a provided
+   * clusterId.
+   * @param {object} params
+   * @param {string} params.clusterId - clusterId of found service
+   * @param {ServiceGroup} [params.serviceGroup] - specify service group
+   * @returns {object} service
+   * @returns {string} service.name
+   * @returns {string} service.url
+   */
+  findServiceFromClusterId(
+    {clusterId, serviceGroup} = {} as {clusterId: string; serviceGroup?: ServiceGroup}
+  ): {name: string; url: string} | undefined {
+    const serviceDetails = this._getServiceDetail(clusterId, serviceGroup);
+
+    if (serviceDetails) {
+      return {
+        name: serviceDetails.serviceName,
+        url: serviceDetails.get(),
+      };
+    }
+
+    return undefined;
+  },
+
+  /**
+   * Find a service based on the provided url.
+   * @param {string} url - Must be parsable by `Url`
+   * @returns {IServiceDetail} - ServiceDetail assocated with provided url
+   */
+  findServiceDetailFromUrl(url: string): IServiceDetail | undefined {
+    const serviceDetails = this._getAllServiceDetails();
+
+    return serviceDetails.find(({serviceUrls}) => {
+      for (const serviceUrl of serviceUrls) {
+        if (url.startsWith(serviceUrl.baseUrl)) {
+          return true;
+        }
+      }
+
+      return false;
+    });
+  },
+
+  /**
+   * Finds an allowed domain that matches a specific url.
+   *
+   * @param {string} url - The url to match the allowed domains against.
+   * @returns {string} - The matching allowed domain.
+   */
+  findAllowedDomain(url: string): string {
+    try {
+      const urlObj = new URL(url);
+
+      return this.allowedDomains.find((allowedDomain) => urlObj.host.includes(allowedDomain));
+    } catch {
+      // If the URL is invalid or can't be found, return undefined
+      return undefined;
+    }
+  },
+
+  /**
+   * Get a service url from the current services list by name. Return undefined
+   * if the service is not found.
+   * @param {string} clusterId
+   * @param {ServiceGroup} serviceGroup
+   * @returns {string | undefined}
+   */
+  get(clusterId: string, serviceGroup?: ServiceGroup): string | undefined {
+    const serviceDetail = this._getServiceDetail(clusterId, serviceGroup);
+
+    return serviceDetail ? serviceDetail.get() : undefined;
+  },
+
+  /**
+   * Get the current allowed domains list.
+   *
+   * @returns {Array<string>} - the current allowed domains list.
+   */
+  getAllowedDomains(): Array<string> {
+    return [...this.allowedDomains];
+  },
+
+  /**
+   * Mark a priority host service url as failed.
+   * This will mark the host associated with the
+   * `ServiceDetail` to be removed from the its
+   * respective host array, and then return the next
+   * 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
+   * @returns {string}
+   */
+  markFailedServiceUrl(url: string): string | undefined {
+    const serviceDetails = this._getAllServiceDetails();
+
+    const serviceDetailWithFailedHost = serviceDetails.find((serviceDetail: IServiceDetail) =>
+      serviceDetail.failHost(url)
+    );
+
+    // if we couldn't find the url we wanted to fail, return undefined
+    if (!serviceDetailWithFailedHost) {
+      return undefined;
+    }
+
+    return serviceDetailWithFailedHost.get();
+  },
+
+  /**
+   * Set the allowed domains for the catalog.
+   *
+   * @param {Array<string>} allowedDomains - allowed domains to be assigned.
+   * @returns {void}
+   */
+  setAllowedDomains(allowedDomains: Array<string>): void {
+    this.allowedDomains = [...allowedDomains];
+  },
+
+  /**
+   *
+   * @param {Array<string>} newAllowedDomains - new allowed domains to add to existing set of allowed domains
+   * @returns {void}
+   */
+  addAllowedDomains(newAllowedDomains: Array<string>): void {
+    this.allowedDomains = union(this.allowedDomains, newAllowedDomains);
+  },
+
+  /**
+   * Update the current list of `ServiceDetail`s against a provided
+   * service hostmap.
+   * @emits ServiceCatalog#preauthorized
+   * @emits ServiceCatalog#postauthorized
+   * @param {ServiceGroup} serviceGroup
+   * @param {Array<IServiceDetail>} serviceDetails
+   * @returns {void}
+   */
+  updateServiceGroups(serviceGroup: ServiceGroup, serviceDetails: Array<IServiceDetail>) {
+    const currentServiceDetails = this.serviceGroups[serviceGroup];
+
+    const unusedServicesDetails = currentServiceDetails.filter((serviceDetail) =>
+      serviceDetails.every(({id}) => id !== serviceDetail.id)
+    );
+
+    this._unloadServiceDetails(serviceGroup, unusedServicesDetails);
+
+    serviceDetails.forEach((serviceObj) => {
+      const serviceDetail = this._getServiceDetail(serviceObj.id, serviceGroup);
+
+      if (serviceDetail) {
+        serviceDetail.serviceUrls = serviceObj.serviceUrls || [];
+      } else {
+        this._loadServiceDetails(serviceGroup, [new ServiceDetail(serviceObj)]);
+      }
+    });
+
+    this.status[serviceGroup].ready = true;
+    this.trigger(serviceGroup);
+  },
+
+  /**
+   * Wait until the service catalog is available,
+   * or reject after a timeout of 60 seconds.
+   * @param {ServiceGroup} serviceGroup
+   * @param {number} [timeout] - in seconds
+   * @returns {Promise<void>}
+   */
+  waitForCatalog(serviceGroup: ServiceGroup, timeout?: number): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      if (this.status[serviceGroup].ready) {
+        resolve();
+      }
+
+      const validatedTimeout = typeof timeout === 'number' && timeout >= 0 ? timeout : 60;
+
+      const timeoutTimer = setTimeout(
+        () =>
+          reject(
+            new Error(
+              `services: timeout occured while waiting for '${serviceGroup}' catalog to populate`
+            )
+          ),
+        validatedTimeout * 1000
+      );
+
+      this.once(serviceGroup, () => {
+        clearTimeout(timeoutTimer);
+        resolve();
+      });
+    });
+  },
+});
+
+export default ServiceCatalog;

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/service-fed-ramp.ts

@@ -0,0 +1,5 @@
+export default {
+  hydra: 'https://api-usgov.webex.com/v1',
+  u2c: 'https://u2c.gov.ciscospark.com/u2c/api/v1',
+  sqdiscovery: 'https://ds.ciscospark.com/v1/region', // TODO: fedramp load balanced URL? this has been here for years as of now but now explicitly done
+};