// 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|
	// }
	//
}
Example #2
0
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()
	}

}