aws-cdk
Version:
AWS CDK CLI, the command line tool for CDK apps
477 lines • 64.9 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.CliIoHost = void 0;
const util = require("node:util");
const cloud_assembly_schema_1 = require("@aws-cdk/cloud-assembly-schema");
const toolkit_lib_1 = require("@aws-cdk/toolkit-lib");
const chalk = require("chalk");
const promptly = require("promptly");
const api_private_1 = require("../../../lib/api-private");
const deploy_1 = require("../../commands/deploy");
const collect_telemetry_1 = require("../telemetry/collect-telemetry");
const error_1 = require("../telemetry/error");
const messages_1 = require("../telemetry/messages");
const session_1 = require("../telemetry/session");
const endpoint_sink_1 = require("../telemetry/sink/endpoint-sink");
const file_sink_1 = require("../telemetry/sink/file-sink");
const funnel_1 = require("../telemetry/sink/funnel");
const ci_1 = require("../util/ci");
/**
* A simple IO host for the CLI that writes messages to the console.
*/
class CliIoHost {
/**
* Returns the singleton instance
*/
static instance(props = {}, forceNew = false) {
if (forceNew || !CliIoHost._instance) {
CliIoHost._instance = new CliIoHost(props);
}
return CliIoHost._instance;
}
/**
* Returns the singleton instance if it exists
*/
static get() {
return CliIoHost._instance;
}
constructor(props = {}) {
/**
* Configure the target stream for notices
*
* (Not a setter because there's no need for additional logic when this value
* is changed yet)
*/
this.noticesDestination = 'stderr';
this._progress = deploy_1.StackActivityProgress.BAR;
// Corked Logging
this.corkedCounter = 0;
this.corkedLoggingBuffer = [];
this.currentAction = props.currentAction ?? 'none';
this.isTTY = props.isTTY ?? process.stdout.isTTY ?? false;
this.logLevel = props.logLevel ?? 'info';
this.isCI = props.isCI ?? (0, ci_1.isCI)();
this.requireDeployApproval = props.requireDeployApproval ?? cloud_assembly_schema_1.RequireApproval.BROADENING;
this.stackProgress = props.stackProgress ?? deploy_1.StackActivityProgress.BAR;
this.autoRespond = props.autoRespond ?? false;
}
async startTelemetry(args, context, proxyAgent) {
// eslint-disable-next-line @typescript-eslint/no-require-imports
const config = require('../cli-type-registry.json');
const validCommands = Object.keys(config.commands);
const cmd = args._[0];
if (!validCommands.includes(cmd)) {
// the user typed in an invalid command - no need for telemetry since the invocation is going to fail
// imminently anyway.
await this.asIoHelper().defaults.trace(`Session instantiated with an invalid command (${cmd}). Not starting telemetry.`);
return;
}
let sinks = [];
const telemetryFilePath = args['telemetry-file'];
if (telemetryFilePath) {
try {
sinks.push(new file_sink_1.FileTelemetrySink({
ioHost: this,
logFilePath: telemetryFilePath,
}));
await this.asIoHelper().defaults.trace('File Telemetry connected');
}
catch (e) {
await this.asIoHelper().defaults.trace(`File Telemetry instantiation failed: ${e.message}`);
}
}
const telemetryEndpoint = process.env.TELEMETRY_ENDPOINT ?? 'https://cdk-cli-telemetry.us-east-1.api.aws/metrics';
if ((0, collect_telemetry_1.canCollectTelemetry)(args, context) && telemetryEndpoint) {
try {
sinks.push(new endpoint_sink_1.EndpointTelemetrySink({
ioHost: this,
agent: proxyAgent,
endpoint: telemetryEndpoint,
}));
await this.asIoHelper().defaults.trace('Endpoint Telemetry connected');
}
catch (e) {
await this.asIoHelper().defaults.trace(`Endpoint Telemetry instantiation failed: ${e.message}`);
}
}
else {
await this.asIoHelper().defaults.trace('Endpoint Telemetry NOT connected');
}
if (sinks.length > 0) {
this.telemetry = new session_1.TelemetrySession({
ioHost: this,
client: new funnel_1.Funnel({ sinks }),
arguments: args,
context: context,
});
}
await this.telemetry?.begin();
}
/**
* Update the stackProgress preference.
*/
set stackProgress(type) {
this._progress = type;
}
/**
* Gets the stackProgress value.
*
* This takes into account other state of the ioHost,
* like if isTTY and isCI.
*/
get stackProgress() {
// We can always use EVENTS
if (this._progress === deploy_1.StackActivityProgress.EVENTS) {
return this._progress;
}
// if a debug message (and thus any more verbose messages) are relevant to the current log level, we have verbose logging
const verboseLogging = (0, api_private_1.isMessageRelevantForLevel)({ level: 'debug' }, this.logLevel);
if (verboseLogging) {
return deploy_1.StackActivityProgress.EVENTS;
}
// On Windows we cannot use fancy output
const isWindows = process.platform === 'win32';
if (isWindows) {
return deploy_1.StackActivityProgress.EVENTS;
}
// On some CI systems (such as CircleCI) output still reports as a TTY so we also
// need an individual check for whether we're running on CI.
// see: https://discuss.circleci.com/t/circleci-terminal-is-a-tty-but-term-is-not-set/9965
const fancyOutputAvailable = this.isTTY && !this.isCI;
if (!fancyOutputAvailable) {
return deploy_1.StackActivityProgress.EVENTS;
}
// Use the user preference
return this._progress;
}
get defaults() {
return this.asIoHelper().defaults;
}
asIoHelper() {
return (0, api_private_1.asIoHelper)(this, this.currentAction);
}
/**
* Executes a block of code with corked logging. All log messages during execution
* are buffered and only written when all nested cork blocks complete (when CORK_COUNTER reaches 0).
* The corking is bound to the specific instance of the CliIoHost.
*
* @param block - Async function to execute with corked logging
* @returns Promise that resolves with the block's return value
*/
async withCorkedLogging(block) {
this.corkedCounter++;
try {
return await block();
}
finally {
this.corkedCounter--;
if (this.corkedCounter === 0) {
// Process each buffered message through notify
for (const ioMessage of this.corkedLoggingBuffer) {
await this.notify(ioMessage);
}
// remove all buffered messages in-place
this.corkedLoggingBuffer.splice(0);
}
}
}
/**
* Notifies the host of a message.
* The caller waits until the notification completes.
*/
async notify(msg) {
await this.maybeEmitTelemetry(msg);
if (this.isStackActivity(msg)) {
if (!this.activityPrinter) {
this.activityPrinter = this.makeActivityPrinter();
}
this.activityPrinter.notify(msg);
return;
}
if (!(0, api_private_1.isMessageRelevantForLevel)(msg, this.logLevel)) {
return;
}
if (this.corkedCounter > 0) {
this.corkedLoggingBuffer.push(msg);
return;
}
const output = this.formatMessage(msg);
const stream = this.selectStream(msg);
stream?.write(output);
}
async maybeEmitTelemetry(msg) {
try {
const telemetryEvent = eventFromMessage(msg);
if (telemetryEvent) {
await this.telemetry?.emit(telemetryEvent);
}
}
catch (e) {
await this.defaults.trace(`Emit Telemetry Failed ${e.message}`);
}
}
/**
* Detect stack activity messages so they can be send to the printer.
*/
isStackActivity(msg) {
return msg.code && [
'CDK_TOOLKIT_I5501',
'CDK_TOOLKIT_I5502',
'CDK_TOOLKIT_I5503',
].includes(msg.code);
}
/**
* Detect special messages encode information about whether or not
* they require approval
*/
skipApprovalStep(msg) {
const approvalToolkitCodes = ['CDK_TOOLKIT_I5060'];
if (!(msg.code && approvalToolkitCodes.includes(msg.code))) {
return false;
}
switch (this.requireDeployApproval) {
// Never require approval
case cloud_assembly_schema_1.RequireApproval.NEVER:
return true;
// Always require approval
case cloud_assembly_schema_1.RequireApproval.ANYCHANGE:
return false;
// Require approval if changes include broadening permissions
case cloud_assembly_schema_1.RequireApproval.BROADENING:
return ['none', 'non-broadening'].includes(msg.data?.permissionChangeType);
}
}
/**
* Determines the output stream, based on message and configuration.
*/
selectStream(msg) {
if (isNoticesMessage(msg)) {
return targetStreamObject(this.noticesDestination);
}
return this.selectStreamFromLevel(msg.level);
}
/**
* Determines the output stream, based on message level and configuration.
*/
selectStreamFromLevel(level) {
// The stream selection policy for the CLI is the following:
//
// (1) Messages of level `result` always go to `stdout`
// (2) Messages of level `error` always go to `stderr`.
// (3a) All remaining messages go to `stderr`.
// (3b) If we are in CI mode, all remaining messages go to `stdout`.
//
switch (level) {
case 'error':
return process.stderr;
case 'result':
return process.stdout;
default:
return this.isCI ? process.stdout : process.stderr;
}
}
/**
* Notifies the host of a message that requires a response.
*
* If the host does not return a response the suggested
* default response from the input message will be used.
*/
async requestResponse(msg) {
// If the request cannot be prompted for by the CliIoHost, we just accept the default
if (!isPromptableRequest(msg)) {
await this.notify(msg);
return msg.defaultResponse;
}
const response = await this.withCorkedLogging(async () => {
// prepare prompt data
// @todo this format is not defined anywhere, probably should be
const data = msg.data ?? {};
const motivation = data.motivation ?? 'User input is needed';
const concurrency = data.concurrency ?? 0;
const responseDescription = data.responseDescription;
// Special approval prompt
// Determine if the message needs approval. If it does, continue (it is a basic confirmation prompt)
// If it does not, return success (true). We only check messages with codes that we are aware
// are requires approval codes.
if (this.skipApprovalStep(msg)) {
return true;
}
// In --yes mode, respond for the user if we can
if (this.autoRespond) {
// respond with yes to all confirmations
if (isConfirmationPrompt(msg)) {
await this.notify({
...msg,
message: `${chalk.cyan(msg.message)} (auto-confirmed)`,
});
return true;
}
// respond with the default for all other messages
if (msg.defaultResponse) {
await this.notify({
...msg,
message: `${chalk.cyan(msg.message)} (auto-responded with default: ${util.format(msg.defaultResponse)})`,
});
return msg.defaultResponse;
}
}
// only talk to user if STDIN is a terminal (otherwise, fail)
if (!this.isTTY) {
throw new toolkit_lib_1.ToolkitError('TtyNotAttached', `${motivation}, but terminal (TTY) is not attached so we are unable to get a confirmation from the user`);
}
// only talk to user if concurrency is 1 (otherwise, fail)
if (concurrency > 1) {
throw new toolkit_lib_1.ToolkitError('ConcurrencyConflict', `${motivation}, but concurrency is greater than 1 so we are unable to get a confirmation from the user`);
}
// Basic confirmation prompt
// We treat all requests with a boolean response as confirmation prompts
if (isConfirmationPrompt(msg)) {
const confirmed = await promptly.confirm(`${chalk.cyan(msg.message)} (y/n)`);
if (!confirmed) {
throw new toolkit_lib_1.ToolkitError('AbortedByUser', 'Aborted by user');
}
return confirmed;
}
// Asking for a specific value
const prompt = extractPromptInfo(msg);
const desc = responseDescription ?? prompt.default;
const answer = await promptly.prompt(`${chalk.cyan(msg.message)}${desc ? ` (${desc})` : ''}`, {
default: prompt.default,
trim: true,
});
return prompt.convertAnswer(answer);
});
// We need to cast this because it is impossible to narrow the generic type
// isPromptableRequest ensures that the response type is one we can prompt for
// the remaining code ensure we are indeed returning the correct type
return response;
}
/**
* Formats a message for console output with optional color support
*/
formatMessage(msg) {
// apply provided style or a default style if we're in TTY mode
let message_text = this.isTTY
? styleMap[msg.level](msg.message)
: msg.message;
// prepend timestamp if IoMessageLevel is DEBUG or TRACE. Postpend a newline.
return ((msg.level === 'debug' || msg.level === 'trace')
? `[${this.formatTime(msg.time)}] ${message_text}`
: message_text) + '\n';
}
/**
* Formats date to HH:MM:SS
*/
formatTime(d) {
const pad = (n) => n.toString().padStart(2, '0');
return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
}
/**
* Get an instance of the ActivityPrinter
*/
makeActivityPrinter() {
const props = {
stream: this.selectStreamFromLevel('info'),
};
switch (this.stackProgress) {
case deploy_1.StackActivityProgress.EVENTS:
return new api_private_1.HistoryActivityPrinter(props);
case deploy_1.StackActivityProgress.BAR:
return new api_private_1.CurrentActivityPrinter(props);
}
}
}
exports.CliIoHost = CliIoHost;
/**
* This IoHost implementation considers a request promptable, if:
* - it's a yes/no confirmation
* - asking for a string or number value
*/
function isPromptableRequest(msg) {
return isConfirmationPrompt(msg)
|| typeof msg.defaultResponse === 'string'
|| typeof msg.defaultResponse === 'number';
}
/**
* Check if the request is a confirmation prompt
* We treat all requests with a boolean response as confirmation prompts
*/
function isConfirmationPrompt(msg) {
return typeof msg.defaultResponse === 'boolean';
}
/**
* Helper to extract information for promptly from the request
*/
function extractPromptInfo(msg) {
const isNumber = (typeof msg.defaultResponse === 'number');
const defaultResponse = util.format(msg.defaultResponse);
return {
default: defaultResponse,
defaultDesc: 'defaultDescription' in msg && msg.defaultDescription ? util.format(msg.defaultDescription) : defaultResponse,
convertAnswer: isNumber ? (v) => Number(v) : (v) => String(v),
};
}
const styleMap = {
error: chalk.red,
warn: chalk.yellow,
result: chalk.reset,
info: chalk.reset,
debug: chalk.gray,
trace: chalk.gray,
};
function targetStreamObject(x) {
switch (x) {
case 'stderr':
return process.stderr;
case 'stdout':
return process.stdout;
case 'drop':
return undefined;
}
}
function isNoticesMessage(msg) {
return api_private_1.IO.CDK_TOOLKIT_I0100.is(msg) || api_private_1.IO.CDK_TOOLKIT_W0101.is(msg) || api_private_1.IO.CDK_TOOLKIT_E0101.is(msg) || api_private_1.IO.CDK_TOOLKIT_I0101.is(msg);
}
function eventFromMessage(msg) {
if (messages_1.CLI_PRIVATE_IO.CDK_CLI_I1001.is(msg)) {
return eventResult('SYNTH', msg);
}
if (messages_1.CLI_PRIVATE_IO.CDK_CLI_I2001.is(msg)) {
return eventResult('INVOKE', msg);
}
if (messages_1.CLI_PRIVATE_IO.CDK_CLI_I3001.is(msg)) {
return eventResult('DEPLOY', msg);
}
// Hotswap lives in the cdk-toolkit so it cannot be a CDK_CLI error code.
// Instead we reuse the existing Hotswap span.
if (api_private_1.IO.CDK_TOOLKIT_I5410.is(msg)) {
// Create a telemetry-compatible result
return hotswapToEventResult(msg.data);
}
return undefined;
function eventResult(eventType, m) {
return {
eventType,
duration: m.data.duration,
error: m.data.error,
counters: m.data.counters,
};
}
}
function hotswapToEventResult(result) {
return {
eventType: 'HOTSWAP',
duration: result.duration,
...(result.error ? {
error: {
name: (0, error_1.cdkCliErrorName)(result.error),
},
} : {}),
counters: {
hotswapped: result.hotswapped ? 1 : 0,
hotswappableChanges: result.hotswappableChanges.length,
nonHotswappableChanges: result.nonHotswappableChanges.length,
},
};
}
//# sourceMappingURL=data:application/json;base64,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