func StartAttachTether(t *testing.T, cfg *metadata.ExecutorConfig) (tether.Tether, extraconfig.DataSource, net.Conn) { store := map[string]string{} sink := extraconfig.MapSink(store) src := extraconfig.MapSource(store) extraconfig.Encode(sink, cfg) log.Debugf("Test configuration: %#v", sink) tthr := tether.New(src, sink, &Mocked) tthr.Register("mocker", &Mocked) tthr.Register("Attach", server) // run the tether to service the attach go func() { erR := tthr.Start() if erR != nil { t.Error(erR) } }() // create client on the mock pipe conn, err := mockBackChannel(context.Background()) if err != nil && (err != io.EOF || server.(*testAttachServer).enabled) { // we accept the case where the error is end-of-file and the attach server is disabled because that's // expected when the tether is shut down. t.Error(err) } return tthr, src, conn }
func TestToExtraConfig(t *testing.T) { exec := metadata.ExecutorConfig{ Common: metadata.Common{ ID: "deadbeef", Name: "configtest", }, Sessions: map[string]metadata.SessionConfig{ "deadbeef": metadata.SessionConfig{ Cmd: metadata.Cmd{ Path: "/bin/bash", Args: []string{"/bin/bash", "-c", "echo hello"}, Dir: "/", Env: []string{"HOME=/", "PATH=/bin"}, }, }, "beefed": metadata.SessionConfig{ Cmd: metadata.Cmd{ Path: "/bin/bash", Args: []string{"/bin/bash", "-c", "echo goodbye"}, Dir: "/", Env: []string{"HOME=/", "PATH=/bin"}, }, }, }, Networks: map[string]*metadata.NetworkEndpoint{ "eth0": &metadata.NetworkEndpoint{ Static: &net.IPNet{IP: localhost, Mask: lmask.Mask}, Network: metadata.ContainerNetwork{ Common: metadata.Common{ Name: "notsure", }, Gateway: net.IPNet{IP: gateway, Mask: gmask.Mask}, Nameservers: []net.IP{}, }, }, }, } // encode metadata package's ExecutorConfig encoded := map[string]string{} extraconfig.Encode(extraconfig.MapSink(encoded), exec) // decode into this package's ExecutorConfig var decoded ExecutorConfig extraconfig.Decode(extraconfig.MapSource(encoded), &decoded) // the networks should be identical assert.Equal(t, exec.Networks["eth0"], decoded.Networks["eth0"]) // the source and destination structs are different - we're doing a sparse comparison expected := exec.Sessions["deadbeef"] actual := *decoded.Sessions["deadbeef"] assert.Equal(t, expected.Cmd.Path, actual.Cmd.Path) assert.Equal(t, expected.Cmd.Args, actual.Cmd.Args) assert.Equal(t, expected.Cmd.Dir, actual.Cmd.Dir) assert.Equal(t, expected.Cmd.Env, actual.Cmd.Env) }
func testConfig() *Configuration { return &Configuration{ source: extraconfig.MapSource(map[string]string{}), sink: extraconfig.MapSink(map[string]string{}), BridgeLink: &mockLink{}, Network: config.Network{ BridgeNetwork: "bridge", ContainerNetworks: map[string]*executor.ContainerNetwork{ "bridge": { Common: executor.Common{ Name: "bridge", }, Type: constants.BridgeScopeType, }, "bar7": { Common: executor.Common{ Name: "external", }, Gateway: net.IPNet{IP: net.ParseIP("10.13.0.1"), Mask: net.CIDRMask(16, 32)}, Nameservers: []net.IP{net.ParseIP("10.10.1.1")}, Pools: []ip.Range{*ip.ParseRange("10.13.1.0-255"), *ip.ParseRange("10.13.2.0-10.13.2.15")}, Type: constants.ExternalScopeType, }, "bar71": { Common: executor.Common{ Name: "external", }, Gateway: net.IPNet{IP: net.ParseIP("10.131.0.1"), Mask: net.CIDRMask(16, 32)}, Nameservers: []net.IP{net.ParseIP("10.131.0.1"), net.ParseIP("10.131.0.2")}, Pools: []ip.Range{*ip.ParseRange("10.131.1.0/16")}, Type: constants.ExternalScopeType, }, "bar72": { Common: executor.Common{ Name: "external", }, Type: constants.ExternalScopeType, }, "bar73": { Common: executor.Common{ Name: "external", }, Gateway: net.IPNet{IP: net.ParseIP("10.133.0.1"), Mask: net.CIDRMask(16, 32)}, Type: constants.ExternalScopeType, }, }, }, PortGroups: map[string]object.NetworkReference{ "bridge": testBridgeNetwork, "bar7": testExternalNetwork, "bar71": testExternalNetwork, "bar72": testExternalNetwork, "bar73": testExternalNetwork, }, } }
// applianceConfiguration updates the configuration passed in with the latest from the appliance VM. // there's no guarantee of consistency within the configuration at this time func (d *Dispatcher) applianceConfiguration(conf *metadata.VirtualContainerHostConfigSpec) error { defer trace.End(trace.Begin("")) extraConfig, err := d.appliance.FetchExtraConfig(d.ctx) if err != nil { return err } extraconfig.Decode(extraconfig.MapSource(extraConfig), conf) return nil }
// OptionValueSource is a convenience method to generate a MapSource source from // and array of OptionValue's func OptionValueSource(src []types.BaseOptionValue) extraconfig.DataSource { // create the key/value store from the extraconfig slice for lookups kv := make(map[string]string) for i := range src { k := src[i].GetOptionValue().Key v := src[i].GetOptionValue().Value.(string) if v == "<nil>" { v = "" } kv[k] = v } return extraconfig.MapSource(kv) }
func RunTether(t *testing.T, cfg *metadata.ExecutorConfig) (Tether, extraconfig.DataSource, error) { store := map[string]string{} sink := extraconfig.MapSink(store) src := extraconfig.MapSource(store) extraconfig.Encode(sink, cfg) log.Debugf("Test configuration: %#v", sink) tthr := New(src, sink, &Mocked) tthr.Register("Mocker", &Mocked) // run the tether to service the attach erR := tthr.Start() return tthr, src, erR }
func (d *Dispatcher) isVCH(vm *vm.VirtualMachine) (bool, error) { if vm == nil { return false, errors.New("nil parameter") } defer trace.End(trace.Begin(vm.InventoryPath)) info, err := vm.FetchExtraConfig(d.ctx) if err != nil { err = errors.Errorf("Failed to fetch guest info of appliance vm: %s", err) return false, err } var remoteConf config.VirtualContainerHostConfigSpec extraconfig.Decode(extraconfig.MapSource(info), &remoteConf) // if the moref of the target matches where we expect to find it for a VCH, run with it if remoteConf.ExecutorConfig.ID == vm.Reference().String() { return true, nil } return false, nil }
func (d *Dispatcher) GetVCHConfig(vm *vm.VirtualMachine) (*metadata.VirtualContainerHostConfigSpec, error) { defer trace.End(trace.Begin("")) //this is the appliance vm mapConfig, err := vm.FetchExtraConfig(d.ctx) if err != nil { err = errors.Errorf("Failed to get VM extra config of %s, %s", vm.Reference(), err) log.Errorf("%s", err) return nil, err } data := extraconfig.MapSource(mapConfig) vchConfig := &metadata.VirtualContainerHostConfigSpec{} result := extraconfig.Decode(data, vchConfig) if result == nil { err = errors.Errorf("Failed to decode VM configuration %s, %s", vm.Reference(), err) log.Errorf("%s", err) return nil, err } // vchConfig.ID return vchConfig, nil }
func TestToExtraConfig(t *testing.T) { exec := executor.ExecutorConfig{ Common: executor.Common{ ID: "deadbeef", Name: "configtest", }, Sessions: map[string]*executor.SessionConfig{ "deadbeef": &executor.SessionConfig{ Cmd: executor.Cmd{ Path: "/bin/bash", Args: []string{"/bin/bash", "-c", "echo hello"}, Dir: "/", Env: []string{"HOME=/", "PATH=/bin"}, }, }, "beefed": &executor.SessionConfig{ Cmd: executor.Cmd{ Path: "/bin/bash", Args: []string{"/bin/bash", "-c", "echo goodbye"}, Dir: "/", Env: []string{"HOME=/", "PATH=/bin"}, }, }, }, Networks: map[string]*executor.NetworkEndpoint{ "eth0": &executor.NetworkEndpoint{ Static: true, IP: &net.IPNet{IP: localhost, Mask: lmask.Mask}, Network: executor.ContainerNetwork{ Common: executor.Common{ Name: "notsure", }, Gateway: net.IPNet{IP: gateway, Mask: gmask.Mask}, Nameservers: []net.IP{}, Pools: []ip.Range{}, Aliases: []string{}, }, }, }, } // encode exec package's ExecutorConfig encoded := map[string]string{} extraconfig.Encode(extraconfig.MapSink(encoded), exec) // decode into this package's ExecutorConfig var decoded ExecutorConfig extraconfig.Decode(extraconfig.MapSource(encoded), &decoded) // the source and destination structs are different - we're doing a sparse comparison expectedNet := exec.Networks["eth0"] actualNet := decoded.Networks["eth0"] assert.Equal(t, expectedNet.Common, actualNet.Common) assert.Equal(t, expectedNet.Static, actualNet.Static) assert.Equal(t, expectedNet.Assigned, actualNet.Assigned) assert.Equal(t, expectedNet.Network, actualNet.Network) expectedSession := exec.Sessions["deadbeef"] actualSession := decoded.Sessions["deadbeef"] assert.Equal(t, expectedSession.Cmd.Path, actualSession.Cmd.Path) assert.Equal(t, expectedSession.Cmd.Args, actualSession.Cmd.Args) assert.Equal(t, expectedSession.Cmd.Dir, actualSession.Cmd.Dir) assert.Equal(t, expectedSession.Cmd.Env, actualSession.Cmd.Env) }