@webex/webex-core 3.8.0-next.2 → 3.8.0-next.20

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

@@ -0,0 +1,23 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+// import {registerInternalPlugin} from '../../webex-core';
+
+import * as constants from './constants';
+// import ServerErrorInterceptor from './interceptors/server-error';
+// import ServiceInterceptor from './interceptors/service';
+export {default as ServicesV2} from './services-v2';
+
+// registerInternalPlugin('services', ServicesV2, {
+//   interceptors: {
+//     ServiceInterceptor: ServiceInterceptor.create,
+//     ServerErrorInterceptor: ServerErrorInterceptor.create,
+//   },
+// });
+
+export {constants};
+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';

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

@@ -0,0 +1,36 @@
+/*!
+ * Copyright (c) 2015-2024 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+
+/**
+ * This interceptor replaces the host in the request uri with the host from the hostmap
+ * It will attempt to do this for every request, but not all URIs will be in the hostmap
+ * URIs with hosts that are not in the hostmap will be left unchanged
+ */
+export default class HostMapInterceptor extends Interceptor {
+  /**
+   * @returns {HostMapInterceptor}
+   */
+  static create() {
+    return new HostMapInterceptor({webex: this});
+  }
+
+  /**
+   * @see Interceptor#onRequest
+   * @param {Object} options
+   * @returns {Object}
+   */
+  onRequest(options) {
+    if (options.uri) {
+      try {
+        options.uri = this.webex.internal.services.replaceHostFromHostmap(options.uri);
+      } catch (error) {
+        /* empty */
+      }
+    }
+
+    return options;
+  }
+}

package/src/lib/services-v2/interceptors/server-error.js

@@ -0,0 +1,48 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+import WebexHttpError from '../../webex-http-error';
+/**
+ * Changes server url when it fails
+ */
+export default class ServerErrorInterceptor extends Interceptor {
+  /**
+   * @returns {HAMessagingInterceptor}
+   */
+  static create() {
+    // eslint-disable-next-line no-invalid-this
+    return new ServerErrorInterceptor({webex: this});
+  }
+
+  /**
+   * @see Interceptor#onResponseError
+   * @param {Object} options
+   * @param {Object} reason
+   * @returns {Object}
+   */
+  onResponseError(options, reason) {
+    if (
+      (reason instanceof WebexHttpError.InternalServerError ||
+        reason instanceof WebexHttpError.BadGateway ||
+        reason instanceof WebexHttpError.ServiceUnavailable) &&
+      options.uri
+    ) {
+      const feature = this.webex.internal.device.features.developer.get('web-high-availability');
+
+      if (feature && feature.value) {
+        this.webex.internal.metrics.submitClientMetrics('web-ha', {
+          fields: {success: false},
+          tags: {action: 'failed', error: reason.message, url: options.uri},
+        });
+
+        return Promise.resolve(this.webex.internal.services.markFailedUrl(options.uri)).then(() =>
+          Promise.reject(reason)
+        );
+      }
+    }
+
+    return Promise.reject(reason);
+  }
+}

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

