core/routemgmt/common/utils.js

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * Route management action common utilities
 */
var request = require('request');
var utils2 = require('./apigw-utils.js');

/**
 * Register a tenant with the API GW.
 * A new tenant is created for each unique namespace/tenantinstance.  If the
 * tenant already exists, the tenant is left as-is
 * Parameters:
 *  gwInfo         - Required. API GW connection information (gwUrl, gwAuth)
 *  namespace      - Required. Namespace of tenant
 *  tenantInstance - Optional. Tenanant instance used to create >1 tenant per namespace
 *                   Defaults to 'openwhisk'
 * Returns:
 *  tenant object  - JSON object representing the tenant in the following format:
 *                   { id: GUID, namespace: NAMESPACE, instance: 'openwhisk' }
 */
function createTenant(gwInfo, namespace, tenantInstance) {
  var instance = tenantInstance || 'openwhisk';  // Default to a fixed instance so all openwhisk tenants have a common instance
  var options = {
    followAllRedirects: true,
    url: gwInfo.gwUrl+'/tenants',
    headers: {
      'Accept': 'application/json'
    },
    json: {                     // Auto set header: 'Content-Type': 'application/json'
      instance: instance,
      namespace: namespace
    }
  };
  if (gwInfo.gwAuth) {
    options.headers.Authorization = 'Basic ' + gwInfo.gwAuth;
  }
  console.log('addTenantToGateway: request: '+JSON.stringify(options));

  return new Promise(function(resolve, reject) {
    request.put(options, function(error, response, body) {
      var statusCode = response ? response.statusCode : undefined;
      console.log('addTenantToGateway: response status: '+ statusCode);
      if (error) console.error('Warning: addTenantToGateway request failed: '+utils2.makeJsonString(error));
      if (body) console.log('addTenantToGateway: response body: '+utils2.makeJsonString(body));

      if (error) {
        console.error('addTenantToGateway: Unable to configure a tenant on the API Gateway');
        reject('Unable to configure the API Gateway: '+utils2.makeJsonString(error));
      } else if (statusCode != 200) {
        if (body) {
          var errMsg = JSON.stringify(body);
          if (body.error && body.error.message) errMsg = body.error.message;
          reject('API Gateway failure (status code '+statusCode+'): '+ errMsg);
        } else {
          reject('Unable to configure the API Gateway: Response failure code: '+statusCode);
        }

      } else {
        if (body && body.id) {  // body has format like:  { id: GUID, namespace: NAMESPACE, instance: 'openwhisk' }
          console.log('addTenantToGateway: got a single tenant response');
          resolve(body);
        } else {
          console.error('addTenantToGateway: failure: No tenant guid provided');
          reject('Unable to configure the API Gateway: Invalid response from API Gateway');
        }
      }
    });
  });
}

/*
 * Return an array of tenants
 */
function getTenants(gwInfo, ns, tenantInstance) {
  var qsNsOnly = { 'filter[where][namespace]' : ns };
  var qsNsAndInstance = { 'filter[where][namespace]' : ns,
                          'filter[where][instance]'  : tenantInstance };
  var qs = qsNsOnly;
  if (tenantInstance) qs = qsNsAndInstance;
  var options = {
    followAllRedirects: true,
    url: gwInfo.gwUrl+'/tenants',
    qs: qs,
    headers: {
      'Accept': 'application/json'
    },
  };
  if (gwInfo.gwAuth) {
    options.headers.Authorization = 'Basic ' + gwInfo.gwAuth;
  }
  console.log('getTenants: request: '+JSON.stringify(options));

  return new Promise(function(resolve, reject) {
    request.get(options, function(error, response, body) {
      var statusCode = response ? response.statusCode : undefined;
      console.log('getTenants: response status: '+ statusCode);
      if (error) console.error('Warning: getTenant request failed: '+utils2.makeJsonString(error));
      if (body) console.log('getTenants: response body: '+utils2.makeJsonString(body));
      if (error) {
        console.error('getTenants: Unable to obtain tenant from the API Gateway');
        reject('Unable to obtain Tenant from the API Gateway: '+utils2.makeJsonString(error));
      } else if (statusCode != 200) {
        if (body) {
          var errMsg = JSON.stringify(body);
          if (body.error && body.error.message) errMsg = body.error.message;
          reject('API Gateway failure (status code '+statusCode+'): '+ errMsg);
        } else {
          reject('Unable to configure the API Gateway: Response failure code: '+statusCode);
        }
      } else {
        if (body) {
          try {
            var bodyJson = JSON.parse(body);
            if (Array.isArray(bodyJson)) {
              resolve(bodyJson);
            } else {
              console.error('getTenants: Invalid API GW response body; a JSON array was not returned');
              resolve( [] );
            }
          } catch(e) {
            console.error('getTenants: Invalid API GW response body; JSON.parse() failure: '+e);
            reject('Internal error. Invalid API Gateway response: '+e);
          }
        } else {
          console.log('getTenants: No tenants found');
          resolve( [] );
        }
      }
    });
  });
}

