Esempio n. 1
23
func TestMain(t *testing.T) {

	ctx := context.Background()

	for i, model := range []*simulator.Model{simulator.ESX(), simulator.VPX()} {
		t.Logf("%d", i)
		defer model.Remove()
		err := model.Create()
		if err != nil {
			t.Fatal(err)
		}

		s := model.Service.NewServer()
		defer s.Close()

		s.URL.User = url.UserPassword("user", "pass")
		t.Logf("server URL: %s", s.URL)

		var sess *session.Session
		if i == 0 {
			sess, err = getESXSession(ctx, s.URL.String())
		} else {
			sess, err = getVPXSession(ctx, s.URL.String())
		}
		if err != nil {
			t.Fatal(err)
		}
		defer sess.Logout(ctx)
		testGetChildrenVMs(ctx, sess, t)
		testGetChildVM(ctx, sess, t)
		testFindResourcePool(ctx, sess, t)
		testGetCluster(ctx, sess, t)
	}
}
Esempio n. 2
7
func TestMain(t *testing.T) {
	log.SetLevel(log.DebugLevel)
	ctx := context.Background()

	for i, model := range []*simulator.Model{simulator.ESX(), simulator.VPX()} {
		t.Logf("%d", i)
		defer model.Remove()
		err := model.Create()
		if err != nil {
			t.Fatal(err)
		}

		s := model.Service.NewServer()
		defer s.Close()

		s.URL.User = url.UserPassword("user", "pass")
		s.URL.Path = ""
		t.Logf("server URL: %s", s.URL)

		var input *data.Data
		if i == 0 {
			input = getESXData(s.URL)
		} else {
			input = getVPXData(s.URL)
		}
		if err != nil {
			t.Fatal(err)
		}
		installSettings := &data.InstallerData{}
		installSettings.ApplianceSize.CPU.Limit = 1
		installSettings.ApplianceSize.Memory.Limit = 1024

		validator, err := validate.NewValidator(ctx, input)
		if err != nil {
			t.Fatalf("Failed to validator: %s", err)
		}

		validator.DisableFirewallCheck = true
		validator.DisableDRSCheck = true

		conf, err := validator.Validate(ctx, input)
		if err != nil {
			log.Errorf("Failed to validate conf: %s", err)
			validator.ListIssues()
		}

		// FIXME: get host NetworkSystem failed in simulator
		//		testCreateNetwork(ctx, validator.Session, conf, t)

		testCreateVolumeStores(ctx, validator.Session, conf, false, t)
		testDeleteVolumeStores(ctx, validator.Session, conf, 1, t)
		errConf := &config.VirtualContainerHostConfigSpec{}
		*errConf = *conf
		errConf.VolumeLocations = make(map[string]*url.URL)
		errConf.VolumeLocations["volume-store"], _ = url.Parse("ds://store_not_exist/volumes/test")
		testCreateVolumeStores(ctx, validator.Session, errConf, true, t)
		testCreateAppliance(ctx, validator.Session, conf, installSettings, false, t)
	}
}
Esempio n. 3
0
func TestWaitForKeyInExtraConfig(t *testing.T) {
	ctx := context.Background()

	m := simulator.ESX()
	defer m.Remove()
	err := m.Create()
	if err != nil {
		t.Fatal(err)
	}

	server := m.Service.NewServer()
	defer server.Close()

	config := &session.Config{
		Service: server.URL.String(),
	}

	s, err := session.NewSession(config).Connect(ctx)
	if err != nil {
		t.Fatal(err)
	}

	if s, err = s.Populate(ctx); err != nil {
		t.Fatal(err)
	}

	vms, err := s.Finder.VirtualMachineList(ctx, "*")
	if err != nil {
		t.Fatal(err)
	}

	vm := NewVirtualMachineFromVM(ctx, s, vms[0])

	opt := &types.OptionValue{Key: "foo", Value: "bar"}
	obj := simulator.Map.Get(vm.Reference()).(*simulator.VirtualMachine)
	obj.Config.ExtraConfig = append(obj.Config.ExtraConfig, opt)

	val, err := vm.WaitForKeyInExtraConfig(ctx, opt.Key)

	if err == nil {
		t.Error("expected error")
	}

	obj.Summary.Runtime.PowerState = types.VirtualMachinePowerStatePoweredOn

	val, err = vm.WaitForKeyInExtraConfig(ctx, opt.Key)
	if err != nil {
		t.Fatal(err)
	}

	if val != opt.Value {
		t.Errorf("%s != %s", val, opt.Value)
	}
}
Esempio n. 4
0
func TestMain(t *testing.T) {
	log.SetLevel(log.DebugLevel)
	trace.Logger.Level = log.DebugLevel
	ctx := context.Background()

	for i, model := range []*simulator.Model{simulator.ESX(), simulator.VPX()} {
		t.Logf("%d", i)
		model.Datastore = 3
		defer model.Remove()
		err := model.Create()
		if err != nil {
			t.Fatal(err)
		}

		s := model.Service.NewServer()
		defer s.Close()

		s.URL.User = url.UserPassword("user", "pass")
		s.URL.Path = ""
		t.Logf("server URL: %s", s.URL)

		var input *data.Data
		if i == 0 {
			input = getESXData(s.URL)
		} else {
			input = getVPXData(s.URL)
		}
		if err != nil {
			t.Fatal(err)
		}

		validator, err := NewValidator(ctx, input)
		if err != nil {
			t.Errorf("Failed to new validator: %s", err)
		}
		ds, _ := validator.Session.Finder.Datastore(validator.Context, "LocalDS_1")
		simulator.Map.Get(ds.Reference()).(mo.Entity).Entity().Name = "Local DS_0"

		ds, _ = validator.Session.Finder.Datastore(validator.Context, "LocalDS_2")
		simulator.Map.Get(ds.Reference()).(mo.Entity).Entity().Name = `😗`

		validator.DisableFirewallCheck = true
		validator.DisableDRSCheck = true
		t.Logf("session pool: %s", validator.Session.Pool)
		if err = createPool(ctx, validator.Session, input.ComputeResourcePath, "validator", t); err != nil {
			t.Errorf("Unable to create resource pool: %s", err)
		}

		conf := testCompute(validator, input, t)
		testTargets(validator, input, conf, t)
		testStorage(validator, input, conf, t)
		//		testNetwork() need dvs support
	}
}
Esempio n. 5
0
func TestConnect(t *testing.T) {
	ctx := context.Background()

	for _, model := range []*simulator.Model{simulator.ESX(), simulator.VPX()} {
		defer model.Remove()
		err := model.Create()
		if err != nil {
			t.Fatal(err)
		}

		model.Service.TLS = new(tls.Config)
		s := model.Service.NewServer()
		defer s.Close()

		config := &Config{
			Keepalive: time.Minute,
			Service:   s.URL.String(),
		}

		for _, thumbprint := range []string{"", s.CertificateInfo().ThumbprintSHA1} {
			u := *s.URL
			config.Service = u.String()
			config.Thumbprint = thumbprint

			_, err = NewSession(config).Connect(ctx)
			if thumbprint == "" {
				if err == nil {
					t.Error("expected x509.UnknownAuthorityError error")
				}
			} else {
				if err != nil {
					t.Error(err)
				}
			}

			u.User = nil
			config.Service = u.String()
			_, err = NewSession(config).Connect(ctx)
			if err == nil {
				t.Fatal("expected login error")
			}

			config.Service = ""
			_, err = NewSession(config).Connect(ctx)
			if err == nil {
				t.Fatal("expected URL parse error")
			}
		}
	}
}
Esempio n. 6
0
func TestFinder(t *testing.T) {
	log.SetLevel(log.DebugLevel)
	trace.Logger.Level = log.DebugLevel
	ctx := context.Background()

	for i, model := range []*simulator.Model{simulator.ESX(), simulator.VPX()} {
		t.Logf("%d", i)
		defer model.Remove()
		if i == 1 {
			model.Datacenter = 2
			model.Cluster = 2
			model.Host = 2
			model.Pool = 0
		}
		err := model.Create()
		if err != nil {
			t.Fatal(err)
		}

		s := model.Service.NewServer()
		defer s.Close()

		s.URL.User = url.UserPassword("user", "pass")
		s.URL.Path = ""
		t.Logf("server URL: %s", s.URL)

		var input *data.Data
		if i == 0 {
			input = getESXData(s.URL)
		} else {
			input = getVPXData(s.URL)
		}
		if err != nil {
			t.Fatal(err)
		}
		validator, err := validate.CreateNoDCCheck(ctx, input)
		if err != nil {
			t.Errorf("Failed to create validator: %s", err)
		}

		prefix := fmt.Sprintf("p%d-", i)
		if err = createTestData(ctx, validator.Session, prefix); err != nil {
			t.Errorf("Failed to create test data: %s", err)
		}
		// FIXME: ServerFaultCode: no such object: SearchIndex:ha-searchindex
		//		testSearchVCHs(t, validator)
	}
}
Esempio n. 7
0
File: main.go Progetto: jak-atx/vic
func main() {
	model := simulator.VPX()

	flag.IntVar(&model.Datacenter, "dc", model.Datacenter, "Number of datacenters")
	flag.IntVar(&model.Cluster, "cluster", model.Cluster, "Number of clusters")
	flag.IntVar(&model.ClusterHost, "host", model.ClusterHost, "Number of hosts per cluster")
	flag.IntVar(&model.Host, "standalone-host", model.Host, "Number of standalone hosts")
	flag.IntVar(&model.Datastore, "ds", model.Datastore, "Number of local datastores")
	flag.IntVar(&model.Machine, "vm", model.Machine, "Number of virtual machines per resource pool")
	flag.IntVar(&model.Pool, "pool", model.Pool, "Number of resource pools per compute resource")

	isESX := flag.Bool("esx", false, "Simulate standalone ESX")

	flag.Parse()

	f := flag.Lookup("httptest.serve")
	if f.Value.String() == "" {
		f.Value.Set("localhost:8989")
	}

	if *isESX {
		opts := model
		model = simulator.ESX()
		// Preserve options that also apply to ESX
		model.Datastore = opts.Datastore
		model.Machine = opts.Machine
	}

	tag := " (govmomi simulator)"
	model.ServiceContent.About.Name += tag
	model.ServiceContent.About.OsType = runtime.GOOS + "-" + runtime.GOARCH

	esx.HostSystem.Summary.Hardware.Vendor += tag

	defer model.Remove()

	err := model.Create()
	if err != nil {
		log.Fatal(err)
	}

	model.Service.NewServer()
}
Esempio n. 8
0
File: main.go Progetto: vmware/vic
func main() {
	model := simulator.VPX()

	flag.IntVar(&model.Datacenter, "dc", model.Datacenter, "Number of datacenters")
	flag.IntVar(&model.Cluster, "cluster", model.Cluster, "Number of clusters")
	flag.IntVar(&model.ClusterHost, "host", model.ClusterHost, "Number of hosts per cluster")
	flag.IntVar(&model.Host, "standalone-host", model.Host, "Number of standalone hosts")
	flag.IntVar(&model.Datastore, "ds", model.Datastore, "Number of local datastores")
	flag.IntVar(&model.Machine, "vm", model.Machine, "Number of virtual machines per resource pool")
	flag.IntVar(&model.Pool, "pool", model.Pool, "Number of resource pools per compute resource")

	isESX := flag.Bool("esx", false, "Simulate standalone ESX")
	isTLS := flag.Bool("tls", false, "Enable TLS")
	cert := flag.String("tlscert", "", "Path to TLS certificate file")
	key := flag.String("tlskey", "", "Path to TLS key file")

	flag.Parse()

	f := flag.Lookup("httptest.serve")
	if f.Value.String() == "" {
		_ = f.Value.Set("127.0.0.1:8989")
	}

	if *isESX {
		opts := model
		model = simulator.ESX()
		// Preserve options that also apply to ESX
		model.Datastore = opts.Datastore
		model.Machine = opts.Machine
	}

	tag := " (govmomi simulator)"
	model.ServiceContent.About.Name += tag
	model.ServiceContent.About.OsType = runtime.GOOS + "-" + runtime.GOARCH

	esx.HostSystem.Summary.Hardware.Vendor += tag

	defer model.Remove()

	err := model.Create()
	if err != nil {
		log.Fatal(err)
	}

	if *isTLS {
		model.Service.TLS = new(tls.Config)
		if *cert != "" {
			c, err := tls.LoadX509KeyPair(*cert, *key)
			if err != nil {
				log.Fatal(err)
			}

			model.Service.TLS.Certificates = []tls.Certificate{c}
		}
	}

	s := model.Service.NewServer()

	fmt.Printf("GOVC_URL=%s", s.URL)

	select {}
}
Esempio n. 9
0
// TestSoapFaults covers the various soap fault checking paths
func TestSoapFaults(t *testing.T) {
	ctx := context.Background()

	// Nothing VC specific in this test, so we use the simpler ESX model
	model := simulator.ESX()
	defer model.Remove()
	err := model.Create()
	if err != nil {
		t.Fatal(err)
	}

	server := model.Service.NewServer()
	defer server.Close()

	client, err := govmomi.NewClient(ctx, server.URL, true)
	if err != nil {
		t.Fatal(err)
	}

	// Any VM will do
	finder := find.NewFinder(client.Client, false)
	vm, err := finder.VirtualMachine(ctx, "/ha-datacenter/vm/*_VM0")
	if err != nil {
		t.Fatal(err)
	}

	// Test the success path
	err = Wait(ctx, func(ctx context.Context) (Task, error) {
		return vm.PowerOn(ctx)
	})
	if err != nil {
		t.Fatal(err)
	}

	// Wrap existing vm MO with faultyVirtualMachine
	ref := simulator.Map.Get(vm.Reference())
	fvm := &faultyVirtualMachine{*ref.(*simulator.VirtualMachine), nil}
	simulator.Map.Put(fvm)

	// Inject TaskInProgress fault
	fvm.fault = new(types.TaskInProgress)
	task, err := vm.PowerOff(ctx)
	if err != nil {
		t.Fatal(err)
	}

	// Test the task.Error path
	res, err := task.WaitForResult(ctx, nil)
	if !isTaskInProgress(err) {
		t.Error(err)
	}

	// Test the soap.IsVimFault() path
	if !isTaskInProgress(soap.WrapVimFault(res.Error.Fault)) {
		t.Errorf("fault=%#v", res.Error.Fault)
	}

	// Test the soap.IsSoapFault() path
	err = vm.MarkAsTemplate(ctx)
	if !isTaskInProgress(err) {
		t.Error(err)
	}

	// Test a fault other than TaskInProgress
	fvm.fault = &types.QuestionPending{
		Text: "now why would you want to do such a thing?",
	}

	err = Wait(ctx, func(ctx context.Context) (Task, error) {
		return vm.PowerOff(ctx)
	})
	if err == nil {
		t.Error("expected error")
	}
	if isTaskInProgress(err) {
		t.Error(err)
	}

	// Test with retry
	fvm.fault = new(types.TaskInProgress)
	called := 0

	err = Wait(ctx, func(ctx context.Context) (Task, error) {
		called++
		if called > 1 {
			simulator.Map.Put(ref) // remove fault injection
		}

		return vm.PowerOff(ctx)
	})
	if err != nil {
		t.Error(err)
	}
	if called != 2 {
		t.Errorf("called=%d", called)
	}
}
Esempio n. 10
-3
func TestDelete(t *testing.T) {
	log.SetLevel(log.DebugLevel)
	trace.Logger.Level = log.DebugLevel
	ctx := context.Background()

	for i, model := range []*simulator.Model{simulator.ESX(), simulator.VPX()} {
		t.Logf("%d", i)
		defer model.Remove()
		err := model.Create()
		if err != nil {
			t.Fatal(err)
		}

		s := model.Service.NewServer()
		defer s.Close()

		s.URL.User = url.UserPassword("user", "pass")
		s.URL.Path = ""
		t.Logf("server URL: %s", s.URL)

		var input *data.Data
		if i == 0 {
			input = getESXData(s.URL)
		} else {
			input = getVPXData(s.URL)
		}
		if err != nil {
			t.Fatal(err)
		}
		installSettings := &data.InstallerData{}
		installSettings.ApplianceSize.CPU.Limit = 1
		installSettings.ApplianceSize.Memory.Limit = 1024
		installSettings.ResourcePoolPath = path.Join(input.ComputeResourcePath, input.DisplayName)

		validator, err := validate.NewValidator(ctx, input)
		if err != nil {
			t.Errorf("Failed to validator: %s", err)
		}

		validator.DisableFirewallCheck = true
		validator.DisableDRSCheck = true

		conf, err := validator.Validate(ctx, input)
		if err != nil {
			log.Errorf("Failed to validate conf: %s", err)
			validator.ListIssues()
		}

		createAppliance(ctx, validator.Session, conf, installSettings, false, t)
		// FIXME: cannot check if it's VCH or not
		// testNewVCHFromCompute(input.ComputeResourcePath, input.DisplayName, validator, t)
		//	testDeleteVCH(validator, conf, t)

		testDeleteDatastoreFiles(validator, t)
	}
}