pulumi/pkg/util/contract/failfast.go

// Copyright 2016-2017, Pulumi Corporation.  All rights reserved.

package contract

import (
	"fmt"
)

// failfast logs and panics the process in a way that is friendly to debugging.
func failfast(msg string) {
	panic(fmt.Sprintf("fatal: %v", msg))
}
Clarify aspects of using the DCO 2017-06-26 23:46:34 +02:00			`// Copyright 2016-2017, Pulumi Corporation. All rights reserved.`
Begin merging MuPackage/MuIL into the compiler This is the first change of many to merge the MuPack/MuIL formats into the heart of the "compiler". In fact, the entire meaning of the compiler has changed, from something that took metadata and produced CloudFormation, into something that takes MuPack/MuIL as input, and produces a MuGL graph as output. Although this process is distinctly different, there are several aspects we can reuse, like workspace management, dependency resolution, and some amount of name binding and symbol resolution, just as a few examples. An overview of the compilation process is available as a comment inside of the compiler.Compile function, although it is currently unimplemented. The relationship between Workspace and Compiler has been semi- inverted, such that all Compiler instances require a Workspace object. This is more natural anyway and moves some of the detection logic "outside" of the Compiler. Similarly, Options has moved to a top-level package, so that Workspace and Compiler may share access to it without causing package import cycles. Finally, all that templating crap is gone. This alone is cause for mass celebration! 2017-01-18 02:04:15 +01:00
			`package contract`

			`import (`
Manually print the stack-trace when --logtostderr is enabled Glog doesn't actually print out the stack traces for all goroutines, when --logtostderr is enabled, the same way it normally does. This makes debugging more complex in some cases. So, we'll manually do it. 2017-02-09 23:50:41 +01:00			`"fmt"`
Begin merging MuPackage/MuIL into the compiler This is the first change of many to merge the MuPack/MuIL formats into the heart of the "compiler". In fact, the entire meaning of the compiler has changed, from something that took metadata and produced CloudFormation, into something that takes MuPack/MuIL as input, and produces a MuGL graph as output. Although this process is distinctly different, there are several aspects we can reuse, like workspace management, dependency resolution, and some amount of name binding and symbol resolution, just as a few examples. An overview of the compilation process is available as a comment inside of the compiler.Compile function, although it is currently unimplemented. The relationship between Workspace and Compiler has been semi- inverted, such that all Compiler instances require a Workspace object. This is more natural anyway and moves some of the detection logic "outside" of the Compiler. Similarly, Options has moved to a top-level package, so that Workspace and Compiler may share access to it without causing package import cycles. Finally, all that templating crap is gone. This alone is cause for mass celebration! 2017-01-18 02:04:15 +01:00			`)`

			`// failfast logs and panics the process in a way that is friendly to debugging.`
			`func failfast(msg string) {`
Simply panic for failfast The old contract library tried to be glog-friendly in its failfast behavior. It turns out glog seldom does the right thing when goroutines are involved (which, as of last sprint, they now are). We already had issues with stacks not getting printed when --logtostderr was turned on, and the code tried to work around this; but this still didn't work for the goroutines case. All of this seems like way too much cleverness. Let's just use Go panics. 2017-06-27 20:12:06 +02:00			`panic(fmt.Sprintf("fatal: %v", msg))`
Begin merging MuPackage/MuIL into the compiler This is the first change of many to merge the MuPack/MuIL formats into the heart of the "compiler". In fact, the entire meaning of the compiler has changed, from something that took metadata and produced CloudFormation, into something that takes MuPack/MuIL as input, and produces a MuGL graph as output. Although this process is distinctly different, there are several aspects we can reuse, like workspace management, dependency resolution, and some amount of name binding and symbol resolution, just as a few examples. An overview of the compilation process is available as a comment inside of the compiler.Compile function, although it is currently unimplemented. The relationship between Workspace and Compiler has been semi- inverted, such that all Compiler instances require a Workspace object. This is more natural anyway and moves some of the detection logic "outside" of the Compiler. Similarly, Options has moved to a top-level package, so that Workspace and Compiler may share access to it without causing package import cycles. Finally, all that templating crap is gone. This alone is cause for mass celebration! 2017-01-18 02:04:15 +01:00			`}`