Example #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)
	}
}
Example #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)
	}
}
Example #3
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
	}
}
Example #4
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")
			}
		}
	}
}
Example #5
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)
	}
}
Example #6
0
File: main.go Project: 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()
}
Example #7
0
File: main.go Project: 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 {}
}
Example #8
-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)
	}
}