// This example demonstrates how to use Dump to dump variables to stdout.
func ExampleDump() {
// The following package level declarations are assumed for this example:
/*
type Flag int
const (
flagOne Flag = iota
flagTwo
)
var flagStrings = map[Flag]string{
flagOne: "flagOne",
flagTwo: "flagTwo",
}
func (f Flag) String() string {
if s, ok := flagStrings[f]; ok {
return s
}
return fmt.Sprintf("Unknown flag (%d)", int(f))
}
type Bar struct {
data uintptr
}
type Foo struct {
unexportedField Bar
ExportedField map[interface{}]interface{}
}
*/
// Setup some sample data structures for the example.
bar := Bar{uintptr(0)}
s1 := Foo{bar, map[interface{}]interface{}{"one": true}}
f := Flag(5)
b := []byte{
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20,
0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30,
0x31, 0x32,
}
// Dump!
spew.Dump(s1, f, b)
// Output:
// (spew_test.Foo) {
// unexportedField: (spew_test.Bar) {
// data: (uintptr) <nil>
// },
// ExportedField: (map[interface {}]interface {}) (len=1) {
// (string) (len=3) "one": (bool) true
// }
// }
// (spew_test.Flag) Unknown flag (5)
// ([]uint8) (len=34 cap=34) {
// 00000000 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 |............... |
// 00000010 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30 |!"#$%&'()*+,-./0|
// 00000020 31 32 |12|
// }
//
}
func main() {
if len(os.Args) != 2 {
bail()
}
libmachine.SetDebug(true)
errR, errW := io.Pipe()
errTracker := &FancyTracker{
r: errR,
w: os.Stderr,
}
outR, outW := io.Pipe()
outTracker := &FancyTracker{
r: outR,
w: os.Stdout,
}
go errTracker.Track()
go outTracker.Track()
dmlog.SetOutWriter(errW)
dmlog.SetErrWriter(outW)
store := libmachine.GetDefaultStore()
store.Path = "./store"
hostName := "mobydick"
data, err := ioutil.ReadFile("moby.yml")
if err != nil {
log.Fatal(err)
}
switch os.Args[1] {
case "up":
driver, err := drivermaker.NewDriver("digitalocean", hostName, "./store")
if err != nil {
log.Fatal(err)
}
h, err := store.NewHost(driver)
if err != nil {
log.Fatal(err)
}
if err := yaml.Unmarshal(data, h); err != nil {
log.Fatal(err)
}
castedDriver, ok := driver.(*digitalocean.Driver)
if !ok {
log.Fatal("Fatal error, shoud be able to cast to driver type \"digitalocean\".")
}
driverWrapper := DriverWrapper{castedDriver}
if err := yaml.Unmarshal(data, &driverWrapper); err != nil {
log.Fatal(err)
}
h.Driver = driverWrapper.DriverOptions
spew.Dump(h)
if err := libmachine.Create(store, h); err != nil {
log.Fatal(err)
}
case "apply":
h, err := store.Get(hostName)
if err != nil {
log.Fatal(err)
}
spew.Dump(h)
if err := yaml.Unmarshal(data, h); err != nil {
log.Fatal(err)
}
if err := h.Provision(); err != nil {
log.Fatal(err)
}
default:
bail()
}
}