func cmdRm(c *cli.Context) { if len(c.Args()) == 0 { cli.ShowCommandHelp(c, "rm") fatal("You must specify a machine name") } force := c.Bool("force") store := getStore(c) for _, hostName := range c.Args() { h, err := loadHost(store, hostName) if err != nil { fatalf("Error removing host %q: %s", hostName, err) } if err := h.Driver.Remove(); err != nil { if !force { log.Errorf("Provider error removing machine %q: %s", hostName, err) continue } } if err := store.Remove(hostName); err != nil { log.Errorf("Error removing machine %q from store: %s", hostName, err) } else { log.Infof("Successfully removed %s", hostName) } } }
func (d *Driver) Remove() error { s, err := d.GetState() if err != nil { if err == ErrMachineNotExist { log.Infof("machine does not exist, assuming it has been removed already") return nil } return err } if s == state.Running { if err := d.Stop(); err != nil { return err } } if err := d.removeDiskImage(); err != nil { return err } if d.NFSShare { log.Infof("Remove NFS share folder must be root. Please insert root password.") if _, err := nfsexports.Remove("", d.nfsExportIdentifier()); err != nil { log.Errorf("failed removing nfs share: %s", err.Error()) } if err := nfsexports.ReloadDaemon(); err != nil { log.Errorf("failed reload nfs daemon: %s", err.Error()) } } return nil }
// SubmitDeploymentJobs api call to deployment jobs func (c *ICSPClient) SubmitDeploymentJobs(dj DeploymentJobs) (jt *JobTask, err error) { log.Info("Applying OS Build plan for ICSP") var ( uri = "/rest/os-deployment-jobs" juri ODSUri ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) jt = jt.NewJobTask(c) jt.Reset() data, err := c.RestAPICall(rest.POST, uri, dj) if err != nil { jt.IsDone = true log.Errorf("Error submitting new build request: %s", err) return jt, err } log.Debugf("Response submit new os build plan job %s", data) if err := json.Unmarshal([]byte(data), &juri); err != nil { jt.IsDone = true jt.JobURI = juri log.Errorf("Error with task un-marshal: %s", err) return jt, err } jt.JobURI = juri return jt, err }
func (c *I3SClient) UpdateGoldenImage(goldenImage GoldenImage) error { log.Infof("Initializing update of golden image for %s.", goldenImage.Name) var ( uri = goldenImage.URI.String() t *Task ) c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, goldenImage) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.PUT, uri, goldenImage) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting update golden image request: %s", err) return err } log.Debugf("Response update Golden Image %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } err = t.Wait() if err != nil { return err } return nil }
func (c *OVClient) UpdateProfileTemplate(serverProfileTemplate ServerProfile) error { log.Infof("Initializing update of server profile template for %s.", serverProfileTemplate.Name) var ( uri = serverProfileTemplate.URI.String() t *Task ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewProfileTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, serverProfileTemplate) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.PUT, uri, serverProfileTemplate) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting update server profile template request: %s", err) return err } log.Debugf("Response update ServerProfileTemplate %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } err = t.Wait() if err != nil { return err } return nil }
// submit new profile template func (c *OVClient) SubmitDeleteProfile(p ServerProfile) (t *Task, err error) { var ( uri = p.URI.String() // task = rest_api(:oneview, :post, '/rest/server-profiles', { 'body' => new_template_profile }) ) t = t.NewProfileTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, p) log.Debugf("task -> %+v", t) if uri == "" { log.Warn("Unable to post delete, no uri found.") t.TaskIsDone = true return t, err } data, err := c.RestAPICall(rest.DELETE, uri, nil) if err != nil { log.Errorf("Error submitting new profile request: %s", err) t.TaskIsDone = true return t, err } log.Debugf("Response delete profile %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return t, err } return t, err }
func (c *I3SClient) CreatePlanScript(planScript PlanScript) error { log.Infof("Initializing creation of plan script for %s.", planScript.Name) var ( uri = "/rest/plan-scripts" attemptedPlanScript *PlanScript ) c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) data, err := c.RestAPICall(rest.POST, uri, planScript) if err != nil { log.Errorf("Error submitting new plan script request: %s", err) return err } log.Debugf("Response New Plan Script %s", data) if err := json.Unmarshal([]byte(data), &attemptedPlanScript); err != nil { log.Errorf("Error with task un-marshal: %s", err) return err } if attemptedPlanScript.URI == "" { return fmt.Errorf("PlanScript not succesfully created") } return nil }
func (c *OVClient) CreateEnclosureGroup(eGroup EnclosureGroup) error { log.Infof("Initializing creation of enclosure group for %s.", eGroup.Name) var ( uri = "/rest/enclosure-groups" t *Task ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewProfileTask(c) t.ResetTask() data, err := c.RestAPICall(rest.POST, uri, eGroup) if err != nil { log.Errorf("Error submitting new enclosure group request: %s", err) return err } log.Debugf("Response New EnclosureGroup %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } return nil }
// IsActive provides a single function for determining if a host is active // based on both the url and if the host is stopped. func isActive(h *host.Host) (bool, error) { currentState, err := h.Driver.GetState() if err != nil { log.Errorf("error getting state for host %s: %s", h.Name, err) return false, err } url, err := h.GetURL() if err != nil { if err == drivers.ErrHostIsNotRunning { url = "" } else { log.Errorf("error getting URL for host %s: %s", h.Name, err) return false, err } } dockerHost := os.Getenv("DOCKER_HOST") notStopped := currentState != state.Stopped correctURL := url == dockerHost isActive := notStopped && correctURL return isActive, nil }
func (c *OVClient) CreateFCNetwork(fcNet FCNetwork) error { log.Infof("Initializing creation of fc network for %s.", fcNet.Name) var ( uri = "/rest/fc-networks" t *Task ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewProfileTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, fcNet) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.POST, uri, fcNet) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting new fc network request: %s", err) return err } log.Debugf("Response New fcNetwork %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } err = t.Wait() if err != nil { return err } return nil }
func attemptGetHostState(h *host.Host, stateQueryChan chan<- HostListItem) { currentState, err := h.Driver.GetState() if err != nil { log.Errorf("error getting state for host %s: %s", h.Name, err) } url, err := h.GetURL() if err != nil { if err == drivers.ErrHostIsNotRunning { url = "" } else { log.Errorf("error getting URL for host %s: %s", h.Name, err) } } active, err := isActive(h) if err != nil { log.Errorf("error determining if host is active for host %s: %s", h.Name, err) } stateQueryChan <- HostListItem{ Name: h.Name, Active: active, DriverName: h.Driver.DriverName(), State: currentState, URL: url, SwarmOptions: h.HostOptions.SwarmOptions, } }
func (c *I3SClient) CreateArtifactsBundle(artifactsBundle InputArtifactsBundle) error { log.Infof("Initializing creation of artifactsBundle for %s.", artifactsBundle.Name) var ( uri = "/rest/artifact-bundles" t *Task ) c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, artifactsBundle) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.POST, uri, artifactsBundle) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting new artifacts bundle request: %s", err) return err } log.Debugf("Response New ArtifactsBundle %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } err = t.Wait() if err != nil { return err } return nil }
func cmdRm(c CommandLine) error { if len(c.Args()) == 0 { c.ShowHelp() return errors.New("You must specify a machine name") } force := c.Bool("force") store := getStore(c) for _, hostName := range c.Args() { h, err := loadHost(store, hostName) if err != nil { return fmt.Errorf("Error removing host %q: %s", hostName, err) } if err := h.Driver.Remove(); err != nil { if !force { log.Errorf("Provider error removing machine %q: %s", hostName, err) continue } } if err := store.Remove(hostName); err != nil { log.Errorf("Error removing machine %q from store: %s", hostName, err) } else { log.Infof("Successfully removed %s", hostName) } } return nil }
func (c *I3SClient) CreateDeploymentPlan(deploymentPlan DeploymentPlan) error { log.Infof("Initializing creation of deploymentPlan for %s.", deploymentPlan.Name) var ( uri = "/rest/deployment-plans" t *Task ) c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, deploymentPlan) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.POST, uri, deploymentPlan) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting new deployment plan request: %s", err) return err } log.Debugf("Response New DeploymentPlan %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } err = t.Wait() if err != nil { return err } return nil }
// SubmitNewServer submit new profile template func (c *ICSPClient) SubmitNewServer(sc ServerCreate) (jt *JobTask, err error) { log.Infof("Initializing creation of server for ICSP, %s.", sc.IPAddress) var ( uri = "/rest/os-deployment-servers" // uri = "/rest/os-deployment-ilos" //TODO: implement hidden api for server deploy that works in Houston juri ODSUri ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) // c.SetAuthHeaderOptions(c.GetAuthHeaderMapNoVer()) //TODO: only needed when using os-deployment-ilos jt = jt.NewJobTask(c) jt.Reset() data, err := c.RestAPICall(rest.POST, uri, sc) if err != nil { jt.IsDone = true log.Errorf("Error submitting new server request: %s", err) return jt, err } log.Debugf("Response submit new server %s", data) if err := json.Unmarshal([]byte(data), &juri); err != nil { jt.IsDone = true jt.JobURI = juri log.Errorf("Error with task un-marshal: %s", err) return jt, err } jt.JobURI = juri return jt, err }
func (c *OVClient) UpdateEnclosureGroup(enclosureGroup EnclosureGroup) error { log.Infof("Initializing update of enclosure group for %s.", enclosureGroup.Name) var ( uri = enclosureGroup.URI.String() t *Task ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewProfileTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, enclosureGroup) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.PUT, uri, enclosureGroup) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting update enclosure group request: %s", err) return err } log.Debugf("Response update EnclosureGroup %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } return nil }
// SubmitNewProfile - submit new profile template func (c *OVClient) SubmitNewProfile(p ServerProfile) (t *Task, err error) { log.Infof("Initializing creation of server profile for %s.", p.Name) var ( uri = "/rest/server-profiles" // task = rest_api(:oneview, :post, '/rest/server-profiles', { 'body' => new_template_profile }) ) t = t.NewProfileTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, p) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.POST, uri, p) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting new profile request: %s", err) return t, err } log.Debugf("Response NewProfile %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return t, err } return t, err }
// Submit desired power state func (pt *PowerTask) SubmitPowerState(s PowerState) { if err := pt.GetCurrentPowerState(); err != nil { pt.TaskIsDone = true log.Errorf("Error getting current power state: %s", err) return } if s != pt.State { log.Infof("Powering %s server %s for %s.", s, pt.Blade.Name, pt.Blade.SerialNumber) var ( body = PowerRequest{PowerState: s.String(), PowerControl: P_PRESSANDHOLD.String()} uri = strings.Join([]string{pt.Blade.URI.String(), "/powerState"}, "") ) log.Debugf("REST : %s \n %+v\n", uri, body) log.Debugf("pt -> %+v", pt) data, err := pt.Blade.Client.RestAPICall(rest.PUT, uri, body) if err != nil { pt.TaskIsDone = true log.Errorf("Error with power state request: %s", err) return } log.Debugf("SubmitPowerState %s", data) if err := json.Unmarshal([]byte(data), &pt); err != nil { pt.TaskIsDone = true log.Errorf("Error with power state un-marshal: %s", err) return } } else { log.Infof("Desired Power State already set -> %s", pt.State) pt.TaskIsDone = true } return }
func (c *OVClient) CreateStorageVolume(sVol StorageVolumeV3) error { log.Infof("Initializing creation of storage volume for %s.", sVol.Name) var ( uri = "/rest/storage-volumes" t *Task ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) t = t.NewProfileTask(c) t.ResetTask() log.Debugf("REST : %s \n %+v\n", uri, sVol) log.Debugf("task -> %+v", t) data, err := c.RestAPICall(rest.POST, uri, sVol) if err != nil { t.TaskIsDone = true log.Errorf("Error submitting new storage volume request: %s", err) return err } log.Debugf("Response New StorageVolume %s", data) if err := json.Unmarshal([]byte(data), &t); err != nil { t.TaskIsDone = true log.Errorf("Error with task un-marshal: %s", err) return err } err = t.Wait() if err != nil { return err } return nil }
func (d *Driver) importVdi(vdi *xsclient.VDI, filename string, timeout time.Duration) error { f, err := os.Open(filename) if err != nil { log.Errorf("Unable to open disk image '%s': %v", filename, err) return err } // Get file length fi, err := f.Stat() if err != nil { log.Errorf("Unable to stat disk image '%s': %v", filename, err) return err } task, err := vdi.Client.CreateTask() if err != nil { return fmt.Errorf("Unable to create task: %v", err) } urlStr := fmt.Sprintf("https://%s/import_raw_vdi?vdi=%s&session_id=%s&task_id=%s", vdi.Client.Host, vdi.Ref, vdi.Client.Session.(string), task.Ref) // Define a new http Transport which allows self-signed certs tr := &http.Transport{ TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, } req, err := http.NewRequest("PUT", urlStr, f) if err != nil { return err } req.ContentLength = fi.Size() resp, err := tr.RoundTrip(req) if err != nil { log.Errorf("Unable to upload VDI: %v", err) return err } defer resp.Body.Close() if resp.StatusCode != 200 { msg, _ := ioutil.ReadAll(resp.Body) err = fmt.Errorf("xenserver reply %s: %v", resp.Status, string(msg)) log.Errorf("Unable to upload VDI: %v", err) return err } log.Infof("Waiting Upload VDI task(%v) to complete...", task.Ref) if err = d.waitTask(task, timeout); err != nil { return err } return nil }
func (d *Driver) Remove() error { log.Infof("%s | Remove instance %s ...", d.MachineName, d.InstanceId) if d.InstanceId == "" { return fmt.Errorf("%s | Unknown instance id", d.MachineName) } s, err := d.GetState() if err == nil && s == state.Running { if err := d.Stop(); err != nil { log.Errorf("%s | Unable to removed the instance %s: %s", d.MachineName, d.InstanceId, err) } } instance, err := d.getInstance() if err != nil { log.Errorf("%s | Unable to describe the instance %s: %s", d.MachineName, d.InstanceId, err) } else { // Check and release EIP if exists if len(instance.EipAddress.AllocationId) != 0 { allocationId := instance.EipAddress.AllocationId err = d.getClient().UnassociateEipAddress(allocationId, instance.InstanceId) if err != nil { log.Errorf("%s | Failed to unassociate EIP address from instance %s: %v", d.MachineName, d.InstanceId, err) } err = d.getClient().WaitForEip(instance.RegionId, allocationId, ecs.EipStatusAvailable, 0) if err != nil { log.Errorf("%s | Failed to wait EIP %s available: %v", d.MachineName, allocationId, err) } err = d.getClient().ReleaseEipAddress(allocationId) if err != nil { log.Errorf("%s | Failed to release EIP address: %v", d.MachineName, err) } } log.Debugf("%s | instance.VpcAttributes: %++v\n", d.MachineName, instance.VpcAttributes) vpcId := instance.VpcAttributes.VpcId if vpcId != "" { // Remove route entry firstly d.removeRouteEntry(vpcId, instance.RegionId, instance.InstanceId) } } log.Infof("%s | Deleting instance: %s", d.MachineName, d.InstanceId) if err := d.getClient().DeleteInstance(d.InstanceId); err != nil { return fmt.Errorf("%s | Unable to delete instance %s: %s", d.MachineName, d.InstanceId, err) } return nil }
// SaveServer save Server, submit new profile template func (c *ICSPClient) SaveServer(s Server) (o Server, err error) { log.Infof("Saving server attributes for %s.", s.Name) var ( uri = s.URI ) // refresh login c.RefreshLogin() c.SetAuthHeaderOptions(c.GetAuthHeaderMap()) log.Debugf("name -> %s, description -> %s", s.Name, s.Description) log.Debugf("CustomAttributes -> %+v", s.CustomAttributes) sc := s.Clone() log.Debugf("options -> %+v", c.Option) log.Debugf("REST : %s \n %+v\n", uri, sc) data, err := c.RestAPICall(rest.PUT, uri.String(), sc) if err != nil { log.Errorf("Error submitting new server request: %s", err) return o, err } if err := json.Unmarshal([]byte(data), &o); err != nil { return o, err } return o, err }
func (c *I3SClient) DeletePlanScript(name string) error { var ( planScript PlanScript err error uri string ) planScript, err = c.GetPlanScriptByName(name) if err != nil { return err } if planScript.Name != "" { log.Debugf("REST : %s \n %+v\n", planScript.URI, planScript) uri = planScript.URI.String() if uri == "" { log.Warn("Unable to post delete, no uri found.") return err } _, err := c.RestAPICall(rest.DELETE, uri, nil) if err != nil { log.Errorf("Error submitting delete plan script request: %s", err) return err } } else { log.Infof("Plan script could not be found to delete, %s, skipping delete ...", name) } return nil }
// UnMarshall json to data func (tc *TestConfig) UnMarshallTestingConfig(json_data []byte) { tc.Cases = []TestCases{} if err := json.Unmarshal(json_data, &tc); err != nil { log.Errorf("Error with un-marshalling test config data: %s", err) os.Exit(1) } }
func (dj DeploymentJobs) NewDeploymentJobs(bp []OSDBuildPlan, bpdata *OSDPersonalityDataV2, servers []Server) DeploymentJobs { var bpURI []string var sd []OSDPersonalizeServerDataV2 for _, plan := range bp { bpURI = append(bpURI, plan.URI.String()) } for _, s := range servers { var pd OSDPersonalizeServerDataV2 if s.URI.IsNil() { log.Errorf("Unable to create new server deployment with nil server refrence.") } pd = OSDPersonalizeServerDataV2{ ServerURI: s.URI.String(), } if bpdata != nil { pd.PersonalityData = bpdata } sd = append(sd, pd) } return DeploymentJobs{ OsbpUris: bpURI, ServerData: sd, } }
func (d *Driver) Start() error { if err := d.getClient().StartInstance(d.InstanceId); err != nil { log.Errorf("%s | Failed to start instance %s: %v", d.MachineName, d.InstanceId, err) return err } // Wait for running err := d.getClient().WaitForInstance(d.InstanceId, ecs.Running, timeout) if err != nil { log.Errorf("%s | Failed to wait instance %s running: %v", d.MachineName, d.InstanceId, err) return err } return nil }
// get a test driver for acceptance testing func getTestDriverA(env string) (*OVTest, *OVClient) { // os.Setenv("DEBUG", "true") // remove comment to debug logs var ot *OVTest var tc *testconfig.TestConfig ot = &OVTest{Tc: tc.NewTestConfig(), Env: env} ot.GetEnvironment(env) ot.Tc.GetTestingConfiguration(os.Getenv("ONEVIEW_TEST_DATA")) ot.Client = &OVClient{ rest.Client{ User: os.Getenv("ONEVIEW_OV_USER"), Password: os.Getenv("ONEVIEW_OV_PASSWORD"), Domain: os.Getenv("ONEVIEW_OV_DOMAIN"), Endpoint: os.Getenv("ONEVIEW_OV_ENDPOINT"), // ConfigDir: SSLVerify: false, APIKey: "none", }, } err := ot.Client.RefreshVersion() if err != nil { log.Errorf("Problem with getting api version refreshed : %+v", err) } // fmt.Println("Setting up test with getTestDriverA") return ot, ot.Client }
func (d *Driver) Stop() error { if err := d.getClient().StopInstance(d.InstanceId, false); err != nil { log.Errorf("%s | Failed to stop instance %s: %v", d.MachineName, d.InstanceId, err) return err } // Wait for stopped err := d.getClient().WaitForInstance(d.InstanceId, ecs.Stopped, timeout) if err != nil { log.Errorf("%s | Failed to wait instance %s stopped: %v", d.MachineName, d.InstanceId, err) return err } return nil }
// workstationDataFilePaths returns a list of paths that are eligible // to contain data files we may want such as vmnet NAT configuration files. func workstationDataFilePaths() []string { leasesPath, err := workstationDhcpLeasesPathRegistry() if err != nil { log.Errorf("Error getting DHCP leases path: %s", err) } if leasesPath != "" { leasesPath = filepath.Dir(leasesPath) } paths := make([]string, 0, 5) if os.Getenv("VMWARE_DATA") != "" { paths = append(paths, os.Getenv("VMWARE_DATA")) } if leasesPath != "" { paths = append(paths, leasesPath) } if os.Getenv("ProgramData") != "" { paths = append(paths, filepath.Join(os.Getenv("ProgramData"), "/VMware")) } if os.Getenv("ALLUSERSPROFILE") != "" { paths = append(paths, filepath.Join(os.Getenv("ALLUSERSPROFILE"), "/Application Data/VMware")) } return paths }
// workstationProgramFilesPaths returns a list of paths that are eligible // to contain program files we may want just as vmware.exe. func workstationProgramFilePaths() []string { path, err := workstationVMwareRoot() if err != nil { log.Errorf("Error finding VMware root: %s", err) } paths := make([]string, 0, 5) if os.Getenv("VMWARE_HOME") != "" { paths = append(paths, os.Getenv("VMWARE_HOME")) } if path != "" { paths = append(paths, path) } if os.Getenv("ProgramFiles(x86)") != "" { paths = append(paths, filepath.Join(os.Getenv("ProgramFiles(x86)"), "/VMware/VMware Workstation")) } if os.Getenv("ProgramFiles") != "" { paths = append(paths, filepath.Join(os.Getenv("ProgramFiles"), "/VMware/VMware Workstation")) } return paths }