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

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.ts

@@ -0,0 +1,360 @@
+import AmpState from 'ampersand-state';
+
+import {union} from 'lodash';
+import ServiceDetail from './service-detail';
+import {IServiceDetail} 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 {string} serviceGroup - The name of the service group to retrieve details for.
+   * @returns {Array<IServiceDetail>} - An array of service details.
+   */
+  _getAllServiceDetails(serviceGroup: string): 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 {string} [serviceGroup]
+   * @returns {IServiceDetail}
+   */
+  _getServiceDetail(clusterId: string, serviceGroup: string): 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 {string} serviceGroup
+   * @param  {Array<ServiceDetail>} serviceDetails
+   * @returns {void}
+   */
+  _loadServiceDetails(serviceGroup: string, 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 {string} serviceGroup
+   * @param  {Array<ServiceDetail>} serviceDetails
+   * @returns {void}
+   */
+  _unloadServiceDetails(serviceGroup: string, 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 {string} [params.serviceGroup] - specify service group
+   * @returns {object} service
+   * @returns {string} service.name
+   * @returns {string} service.url
+   */
+  findServiceFromClusterId(
+    {clusterId, serviceGroup} = {} as {clusterId: string; serviceGroup: string}
+  ): {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.
+   * @param {string} clusterId
+   * @param {string} serviceGroup
+   * @returns {string}
+   */
+  get(clusterId: string, serviceGroup: string): 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 {string} serviceGroup
+   * @param {Array<IServiceDetail>} serviceDetails
+   * @returns {void}
+   */
+  updateServiceGroups(serviceGroup: string, 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 {string} serviceGroup
+   * @param {number} [timeout] - in seconds
+   * @returns {Promise<void>}
+   */
+  waitForCatalog(serviceGroup: string, 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
+};