How to use @f5devcentral/f5-cloud-libs - 10 common examples

setUp(callback) {
        /* eslint-disable global-require */
        cloudUtilMock = require('@f5devcentral/f5-cloud-libs').util;
        computeMock = require('@google-cloud/compute');

        fsMock = require('fs');

        CloudProvider = require('@f5devcentral/f5-cloud-libs').cloudProvider;
        GceCloudProvider = require('../../lib/gceCloudProvider');
        /* eslint-enable global-require */

        provider = new GceCloudProvider();
        provider.compute = {};

        cloudUtilMock.getDataFromUrl = function getDataFromUrl(url) {
            if (url.endsWith('instance/zone')) {
                return q(`projects/734288666861/zones/${region}-a`);
            } else if (url.endsWith('instance/name')) {
                return q(instanceId);

setUp(callback) {
        /* eslint-disable global-require */
        cloudUtilMock = require('@f5devcentral/f5-cloud-libs').util;
        computeMock = require('@google-cloud/compute');

        fsMock = require('fs');

        CloudProvider = require('@f5devcentral/f5-cloud-libs').cloudProvider;
        GceCloudProvider = require('../../lib/gceCloudProvider');
        /* eslint-enable global-require */

        provider = new GceCloudProvider();
        provider.compute = {};

        cloudUtilMock.getDataFromUrl = function getDataFromUrl(url) {
            if (url.endsWith('instance/zone')) {
                return q(`projects/734288666861/zones/${region}-a`);
            } else if (url.endsWith('instance/name')) {
                return q(instanceId);
            } else if (url.endsWith('project/project-id')) {
                return q(projectId);
            }

            return q();

* 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.
 */

'use strict';

/* eslint-disable prefer-spread */

const PRODUCTS = require('@f5devcentral/f5-cloud-libs').sharedConstants.PRODUCTS;

const AjvValidator = require('./ajvValidator');
const configItems = require('./configItems.json');
const ConfigManager = require('./configManager');
const doUtil = require('./doUtil');
const Logger = require('./logger');
const State = require('./state');

const LOCALHOST_ADDRS = ['localhost', '127.0.0.1'];
const NAMELESS_CLASSES = require('./sharedConstants').NAMELESS_CLASSES;
const PROCESS_MAX_TIMEOUT = require('./sharedConstants').ENDPOINT_MAX_TIMEOUT;
const SCHEMA_VERSION = require('../../schema/latest/base.schema.json').properties.schemaVersion.enum[0];
const STATUS = require('./sharedConstants').STATUS;

const logger = new Logger(module);

.then((promptSaysRebootRequired) => {
                // Double check the db var. If either the prompt or the db var says
                // reboot required, then reboot is required.
                if (!promptSaysRebootRequired) {
                    return bigIp.list('/tm/sys/db/provision.action', null, cloudUtil.NO_RETRY)
                        .then(response => Promise.resolve(response.value === 'reboot'));
                }
                return Promise.resolve(true);
            })
            .then(rebootRequired => Promise.resolve(rebootRequired));

Object.keys(this.declaration.Common[deleteableClass]).forEach((itemToDelete) => {
                    // Special case for device groups
                    if (deleteableClass === 'DeviceGroup') {
                        if (READ_ONLY_DEVICE_GROUPS.indexOf(itemToDelete) === -1) {
                            classPromises.push(this.bigIp.cluster.deleteDeviceGroup(itemToDelete));
                        }
                    } else if (deleteableClass === 'RemoteAuthRole') {
                        const path = `${PATHS.AuthRemoteRole}/${itemToDelete}`;
                        classPromises.push(this.bigIp.delete(path, null, null, cloudUtil.NO_RETRY));
                    } else if (deleteableClass === 'RouteDomain' && itemToDelete === '0') {
                        // Route Domain 0 can't be deleted
                    } else {
                        const commonPrefix = deleteableClass === 'Trunk' ? '' : '~Common~';
                        const path = `${PATHS[deleteableClass]}/${commonPrefix}${itemToDelete}`;
                        classPromises.push(this.bigIp.delete(path, null, null, cloudUtil.NO_RETRY));
                    }
                });
                if (classPromises.length > 0) {

.setReferer(incomingRestOp.getUri().href);

    const retryFunc = () => this.restRequestSender.sendGet(restOperation)
        .then((response) => {
            const body = response.getBody();
            if (body.status === 'FAILED' || body.status === 'FINISHED') {
                return Promise.resolve(body);
            }
            return Promise.reject();
        })
        .catch(() => Promise.reject());

    // retry interval:
    //   - this.retryInterval for testing
    //   - we want to poll for more than 30 minutes because that is the TCW -> DO timeout so DO should be longer
    return cloudUtil.tryUntil(
        this,
        { retryIntervalMs: this.retryInterval || 5000, maxRetries: 384 },
        retryFunc
    )
        .then((response) => {
            switch (response.status) {
            case 'FINISHED':
                this.state.doState.updateResult(taskId, 200, STATUS.STATUS_OK, 'success');
                break;
            case 'FAILED':
                this.state.doState.updateResult(
                    taskId,
                    422,
                    STATUS.STATUS_ERROR,
                    'failed',
                    response.errorMessage

error.code = 424;
                            reject(error);
                            return;
                        }
                        resolve(true);
                    });
                } catch (error) {
                    // if DNS.resolve errors it throws an exception instead of rejecting
                    error.message = `Unable to resolve host ${addrToCheck}: ${error.message}`;
                    error.code = 424;
                    reject(error);
                }
            });
        }

        return cloudUtil.tryUntil(this, cloudUtil.MEDIUM_RETRY, checkDns, [address]);
    },

#!/usr/bin/env node

'use strict';

const parser = require('commander');
const fs = require('fs');
const q = require('q');
const ipaddr = require('ipaddr.js');

const Compute = require('@google-cloud/compute');
const f5CloudLibs = require('@f5devcentral/f5-cloud-libs');

const util = f5CloudLibs.util;
const httpUtil = f5CloudLibs.httpUtil;
const Logger = f5CloudLibs.logger;
const compute = new Compute();

// Parse command line arguments

parser
    .version('1.0.0')

    .option('--log-level [type]', 'Specify the log level', 'info')
    .option('--log-file [type]', 'Specify the log file location', '/var/log/cloud/google/failover.log')
    .option('--config-file [type]', 'Specify the log level', '/config/cloud/.deployment')
    .parse(process.argv);

const loggerOptions = { logLevel: parser.logLevel, fileName: parser.logFile, console: true };
const logger = Logger.getLogger(loggerOptions);
const BigIp = f5CloudLibs.bigIp;

if (selectProperties.length > 0) {
                            query.$select = selectProperties.join(',');
                        }
                        const encodedQuery = querystring.stringify(query);
                        const options = {};
                        let path = `${configItem.path}?${encodedQuery}`;

                        // do any replacements
                        path = path.replace(hostNameRegex, tokenMap.hostName);
                        path = path.replace(deviceNameRegex, tokenMap.deviceName);

                        if (configItem.silent) {
                            options.silent = configItem.silent;
                        }

                        return this.bigIp.list(path, null, cloudUtil.SHORT_RETRY, options);
                    }));
            })

function GceCloudProvider(options) {
    GceCloudProvider.super_.call(this, options);

    this.features[CloudProvider.FEATURE_MESSAGING] = true;
    this.features[CloudProvider.FEATURE_ENCRYPTION] = true;

    this.loggerOptions = options ? options.loggerOptions : undefined;

    logger = options ? options.logger : undefined;

    if (logger) {
        this.logger = logger;
        cloudUtil.setLogger(logger);
        cryptoUtil.setLogger(logger);
    } else if (this.loggerOptions) {
        this.loggerOptions.module = module;
        logger = Logger.getLogger(this.loggerOptions);
        cloudUtil.setLoggerOptions(this.loggerOptions);
        cryptoUtil.setLoggerOptions(this.loggerOptions);
        this.logger = logger;
    } else {
        // use super's logger
        logger = this.logger;
        cloudUtil.setLogger(logger);
        cryptoUtil.setLogger(logger);
    }
}