private static void InitVMIdentity(VirtualMachineInner vmInner, ResourceIdentityType identityType)
{
if (!identityType.Equals(ResourceIdentityType.UserAssigned) &&
!identityType.Equals(ResourceIdentityType.SystemAssigned))
{
throw new ArgumentException("Invalid argument: " + identityType);
}
if (vmInner.Identity == null)
{
vmInner.Identity = new VirtualMachineIdentity();
}
ResourceIdentityType?parsedIdentityType = vmInner.Identity.Type;
if (parsedIdentityType == null ||
parsedIdentityType.Equals(ResourceIdentityType.None) ||
parsedIdentityType.Equals(identityType))
{
vmInner.Identity.Type = identityType;
}
else
{
vmInner.Identity.Type = ResourceIdentityType.SystemAssignedUserAssigned;
}
if (vmInner.Identity.IdentityIds == null)
{
if (identityType.Equals(ResourceIdentityType.UserAssigned) ||
identityType.Equals(ResourceIdentityType.SystemAssignedUserAssigned))
{
vmInner.Identity.IdentityIds = new List <string>();
}
}
}
/// <summary>
/// Gets the MSI identity type.
/// </summary>
/// <param name="inner">the virtual machine inner</param>
/// <returns>the MSI identity type</returns>
internal static ResourceIdentityType?ManagedServiceIdentityType(VirtualMachineInner inner)
{
if (inner.Identity != null)
{
return(inner.Identity.Type);
}
return(null);
}
/// <summary>
/// Gets the MSI identity type.
/// </summary>
/// <param name="inner">the virtual machine inner</param>
/// <returns>the MSI identity type</returns>
internal static ResourceIdentityType?ManagedServiceIdentityType(VirtualMachineInner inner)
{
if (inner.Identity != null)
{
return(ResourceIdentityTypeEnumExtension.ParseResourceIdentityType(inner.Identity.Type));
}
return(null);
}
/// <summary>
/// Specifies the definition of a not-yet-created user assigned identity to be associated with the virtual machine.
/// </summary>
/// <param name="virtualMachineInner">The virtual machine to set the identity.</param>
/// <param name="vmTaskGroup">the task group of the virtual machine</param>
/// <param name="creatableIdentity">the creatable user assigned identity</param>
/// <returns>VirtualMachineMsiHelper.</returns>
internal VirtualMachineMsiHelper WithNewUserAssignedManagedServiceIdentity(VirtualMachineInner virtualMachineInner, CreatorTaskGroup <IHasId> vmTaskGroup, ICreatable <IIdentity> creatableIdentity)
{
if (!this.userAssignedIdentityCreatableKeys.Contains(creatableIdentity.Key))
{
InitVMIdentity(virtualMachineInner, ResourceIdentityType.UserAssigned);
this.userAssignedIdentityCreatableKeys.Add(creatableIdentity.Key);
((creatableIdentity as IResourceCreator <IHasId>).CreatorTaskGroup).Merge(vmTaskGroup);
}
return(this);
}
/// <summary>
/// Retrieve the virtual machine.
/// If the virtual machine does not exists then an error observable will be returned.
/// </summary>
/// <return>The retrieved virtual machine.</return>
private async Task <VirtualMachineInner> RetrieveVirtualMachineAsync(CancellationToken cancellationToken = default(CancellationToken))
{
virtualMachine = await this.computeManager.Inner.VirtualMachines.GetAsync(rgName, vmName, InstanceViewTypes.InstanceView, cancellationToken);
if (virtualMachine == null)
{
throw new Exception($"VM with name '{vmName}' not found (resource group '{rgName}')");
}
return(virtualMachine);
}
/// <summary>
/// Set user assigned identity ids to the given virtual machine inner model
/// </summary>
/// <param name="virtualMachineInner">the virtual machine inner model</param>
/// <param name="vmTaskGroup">the virtual machine task group</param>
internal void HandleUserAssignedIdentities(VirtualMachineInner virtualMachineInner, CreatorTaskGroup <IHasId> vmTaskGroup)
{
try
{
if (virtualMachineInner.Identity == null || virtualMachineInner.Identity.Type == null)
{
return;
}
var parsedIdentityType = virtualMachineInner.Identity.Type;
if (parsedIdentityType.Equals(ResourceIdentityType.None) ||
parsedIdentityType.Equals(ResourceIdentityType.SystemAssigned))
{
return;
}
foreach (var key in this.userAssignedIdentityCreatableKeys)
{
var identity = (IIdentity)vmTaskGroup.CreatedResource(key);
if (!this.userAssignedIdentityIdsToAssociate.Contains(identity.Id))
{
this.userAssignedIdentityIdsToAssociate.Add(identity.Id);
}
}
if (virtualMachineInner.Identity.IdentityIds == null)
{
virtualMachineInner.Identity.IdentityIds = new List <string>();
}
foreach (var identityId in this.userAssignedIdentityIdsToAssociate)
{
if (!virtualMachineInner.Identity.IdentityIds.Contains(identityId))
{
virtualMachineInner.Identity.IdentityIds.Add(identityId);
}
}
foreach (var identityId in this.userAssignedIdentityIdsToRemove)
{
if (virtualMachineInner.Identity.IdentityIds.Contains(identityId))
{
virtualMachineInner.Identity.IdentityIds.Remove(identityId);
}
}
if (virtualMachineInner.Identity.IdentityIds.Any())
{
this.installExtensionIfNotInstalled = true;
}
}
finally
{
this.userAssignedIdentityCreatableKeys.Clear();
this.userAssignedIdentityIdsToAssociate.Clear();
this.userAssignedIdentityIdsToRemove.Clear();
}
}
/// <summary>
/// Specifies that Managed Service Identity property needs to be set in the virtual machine.
/// The access token will be available in the virtual machine at given port.
/// </summary>
/// <param name="port">The port in the virtual machine to get the access token from.</param>
/// <param name="virtualMachineInner">The virtual machine to set the identity.</param>
/// <param name="virtualMachineInner">The virtual machine to set the identity.</param>
/// <return>VirtualMachineMsiHelper.</return>
///GENMHASH:4189D61DE8E151C0FB589513AA0D4612:40AA004E3EDDABF6FA387290F36BF4D4
internal VirtualMachineMsiHelper WithManagedServiceIdentity(int?port, VirtualMachineInner virtualMachineInner)
{
this.requireSetup = true;
this.tokenPort = port;
if (virtualMachineInner.Identity == null)
{
virtualMachineInner.Identity = new VirtualMachineIdentity();
}
if (virtualMachineInner.Identity.Type == null)
{
virtualMachineInner.Identity.Type = ResourceIdentityType.SystemAssigned;
}
return(this);
}
/// <summary>
/// Shuts down the virtual machine and releases the compute resources.
/// This method will not wait for the deallocation to happen.
/// </summary>
/// <param name="resourceGroup"></param>
/// <param name="vm"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task BeginDeallocateVMAsync(
IResourceGroup resourceGroup,
VirtualMachineInner vm,
CancellationToken cancellationToken = default
)
{
await _computeManagementClient
.VirtualMachines
.BeginDeallocateAsync(
resourceGroup.Name,
vm.Name,
cancellationToken : cancellationToken
);
}
public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken))
{
this.virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken);
if (virtualMachine.InstanceView != null && virtualMachine.InstanceView.Extensions != null)
{
foreach (var extension in virtualMachine.InstanceView.Extensions)
{
if (extension.Type != null && extension.Type.ToLower().StartsWith(EncryptionExtensionIdentifier.GetPublisherName().ToLower()) &&
extension.Name != null && EncryptionExtensionIdentifier.IsEncryptionTypeName(extension.Name, this.OSType()))
{
this.extensionInstanceView = extension;
break;
}
}
}
return(this);
}
/// <summary>
/// Checks system assigned identity is enabled for the virtual machine.
/// </summary>
/// <param name="virtualMachine">the virtual machine</param>
/// <returns>true if system assigned MSI is enabled, false otherwise</returns>
private static bool IsSystemAssignedMSIEnabled(IVirtualMachine virtualMachine)
{
VirtualMachineInner VMInner = virtualMachine.Inner;
if (VMInner.Identity == null)
{
return(false);
}
ResourceIdentityType?parsedIdentityType = VMInner.Identity.Type;
if (parsedIdentityType == null || parsedIdentityType.Equals(ResourceIdentityType.None))
{
return(false);
}
else
{
return(parsedIdentityType.Equals(ResourceIdentityType.SystemAssigned) || parsedIdentityType.Equals(ResourceIdentityType.SystemAssignedUserAssigned));
}
}
///GENMHASH:5A2D79502EDA81E37A36694062AEDC65:061A846F0F7CA8B3F2DF8CA79A8D8B5A
public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken))
{
// Refreshes the cached Windows virtual machine and installed encryption extension
//
var virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken);
this.virtualMachine = virtualMachine;
if (virtualMachine.Resources != null)
{
foreach (var extension in virtualMachine.Resources)
{
if (EncryptionExtensionIdentifier.IsEncryptionPublisherName(extension.Publisher) &&
EncryptionExtensionIdentifier.IsEncryptionTypeName(extension.VirtualMachineExtensionType, OperatingSystemTypes.Windows))
{
this.encryptionExtension = extension;
break;
}
}
}
return(this);
}
///GENMHASH:5A2D79502EDA81E37A36694062AEDC65:061A846F0F7CA8B3F2DF8CA79A8D8B5A
public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken))
{
// Refreshes the cached Windows virtual machine and installed encryption extension
//
var virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken);
this.virtualMachine = virtualMachine;
if (virtualMachine.Resources != null)
{
foreach (var extension in virtualMachine.Resources)
{
if (extension.Publisher.Equals("Microsoft.Azure.Security", StringComparison.OrdinalIgnoreCase) &&
extension.VirtualMachineExtensionType.Equals("AzureDiskEncryption", StringComparison.OrdinalIgnoreCase))
{
this.encryptionExtension = extension;
break;
}
}
}
return(this);
}
public String GetPublicIpAdresss(string subId, string resourceGroup, string vmName)
{
foreach (IVirtualMachine virtualmachine in azure.VirtualMachines.List())
{
Console.WriteLine("Addresss");
Console.WriteLine(virtualmachine.GetPrimaryPublicIPAddress().IPAddress);
Console.WriteLine("Name");
Console.WriteLine(virtualmachine.Name);
Console.WriteLine("ResourceGroupName");
Console.WriteLine(virtualmachine.ResourceGroupName);
if (virtualmachine.ResourceGroupName.ToLower().Equals(resourceGroup.ToLower()) && virtualmachine.Name.ToLower().Equals(vmName.ToLower()))
{
return(virtualmachine.GetPrimaryPublicIPAddress().IPAddress);
}
}
// var ipadress = azure.VirtualMachines.GetById(vmName).GetPrimaryPublicIPAddress().IPAddress;
//Console.WriteLine("Addresss");
//Console.WriteLine(ipadress);
// Console.ReadLine();
var
credentials = SdkContext.AzureCredentialsFactory.FromServicePrincipal(clientId
, clientsecrett, tenantId
, AzureEnvironment.AzureGlobalCloud);
var client = new ComputeManagementClient(credentials);
client.SubscriptionId = subId;
VirtualMachineInner vm = VirtualMachinesOperationsExtensions.GetAsync(client.VirtualMachines, resourceGroup, vmName).Result;
var networkName = vm.NetworkProfile.NetworkInterfaces[0].Id.Split('/').Last();
var clientNetwork = new NetworkManagementClient(credentials);
clientNetwork.SubscriptionId = subId;
var network = NetworkInterfacesOperationsExtensions.GetAsync(clientNetwork.NetworkInterfaces, resourceGroup, vmName).Result;
string ip = network.IpConfigurations[0].PrivateIPAddress;
return(ip);
}
/// <summary>
/// Retrieve the encryption extension from the virtual machine and then retrieve it again with instance view expanded.
/// If the virtual machine does not exists then an error observable will be returned, if the extension could not be
/// located then an empty observable will be returned.
/// </summary>
/// <return>The retrieved extension.</return>
///GENMHASH:F5645D5F0FF252C17769B3B4778AD204:9A94E8179A8202B9101EC72C66DB254C
private async Task <Models.VirtualMachineExtensionInner> RetrieveEncryptExtensionWithInstanceViewFromVMAsync(CancellationToken cancellationToken = default(CancellationToken))
{
VirtualMachineInner virtualMachine = await this.computeManager
.Inner
.VirtualMachines
.GetAsync(rgName, vmName, cancellationToken : cancellationToken);
if (virtualMachine == null)
{
new Exception($"VM with name '{vmName}' not found (resource group '{rgName}')");
}
if (virtualMachine.Resources != null)
{
foreach (var extension in virtualMachine.Resources)
{
if (extension.Publisher.Equals("Microsoft.Azure.Security", StringComparison.OrdinalIgnoreCase) &&
extension.VirtualMachineExtensionType.Equals("AzureDiskEncryptionForLinux", StringComparison.OrdinalIgnoreCase))
{
return(await RetrieveExtensionWithInstanceViewAsync(extension, cancellationToken));
}
}
}
return(await Task.FromResult <Models.VirtualMachineExtensionInner>(null));
}
public async Task <Microsoft.Azure.Management.Compute.Fluent.IDiskVolumeEncryptionMonitor> RefreshAsync(CancellationToken cancellationToken = default(CancellationToken))
{
this.virtualMachine = await RetrieveVirtualMachineAsync(cancellationToken);
return(this);
}
/// <summary>
/// Specifies that System Assigned Managed Service Identity needs to be enabled in the virtual machine.
/// </summary>
/// <param name="port">The port in the virtual machine to get the access token from.</param>
/// <param name="virtualMachineInner">The virtual machine to set the identity.</param>
/// <return>VirtualMachineMsiHelper.</return>
internal VirtualMachineMsiHelper WithSystemAssignedManagedServiceIdentity(int?port, VirtualMachineInner virtualMachineInner)
{
this.installExtensionIfNotInstalled = true;
this.tokenPort = port;
InitVMIdentity(virtualMachineInner, ResourceIdentityType.SystemAssigned);
return(this);
}
/// <summary>
/// Specifies that System Assigned Managed Service Identity needs to be enabled in the virtual machine.
/// </summary>
/// <param name="virtualMachineInner">The virtual machine to set the identity.</param>
/// <return>VirtualMachineMsiHelper.</return>
internal VirtualMachineMsiHelper WithSystemAssignedManagedServiceIdentity(VirtualMachineInner virtualMachineInner)
{
return(WithSystemAssignedManagedServiceIdentity(null, virtualMachineInner));
}
/// <summary>
/// Specifies an existing user assigned identity to be associated with the virtual machine.
/// </summary>
/// <param name="identity">an existing user assigned identity</param>
/// <returns>VirtualMachineMsiHelper.</returns>
internal VirtualMachineMsiHelper WithExistingUserAssignedManagedServiceIdentity(VirtualMachineInner virtualMachineInner, IIdentity identity)
{
if (!this.userAssignedIdentityIdsToAssociate.Contains(identity.Id))
{
InitVMIdentity(virtualMachineInner, ResourceIdentityType.UserAssigned);
this.userAssignedIdentityIdsToAssociate.Add(identity.Id);
}
return(this);
}
/// <summary>
/// The operation to create or update a virtual machine.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// The name of the resource group.
/// </param>
/// <param name='vmName'>
/// The name of the virtual machine.
/// </param>
/// <param name='parameters'>
/// Parameters supplied to the Create Virtual Machine operation.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <VirtualMachineInner> CreateOrUpdateAsync(this IVirtualMachinesOperations operations, string resourceGroupName, string vmName, VirtualMachineInner parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateWithHttpMessagesAsync(resourceGroupName, vmName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