/**
 * Configures an API route on the API Gateway.  This API will map to an OpenWhisk action that
 * will be invoked by the API Gateway when the API route is accessed.
 *
 * @param gwInfo Required.
 * @param    gwUrl   Required.  The base URL gateway path (i.e.  'PROTOCOL://gw.host.domain:PORT/CONTEXT')
 * @param    gwAuth  Required.  The credentials used to access the API Gateway REST endpoints
 * @param tenantId   Required.
 * @param swaggerApi   Required. The gateway API object to send to the API gateway
 * @param   payload.namespace  Required. The OpenWhisk namespace of the user defining this API route
 * @param   payload.gatewayPath  Required.  The relative path for this route
 * @param   payload.gatewayMethod  Required.  The gateway route REST verb
 * @param   payload.backendUrl  Required.  The full REST URL used to invoke the associated action
 * @param   payload.backendMethod  Required.  The REST verb used to invoke the associated action
 * @return A promise for an object describing the result with fields error and response
 */
function addApiToGateway(gwInfo, tenantId, swaggerApi, gwApiId) {
  var requestFcn = request.post;

  // Init the GW API configuration object; base it off the swagger API
  var gwApi;
  try {
    gwApi = generateGwApiFromSwaggerApi(swaggerApi);
  } catch(e) {
    console.error('generateGwApiFromSwaggerApi exception: '+e);
    return Promise.reject('Invalid API configuration: '+e);
  }
  gwApi.tenantId = tenantId;

  var options = {
    followAllRedirects: true,
    url: gwInfo.gwUrl+'/apis',
    headers: {
      'Accept': 'application/json'
    },
    json: gwApi,  // Use of json automaticatlly sets header: 'Content-Type': 'application/json'
  };
  if (gwInfo.gwAuth) {
    options.headers.Authorization = 'Basic ' + gwInfo.gwAuth;
  }

  if (gwApiId) {
    console.log("addApiToGateway: Updating existing API");
    gwApi.id = gwApiId;
    options.url = gwInfo.gwUrl+'/apis/'+gwApiId;
    requestFcn = request.put;
  }

  console.log('addApiToGateway: request: '+JSON.stringify(options, " ", 2));

  return new Promise(function(resolve, reject) {
    requestFcn(options, function(error, response, body) {
      var statusCode = response ? response.statusCode : undefined;
      console.log('addApiToGateway: response status:'+ statusCode);
      if (error) console.error('Warning: addRouteToGateway request failed: '+ utils2.makeJsonString(error));
      if (body) console.log('addApiToGateway: response body: '+utils2.makeJsonString(body));

      if (error) {
        console.error('addApiToGateway: Unable to configure the API Gateway');
        reject('Unable to configure the API Gateway: '+utils2.makeJsonString(error));
      } else if (statusCode != 200) {
        if (body) {
          var errMsg = JSON.stringify(body);
          if (body.error && body.error.message) errMsg = body.error.message;
          reject('Unable to configure the API Gateway (status code '+statusCode+'): '+ errMsg);
        } else {
          reject('Unable to configure the API Gateway: Response failure code: '+statusCode);
        }
      } else if (!body) {
        console.error('addApiToGateway: Unable to configure the API Gateway: No response body');
        reject('Unable to configure the API Gateway: No response received from the API Gateway');
      } else {
        resolve(body);
      }
    });
  });
}

