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)
}
}
func (l *List) Run(cli *cli.Context) (err error) {
if err = l.processParams(); err != nil {
return err
}
if l.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Listing VCHs ####")
ctx, cancel := context.WithTimeout(context.Background(), l.Timeout)
defer cancel()
defer func() {
if ctx.Err() != nil && ctx.Err() == context.DeadlineExceeded {
//context deadline exceeded, replace returned error message
err = errors.Errorf("List timed out: use --timeout to add more time")
}
}()
var validator *validate.Validator
if l.Data.ComputeResourcePath == "" {
validator, err = validate.CreateNoDCCheck(ctx, l.Data)
} else {
validator, err = validate.NewValidator(ctx, l.Data)
}
if err != nil {
log.Errorf("List cannot continue - failed to create validator: %s", err)
return errors.New("list failed")
}
_, err = validator.ValidateTarget(ctx, l.Data)
if err != nil {
log.Errorf("List cannot continue - target validation failed: %s", err)
return err
}
_, err = validator.ValidateCompute(ctx, l.Data)
if err != nil {
log.Errorf("List cannot continue - compute resource validation failed: %s", err)
return err
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, false)
vchs, err := executor.SearchVCHs(validator.ResourcePoolPath)
if err != nil {
log.Errorf("List cannot continue - failed to search VCHs in %s: %s", validator.ResourcePoolPath, err)
}
l.prettyPrint(cli, ctx, vchs, executor)
return nil
}
func (c *Create) Run(cliContext *cli.Context) (err error) {
if c.advancedOptions {
cli.HelpPrinter(cliContext.App.Writer, EntireOptionHelpTemplate, cliContext.Command)
return nil
}
if c.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if err = c.processParams(); err != nil {
return err
}
var images map[string]string
if images, err = c.checkImagesFiles(cliContext); err != nil {
return err
}
if len(cliContext.Args()) > 0 {
log.Errorf("Unknown argument: %s", cliContext.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Installing VCH ####")
var keypair *certificate.Keypair
if keypair, err = c.loadCertificate(); err != nil {
log.Error("Create cannot continue: unable to load certificate")
return err
}
if keypair != nil {
c.KeyPEM = keypair.KeyPEM
c.CertPEM = keypair.CertPEM
}
ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
defer cancel()
defer func() {
if ctx.Err() != nil && ctx.Err() == context.DeadlineExceeded {
//context deadline exceeded, replace returned error message
err = errors.Errorf("Create timed out: use --timeout to add more time")
}
}()
validator, err := validate.NewValidator(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: failed to create validator")
return err
}
vchConfig, err := validator.Validate(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: configuration validation failed")
return err
}
if keypair != nil {
vchConfig.UserKeyPEM = string(keypair.KeyPEM)
vchConfig.UserCertPEM = string(keypair.CertPEM)
}
vConfig := validator.AddDeprecatedFields(ctx, vchConfig, c.Data)
vConfig.ImageFiles = images
vConfig.ApplianceISO = path.Base(c.ApplianceISO)
vConfig.BootstrapISO = path.Base(c.BootstrapISO)
{ // create certificates for VCH extension
var certbuffer, keybuffer bytes.Buffer
if certbuffer, keybuffer, err = certificate.CreateRawKeyPair(); err != nil {
return errors.Errorf("Failed to create certificate for VIC vSphere extension: %s", err)
}
vchConfig.ExtensionCert = certbuffer.String()
vchConfig.ExtensionKey = keybuffer.String()
}
executor := management.NewDispatcher(ctx, validator.Session, vchConfig, c.Force)
if err = executor.CreateVCH(vchConfig, vConfig); err != nil {
executor.CollectDiagnosticLogs()
return err
}
log.Infof("Initialization of appliance successful")
executor.ShowVCH(vchConfig, c.key, c.cert)
log.Infof("Installer completed successfully")
return nil
}
func (d *Uninstall) Run(cli *cli.Context) (err error) {
if err = d.processParams(); err != nil {
return err
}
if d.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Removing VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), d.Timeout)
defer cancel()
defer func() {
if ctx.Err() != nil && ctx.Err() == context.DeadlineExceeded {
//context deadline exceeded, replace returned error message
err = errors.Errorf("Delete timed out: use --timeout to add more time")
}
}()
validator, err := validate.NewValidator(ctx, d.Data)
if err != nil {
log.Errorf("Delete cannot continue - failed to create validator: %s", err)
return errors.New("delete failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, d.Force)
var vch *vm.VirtualMachine
if d.Data.ID != "" {
vch, err = executor.NewVCHFromID(d.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(d.Data.ComputeResourcePath, d.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", d.DisplayName)
log.Error(err)
return errors.New("delete failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("delete failed")
}
executor.InitDiagnosticLogs(vchConfig)
if err = executor.DeleteVCH(vchConfig); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("delete failed")
}
log.Infof("Completed successfully")
return nil
}
func (i *Inspect) Run(cli *cli.Context) error {
var err error
if err = i.processParams(); err != nil {
return err
}
if i.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Inspecting VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), i.Timeout)
defer cancel()
validator, err := validate.NewValidator(ctx, i.Data)
if err != nil {
log.Errorf("Inspect cannot continue - failed to create validator: %s", err)
return errors.New("inspect failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, i.Force)
var vch *vm.VirtualMachine
if i.Data.ID != "" {
vch, err = executor.NewVCHFromID(i.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(i.Data.ComputeResourcePath, i.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", i.DisplayName)
log.Error(err)
return errors.New("inspect failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("inspect failed")
}
executor.InitDiagnosticLogs(vchConfig)
if err = executor.InspectVCH(vch, vchConfig); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("inspect failed")
}
log.Infof("Completed successfully")
return nil
}
func (u *Upgrade) Run(cli *cli.Context) error {
var err error
if err = u.processParams(); err != nil {
return err
}
if u.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
var images map[string]string
if images, err = u.CheckImagesFiles(u.Force); err != nil {
return err
}
log.Infof("### Upgrading VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), u.Timeout)
defer cancel()
validator, err := validate.NewValidator(ctx, u.Data)
if err != nil {
log.Errorf("Upgrade cannot continue - failed to create validator: %s", err)
return errors.New("upgrade failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, u.Force)
var vch *vm.VirtualMachine
if u.Data.ID != "" {
vch, err = executor.NewVCHFromID(u.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(u.Data.ComputeResourcePath, u.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", u.DisplayName)
log.Error(err)
return errors.New("upgrade failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("upgrade failed")
}
executor.InitDiagnosticLogs(vchConfig)
vConfig := validator.AddDeprecatedFields(ctx, vchConfig, u.Data)
vConfig.ImageFiles = images
vConfig.ApplianceISO = path.Base(u.ApplianceISO)
vConfig.BootstrapISO = path.Base(u.BootstrapISO)
vConfig.RollbackTimeout = u.Timeout
if vchConfig, err = validator.MigrateConfig(ctx, vchConfig); err != nil {
log.Errorf("Failed to migrate Virtual Container Host configuration %s", u.DisplayName)
log.Error(err)
return errors.New("upgrade failed")
}
if err = executor.Upgrade(vch, vchConfig, vConfig); err != nil {
// upgrade failed
executor.CollectDiagnosticLogs()
if err == nil {
err = errors.New("upgrade failed")
}
return err
}
// check the docker endpoint is responsive
if err = executor.CheckDockerAPI(vchConfig, nil); err != nil {
executor.CollectDiagnosticLogs()
return err
}
log.Infof("Completed successfully")
return nil
}
func (d *Debug) Run(cli *cli.Context) error {
var err error
if err = d.processParams(); err != nil {
return err
}
if d.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if len(cli.Args()) > 0 {
log.Errorf("Unknown argument: %s", cli.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Configuring VCH for debug ####")
ctx, cancel := context.WithTimeout(context.Background(), d.Timeout)
defer cancel()
validator, err := validate.NewValidator(ctx, d.Data)
if err != nil {
log.Errorf("Debug cannot continue - failed to create validator: %s", err)
return errors.New("Debug failed")
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, d.Force)
var vch *vm.VirtualMachine
if d.Data.ID != "" {
vch, err = executor.NewVCHFromID(d.Data.ID)
} else {
vch, err = executor.NewVCHFromComputePath(d.Data.ComputeResourcePath, d.Data.DisplayName, validator)
}
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", d.DisplayName)
log.Error(err)
return errors.New("Debug failed")
}
log.Infof("")
log.Infof("VCH ID: %s", vch.Reference().String())
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Error("Failed to get Virtual Container Host configuration")
log.Error(err)
return errors.New("Debug failed")
}
executor.InitDiagnosticLogs(vchConfig)
installerVer := version.GetBuild()
log.Info("")
log.Infof("Installer version: %s", installerVer.ShortVersion())
log.Infof("VCH version: %s", vchConfig.Version.ShortVersion())
// load the key file if set
var key []byte
if d.authorizedKey != "" {
key, err = ioutil.ReadFile(d.authorizedKey)
if err != nil {
log.Errorf("Unable to read public key from %s: %s", d.authorizedKey, err)
return errors.New("unable to load public key")
}
}
if err = executor.DebugVCH(vch, vchConfig, d.password, string(key)); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("Debug failed")
}
// display the VCH endpoints again for convenience
if err = executor.InspectVCH(vch, vchConfig); err != nil {
executor.CollectDiagnosticLogs()
log.Errorf("%s", err)
return errors.New("inspect failed")
}
log.Infof("Completed successfully")
return nil
}
func (d *Uninstall) Run(cli *cli.Context) error {
var err error
if err = d.processParams(); err != nil {
return err
}
// Open log file
f, err := os.OpenFile(d.logfile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
err = errors.Errorf("Error opening logfile %s: %v", d.logfile, err)
return err
}
defer f.Close()
// Initiliaze logger with default TextFormatter
log.SetFormatter(&log.TextFormatter{ForceColors: true, FullTimestamp: true})
// SetOutput to io.MultiWriter so that we can log to stdout and a file
log.SetOutput(io.MultiWriter(os.Stdout, f))
if d.Debug.Debug {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
log.Infof("### Removing VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), d.Timeout)
defer cancel()
validator, err := validate.NewValidator(ctx, d.Data)
if err != nil {
err = errors.Errorf("%s. Exiting...", err)
return err
}
executor := management.NewDispatcher(validator.Context, validator.Session, nil, d.Force)
vch, err := executor.NewVCHFromComputePath(d.Data.ComputeResourcePath, d.Data.DisplayName)
if err != nil {
log.Errorf("Failed to get Virtual Container Host %s", d.DisplayName)
return err
}
vchConfig, err := executor.GetVCHConfig(vch)
if err != nil {
log.Errorf("Failed to get Virtual Container Host configuration")
return err
}
executor.InitDiagnosticLogs(vchConfig)
if validator.IsVC() {
log.Infoln("Removing VCH vSphere extension")
if err = executor.GenerateExtensionName(vchConfig); err != nil {
log.Warnf("Wasn't able to get extension name during VCH deletion. Failed with error: %s", err)
}
if err = executor.UnregisterExtension(vchConfig.ExtensionName); err != nil {
log.Warnf("Wasn't able to remove extension %s due to error: %s", vchConfig.ExtensionName, err)
}
}
if err = executor.DeleteVCH(vchConfig); err != nil {
executor.CollectDiagnosticLogs()
return err
}
log.Infof("Completed successfully")
return nil
}
func (c *Create) Run(cliContext *cli.Context) (err error) {
if c.advancedOptions {
cli.HelpPrinter(cliContext.App.Writer, EntireOptionHelpTemplate, cliContext.Command)
return nil
}
if c.Debug.Debug > 0 {
log.SetLevel(log.DebugLevel)
trace.Logger.Level = log.DebugLevel
}
if err = c.processParams(); err != nil {
return err
}
var images map[string]string
if images, err = c.CheckImagesFiles(c.Force); err != nil {
return err
}
if len(cliContext.Args()) > 0 {
log.Errorf("Unknown argument: %s", cliContext.Args()[0])
return errors.New("invalid CLI arguments")
}
log.Infof("### Installing VCH ####")
ctx, cancel := context.WithTimeout(context.Background(), c.Timeout)
defer cancel()
defer func() {
if ctx.Err() != nil && ctx.Err() == context.DeadlineExceeded {
//context deadline exceeded, replace returned error message
err = errors.Errorf("Create timed out: use --timeout to add more time")
}
}()
validator, err := validate.NewValidator(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: failed to create validator")
return err
}
vchConfig, err := validator.Validate(ctx, c.Data)
if err != nil {
log.Error("Create cannot continue: configuration validation failed")
return err
}
vConfig := validator.AddDeprecatedFields(ctx, vchConfig, c.Data)
vConfig.ImageFiles = images
vConfig.ApplianceISO = path.Base(c.ApplianceISO)
vConfig.BootstrapISO = path.Base(c.BootstrapISO)
vConfig.HTTPProxy = c.HTTPProxy
vConfig.HTTPSProxy = c.HTTPSProxy
vchConfig.InsecureRegistries = c.Data.InsecureRegistries
if validator.Session.IsVC() { // create certificates for VCH extension
var certbuffer, keybuffer bytes.Buffer
if certbuffer, keybuffer, err = certificate.CreateSelfSigned("", []string{"VMware Inc."}, 2048); err != nil {
return errors.Errorf("Failed to create certificate for VIC vSphere extension: %s", err)
}
vchConfig.ExtensionCert = certbuffer.String()
vchConfig.ExtensionKey = keybuffer.String()
}
// separate initial validation from dispatch of creation task
log.Info("")
executor := management.NewDispatcher(ctx, validator.Session, vchConfig, c.Force)
if err = executor.CreateVCH(vchConfig, vConfig); err != nil {
executor.CollectDiagnosticLogs()
return err
}
// check the docker endpoint is responsive
if err = executor.CheckDockerAPI(vchConfig, c.clientCert); err != nil {
executor.CollectDiagnosticLogs()
return err
}
log.Infof("Initialization of appliance successful")
executor.ShowVCH(vchConfig, c.key, c.cert, c.cacert, c.envFile)
log.Infof("Installer completed successfully")
return nil
}
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)
}
}