@@ -0,0 +1,101 @@
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Interceptor} from '@webex/http-core';
+
+const trailingSlashes = /(?:^\/)|(?:\/$)/;
+
+/**
+ * @class
+ */
+export default class ServiceInterceptor extends Interceptor {
+  /**
+   * @returns {ServiceInterceptor}
+   */
+  static create() {
+    /* eslint no-invalid-this: [0] */
+    return new ServiceInterceptor({webex: this});
+  }
+
+  /* eslint-disable no-param-reassign */
+  /**
+   * @see Interceptor#onRequest
+   * @param {Object} options - The request PTO.
+   * @returns {Object} - The mutated request PTO.
+   */
+  onRequest(options) {
+    // Validate that the PTO includes a uri property.
+    if (options.uri) {
+      return options;
+    }
+
+    // Normalize and validate the PTO.
+    this.normalizeOptions(options);
+    this.validateOptions(options);
+
+    // Destructure commonly referenced namespaces.
+    const {services} = this.webex.internal;
+    const {service, resource, waitForServiceTimeout} = options;
+
+    // Attempt to collect the service url.
+    return services
+      .waitForService({name: service, timeout: waitForServiceTimeout})
+      .then((serviceUrl) => {
+        // Generate the combined service url and resource.
+        options.uri = this.generateUri(serviceUrl, resource);
+
+        return options;
+      })
+      .catch(() =>
+        Promise.reject(new Error(`service-interceptor: '${service}' is not a known service`))
+      );
+  }
+
+  /* eslint-disable class-methods-use-this */
+  /**
+   * Generate a usable request uri string from a service url and a resouce.
+   *
+   * @param {string} serviceUrl - The service url.
+   * @param {string} [resource] - The resouce to be appended to the service url.
+   * @returns {string} - The combined service url and resource.
+   */
+  generateUri(serviceUrl, resource = '') {
+    const formattedService = serviceUrl.replace(trailingSlashes, '');
+    const formattedResource = resource.replace(trailingSlashes, '');
+
+    return `${formattedService}/${formattedResource}`;
+  }
+
+  /**
+   * Normalizes request options relative to service identification.
+   *
+   * @param {Object} options - The request PTO.
+   * @returns {Object} - The mutated request PTO.
+   */
+  normalizeOptions(options) {
+    // Validate if the api property is used.
+    if (options.api) {
+      // Assign the service property the value of the api property if necessary.
+      options.service = options.service || options.api;
+      delete options.api;
+    }
+  }
+
+  /**
+   * Validates that the appropriate options for this interceptor are present.
+   *
+   * @param {Object} options - The request PTO.
+   * @returns {Object} - The mutated request PTO.
+   */
+  validateOptions(options) {
+    if (!options.resource) {
+      throw new Error('a `resource` parameter is required');
+    }
+
+    if (!options.service) {
+      throw new Error("a valid 'service' parameter is required");
+    }
+  }
+  /* eslint-enable class-methods-use-this, no-param-reassign */
+}

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

@@ -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.js