/**
 * Removes an API route from the API Gateway.
 *
 * @param gwInfo Required.
 * @param    gwUrl   Required. The base URL gateway path (i.e.  'PROTOCOL://gw.host.domain:PORT/CONTEXT')
 * @param    gwAuth  Optional. The credentials used to access the API Gateway REST endpoints
 * @param apiId  Required.  Unique Gateway API Id
 * @return A promise for an object describing the result with fields error and response
 */
function deleteApiFromGateway(gwInfo, gwApiId) {
  var options = {
    followAllRedirects: true,
    url: gwInfo.gwUrl+'/apis/'+gwApiId,
    agentOptions: {rejectUnauthorized: false},
    headers: {
      'Accept': 'application/json'
    }
  };
  if (gwInfo.gwAuth) {
    options.headers.Authorization = 'Basic ' + gwInfo.gwAuth;
  }
  console.log('deleteApiFromGateway: request: '+JSON.stringify(options, " ", 2));

  return new Promise(function(resolve, reject) {
    request.delete(options, function(error, response, body) {
      var statusCode = response ? response.statusCode : undefined;
      console.log('deleteApiFromGateway: response status:'+ statusCode);
      if (error) console.error('Warning: deleteGatewayApi request failed: '+ utils2.makeJsonString(error));
      if (body) console.log('deleteApiFromGateway: response body: '+utils2.makeJsonString(body));

      if (error) {
        console.error('deleteApiFromGateway: Unable to delete the API Gateway');
        reject('Unable to delete the API Gateway: '+utils2.makeJsonString(error));
      } else if (statusCode != 200) {
        if (body) {
          var errMsg = JSON.stringify(body);
          if (body.error && body.error.message) errMsg = body.error.message;
          reject('Unable to delete the API Gateway (status code '+statusCode+'): '+ errMsg);
        } else {
          reject('Unable to delete the API Gateway: Response failure code: '+statusCode);
        }
      } else {
        resolve();
      }
    });
  });
}

/**
 * Return an array of APIs
 */
function getApis(gwInfo, tenantId, bpOrApiName) {
  var qsBasepath = { 'filter[where][basePath]' : bpOrApiName };
  var qsApiName = { 'filter[where][name]' : bpOrApiName };
  var qs;
  if (bpOrApiName) {
    if (bpOrApiName.indexOf('/') !== 0) {
      console.log('getApis: querying APIs based on api name');
      qs = qsApiName;
    } else {
      console.log('getApis: querying APIs based on basepath');
      qs = qsBasepath;
    }
  }
  var options = {
    followAllRedirects: true,
    url: gwInfo.gwUrl+'/tenants/'+tenantId+'/apis',
    headers: {
      'Accept': 'application/json'
    },
  };
  if (qs) {
    options.qs = qs;
  }
  if (gwInfo.gwAuth) {
    options.headers.Authorization = 'Basic ' + gwInfo.gwAuth;
  }
  console.log('getApis: request: '+JSON.stringify(options));

  return new Promise(function(resolve, reject) {
    request.get(options, function(error, response, body) {
      var statusCode = response ? response.statusCode : undefined;
      console.log('getApis: response status: '+ statusCode);
      if (error) console.error('Warning: getApis request failed: '+utils2.makeJsonString(error));
      if (body) console.log('getApis: response body: '+utils2.makeJsonString(body));
      if (error) {
        console.error('getApis: Unable to obtain API(s) from the API Gateway');
        reject('Unable to obtain API(s) from the API Gateway: '+utils2.makeJsonString(error));
      } else if (statusCode != 200) {
        if (body) {
          var errMsg = JSON.stringify(body);
          if (body.error && body.error.message) errMsg = body.error.message;
          reject('Unable to obtain API(s) from the API Gateway (status code '+statusCode+'): '+ errMsg);
        } else {
          reject('Unable to obtain API(s) from the API Gateway: Response failure code: '+statusCode);
        }
      } else {
        if (body) {
          try {
            var bodyJson = JSON.parse(body);
            if (Array.isArray(bodyJson)) {
              resolve(bodyJson);
            } else {
              console.error('getApis: Invalid API GW response body; a JSON array was not returned');
              resolve( [] );
            }
          } catch(e) {
            console.error('getApis: Invalid API GW response body; JSON.parse() failure: '+e);
            reject('Invalid API Gateway response: '+e);
          }
        } else {
          console.log('getApis: No APIs found');
          resolve( [] );
        }
      }
    });
  });
}

