@alicloud/fun/lib/vpc.js

'use strict';
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
const getProfile = require('./profile').getProfile;
const vswitch = require('./vswitch');
const securityGroup = require('./security-group');
const debug = require('debug')('fun:nas');
const { green } = require('colors');
const { sleep } = require('./time');
const { getVpcPopClient, getEcsPopClient } = require('./client');
const _ = require('lodash');
var requestOption = {
    method: 'POST'
};
const defaultVSwitchName = 'fc-fun-vswitch-1';
const defaultSecurityGroupName = 'fc-fun-sg-1';
function findVpc(vpcClient, region, vpcName) {
    return __awaiter(this, void 0, void 0, function* () {
        const pageSize = 50; // max value is 50. see https://help.aliyun.com/document_detail/104577.html
        let requestPageNumber = 0;
        let totalCount;
        let pageNumber;
        let vpc;
        do {
            var params = {
                'RegionId': region,
                'PageSize': pageSize,
                'PageNumber': ++requestPageNumber
            };
            const rs = yield vpcClient.request('DescribeVpcs', params, requestOption);
            totalCount = rs.TotalCount;
            pageNumber = rs.PageNumber;
            const vpcs = rs.Vpcs.Vpc;
            debug('find vpc rs: %s', rs);
            vpc = _.find(vpcs, { VpcName: vpcName });
            debug('find default vpc: %s', vpc);
        } while (!vpc && totalCount && pageNumber && pageNumber * pageSize < totalCount);
        return vpc;
    });
}
function createVpc(vpcClient, region, vpcName) {
    return __awaiter(this, void 0, void 0, function* () {
        var createParams = {
            'RegionId': region,
            'CidrBlock': '10.0.0.0/8',
            'EnableIpv6': false,
            'VpcName': vpcName,
            'Description': 'default vpc created by fc fun'
        };
        var createRs;
        try {
            createRs = yield vpcClient.request('CreateVpc', createParams, requestOption);
        }
        catch (ex) {
            throw ex;
        }
        const vpcId = createRs.VpcId;
        debug('create vpc rs is: %j', createRs);
        yield waitVpcUntilAvaliable(vpcClient, region, vpcId);
        return vpcId;
    });
}
function waitVpcUntilAvaliable(vpcClient, region, vpcId) {
    return __awaiter(this, void 0, void 0, function* () {
        let count = 0;
        let status;
        do {
            count++;
            var params = {
                'RegionId': region,
                'VpcId': vpcId
            };
            yield sleep(800);
            const rs = yield vpcClient.request('DescribeVpcs', params, requestOption);
            const vpcs = rs.Vpcs.Vpc;
            if (vpcs && vpcs.length) {
                status = vpcs[0].Status;
                debug('vpc status is: ' + status);
                console.log(`\t\tVPC already created, waiting for status to be 'Available', the status is ${status} currently`);
            }
        } while (count < 15 && status !== 'Available');
        if (status !== 'Available') {
            throw new Error(`Timeout while waiting for vpc ${vpcId} status to be 'Available'`);
        }
    });
}
function createDefaultVSwitchIfNotExist(vpcClient, region, vpcId, vswitchIds) {
    return __awaiter(this, void 0, void 0, function* () {
        let vswitchId = yield vswitch.findVswitchExistByName(vpcClient, region, vswitchIds, defaultVSwitchName);
        if (!vswitchId) { // create vswitch
            console.log('\t\tcould not find default vswitch, ready to generate one');
            vswitchId = yield vswitch.createDefaultVSwitch(vpcClient, region, vpcId, defaultVSwitchName);
            console.log(green('\t\tdefault vswitch has been generated, vswitchId is: ' + vswitchId));
        }
        else {
            console.log(green('\t\tvswitch already generated, vswitchId is: ' + vswitchId));
        }
        return vswitchId;
    });
}
function createDefaultSecurityGroupIfNotExist(ecsClient, region, vpcId) {
    return __awaiter(this, void 0, void 0, function* () {
        // check fun default security group exist?
        let defaultSecurityGroup = yield securityGroup.describeSecurityGroups(ecsClient, region, vpcId, defaultSecurityGroupName);
        debug('default security grpup: %j', defaultSecurityGroup);
        // create security group
        if (_.isEmpty(defaultSecurityGroup)) {
            console.log('\t\tcould not find default security group, ready to generate one');
            const securityGroupId = yield securityGroup.createSecurityGroup(ecsClient, region, vpcId, defaultSecurityGroupName);
            console.log('\t\t\tsetting default security group rules');
            yield securityGroup.authDefaultSecurityGroupRules(ecsClient, region, securityGroupId);
            console.log(green('\t\t\tdefault security group rules has been generated'));
            console.log(green('\t\tdefault security group has been generated, security group is: ' + securityGroupId));
            return securityGroupId;
        }
        const securityGroupId = defaultSecurityGroup[0].SecurityGroupId;
        console.log(green('\t\tsecurity group already generated, security group is: ' + securityGroupId));
        return securityGroupId;
    });
}
function createDefaultVpcIfNotExist() {
    return __awaiter(this, void 0, void 0, function* () {
        const profile = yield getProfile();
        const region = profile.defaultRegion;
        const vpcClient = yield getVpcPopClient();
        const ecsClient = yield getEcsPopClient();
        const defaultVpcName = 'fc-fun-vpc';
        let vswitchIds;
        let vpcId;
        const funDefaultVpc = yield findVpc(vpcClient, region, defaultVpcName);
        if (funDefaultVpc) { // update
            vswitchIds = funDefaultVpc.VSwitchIds.VSwitchId;
            vpcId = funDefaultVpc.VpcId;
            console.log(green('\t\tvpc already generated, vpcId is: ' + vpcId));
        }
        else { // create
            console.log('\t\tcould not find default vpc, ready to generate one');
            vpcId = yield createVpc(vpcClient, region, defaultVpcName);
            console.log(green('\t\tdefault vpc has been generated, vpcId is: ' + vpcId));
        }
        debug('vpcId is %s', vpcId);
        const vswitchId = yield createDefaultVSwitchIfNotExist(vpcClient, region, vpcId, vswitchIds);
        vswitchIds = [vswitchId];
        // create security
        const securityGroupId = yield createDefaultSecurityGroupIfNotExist(ecsClient, region, vpcId);
        return {
            vpcId,
            vswitchIds,
            securityGroupId
        };
    });
}
module.exports = {
    createDefaultVpcIfNotExist,
    findVpc,
    createVpc
};