157 lines
3.4 KiB
Go
157 lines
3.4 KiB
Go
package vcenter
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"log/slog"
|
|
"net/url"
|
|
"os"
|
|
|
|
"github.com/vmware/govmomi"
|
|
"github.com/vmware/govmomi/find"
|
|
"github.com/vmware/govmomi/view"
|
|
"github.com/vmware/govmomi/vim25/mo"
|
|
"github.com/vmware/govmomi/vim25/soap"
|
|
"github.com/vmware/govmomi/vim25/types"
|
|
)
|
|
|
|
type Vcenter struct {
|
|
Logger *slog.Logger
|
|
ctx context.Context
|
|
client *govmomi.Client
|
|
}
|
|
|
|
type VmProperties struct {
|
|
Vm mo.VirtualMachine
|
|
Datacenter string
|
|
}
|
|
|
|
// New creates a new Vcenter with the given logger
|
|
func New(logger *slog.Logger) *Vcenter {
|
|
|
|
//ctx, cancel := context.WithCancel(context.Background())
|
|
//defer cancel()
|
|
|
|
return &Vcenter{
|
|
Logger: logger,
|
|
ctx: context.Background(),
|
|
}
|
|
}
|
|
|
|
func (v *Vcenter) Login(vUrl string) error {
|
|
var insecure bool
|
|
|
|
insecureString := os.Getenv("VCENTER_INSECURE")
|
|
username := os.Getenv("VCENTER_USERNAME")
|
|
password := os.Getenv("VCENTER_PASSWORD")
|
|
|
|
// Connect to vCenter
|
|
u, err := soap.ParseURL(vUrl)
|
|
if err != nil {
|
|
log.Fatalf("Error parsing vCenter URL: %s", err)
|
|
}
|
|
|
|
u.User = url.UserPassword(username, password)
|
|
|
|
/*
|
|
c, err := govmomi.NewClient(ctx, u, insecure)
|
|
if err != nil {
|
|
log.Fatalf("Error connecting to vCenter: %s", err)
|
|
}
|
|
*/
|
|
|
|
if insecureString == "true" {
|
|
insecure = true
|
|
}
|
|
|
|
c, err := govmomi.NewClient(v.ctx, u, insecure)
|
|
if err != nil {
|
|
v.Logger.Error("Unable to connect to vCenter", "error", err)
|
|
return fmt.Errorf("unable to connect to vCenter : %s", err)
|
|
}
|
|
|
|
//defer c.Logout(v.ctx)
|
|
|
|
v.client = c
|
|
|
|
v.Logger.Debug("successfully connected to vCenter")
|
|
|
|
return nil
|
|
}
|
|
|
|
func (v *Vcenter) Logout() error {
|
|
return v.client.Logout(v.ctx)
|
|
}
|
|
|
|
func (v *Vcenter) FindVMByName(vmName string) ([]mo.VirtualMachine, error) {
|
|
m := view.NewManager(v.client.Client)
|
|
|
|
vms, err := m.CreateContainerView(v.ctx, v.client.ServiceContent.RootFolder, []string{"VirtualMachine"}, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer vms.Destroy(v.ctx)
|
|
|
|
var matchingVMs []mo.VirtualMachine
|
|
|
|
err = vms.Retrieve(v.ctx, []string{"VirtualMachine"}, []string{"name"}, &matchingVMs)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// Temporarily just return all VMs
|
|
//return matchingVMs, nil
|
|
|
|
var result []mo.VirtualMachine
|
|
|
|
for _, vm := range matchingVMs {
|
|
if vm.Name == vmName {
|
|
result = append(result, vm)
|
|
}
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
func (v *Vcenter) FindVMByID(vmID string) (*VmProperties, error) {
|
|
finder := find.NewFinder(v.client.Client, true)
|
|
|
|
// List all datacenters
|
|
datacenters, err := finder.DatacenterList(v.ctx, "*")
|
|
if err != nil {
|
|
return nil, fmt.Errorf("failed to list datacenters: %w", err)
|
|
}
|
|
|
|
for _, dc := range datacenters {
|
|
// Set the current datacenter
|
|
finder.SetDatacenter(dc)
|
|
|
|
// Create a ManagedObjectReference for the VM
|
|
vmRef := types.ManagedObjectReference{
|
|
Type: "VirtualMachine",
|
|
Value: vmID,
|
|
}
|
|
|
|
// Try to find the VM by ID in the current datacenter
|
|
//vm, err := finder.ObjectReference(v.ctx, vmRef)
|
|
|
|
var vm mo.VirtualMachine
|
|
err := v.client.RetrieveOne(v.ctx, vmRef, []string{"config", "name"}, &vm)
|
|
if err != nil {
|
|
// If the error is not a NotFoundError, return it
|
|
if err == err.(*find.NotFoundError) {
|
|
return nil, fmt.Errorf("failed to retrieve VM with ID %s in datacenter %s: %w", vmID, dc.Name(), err)
|
|
}
|
|
return nil, fmt.Errorf("failed to retrieve VM: %w", err)
|
|
}
|
|
|
|
return &VmProperties{
|
|
Datacenter: dc.Name(),
|
|
Vm: vm,
|
|
}, nil
|
|
}
|
|
|
|
return nil, fmt.Errorf("VM with ID %s not found in any datacenter", vmID)
|
|
}
|