/**
 * Convert API object array into specified format
 * Parameters:
 *  apis    : array of 0 or more APIs
 *  format  : 'apigw' or 'swagger'
 * Returns:
 *  array   : New array of API object - each in the specified format
 */
function transformApis(apis, format) {
  var apisOutput;
  try {
    if (format.toLowerCase() === 'apigw') {
      apisOutput = apis;
    } else if (format.toLowerCase() === 'swagger') {
      apisOutput = JSON.parse(JSON.stringify(apis));
      for (var i = 0; i < apisOutput.length; i++) {
        apisOutput[i] = generateSwaggerApiFromGwApi(apisOutput[i]);
      }
    } else {
      console.error('transformApis: Invalid format specification: '+format);
      throw 'Internal error. Invalid format specification: '+format;
    }
  } catch(e) {
    console.error('transformApis: exception caught: '+e);
    throw 'API format transformation error: '+e;
  }

  return apisOutput;
}

/**
 * Convert API object into swagger JSON format
 * Parameters:
 *  gwApi  : API object as returned from the API Gateway
 * Returns:
 *  object : New API object in swagger JSON format
 */
function generateSwaggerApiFromGwApi(gwApi) {
  // Start with a copy of the gwApi object.  It's close to the desired swagger format
  var swaggerApi = JSON.parse(JSON.stringify(gwApi));
  swaggerApi.swagger = '2.0';
  swaggerApi.info = {
    title: gwApi.name,
    version: '1.0.0'
  };

  // Copy the gwAPI's 'resources' object as the starting point for the swagger 'paths' object
  swaggerApi.paths = JSON.parse(JSON.stringify(gwApi.resources));
  for (var path in swaggerApi.paths) {
    if (!swaggerApi.paths[path]) {
      console.error('generateSwaggerApiFromGwApi: no operations defined for ignored relpath \''+path+'\'');
      delete swaggerApi.paths[path];
      continue;
    }
    for (var op in swaggerApi.paths[path].operations) {
      console.log('generateSwaggerApiFromGwApi: processing path '+path+'; operation '+op);
      if (!op) {
        console.error('generateSwaggerApiFromGwApi: path \''+path+'\' has no operations!');
        continue;
      }
      // swagger wants lower case operations
      var oplower = op.toLowerCase();

      // Valid swagger requires a 'responses' object for each operation
      swaggerApi.paths[path][oplower] = {
        responses: {
          default: {
            description: 'Default response'
          }
        }
      };
      // Custom swagger extension to hold the action mapping configuration
      swaggerApi.paths[path][oplower]['x-ibm-op-ext'] = {
        backendMethod : swaggerApi.paths[path].operations[op].backendMethod,
        backendUrl : swaggerApi.paths[path].operations[op].backendUrl,
        policies : JSON.parse(JSON.stringify(swaggerApi.paths[path].operations[op].policies)),
        actionName: getActionNameFromActionUrl(swaggerApi.paths[path].operations[op].backendUrl),
        actionNamespace: getActionNamespaceFromActionUrl(swaggerApi.paths[path].operations[op].backendUrl)
      };
    }
    delete swaggerApi.paths[path].operations;
  }
  delete swaggerApi.resources;
  delete swaggerApi.name;
  delete swaggerApi.id;
  delete swaggerApi.managedUrl;
  delete swaggerApi.tenantId;
  return swaggerApi;
}

/**
 * Create a base swagger API object containing the API basepath, but no endpoints
 * Parameters:
 *   basepath   - Required. API basepath
 *   apiname    - Optional. API friendly name. Defaults to basepath
 * Returns:
 *   swaggerApi - API swagger JSON object
 */
