vcloud-client/index.js

Library which consumes directly VCloud API

const https = require('https');
const axios = require('axios').default;
const chalk = require('chalk');
const vcloud = require("./module/vcloud");

const VCLOUD_ACCEPT_VERSION_HEADER = process.env.VCLOUD_API_VERSION ? 'application/*+json;version='+process.env.VCLOUD_API_VERSION : "application/*+json;version=36.3"

/**
 * 
 * @param {*} baseUrl Base url pointing to VCloud API. Should match to the following pattern: https://vcloud_server/api
 * @param {*} user User who logs in
 * @param {*} password Password of the user
 * @param {*} organization VCloud organization name of the user
 *
 * @returns Authorization Token to be used in the rest of the services
 *
 * @Deprecated -> use vcloudLogin
 */
exports.login = async (baseUrl, user, password, organization) => {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({  
        rejectUnauthorized: false
      })
    });
  
    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER,
      'Content-Type': 'application/json',
      "Authorization": "Basic " + Buffer.from(user + "@" + organization + ":" + password).toString("base64")
    }
    
    let res = await instance.post(baseUrl + "/sessions", null, {
      headers: headers
    });
  
    return res.headers['x-vcloud-authorization'];
}

exports.vcloudLogin = vcloud.login;

/**
 * Retrieves all the VM that matches with the name supplied by parameter
 * 
 * @param {*} baseUrl Base url pointing to VCloud API. Should match to the following pattern: https://vcloud_server/api
 * @param {*} token Valid security token
 * @param {*} vmName name of the VM to search. Allows *
 * @param {*} page result's page
 * 
 * @returns
 * @Deprecated -> Use vmByName
 */
exports.findVMByName = async (baseUrl, token, vmName, page) => {
  try {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({  
        rejectUnauthorized: false
      })
    });
  
    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER, 
      "x-vcloud-authorization": token,
      "Cookie": "vcloud-token=" + token
    }
    
    let httpRequest = baseUrl + `/query?type=adminVM&filter=(name==${vmName})&page=${page}`;
    
    let res = await instance.get(httpRequest, {
      headers: headers
    });
  
    return res.data;
  }
  catch(ex) {
    printError(ex);
  }
}

exports.vmByName = vcloud.findVMByName;

/**
 * 
 * @param {*} baseUrl 
 * @param {*} token 
 * @param {*} organizationName 
 * @param {*} page 
 * @returns
 *
 * @Deprecated -> use organizationVDCsByOrgName
 */
exports.findOrganizationVDC = async (baseUrl, token, organizationName, page) => {
  try {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({  
        rejectUnauthorized: false
      })
    });
  
    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER, 
      "x-vcloud-authorization": token,
      "Cookie": "vcloud-token=" + token
    }
    
    let httpRequest = baseUrl + `/query?type=adminOrgVdc&filter=(orgName==${organizationName})&page=${page}`;
    
    let res = await instance.get(httpRequest, {
      headers: headers
    });
  
    return res.data;
  }
  catch(ex) {
    printError(ex);
  }
}

exports.organizationVDCsByOrgName = vcloud.findOrganizationVDC;

/**
 * 
 * @param {*} baseUrl 
 * @param {*} token 
 * @param {*} organizationHref 
 * @param {*} page 
 * @returns
 *
 * @Deprecated -> use organizationVDCsByHref
 */
exports.findOrganizationVDCByHref = async (baseUrl, token, organizationHref, page) => {
  try {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({  
        rejectUnauthorized: false
      })
    });
  
    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER, 
      "x-vcloud-authorization": token,
      "Cookie": "vcloud-token=" + token
    }
    
    let httpRequest = baseUrl + `/query?type=adminOrgVdc&filter=(org==${organizationHref})&page=${page}`;
    
    let res = await instance.get(httpRequest, {
      headers: headers
    });
  
    return res.data;
  }
  catch(ex) {
    printError(ex);
  }
}

exports.organizationVDCsByHref = vcloud.findOrganizationVDCByHref;

/**
 *
 * @param baseUrl
 * @param token
 * @param page
 * @returns {Promise<any>}
 *
 * @Deprecated -> use allOrganizations
 */
exports.getAllOrganizations = async (baseUrl, token, page) => {
  try {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({  
        rejectUnauthorized: false
      })
    });
  
    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER, 
      "x-vcloud-authorization": token,
      "Cookie": "vcloud-token=" + token
    }
    
    let httpRequest = baseUrl + `/query?type=organization&page=${page}`;
    
    let res = await instance.get(httpRequest, {
      headers: headers
    });
  
    return res.data;
  }
  catch(ex) {
    printError(ex);
  }
}

exports.allOrganizations = vcloud.getAllOrganizations;

/**
 * 
 * @param {*} baseUrl 
 * @param {*} token 
 * @param {*} vdcHref 
 * @param {*} page 
 * @returns 
 */
exports.findVMByVDCHref = async (baseUrl, token, vdcHref, page) => {
  try {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({  
        rejectUnauthorized: false
      })
    });
  
    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER, 
      "x-vcloud-authorization": token,
      "Cookie": "vcloud-token=" + token
    }
    
    let httpRequest = baseUrl + `/query?type=adminVM&filter=(vdc==${vdcHref})&page=${page}`;
    
    let res = await instance.get(httpRequest, {
      headers: headers
    });
  
    return res.data;
  }
  catch(ex) {
    printError(ex);
  }
}

