async describeInstance()

in functions/source/nic-attachment/lib/aws/index.js [607:695]
80 lines of code
25 McCabe index (conditional complexity)

    async describeInstance(parameters) {
        logger.info('calling describeInstance');
        let readCache = this._settings['enable-vm-info-cache'] === 'true';
        let virtualMachine,
            hitCache = '';

        if (readCache) {
            virtualMachine = await this.getVmInfoCache(
                parameters.scalingGroupName,
                parameters.instanceId,
                null
            );
            hitCache = virtualMachine && '(hit cache)';
        }

        // if not hit the cache
        if (!virtualMachine) {
            let params = {
                    Filters: []
                },
                instanceId;
            // check if instance is in scaling group
            if (parameters.scalingGroupName) {
                // describe the instance in auto scaling group
                let scalingGroup = await autoScaling
                    .describeAutoScalingGroups({
                        AutoScalingGroupNames: [parameters.scalingGroupName]
                    })
                    .promise();
                if (
                    scalingGroup &&
                    Array.isArray(scalingGroup.AutoScalingGroups) &&
                    scalingGroup.AutoScalingGroups[0] &&
                    scalingGroup.AutoScalingGroups[0].AutoScalingGroupName ===
                        parameters.scalingGroupName
                ) {
                    const instances = scalingGroup.AutoScalingGroups[0].Instances.filter(
                        instance => {
                            return instance.InstanceId === parameters.instanceId;
                        }
                    );
                    if (instances && instances.length === 1) {
                        instanceId = instances[0].InstanceId;
                    }
                }
            } else if (parameters.instanceId) {
                instanceId = parameters.instanceId;
            }
            // describe the instance
            if (instanceId) {
                params.Filters.push({
                    Name: 'instance-id',
                    Values: [parameters.instanceId]
                });
            }
            if (parameters.publicIp) {
                params.Filters.push({
                    Name: 'ip-address',
                    Values: [parameters.publicIp]
                });
            }
            if (parameters.privateIp) {
                params.Filters.push({
                    Name: 'private-ip-address',
                    Values: [parameters.privateIp]
                });
            }
            const result = instanceId && (await ec2.describeInstances(params).promise());
            // parse to virtual machine instance
            virtualMachine =
                result && result.Reservations[0] && result.Reservations[0].Instances[0];
            hitCache = (virtualMachine && hitCache) || '';
            // cache the vm info
            if (virtualMachine && readCache) {
                let cacheTime = this._settings['vm-info-cache-time'];
                cacheTime = isNaN(cacheTime) ? 3600 : parseInt(cacheTime);
                await this.setVmInfoCache(parameters.scalingGroupName, virtualMachine, cacheTime);
            }
        }
        // if mv is found
        virtualMachine =
            virtualMachine &&
            AutoScaleCore.VirtualMachine.fromAwsEc2(
                virtualMachine,
                parameters.scalingGroupName || null
            );
        logger.info(`called describeInstance${hitCache}, virtualMachine: ${virtualMachine}`);
        return virtualMachine;
    }