function generateBaseSwaggerApi(basepath, apiname) {
  var swaggerApi = {
    swagger: "2.0",
    info: {
      title: apiname || basepath,
      version: "1.0.0"
    },
    basePath: basepath,
    paths: {}
  };
  return swaggerApi;
}

/**
 * Take an API in JSON swagger format and create an API GW compatible
 * API configuration JSON object
 * Parameters:
 *   swaggerApi - JSON object defining API in swagger format
 * Returns:
 *   gwApi      - JSON object defining API in API GW format
 */
function generateGwApiFromSwaggerApi(swaggerApi) {
  var gwApi = {};
  gwApi.basePath = swaggerApi.basePath;
  gwApi.name = swaggerApi.info.title;
  gwApi.resources = {};
  for (var path in swaggerApi.paths) {
  console.log('generateGwApiFromSwaggerApi: processing swaggerApi path: ', path);
    gwApi.resources[path] = {};
    var gwpathop = gwApi.resources[path].operations = {};
    for (var operation in swaggerApi.paths[path]) {
      console.log('generateGwApiFromSwaggerApi: processing swaggerApi operation: ', operation);
      console.log('generateGwApiFromSwaggerApi: processing operation backendMethod: ', swaggerApi.paths[path][operation]['x-ibm-op-ext'].backendMethod);
      var gwop = gwpathop[operation] = {};
      gwop.backendMethod = swaggerApi.paths[path][operation]['x-ibm-op-ext'].backendMethod;
      gwop.backendUrl = swaggerApi.paths[path][operation]['x-ibm-op-ext'].backendUrl;
      gwop.policies = swaggerApi.paths[path][operation]['x-ibm-op-ext'].policies;
    }
  }
  return gwApi;
}

/**
 * Take an existing API in JSON swagger format, and update it with a single path/operation.
 * The addition can be an entirely new path or a new operation under an existing path.
 * Parameters:
 *   swaggerApi - API to augment in swagger JSON format.  This will be updated.
 *   endpoint   - JSON object describing new path/operation.  Required fields
 *                {
 *                  gatewayMethod:
 *                  gatewayPath:
 *                  action: {
 *                    authkey:
 *                    backendMethod:
 *                    backendUrl:
 *                    name:
 *                    namespace:
 *                  }
 *                }
 * Returns:
 *   swaggerApi - Input JSON object in swagger format containing the union of swaggerApi + new path/operation
 */
function addEndpointToSwaggerApi(swaggerApi, endpoint) {
  var operation = endpoint.gatewayMethod.toLowerCase();
  var auth_base64 = Buffer.from(endpoint.action.authkey,'ascii').toString('base64');

  // If the relative path already exists, append to it; otherwise create it
  if (!swaggerApi.paths[endpoint.gatewayPath]) {
    swaggerApi.paths[endpoint.gatewayPath] = {};
  }
  swaggerApi.paths[endpoint.gatewayPath][operation] = {
    'x-ibm-op-ext': {
      backendMethod: endpoint.action.backendMethod,
      backendUrl: endpoint.action.backendUrl,
      actionName: endpoint.action.name,
      actionNamespace: endpoint.action.namespace,
      policies: [
        {
          type: 'reqMapping',
          value: [
            {
              action: 'transform',
              from: {
                name: '*',
                location: 'query'
              },
              to: {
                name: '*',
                location: 'body'
              }
            },
            {
              action: 'insert',
              from: {
                value: 'Basic '+auth_base64
              },
              to: {
                name: 'Authorization',
                location: 'header'
              }
            },
            {
              action: 'insert',
              from: {
                value: 'application/json'
              },
              to: {
                name: 'Content-Type',
                location: 'header'
              }
            },
            {
              action: 'insert',
              from: {
                value: 'true'
              },
              to: {
                name: 'blocking',
                location: 'query'
              }
            },
            {
              action: 'insert',
              from: {
                value: 'true'
              },
              to: {
                name: 'result',
                location: 'query'
              }
            }
          ]
        }
      ]
    },
    responses: {
      default: {
        description: "Default response"
      }
    }
  };

  return swaggerApi;
}