/**
 *
 * @param baseUrl
 * @param token
 * @param objectType
 * @param page
 * @returns {Promise<any|undefined>}
 *
 * @Deprecated -> use adminTasksByObjectType
 */
exports.findAdminTasksByObjectType = async (baseUrl, token, objectType, page) => {
  return this.findAdminTasks(baseUrl, token, null, objectType, null, null, null, page);
}

exports.adminTasksByObjectType = vcloud.findAdminTasksByObjectType;

/**
 *
 * @param baseUrl
 * @param token
 * @param organizationName
 * @param objectType
 * @param objectName
 * @param page
 * @returns {Promise<any|undefined>}
 *
 * @Deprecated use allAdminTasks
 */
exports.findAllAdminTasks = async (baseUrl, token, organizationName, objectType, objectName, page) => {
  return this.findAdminTasks(baseUrl, token, organizationName, objectType, objectName, null, null, page);
}

exports.allAdminTasks = vcloud.findAllAdminTasks;

/**
 * TODO: Esto se puede simplificar
 * @param vcloudHost ip of vcloud, it could be undefined if dns works properly
 * @param vcloudToken vcloud token
 * @param vdc
 * @param vmMoRef
 * @returns {Promise<*>}
 */
exports.obtainVCloudMachine = async (vcloudHost, vcloudToken, vdc, vmMoRef) => {
  const orgFromVcloud = await this.getFromVcloud(this.vcloudDns(vcloudHost, vdc), vcloudToken);
  if (!orgFromVcloud) {
    return;
  }
  for (let vApp of orgFromVcloud?.resourceEntities?.resourceEntity) {
    const vapInfo = await this.getFromVcloud(this.vcloudDns(vcloudHost, vApp.href), vcloudToken);
    const maquina = vapInfo?.children?.vm?.filter(machine =>
        machine?.vCloudExtension.map (obj => obj?.any?.filter(vmVimInfo => vmVimInfo._type === 'VmVimInfoType')
            ?.reduce((previous, current) => current, {})?.vmVimObjectRef?.moRef === vmMoRef)
            ?.reduce((previous, current) => current, {}) === true
    )?.reduce((previousValue, currentValue) => currentValue, {});
    if (maquina && Object.keys(maquina).length > 0) {
      maquina.vappRef = vapInfo.href;
      maquina.vapp = vapInfo.name;
      return maquina;
    }
  }
}

exports.vcloudDns = (vcloudHost, href) => {
  const url = new URL(href);
  if (vcloudHost) {
    url.host = vcloudHost;
  }
  return url.toString();
}

// TODO: Esto esta para revisar, baseUrl es en realidad un recurso
//  y devuelve los objetos asociados.
//  Revisar en conjunto con obtainVCloudMachine
exports.getFromVcloud = async (baseUrl, token) => {
  try {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({
        rejectUnauthorized: false
      })
    });

    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER,
      "x-vcloud-authorization": token,
      "Cookie": "vcloud-token=" + token
    }

    let httpRequest = baseUrl;

    let res = await instance.get(httpRequest, {
      headers: headers
    });

    return res.data;
  }catch (ex) {
    printError(ex);
  }
};

/**
 * 
 * @param {*} baseUrl VCloud base URL
 * @param {*} token VCloud Token
 * @param {*} organizationName Organization name
 * @param {*} objectType Type (i.e: "vm")
 * @param {*} objectName Name (i.e: "DevOps")
 * @param {*} from Started from (UTC), mandatory format 2021-06-09T03:46:22.941Z
 * @param {*} to Ended to (UTC), mandatory format 2021-06-09T03:46:22.941Z
 * @param {*} page 
 * @returns
 *
 * @Deprecated -> use adminTasks
 */
exports.findAdminTasks = async (baseUrl, token, organizationName, objectType, objectName, from, to, page) => {
  try {
    https.globalAgent.options.rejectUnauthorized = false;
    const instance = axios.create({
      httpsAgent: new https.Agent({  
        rejectUnauthorized: false
      })
    });
  
    const headers = {
      "Accept": VCLOUD_ACCEPT_VERSION_HEADER, 
      "x-vcloud-authorization": token,
      "Cookie": "vcloud-token=" + token
    }
    
    let filter = `filter=(objectType==${objectType}`;

    if(organizationName) {
      filter = `${filter};orgName==${organizationName}`;
    }

    if(objectName) {
      filter = `${filter};objectName==${objectName}`;
    }

    if(from) {
      filter = `${filter};startDate=gt=${from}`;
    }

    if(to) {
      filter = `${filter};endDate=lt=${to}`;
    }

    // Close the parenthesis
    filter = `${filter})`;

    let httpRequest = baseUrl + `/query?type=adminTask&${filter}&page=${page}&sortAsc=startDate`;
    
    let res = await instance.get(httpRequest, {
      headers: headers
    });
  
    return res.data;
  }
  catch(ex) {
    printError(ex);
  }
}

exports.adminTasks = vcloud.findAdminTasks;

function printError(ex) {
  console.log(chalk.bgRed('Error', ex));
  console.log(chalk.bgRedBright(ex.stack));
}

/*
let res = this.findAllAdminTasks("https://10.50.0.215:443/api", "993314082ffd4f9484683dd6b071f023", "Desarrollo", "vm", "BillingTest", 1);
res.then(
  (r) => { console.log(r); }
)
*/