nathan/vm-report-confluence
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Nathan Coad
2023-10-25 17:06:44 +11:00
commit a57d3002b9
4 changed files with 289 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
README.md Normal file
View File

5
go.mod Normal file
View File

@@ -0,0 +1,5 @@
module nathan/vm-report-confluence/v2
go 1.21.0
require github.com/vmware/govmomi v0.32.0

14
go.sum Normal file
View File

@@ -0,0 +1,14 @@
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/uuid v1.3.1 h1:KjJaJ9iWZ3jOFZIf1Lqf4laDRCasjl0BCmnEGxkdLb4=
github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
github.com/vmware/govmomi v0.32.0 h1:Rsdi/HAX5Ebf9Byp/FvBir4sfM7yP5DBUeRlbC6vLBo=
github.com/vmware/govmomi v0.32.0/go.mod h1:JA63Pg0SgQcSjk+LuPzjh3rJdcWBo/ZNCIwbb1qf2/0=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

270
main.go Normal file
View File

@@ -0,0 +1,270 @@
package main
import (
"context"
"encoding/json"
"flag"
"fmt"
"log"
"net/url"
"os"
"reflect"
"strings"
"time"
_ "time/tzdata"
"github.com/vmware/govmomi"
"github.com/vmware/govmomi/property"
"github.com/vmware/govmomi/view"
"github.com/vmware/govmomi/vim25/mo"
"github.com/vmware/govmomi/vim25/types"
)
var (
c *govmomi.Client
ctx context.Context
cancel context.CancelFunc
sha1ver string // sha1 revision used to build the program
buildTime string // when the executable was built
results []DrsResults
location *time.Location
)
type DrsResults struct {
ClusterName string
DrsScore int32
Vcenter string
NumVmsDrsBucket0To20 int32
NumVmsDrsBucket21To40 int32
NumVmsDrsBucket41To60 int32
NumVmsDrsBucket61To80 int32
NumVmsDrsBucket81To100 int32
}
// From https://stackoverflow.com/a/33769379
func Scan(d interface{}) {
v := reflect.ValueOf(d)
i := reflect.Indirect(v)
s := i.Type()
println(s.NumField()) // will print out 0, if you change Host to have 1 field, it prints out 1
}
func query(t reflect.Type) {
value := reflect.New(t).Interface()
Scan(value)
}
func getScsiBusSharingVMs(client *govmomi.Client) error {
ctx := context.Background()
m := view.NewManager(client.Client)
vms, err := m.CreateContainerView(ctx, client.ServiceContent.RootFolder, []string{"VirtualMachine"}, true)
if err != nil {
return err
}
defer vms.Destroy(ctx)
var vmList []mo.VirtualMachine
err = vms.Retrieve(ctx, []string{"VirtualMachine"}, nil, &vmList)
if err != nil {
log.Printf("Error retrieving vm list : '%s'\n", err)
return err
}
// Iterate through VMs and check for SCSI bus sharing
for _, vm := range vmList {
fmt.Printf("vm: %s\n", vm.Name)
if len(vm.Config.Hardware.Device) > 0 {
for _, device := range vm.Config.Hardware.Device {
//fmt.Printf("device: %v\n", device)
if scsi, ok := device.(types.BaseVirtualSCSIController); ok {
fmt.Printf("scsi: %v\n", scsi)
controller := scsi.GetVirtualSCSIController()
if controller.SharedBus != "noSharing" {
fmt.Printf("VM %s is using SCSI bus sharing mode: %v\n", vm.Name, controller.SharedBus)
}
}
}
}
/*
// Retrieve VM's ConfigInfo
var configInfo types.VirtualMachineConfigInfo
err = property.DefaultCollector(client.Client).RetrieveOne(ctx, vm.Reference(), []string{"config"}, &configInfo)
if err != nil {
log.Fatal(err)
}
// Check if SCSI bus sharing is enabled
if configInfo != nil && configInfo.GetVmConfigInfo() != nil && configInfo.GetVmConfigInfo().GetHardware() != nil {
hardware := configInfo.GetVmConfigInfo().GetHardware()
if devices := hardware.GetDevice(); devices != nil {
for _, device := range devices {
if scsi, ok := device.(object.VirtualSCSIController); ok {
if scsi.SharedBus != nil && scsi.SharedBus.Value != "" {
fmt.Printf("VM %s is using SCSI bus sharing mode: %s\n", vm.Name, scsi.SharedBus.Value)
}
}
}
}
}
*/
}
return nil
}
func getNumVmsPerDrsScoreBucket(client *govmomi.Client) error {
//properties := []string{"drsVmConfig.numVmPerDrsScoreBucket"}
ctx := context.Background()
m := view.NewManager(client.Client)
clusters, err := m.CreateContainerView(ctx, client.ServiceContent.RootFolder, []string{"ClusterComputeResource"}, true)
if err != nil {
return err
}
defer clusters.Destroy(ctx)
var clusterList []mo.ClusterComputeResource
err = clusters.Retrieve(ctx, []string{"ClusterComputeResource"}, nil, &clusterList)
if err != nil {
log.Printf("Error retrieving cluster list : '%s'\n", err)
return err
}
for _, cluster := range clusterList {
log.Printf("Cluster: %s\n", cluster.Name)
pc := property.DefaultCollector(client.Client)
clusterProps := mo.ClusterComputeResource{}
//err := pc.RetrieveOne(ctx, cluster.Reference(), properties, &clusterProps)
err := pc.RetrieveOne(ctx, cluster.Reference(), nil, &clusterProps)
if err != nil {
log.Printf("Error retrieving property : '%s'\n", err)
return err
}
// Properties defined at https://vdc-download.vmware.com/vmwb-repository/dcr-public/bf660c0a-f060-46e8-a94d-4b5e6ffc77ad/208bc706-e281-49b6-a0ce-b402ec19ef82/SDK/vsphere-ws/docs/ReferenceGuide/vim.ClusterComputeResource.Summary.html
ccr := clusterProps.Summary.(*types.ClusterComputeResourceSummary)
/*
fmt.Printf("DRS Score: %v\n", ccr.DrsScore)
fmt.Printf("VMs in DRS Score Bucket 0%% to 20%% : %d\n", ccr.NumVmsPerDrsScoreBucket[0])
fmt.Printf("VMs in DRS Score Bucket 21%% to 40%% : %d\n", ccr.NumVmsPerDrsScoreBucket[1])
fmt.Printf("VMs in DRS Score Bucket 41%% to 60%% : %d\n", ccr.NumVmsPerDrsScoreBucket[2])
fmt.Printf("VMs in DRS Score Bucket 61%% to 80%% : %d\n", ccr.NumVmsPerDrsScoreBucket[3])
fmt.Printf("VMs in DRS Score Bucket 81%% to 100%% : %d\n", ccr.NumVmsPerDrsScoreBucket[4])
*/
// Create a new result
result := DrsResults{
Vcenter: client.URL().Host,
ClusterName: cluster.Name,
DrsScore: ccr.DrsScore,
NumVmsDrsBucket0To20: ccr.NumVmsPerDrsScoreBucket[0],
NumVmsDrsBucket21To40: ccr.NumVmsPerDrsScoreBucket[1],
NumVmsDrsBucket41To60: ccr.NumVmsPerDrsScoreBucket[2],
NumVmsDrsBucket61To80: ccr.NumVmsPerDrsScoreBucket[3],
NumVmsDrsBucket81To100: ccr.NumVmsPerDrsScoreBucket[4],
}
// Append to list of all results
results = append(results, result)
/*
// Print properties (fields)
objType := reflect.TypeOf(clusterProps)
for i := 0; i < objType.NumField(); i++ {
field := objType.Field(i)
fmt.Printf("Field %d: %s (Type: %s)\n", i, field.Name, field.Type)
}
// Print methods
methods := reflect.TypeOf(clusterProps)
for i := 0; i < methods.NumMethod(); i++ {
method := methods.Method(i)
fmt.Printf("Method %d: %s\n", i, method.Name)
}
*/
}
return nil
}
func main() {
// Command line flags
vURL := flag.String("url", "", "The URL of a vCenter server, eg https://server.domain.example/sdk")
vUser := flag.String("user", "", "The username to use when connecting to vCenter")
vPass := flag.String("password", "", "The password to use when connecting to vCenter")
vTZ := flag.String("tz", "Australia/Sydney", "The timezone to use when converting vCenter UTC times")
vInsecure := flag.Bool("insecure", true, "Allow insecure connections to vCenter")
//vmName := flag.String("vmname", "example-vm", "The vm to query metrics")
//begin := flag.Duration("b", time.Hour, "Begin time") // default BeginTime is 1h ago
flag.Parse()
// Print logs to file
f, err := os.OpenFile("log.txt", os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
if err != nil {
log.Fatalf("error opening file: %v", err)
}
defer f.Close()
log.SetOutput(f)
log.Printf("Starting execution. Built on %s from sha1 %s\n", buildTime, sha1ver)
// So we can convert vCenter UTC to our local timezone
log.Printf("Setting timezone to '%s'\n", *vTZ)
location, err = time.LoadLocation(*vTZ)
if err != nil {
fmt.Fprintf(os.Stderr, "Error setting timezone to %s : %s\n", *vTZ, err)
os.Exit(1)
}
u, err := url.Parse(*vURL)
if err != nil {
fmt.Fprintf(os.Stderr, "Error parsing url %s : %s\n", *vURL, err)
os.Exit(1)
} else {
if !strings.HasSuffix(u.Path, "/sdk") {
u.Path, _ = url.JoinPath(u.Path, "/sdk")
log.Printf("Updated vCenter URL to '%v'\n", u)
}
}
log.Printf("Connecting to vCenter %s\n", u)
u.User = url.UserPassword(*vUser, *vPass)
ctx, cancel = context.WithCancel(context.Background())
defer cancel()
// Login to vcenter
c, err = govmomi.NewClient(ctx, u, *vInsecure)
if err != nil {
fmt.Fprintf(os.Stderr, "Logging in error: %s\n", err)
os.Exit(1)
}
defer c.Logout(ctx)
/*
err = getNumVmsPerDrsScoreBucket(c)
if err != nil {
log.Printf("Error retrieving NumVmsPerDrsScoreBucket: %s\n", err)
return
}
*/
err = getScsiBusSharingVMs(c)
if err != nil {
log.Printf("Error retrieving list of VMs with SCSI Bus Sharing : %s\n", err)
return
}
// Output final results in JSON
if len(results) > 0 {
j, _ := json.Marshal(results)
fmt.Println(string(j))
} else {
fmt.Println("{}")
}
}