VM, NIC and disk hydration

services/compute/compute.go

@@ -31,6 +31,7 @@ type OperatingSystemBootstrapEngine string
 const (
 	CloudInit          OperatingSystemBootstrapEngine = "CloudInit"
 	WindowsAnswerFiles OperatingSystemBootstrapEngine = "WindowsAnswerFiles"
+	Hydrated 		   OperatingSystemBootstrapEngine = "Hydrated"
 )
 
 type VMType string

services/compute/virtualmachine/client.go

@@ -18,6 +18,7 @@ import (
 type Service interface {
 	Get(context.Context, string, string) (*[]compute.VirtualMachine, error)
 	CreateOrUpdate(context.Context, string, string, *compute.VirtualMachine) (*compute.VirtualMachine, error)
+	Hydrate(context.Context, string, string, *compute.VirtualMachine) (*compute.VirtualMachine, error)
 	Delete(context.Context, string, string) error
 	Query(context.Context, string, string) (*[]compute.VirtualMachine, error)
 	Start(context.Context, string, string) error
@@ -60,6 +61,11 @@ func (c *VirtualMachineClient) CreateOrUpdate(ctx context.Context, group, name s
 	return c.internal.CreateOrUpdate(ctx, group, name, compute)
 }
 
+// Hydrate methods creates MOC representation of the VM resource
+func (c *VirtualMachineClient) Hydrate(ctx context.Context, group, name string, compute *compute.VirtualMachine) (*compute.VirtualMachine, error) {
+	return c.internal.Hydrate(ctx, group, name, compute)
+}
+
 // Delete methods invokes delete of the compute resource
 func (c *VirtualMachineClient) Delete(ctx context.Context, group string, name string) error {
 	return c.internal.Delete(ctx, group, name)

services/compute/virtualmachine/virtualmachine.go

@@ -4,6 +4,7 @@
 package virtualmachine
 
 import (
+	"github.com/google/go-cmp/cmp"
 	"github.com/microsoft/moc-sdk-for-go/services/compute"
 	"github.com/microsoft/moc/pkg/convert"
 	"github.com/microsoft/moc/pkg/errors"
@@ -555,13 +556,23 @@ func (c *client) getWssdVirtualMachineProxyConfiguration(proxyConfig *compute.Pr
 
 // Conversion functions from wssdcloudcompute to compute
 
-func (c *client) getVirtualMachine(vm *wssdcloudcompute.VirtualMachine, group string) *compute.VirtualMachine {
+func (c *client) getVirtualMachine(vm *wssdcloudcompute.VirtualMachine) *compute.VirtualMachine {
+	if vm == nil {
+		return &compute.VirtualMachine{}
+	}
+
 	vmtype := compute.Tenant
 	if vm.VmType == wssdcloudcompute.VMType_LOADBALANCER {
 		vmtype = compute.LoadBalancer
 	} else if vm.VmType == wssdcloudcompute.VMType_STACKEDCONTROLPLANE {
 		vmtype = compute.StackedControlPlane
 	}
+
+	version := ""
+	if vm.Status != nil && vm.Status.Version != nil {
+		version = vm.Status.Version.Number
+	}
+
 	return &compute.VirtualMachine{
 		Name: &vm.Name,
 		ID:   &vm.Id,
@@ -583,7 +594,7 @@ func (c *client) getVirtualMachine(vm *wssdcloudcompute.VirtualMachine, group st
 			Host:                    c.getVirtualMachineHostDescription(vm),
 			ZoneConfiguration:       c.getZoneConfiguration(vm.ZoneConfiguration),
 		},
-		Version:  &vm.Status.Version.Number,
+		Version:  &version,
 		Location: &vm.LocationName,
 	}
 }
@@ -744,6 +755,10 @@ func (c *client) getVirtualMachineNetworkProfile(n *wssdcloudcompute.NetworkConf
 		NetworkInterfaces: &[]compute.NetworkInterfaceReference{},
 	}
 
+	if n == nil {
+		return np
+	}
+
 	for _, nic := range n.Interfaces {
 		if nic == nil {
 			continue
@@ -793,12 +808,12 @@ func (c *client) getVirtualMachineGuestInstanceView(g *wssdcommon.VirtualMachine
 }
 
 func (c *client) getVirtualMachineWindowsConfiguration(windowsConfiguration *wssdcloudcompute.WindowsConfiguration) *compute.WindowsConfiguration {
-	wc := &compute.WindowsConfiguration{
-		RDP: &compute.RDPConfiguration{},
+	if windowsConfiguration == nil || cmp.Equal(windowsConfiguration, wssdcloudcompute.WindowsConfiguration{}) {
+		return nil
 	}
 
-	if windowsConfiguration == nil {
-		return wc
+	wc := &compute.WindowsConfiguration{
+		RDP: &compute.RDPConfiguration{},
 	}
 
 	if windowsConfiguration.WinRMConfiguration != nil && len(windowsConfiguration.WinRMConfiguration.Listeners) >= 1 {
@@ -830,6 +845,10 @@ func (c *client) getVirtualMachineWindowsConfiguration(windowsConfiguration *wss
 }
 
 func (c *client) getVirtualMachineLinuxConfiguration(linuxConfiguration *wssdcloudcompute.LinuxConfiguration) *compute.LinuxConfiguration {
+	if linuxConfiguration == nil || cmp.Equal(linuxConfiguration, wssdcloudcompute.LinuxConfiguration{}) {
+		return nil
+	}
+
 	lc := &compute.LinuxConfiguration{}
 
 	if linuxConfiguration != nil {
@@ -860,6 +879,10 @@ func (c *client) getInstanceViewStatus(status *wssdcommon.InstanceViewStatus) *c
 }
 
 func (c *client) getVirtualMachineOSProfile(o *wssdcloudcompute.OperatingSystemConfiguration) *compute.OSProfile {
+	if o == nil {
+		return &compute.OSProfile{}
+	}
+
 	osType := compute.Windows
 	switch o.Ostype {
 	case wssdcommon.OperatingSystemType_LINUX:
@@ -870,6 +893,8 @@ func (c *client) getVirtualMachineOSProfile(o *wssdcloudcompute.OperatingSystemC
 
 	osBootstrapEngine := compute.CloudInit
 	switch o.OsBootstrapEngine {
+	case wssdcommon.OperatingSystemBootstrapEngine_HYDRATED:
+		osBootstrapEngine = compute.Hydrated
 	case wssdcommon.OperatingSystemBootstrapEngine_WINDOWS_ANSWER_FILES:
 		osBootstrapEngine = compute.WindowsAnswerFiles
 	case wssdcommon.OperatingSystemBootstrapEngine_CLOUD_INIT:

services/compute/virtualmachine/wssd.go

@@ -77,6 +77,24 @@ func (c *client) CreateOrUpdate(ctx context.Context, group, name string, sg *com
 	return &(*vms)[0], nil
 }
 
+// Hydrate
+func (c *client) Hydrate(ctx context.Context, group, name string, sg *compute.VirtualMachine) (*compute.VirtualMachine, error) {
+	request, err := c.getVirtualMachineRequest(wssdcloudproto.Operation_HYDRATE, group, name, sg)
+	if err != nil {
+		return nil, err
+	}
+	response, err := c.VirtualMachineAgentClient.Invoke(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+	vms := c.getVirtualMachineFromResponse(response, group)
+	if len(*vms) == 0 {
+		return nil, fmt.Errorf("hydration of Virtual Machine failed to unknown reason")
+	}
+
+	return &(*vms)[0], nil
+}
+
 // Delete methods invokes create or update on the client
 func (c *client) Delete(ctx context.Context, group, name string) error {
 	vm, err := c.Get(ctx, group, name)
@@ -327,7 +345,7 @@ func (c *client) getVirtualMachineRunCommandResponse(mocResponse *wssdcloudcompu
 func (c *client) getVirtualMachineFromResponse(response *wssdcloudcompute.VirtualMachineResponse, group string) *[]compute.VirtualMachine {
 	vms := []compute.VirtualMachine{}
 	for _, vm := range response.GetVirtualMachines() {
-		vms = append(vms, *(c.getVirtualMachine(vm, group)))
+		vms = append(vms, *(c.getVirtualMachine(vm)))
 	}
 
 	return &vms

services/network/networkinterface/client.go

@@ -14,6 +14,7 @@ import (
 type Service interface {
 	Get(context.Context, string, string) (*[]network.Interface, error)
 	CreateOrUpdate(context.Context, string, string, *network.Interface) (*network.Interface, error)
+	Hydrate(context.Context, string, string, *network.Interface) (*network.Interface, error)
 	Delete(context.Context, string, string) error
 	Precheck(ctx context.Context, group string, networkInterfaces []*network.Interface) (bool, error)
 }
@@ -44,6 +45,11 @@ func (c *InterfaceClient) CreateOrUpdate(ctx context.Context, group, name string
 	return c.internal.CreateOrUpdate(ctx, group, name, networkInterface)
 }
 
+// Hydrate methods invokes hydrate on the client
+func (c *InterfaceClient) Hydrate(ctx context.Context, group, name string, networkInterface *network.Interface) (*network.Interface, error) {
+	return c.internal.Hydrate(ctx, group, name, networkInterface)
+}
+
 // Delete methods invokes delete of the network interface resource
 func (c *InterfaceClient) Delete(ctx context.Context, group, name string) error {
 	return c.internal.Delete(ctx, group, name)

services/network/networkinterface/networkinterface.go

@@ -148,15 +148,24 @@ func getWssdNetworkInterfaceIPConfig(ipConfig *network.InterfaceIPConfiguration,
 
 // Conversion function from wssdcloud network interface to network interface
 func getNetworkInterface(server, group string, c *wssdcloudnetwork.NetworkInterface) (*network.Interface, error) {
+	if c == nil {
+		return &network.Interface{}, nil
+	}
+
 	ipConfigs := []network.InterfaceIPConfiguration{}
 	for _, wssdipconfig := range c.IpConfigurations {
 		ipConfigs = append(ipConfigs, *(getNetworkIpConfig(wssdipconfig)))
 	}
 
+	version := ""
+	if c.Status != nil && c.Status.Version != nil {
+		version = c.Status.Version.Number
+	}
+
 	vnetIntf := &network.Interface{
 		Name:    &c.Name,
 		ID:      &c.Id,
-		Version: &c.Status.Version.Number,
+		Version: &version,
 		InterfacePropertiesFormat: &network.InterfacePropertiesFormat{
 			MacAddress: &c.Macaddress,
 			// TODO: Type

services/network/networkinterface/wssd.go

@@ -66,6 +66,24 @@ func (c *client) CreateOrUpdate(ctx context.Context, group, name string, vnetInt
 	return &(*vnets)[0], nil
 }
 
+// Hydrate
+func (c *client) Hydrate(ctx context.Context, group, name string, networkInterface *network.Interface) (*network.Interface, error) {
+	request, err := c.getNetworkInterfaceRequest(wssdcloudcommon.Operation_HYDRATE, group, name, networkInterface)
+	if err != nil {
+		return nil, err
+	}
+	response, err := c.NetworkInterfaceAgentClient.Invoke(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+	vnics, err := c.getInterfacesFromResponse(group, response)
+	if err != nil {
+		return nil, err
+	}
+
+	return &(*vnics)[0], nil
+}
+
 // Delete methods invokes create or update on the client
 func (c *client) Delete(ctx context.Context, group, name string) error {
 	vnetInterface, err := c.Get(ctx, group, name)

services/storage/virtualharddisk/client.go

@@ -17,6 +17,7 @@ import (
 // Service interface
 type Service interface {
 	Get(context.Context, string, string, string) (*[]storage.VirtualHardDisk, error)
+	Hydrate(context.Context, string, string, string, *storage.VirtualHardDisk) (*storage.VirtualHardDisk, error)
 	CreateOrUpdate(context.Context, string, string, string, *storage.VirtualHardDisk, string, common.ImageSource) (*storage.VirtualHardDisk, error)
 	Delete(context.Context, string, string, string) error
 	Precheck(context.Context, string, string, []*storage.VirtualHardDisk) (bool, error)
@@ -48,6 +49,13 @@ func (c *VirtualHardDiskClient) CreateOrUpdate(ctx context.Context, group, conta
 	return c.internal.CreateOrUpdate(ctx, group, container, name, storage, "", common.ImageSource_LOCAL_SOURCE)
 }
 
+// The entry point for the hydrate call takes the group name, container name and the name of the disk file. The group is standard input for every call.
+// Ultimately, we need the full path on disk to the disk file which we assemble from the path of the container plus the file name of the disk.
+// (e.g. "C:\ClusterStorage\Userdata_1\abc123" for the container path and "my_disk.vhd" for the disk name)
+func (c *VirtualHardDiskClient) Hydrate(ctx context.Context, group, container, name string, storage *storage.VirtualHardDisk) (*storage.VirtualHardDisk, error) {
+	return c.internal.Hydrate(ctx, group, container, name, storage)
+}
+
 // Delete methods invokes delete of the storage resource
 func (c *VirtualHardDiskClient) Delete(ctx context.Context, group, container, name string) error {
 	return c.internal.Delete(ctx, group, container, name)

services/storage/virtualharddisk/wssd.go

@@ -61,14 +61,35 @@ func (c *client) CreateOrUpdate(ctx context.Context, group, container, name stri
 	return &((*vhds)[0]), nil
 }
 
+// The hydrate call takes the group name, container name and the name of the disk file. The group is standard input for every call.
+// Ultimately, we need the full path on disk to the disk file which we assemble from the path of the container plus the file name of the disk.
+// (e.g. "C:\ClusterStorage\Userdata_1\abc123" for the container path and "my_disk.vhd" for the disk name)
+func (c *client) Hydrate(ctx context.Context, group, container, name string, vhd *storage.VirtualHardDisk) (*storage.VirtualHardDisk, error) {
+	request, err := getVirtualHardDiskRequest(wssdcloudcommon.Operation_HYDRATE, group, container, name, vhd, "", common.ImageSource_LOCAL_SOURCE)
+	if err != nil {
+		return nil, err
+	}
+	response, err := c.VirtualHardDiskAgentClient.Invoke(ctx, request)
+	if err != nil {
+		return nil, err
+	}
+	vhds := getVirtualHardDisksFromResponse(response, group)
+
+	if len(*vhds) == 0 {
+		return nil, fmt.Errorf("[VirtualHardDisk][Hydrate] Unexpected error: Hydrating a storage interface returned no result")
+	}
+
+	return &((*vhds)[0]), nil
+}
+
 // Delete methods invokes create or update on the client
 func (c *client) Delete(ctx context.Context, group, container, name string) error {
 	vhd, err := c.Get(ctx, group, container, name)
 	if err != nil {
 		return err
 	}
 	if len(*vhd) == 0 {
-		return fmt.Errorf("Virtual Network [%s] not found", name)
+		return fmt.Errorf("[VirtualHardDisk][Delete] %s: not found", name)
 	}
 
 	request, err := getVirtualHardDiskRequest(wssdcloudcommon.Operation_DELETE, group, container, name, &(*vhd)[0], "", common.ImageSource_LOCAL_SOURCE)