VM, NIC and disk hydration

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, error)
 	Delete(context.Context, string, string) error
 	Query(context.Context, string, string) (*[]compute.VirtualMachine, error)
 	Start(context.Context, string, string) error
@@ -59,6 +60,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.VirtualMachine, error) {
+	return c.internal.Hydrate(ctx, group, name)
+}
+
 // 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"
@@ -508,13 +509,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,
@@ -535,7 +546,7 @@ func (c *client) getVirtualMachine(vm *wssdcloudcompute.VirtualMachine, group st
 			DisableHighAvailability: &vm.DisableHighAvailability,
 			Host:                    c.getVirtualMachineHostDescription(vm),
 		},
-		Version:  &vm.Status.Version.Number,
+		Version:  &version,
 		Location: &vm.LocationName,
 	}
 }
@@ -679,6 +690,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
@@ -728,12 +743,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 {
@@ -765,6 +780,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 {
@@ -795,6 +814,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:

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) (*compute.VirtualMachine, error) {
+	request, err := c.getVirtualMachineRequest(wssdcloudproto.Operation_HYDRATE, group, name, nil)
+	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)
@@ -316,7 +334,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)