/**
 * Update an existing DB API document by removing the specified relpath/operation section.
 *   swaggerApi - API from which to remove the specified endpoint.  This object will be updated.
 *   endpoint   - JSON object describing new path/operation.  Required fields
 *                {
 *                  gatewayPath:    Optional.  The relative path.  If not provided, the original swaggerApi is returned
 *                  gatewayMethod:  Optional.  The operation under gatewayPath.  If not provided, the entire gatewayPath is deleted.
 *                                             If updated gatewayPath has no more operations, then the entire gatewayPath is deleted.
 *                }
 * @returns Updated JSON swagger API
 */
function removeEndpointFromSwaggerApi(swaggerApi, endpoint) {
  var relpath = endpoint.gatewayPath;
  var operation = endpoint.gatewayMethod ? endpoint.gatewayMethod.toLowerCase() : endpoint.gatewayMethod;
  console.log('removeEndpointFromSwaggerApi: relpath '+relpath+' operation '+operation);
  if (!relpath) {
      console.log('removeEndpointFromSwaggerApi: No relpath specified; nothing to remove');
      return 'No relpath provided; nothing to remove';
  }

  // If an operation is not specified, delete the entire relpath
  if (!operation) {
      console.log('removeEndpointFromSwaggerApi: No operation; removing entire relpath '+relpath);
      if (swaggerApi.paths[relpath]) {
          delete swaggerApi.paths[relpath];
      } else {
          console.log('removeEndpointFromSwaggerApi: relpath '+relpath+' does not exist in the API; already deleted');
          return 'relpath '+relpath+' does not exist in the API';
      }
  } else {
      if (swaggerApi.paths[relpath] && swaggerApi.paths[relpath][operation]) {
          delete swaggerApi.paths[relpath][operation];
          if (Object.keys(swaggerApi.paths[relpath]).length === 0) {
            console.log('removeEndpointFromSwaggerApi: after deleting operation '+operation+', relpath '+relpath+' has no more operations; so deleting entire relpath '+relpath);
            delete swaggerApi.paths[relpath];
          }
      } else {
          console.log('removeEndpointFromSwaggerApi: relpath '+relpath+' with operation '+operation+' does not exist in the API');
          return 'relpath '+relpath+' with operation '+operation+' does not exist in the API';
      }
  }

  return swaggerApi;
}

function confidentialPrint(str) {
    var printStr;
    if (str) {
        printStr = 'XXXXXXXXXX';
    }
    return printStr;
}

/**
 * Create the CLI response payload from an array of GW API objects
 * Parameters:
 *  gwApis    - Array of JSON GW API objects
 * Returns:
 *  respApis  - A new array of JSON CLI API objects
 */
function generateCliResponse(gwApis) {
  var respApis = [];
  try {
    for (var i=0; i<gwApis.length; i++) {
      respApis.push(generateCliApiFromGwApi(gwApis[i]));
    }
  } catch(e) {
    console.error('generateCliResponse: exception caught: '+e);
    throw 'API format transformation error: '+e;
  }
  return respApis;
}

/**
 * Use the specified GW API object to create an API JSON object in for format the CLI expects.
 * Parameters:
 *  gwApi      - JSON GW API object
 * Returns:
 *  cliApi     - JSON CLI API object
 */
function generateCliApiFromGwApi(gwApi) {
  var cliApi = {};
  cliApi.id = 'Not Used';
  cliApi.key = 'Not Used';
  cliApi.value = {};
  cliApi.value.namespace = 'Not Used';
  cliApi.value.gwApiActivated = true;
  cliApi.value.tenantId = 'Not Used';
  cliApi.value.gwApiUrl = gwApi.managedUrl;
  cliApi.value.apidoc = generateSwaggerApiFromGwApi(gwApi);
  return cliApi;
}

