This change improves our output formatting by generally adding fewer prefixes. As shown in pulumi/pulumi#359, we were being excessively verbose in many places, including prefixing every console.out with "langhost[nodejs].stdout: ", displaying full stack traces for simple errors like missing configuration, etc. Overall, this change includes the following: * Don't prefix stdout and stderr output from the program, other than the standard "info:" prefix. I experimented with various schemes here, but they all felt gratuitous. Simply emitting the output seems fine, especially as it's closer to what would happen if you just ran the program under node. * Do NOT make writes to stderr fail the plan/deploy. Previously we assumed that any console.errors, for instance, meant that the overall program should fail. This simply isn't how stderr is treated generally and meant you couldn't use certain logging techniques and libraries, among other things. * Do make sure that stderr writes in the program end up going to stderr in the Pulumi CLI output, however, so that redirection works as it should. This required a new Infoerr log level. * Make a small fix to the planning logic so we don't attempt to print the summary if an error occurs. * Finally, add a new error type, RunError, that when thrown and uncaught does not result in a full stack trace being printed. Anyone can use this, however, we currently use it for config errors so that we can terminate with a pretty error message, rather than the monstrosity shown in pulumi/pulumi#359.
172 lines
5.6 KiB
TypeScript
172 lines
5.6 KiB
TypeScript
// Copyright 2016-2017, Pulumi Corporation. All rights reserved.
|
|
|
|
import { RunError } from "./errors";
|
|
import * as runtime from "./runtime";
|
|
|
|
/**
|
|
* Config is a bag of related configuration state. Each bag contains any number of configuration variables, indexed by
|
|
* simple keys, and each has a name that uniquely identifies it; two bags with different names do not share values for
|
|
* variables that otherwise share the same key. For example, a bag whose name is `pulumi:foo`, with keys `a`, `b`,
|
|
* and `c`, is entirely separate from a bag whose name is `pulumi:bar` with the same simple key names. Each key has a
|
|
* fully qualified names, such as `pulumi:foo:a`, ..., and `pulumi:bar:a`, respectively.
|
|
*/
|
|
export class Config {
|
|
/**
|
|
* name is the configuration bag's logical name and uniquely identifies it.
|
|
*/
|
|
public readonly name: string;
|
|
|
|
constructor(name: string) {
|
|
this.name = name;
|
|
}
|
|
|
|
/**
|
|
* get loads an optional configuration value by its key, or undefined if it doesn't exist.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public get(key: string): string | undefined {
|
|
return runtime.getConfig(this.fullKey(key));
|
|
}
|
|
|
|
/**
|
|
* getBoolean loads an optional configuration value, as a boolean, by its key, or undefined if it doesn't exist.
|
|
* If the configuration value isn't a legal boolean, this function will throw an error.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public getBoolean(key: string): boolean | undefined {
|
|
let v: string | undefined = this.get(key);
|
|
if (v === undefined) {
|
|
return undefined;
|
|
} else if (v === "true") {
|
|
return true;
|
|
} else if (v === "false") {
|
|
return false;
|
|
}
|
|
throw new ConfigTypeError(this.fullKey(key), v, "boolean");
|
|
}
|
|
|
|
/**
|
|
* getNumber loads an optional configuration value, as a number, by its key, or undefined if it doesn't exist.
|
|
* If the configuration value isn't a legal number, this function will throw an error.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public getNumber(key: string): number | undefined {
|
|
let v: string | undefined = this.get(key);
|
|
if (v === undefined) {
|
|
return undefined;
|
|
}
|
|
let f: number = parseFloat(v);
|
|
if (isNaN(f)) {
|
|
throw new ConfigTypeError(this.fullKey(key), v, "number");
|
|
}
|
|
return f;
|
|
}
|
|
|
|
/**
|
|
* getObject loads an optional configuration value, as an object, by its key, or undefined if it doesn't exist.
|
|
* This routine simply JSON parses and doesn't validate the shape of the contents.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public getObject<T>(key: string): T | undefined {
|
|
let v: string | undefined = this.get(key);
|
|
if (v === undefined) {
|
|
return undefined;
|
|
}
|
|
try {
|
|
return <T>JSON.parse(v);
|
|
}
|
|
catch (err) {
|
|
throw new ConfigTypeError(this.fullKey(key), v, "JSON object");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* require loads a configuration value by its given key. If it doesn't exist, an error is thrown.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public require(key: string): string {
|
|
let v: string | undefined = this.get(key);
|
|
if (v === undefined) {
|
|
throw new ConfigMissingError(this.fullKey(key));
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* requireBoolean loads a configuration value, as a boolean, by its given key. If it doesn't exist, or the
|
|
* configuration value is not a legal boolean, an error is thrown.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public requireBoolean(key: string): boolean {
|
|
let v: boolean | undefined = this.getBoolean(key);
|
|
if (v === undefined) {
|
|
throw new ConfigMissingError(this.fullKey(key));
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* requireNumber loads a configuration value, as a number, by its given key. If it doesn't exist, or the
|
|
* configuration value is not a legal number, an error is thrown.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public requireNumber(key: string): number {
|
|
let v: number | undefined = this.getNumber(key);
|
|
if (v === undefined) {
|
|
throw new ConfigMissingError(this.fullKey(key));
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* requireObject loads a configuration value, as a number, by its given key. If it doesn't exist, or the
|
|
* configuration value is not a legal number, an error is thrown.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
public requireObject<T>(key: string): T {
|
|
let v: T | undefined = this.getObject<T>(key);
|
|
if (v === undefined) {
|
|
throw new ConfigMissingError(this.fullKey(key));
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/**
|
|
* fullKey turns a simple configuration key into a fully resolved one, by prepending the bag's name.
|
|
*
|
|
* @param key The key to lookup.
|
|
*/
|
|
private fullKey(key: string): string {
|
|
return `${this.name}:${key}`;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ConfigTypeError is used when a configuration value is of the wrong type.
|
|
*/
|
|
class ConfigTypeError extends RunError {
|
|
constructor(key: string, v: any, expectedType: string) {
|
|
super(`Configuration '${key}' value '${v}' is not a valid ${expectedType}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ConfigMissingError is used when a configuration value is completely missing.
|
|
*/
|
|
class ConfigMissingError extends RunError {
|
|
constructor(key: string) {
|
|
super(
|
|
`Missing required configuration variable '${key}'\n` +
|
|
`\tplease set a value using the command \`pulumi config ${key} <value>\``
|
|
);
|
|
}
|
|
}
|
|
|