@@ -0,0 +1,455 @@
+import Url from 'url';
+
+import AmpState from 'ampersand-state';
+
+import {union} from 'lodash';
+import ServiceUrl from './service-url';
+
+/* eslint-disable no-underscore-dangle */
+/**
+ * @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
+   * Search the service url array to locate a `ServiceUrl`
+   * class object based on its name.
+   * @param {string} name
+   * @param {string} [serviceGroup]
+   * @returns {ServiceUrl}
+   */
+  _getUrl(name, serviceGroup) {
+    const serviceUrls =
+      typeof serviceGroup === 'string'
+        ? this.serviceGroups[serviceGroup] || []
+        : [
+            ...this.serviceGroups.override,
+            ...this.serviceGroups.postauth,
+            ...this.serviceGroups.signin,
+            ...this.serviceGroups.preauth,
+            ...this.serviceGroups.discovery,
+          ];
+
+    return serviceUrls.find((serviceUrl) => serviceUrl.name === name);
+  },
+
+  /**
+   * @private
+   * Generate an array of `ServiceUrl`s that is organized from highest auth
+   * level to lowest auth level.
+   * @returns {Array<ServiceUrl>} - array of `ServiceUrl`s
+   */
+  _listServiceUrls() {
+    return [
+      ...this.serviceGroups.override,
+      ...this.serviceGroups.postauth,
+      ...this.serviceGroups.signin,
+      ...this.serviceGroups.preauth,
+      ...this.serviceGroups.discovery,
+    ];
+  },
+
+  /**
+   * @private
+   * Safely load one or more `ServiceUrl`s into this `Services` instance.
+   * @param {string} serviceGroup
+   * @param  {Array<ServiceUrl>} services
+   * @returns {Services}
+   */
+  _loadServiceUrls(serviceGroup, services) {
+    // declare namespaces outside of loop
+    let existingService;
+
+    services.forEach((service) => {
+      existingService = this._getUrl(service.name, serviceGroup);
+
+      if (!existingService) {
+        this.serviceGroups[serviceGroup].push(service);
+      }
+    });
+
+    return this;
+  },
+
+  /**
+   * @private
+   * Safely unload one or more `ServiceUrl`s into this `Services` instance
+   * @param {string} serviceGroup
+   * @param  {Array<ServiceUrl>} services
+   * @returns {Services}
+   */
+  _unloadServiceUrls(serviceGroup, services) {
+    // declare namespaces outside of loop
+    let existingService;
+
+    services.forEach((service) => {
+      existingService = this._getUrl(service.name, serviceGroup);
+
+      if (existingService) {
+        this.serviceGroups[serviceGroup].splice(
+          this.serviceGroups[serviceGroup].indexOf(existingService),
+          1
+        );
+      }
+    });
+
+    return this;
+  },
+
+  /**
+   * Clear all collected catalog data and reset catalog status.
+   *
+   * @returns {void}
+   */
+  clean() {
+    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} - ClusterId of a given url
+   */
+  findClusterId(url) {
+    const incomingUrlObj = Url.parse(url);
+    let serviceUrlObj;
+
+    for (const key of Object.keys(this.serviceGroups)) {
+      for (const service of this.serviceGroups[key]) {
+        serviceUrlObj = Url.parse(service.defaultUrl);
+
+        for (const host of service.hosts) {
+          if (incomingUrlObj.hostname === host.host && host.id) {
+            return host.id;
+          }
+        }
+
+        if (serviceUrlObj.hostname === incomingUrlObj.hostname && service.hosts.length > 0) {
+          // no exact match, so try to grab the first home cluster
+          for (const host of service.hosts) {
+            if (host.homeCluster) {
+              return host.id;
+            }
+          }
+
+          // no match found still, so return the first entry
+          return service.hosts[0].id;
+        }
+      }
+    }
+
+    return undefined;
+  },
+
+  /**
+   * Search over all service groups and return a service value from a provided
+   * clusterId. Currently, this method will return either a service name, or a
+   * service url depending on the `value` parameter. If the `value` parameter
+   * is set to `name`, it will return a service name to be utilized within the
+   * Services plugin methods.
+   * @param {object} params
+   * @param {string} params.clusterId - clusterId of found service
+   * @param {boolean} [params.priorityHost = true] - returns priority host url if true
+   * @param {string} [params.serviceGroup] - specify service group
+   * @returns {object} service
+   * @returns {string} service.name
+   * @returns {string} service.url
+   */
+  findServiceFromClusterId({clusterId, priorityHost = true, serviceGroup} = {}) {
+    const serviceUrls =
+      typeof serviceGroup === 'string'
+        ? this.serviceGroups[serviceGroup] || []
+        : [
+            ...this.serviceGroups.override,
+            ...this.serviceGroups.postauth,
+            ...this.serviceGroups.signin,
+            ...this.serviceGroups.preauth,
+            ...this.serviceGroups.discovery,
+          ];
+
+    const identifiedServiceUrl = serviceUrls.find((serviceUrl) =>
+      serviceUrl.hosts.find((host) => host.id === clusterId)
+    );
+
+    if (identifiedServiceUrl) {
+      return {
+        name: identifiedServiceUrl.name,
+        url: identifiedServiceUrl.get(priorityHost, clusterId),
+      };
+    }
+
+    return undefined;
+  },
+
+  /**
+   * Find a service based on the provided url.
+   * @param {string} url - Must be parsable by `Url`
+   * @returns {serviceUrl} - ServiceUrl assocated with provided url
+   */
+  findServiceUrlFromUrl(url) {
+    const serviceUrls = [
+      ...this.serviceGroups.discovery,
+      ...this.serviceGroups.preauth,
+      ...this.serviceGroups.signin,
+      ...this.serviceGroups.postauth,
+      ...this.serviceGroups.override,
+    ];
+
+    return serviceUrls.find((serviceUrl) => {
+      // Check to see if the URL we are checking starts with the default URL
+      if (url.startsWith(serviceUrl.defaultUrl)) {
+        return true;
+      }
+
+      // If not, we check to see if the alternate URLs match
+      // These are made by swapping the host of the default URL
+      // with that of an alternate host
+      for (const host of serviceUrl.hosts) {
+        const alternateUrl = new URL(serviceUrl.defaultUrl);
+        alternateUrl.host = host.host;
+
+        if (url.startsWith(alternateUrl.toString())) {
+          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) {
+    const urlObj = Url.parse(url);
+
+    if (!urlObj.host) {
+      return undefined;
+    }
+
+    return this.allowedDomains.find((allowedDomain) => urlObj.host.includes(allowedDomain));
+  },
+
+  /**
+   * Get a service url from the current services list by name.
+   * @param {string} name
+   * @param {boolean} priorityHost
+   * @param {string} serviceGroup
+   * @returns {string}
+   */
+  get(name, priorityHost, serviceGroup) {
+    const serviceUrl = this._getUrl(name, serviceGroup);
+
+    return serviceUrl ? serviceUrl.get(priorityHost) : undefined;
+  },
+
+  /**
+   * Get the current allowed domains list.
+   *
+   * @returns {Array<string>} - the current allowed domains list.
+   */
+  getAllowedDomains() {
+    return [...this.allowedDomains];
+  },
+
+  /**
+   * Creates an object where the keys are the service names
+   * and the values are the service urls.
+   * @param {boolean} priorityHost - use the highest priority if set to `true`
+   * @param {string} [serviceGroup]
+   * @returns {Record<string, string>}
+   */
+  list(priorityHost, serviceGroup) {
+    const output = {};
+
+    const serviceUrls =
+      typeof serviceGroup === 'string'
+        ? this.serviceGroups[serviceGroup] || []
+        : [
+            ...this.serviceGroups.discovery,
+            ...this.serviceGroups.preauth,
+            ...this.serviceGroups.signin,
+            ...this.serviceGroups.postauth,
+            ...this.serviceGroups.override,
+          ];
+
+    if (serviceUrls) {
+      serviceUrls.forEach((serviceUrl) => {
+        output[serviceUrl.name] = serviceUrl.get(priorityHost);
+      });
+    }
+
+    return output;
+  },
+
+  /**
+   * Mark a priority host service url as failed.
+   * This will mark the host associated with the
+   * `ServiceUrl` 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
+   * hosts are available, or if `noPriorityHosts` is set to
+   * `true`.
+   * @param {string} url
+   * @param {boolean} noPriorityHosts
+   * @returns {string}
+   */
+  markFailedUrl(url, noPriorityHosts) {
+    const serviceUrl = this._getUrl(
+      Object.keys(this.list()).find((key) => this._getUrl(key).failHost(url))
+    );
+
+    if (!serviceUrl) {
+      return undefined;
+    }
+
+    return noPriorityHosts ? serviceUrl.get(false) : serviceUrl.get(true);
+  },
+
+  /**
+   * Set the allowed domains for the catalog.
+   *
+   * @param {Array<string>} allowedDomains - allowed domains to be assigned.
+   * @returns {void}
+   */
+  setAllowedDomains(allowedDomains) {
+    this.allowedDomains = [...allowedDomains];
+  },
+
+  /**
+   *
+   * @param {Array<string>} newAllowedDomains - new allowed domains to add to existing set of allowed domains
+   * @returns {void}
+   */
+  addAllowedDomains(newAllowedDomains) {
+    this.allowedDomains = union(this.allowedDomains, newAllowedDomains);
+  },
+
+  /**
+   * Update the current list of `ServiceUrl`s against a provided
+   * service hostmap.
+   * @emits ServiceCatalog#preauthorized
+   * @emits ServiceCatalog#postauthorized
+   * @param {string} serviceGroup
+   * @param {object} serviceHostmap
+   * @returns {Services}
+   */
+  updateServiceUrls(serviceGroup, serviceHostmap) {
+    const currentServiceUrls = this.serviceGroups[serviceGroup];
+
+    const unusedUrls = currentServiceUrls.filter((serviceUrl) =>
+      serviceHostmap.every((item) => item.name !== serviceUrl.name)
+    );
+
+    this._unloadServiceUrls(serviceGroup, unusedUrls);
+
+    serviceHostmap.forEach((serviceObj) => {
+      const service = this._getUrl(serviceObj.name, serviceGroup);
+
+      if (service) {
+        service.defaultUrl = serviceObj.defaultUrl;
+        service.hosts = serviceObj.hosts || [];
+      } else {
+        this._loadServiceUrls(serviceGroup, [
+          new ServiceUrl({
+            ...serviceObj,
+          }),
+        ]);
+      }
+    });
+
+    this.status[serviceGroup].ready = true;
+    this.trigger(serviceGroup);
+
+    return this;
+  },
+
+  /**
+   * Wait until the service catalog is available,
+   * or reject after a timeout of 60 seconds.
+   * @param {string} serviceGroup
+   * @param {number} [timeout] - in seconds
+   * @returns {Promise<void>}
+   */
+  waitForCatalog(serviceGroup, timeout) {
+    return new Promise((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();
+      });
+    });
+  },
+});
+/* eslint-enable no-underscore-dangle */
+
+export default ServiceCatalog;

package/src/lib/services-v2/service-fed-ramp.js

@@ -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
+};