/*
 * Parses the openwhisk action URL and returns the various components
 * Parameters
 *  url    - in format PROTOCOL://HOST/api/v1/namespaces/NAMESPACE/actions/ACTIONNAME
 * Returns
 *  result - an array of strings.
 *           result[0] : Entire URL
 *           result[1] : protocol (i.e. https)
 *           result[2] : host (i.e. myco.com, 1.2.3.4, myco.com/whisk)
 *           result[3] : namespace
 *           result[4] : action name, including the package if used (i.e. myaction, mypkg/myaction)
 */
function parseActionUrl(actionUrl) {
  var actionUrlPattern = /(\w+):\/\/([:\/\w.\-]+)\/api\/v\d\/namespaces\/([@\w .\-]+)\/actions\/([@\w .\-\/]+)/;
  try {
    return actionUrl.match(actionUrlPattern);
  } catch(e) {
    console.error('parseActionUrl: exception: '+e);
    throw 'parseActionUrl: exception: '+e;
  }
}

/*
 * https://172.17.0.1/api/v1/namespaces/whisk.system/actions/getaction
 * would return getaction
 * https://my-host.mycompany.com/api/v1/namespaces/myid@gmail.com_dev/actions/getaction
 * would return getaction
 *
 * https://172.17.0.1/api/v1/namespaces/whisk.system/actions/mypkg/getaction
 * would return mypkg/getaction
 * https://my-host.mycompany.com/api/v1/namespaces/myid@gmail.com_dev/actions/mypkg/getaction
 * would return mypkg/getaction
 */
function getActionNameFromActionUrl(actionUrl) {
  return parseActionUrl(actionUrl)[4];
}

/*
 * https://172.17.0.1/api/v1/namespaces/whisk.system/actions/getaction
 * would return whisk.system
 * https://my-host.mycompany.com/api/v1/namespaces/myid@gmail.com_dev/actions/mypkg/getaction
 * would return myid@gmail.com_dev
 */
function getActionNamespaceFromActionUrl(actionUrl) {
  return parseActionUrl(actionUrl)[3];
}

/*
 * Replace the namespace values that are used in the apidoc with the
 * specified namespace
 */
function updateNamespace(apidoc, namespace) {
  if (apidoc && namespace) {
    if (apidoc.action) {
      // The action namespace does not have to match the CLI user's namespace
      // If it is different, leave it alone; otherwise use the replacement namespace
      if (apidoc.namespace === apidoc.action.namespace) {
        apidoc.action.namespace = namespace;
        apidoc.action.backendUrl = replaceNamespaceInUrl(apidoc.action.backendUrl, namespace);      }
    }
    apidoc.namespace = namespace;
  }
}

/*
 * Take an OpenWhisk URL (i.e. action invocation URL) and replace the namespace
 * path parameter value with the provided namespace value
 */
function replaceNamespaceInUrl(url, namespace) {
  var namespacesPattern = /\/namespaces\/([\w@.-]+)\//;
  console.log('replaceNamespaceInUrl: url before - '+url);
  matchResult = url.match(namespacesPattern);
  if (matchResult !== null) {
    console.log('replaceNamespaceInUrl: replacing namespace \''+matchResult[1]+'\' with \''+namespace+'\'');
    url = url.replace(namespacesPattern, '/namespaces/'+namespace+'/');
  }
  console.log('replaceNamespaceInUrl: url after - '+url);
  return url;
}

module.exports.createTenant = createTenant;
module.exports.getTenants = getTenants;
module.exports.getApis = getApis;
module.exports.addApiToGateway = addApiToGateway;
module.exports.deleteApiFromGateway = deleteApiFromGateway;
module.exports.generateBaseSwaggerApi = generateBaseSwaggerApi;
module.exports.generateGwApiFromSwaggerApi = generateGwApiFromSwaggerApi;
module.exports.transformApis = transformApis;
module.exports.generateSwaggerApiFromGwApi = generateSwaggerApiFromGwApi;
module.exports.addEndpointToSwaggerApi = addEndpointToSwaggerApi;
module.exports.removeEndpointFromSwaggerApi = removeEndpointFromSwaggerApi;
module.exports.confidentialPrint = confidentialPrint;
module.exports.generateCliResponse = generateCliResponse;
module.exports.generateCliApiFromGwApi = generateCliApiFromGwApi;
module.exports.updateNamespace = updateNamespace;