// NoLB parameter set
public AzureEndPointConfigInfo(ParameterSet paramset,
ProtocolInfo endpointProtocol,
int endpointLocalPort,
int endpointPublicPort,
string endpointName,
NetworkAclObject aclObj = null,
bool directServerReturn = false,
string internalLoadBalancer = null,
string serviceName = null,
string loadBalancerDistribution = null,
string VirtualIPName = null)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
string.Empty,
0,
ProtocolInfo.tcp,
string.Empty,
null,
null,
paramset,
aclObj,
directServerReturn,
internalLoadBalancer,
serviceName,
loadBalancerDistribution,
VirtualIPName);
}
// NoLB parameter set
public AzureEndPointConfigInfo(ParameterSet paramset,
ProtocolInfo endpointProtocol,
int endpointLocalPort,
int endpointPublicPort,
string endpointName,
NetworkAclObject aclObj = null,
bool directServerReturn = false,
string internalLoadBalancer = null,
string serviceName = null,
string loadBalancerDistribution = null,
string VirtualIPName = null)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
string.Empty,
0,
ProtocolInfo.tcp,
string.Empty,
null,
null,
paramset,
aclObj,
directServerReturn,
internalLoadBalancer,
serviceName,
loadBalancerDistribution,
VirtualIPName);
}
public void AddEndPointACLsonExistingDeployment()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string newAzureQuickVMName = Utilities.GetUniqueShortName(vmNamePrefix);
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows", "testvmimage" }, false);
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, newAzureQuickVMName, serviceName, imageName, username, password, locationName);
PersistentVMRoleContext vmRoleCtxt = vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName);
Assert.AreEqual(newAzureQuickVMName, vmRoleCtxt.Name, true);
NetworkAclObject aclObj = vmPowershellCmdlets.NewAzureAclConfig();
vmPowershellCmdlets.SetAzureAclConfig(SetACLConfig.AddRule, aclObj, 100, ACLAction.Deny, "172.0.0.0/8", "notes3");
AzureEndPointConfigInfo epConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.NoLB, ProtocolInfo.tcp, 80, 80, "web", aclObj);
vmPowershellCmdlets.AddEndPoint(newAzureQuickVMName, serviceName, new[] { epConfigInfo });
// Cleanup
vmPowershellCmdlets.RemoveAzureVM(newAzureQuickVMName, serviceName);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName));
pass = true;
}
internal static bool AzureAclConfig(NetworkAclObject expectedAcl, NetworkAclObject actualAcl)
{
for (int i = 0; i < expectedAcl.Rules.Count; i++)
{
Assert.IsTrue(CompareContext(expectedAcl.Rules[i], actualAcl.Rules[i]));
}
return(true);
}
public SetAzureAclConfigCmdletInfo(string aclConfig, NetworkAclObject aclObj, int?order, string aclAction, string remoteSubnet, string desc, int?ruleId)
{
this.cmdletName = Utilities.SetAzureAclConfigCmdletName;
switch (aclConfig)
{
case "AddRule":
this.cmdletParams.Add(new CmdletParam(aclConfig));
this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
this.cmdletParams.Add(new CmdletParam("Action", aclAction));
this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));
if (order.HasValue)
{
this.cmdletParams.Add(new CmdletParam("Order", order));
}
if (desc != null)
{
this.cmdletParams.Add(new CmdletParam("Description", desc));
}
break;
case "RemoveRule":
this.cmdletParams.Add(new CmdletParam(aclConfig));
this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));
break;
case "SetRule":
this.cmdletParams.Add(new CmdletParam(aclConfig));
this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));
if (order.HasValue)
{
this.cmdletParams.Add(new CmdletParam("Order", order));
}
if (aclAction != null)
{
this.cmdletParams.Add(new CmdletParam("Action", aclAction));
}
if (remoteSubnet != null)
{
this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));
}
if (desc != null)
{
this.cmdletParams.Add(new CmdletParam("Description", desc));
}
break;
default:
break;
}
}
public SetAzureAclConfigCmdletInfo(string aclConfig, NetworkAclObject aclObj, int? order, string aclAction, string remoteSubnet, string desc, int? ruleId)
{
this.cmdletName = Utilities.SetAzureAclConfigCmdletName;
switch(aclConfig)
{
case "AddRule" :
this.cmdletParams.Add(new CmdletParam(aclConfig));
this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
this.cmdletParams.Add(new CmdletParam("Action", aclAction));
this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));
if (order.HasValue)
{
this.cmdletParams.Add(new CmdletParam("Order", order));
}
if (desc != null)
{
this.cmdletParams.Add(new CmdletParam("Description", desc));
}
break;
case "RemoveRule" :
this.cmdletParams.Add(new CmdletParam(aclConfig));
this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));
break;
case "SetRule" :
this.cmdletParams.Add(new CmdletParam(aclConfig));
this.cmdletParams.Add(new CmdletParam("ACL", aclObj));
this.cmdletParams.Add(new CmdletParam("RuleID", ruleId));
if (order.HasValue)
{
this.cmdletParams.Add(new CmdletParam("Order", order));
}
if (aclAction != null)
{
this.cmdletParams.Add(new CmdletParam("Action", aclAction));
}
if (remoteSubnet != null)
{
this.cmdletParams.Add(new CmdletParam("RemoteSubnet", remoteSubnet));
}
if (desc != null)
{
this.cmdletParams.Add(new CmdletParam("Description", desc));
}
break;
default:
break;
}
}
//NoLB
public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
int endpointPublicPort, string endpointName, NetworkAclObject aclObj = null, bool directServerReturn = false)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
string.Empty,
0,
ProtocolInfo.tcp,
string.Empty,
null,
null,
paramset,
aclObj,
directServerReturn);
}
//NoLB
public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
int endpointPublicPort, string endpointName, NetworkAclObject aclObj = null, bool directServerReturn = false)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
string.Empty,
0,
ProtocolInfo.tcp,
string.Empty,
null,
null,
paramset,
aclObj,
directServerReturn);
}
internal void ExecuteCommand()
{
var role = this.VM.GetInstance();
var networkConfiguration = role.ConfigurationSets.OfType<NetworkConfigurationSet>().SingleOrDefault();
if (networkConfiguration != null
&& networkConfiguration.InputEndpoints != null)
{
if (string.IsNullOrEmpty(this.EndpointName))
{
var ret = new List<NetworkAclObject>();
foreach (var endpoint in networkConfiguration.InputEndpoints)
{
ret.Add(endpoint.EndpointAccessControlList);
}
this.WriteObject(ret, true);
}
else
{
var endpoint = (from e in networkConfiguration.InputEndpoints
where e.Name.Equals(this.EndpointName, StringComparison.InvariantCultureIgnoreCase)
select e).SingleOrDefault();
if (endpoint == null)
{
this.ThrowTerminatingError(
new ErrorRecord(
new InvalidOperationException(
string.Format(
CultureInfo.InvariantCulture,
Resources.EndpointCanNotBeFoundInVMConfiguration,
this.EndpointName)),
string.Empty,
ErrorCategory.InvalidData,
null));
}
NetworkAclObject acl = endpoint.EndpointAccessControlList ?? new NetworkAclObject();
this.WriteObject(acl);
}
}
}
// CustoProbe
public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
int endpointPublicPort, string endpointName, string lBSetName, int probePort,
ProtocolInfo probeProtocol, string probePath, int? probeInterval, int? probeTimeout, NetworkAclObject aclObj = null, bool directServerReturn = false)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
lBSetName,
probePort,
probeProtocol,
probePath,
probeInterval,
probeTimeout,
paramset,
aclObj,
directServerReturn);
}
public void AddEndPointACLsWithNewDeployment()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string newAzureVM1Name = Utilities.GetUniqueShortName(vmNamePrefix);
string newAzureVM2Name = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows", "testvmimage" }, false);
}
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
NetworkAclObject aclObj = vmPowershellCmdlets.NewAzureAclConfig();
vmPowershellCmdlets.SetAzureAclConfig(SetACLConfig.AddRule, aclObj, 100, ACLAction.Permit, "172.0.0.0/8", "notes1");
vmPowershellCmdlets.SetAzureAclConfig(SetACLConfig.AddRule, aclObj, 200, ACLAction.Deny, "10.0.0.0/8", "notes2");
AzureVMConfigInfo azureVMConfigInfo1 = new AzureVMConfigInfo(newAzureVM1Name, InstanceSize.ExtraSmall, imageName);
AzureVMConfigInfo azureVMConfigInfo2 = new AzureVMConfigInfo(newAzureVM2Name, InstanceSize.ExtraSmall, imageName);
AzureProvisioningConfigInfo azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, username, password);
AddAzureDataDiskConfig azureDataDiskConfigInfo = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, 50, "datadisk1", 0);
AzureEndPointConfigInfo azureEndPointConfigInfo = new AzureEndPointConfigInfo(AzureEndPointConfigInfo.ParameterSet.DefaultProbe, ProtocolInfo.tcp, 80, 80, "web", "lbweb", aclObj, true);
PersistentVMConfigInfo persistentVMConfigInfo1 = new PersistentVMConfigInfo(azureVMConfigInfo1, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
PersistentVMConfigInfo persistentVMConfigInfo2 = new PersistentVMConfigInfo(azureVMConfigInfo2, azureProvisioningConfig, azureDataDiskConfigInfo, azureEndPointConfigInfo);
PersistentVM persistentVM1 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo1);
PersistentVM persistentVM2 = vmPowershellCmdlets.GetPersistentVM(persistentVMConfigInfo2);
PersistentVM[] VMs = { persistentVM1, persistentVM2 };
vmPowershellCmdlets.NewAzureVM(serviceName, VMs);
// Cleanup
vmPowershellCmdlets.RemoveAzureVM(newAzureVM1Name, serviceName);
vmPowershellCmdlets.RemoveAzureVM(newAzureVM2Name, serviceName);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM1Name, serviceName));
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVM2Name, serviceName));
pass = true;
}
private void Initialize(ProtocolInfo protocol, int internalPort,
int? externalPort, string endpointName, string lBSetName, int probePort,
ProtocolInfo probeProtocol, string probePath,
int? probeInterval, int? probeTimeout, ParameterSet paramSet, NetworkAclObject aclObj, bool directServerReturn)
{
this.EndpointLocalPort = internalPort;
this.EndpointProtocol = protocol;
this.EndpointPublicPort = externalPort;
this.EndpointName = endpointName;
this.LBSetName = lBSetName;
this.ProbePort = probePort;
this.ProbeProtocol = probeProtocol;
this.ProbeInterval = probeInterval;
this.ProbeTimeout = probeTimeout;
this.ParamSet = paramSet;
this.Acl = aclObj;
this.DirectServerReturn = directServerReturn;
if (this.ProbeProtocol.ToString().Equals("http"))
this.ProbePath = probePath;
}
// ParameterSet.LoadBalancedNoProbe
public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
int endpointPublicPort, string endpointName, string lBSetName, NetworkAclObject aclObj = null, bool directServerReturn = false)
{
if ( (paramset == ParameterSet.LoadBalancedNoProbe) || (paramset == ParameterSet.DefaultProbe) )
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
lBSetName,
0,
ProtocolInfo.tcp,
string.Empty,
null,
null,
paramset,
aclObj,
directServerReturn);
}
}
private void Initialize(
ProtocolInfo protocol,
int internalPort,
int?externalPort,
string endpointName,
string lBSetName,
int probePort,
ProtocolInfo probeProtocol,
string probePath,
int?probeInterval,
int?probeTimeout,
ParameterSet paramSet,
NetworkAclObject aclObj,
bool directServerReturn,
string internalLoadBalancer,
string serviceName,
string loadBalancerDistribution,
string VirtualIPName)
{
this.EndpointLocalPort = internalPort;
this.EndpointProtocol = protocol;
this.EndpointPublicPort = externalPort;
this.EndpointName = endpointName;
this.LBSetName = lBSetName;
this.ProbePort = probePort;
this.ProbeProtocol = probeProtocol;
this.ProbeInterval = probeInterval;
this.ProbeTimeout = probeTimeout;
this.ParamSet = paramSet;
this.Acl = aclObj;
this.DirectServerReturn = directServerReturn;
if (this.ProbeProtocol.ToString().Equals("http"))
{
this.ProbePath = probePath;
}
this.InternalLoadBalancerName = internalLoadBalancer;
this.ServiceName = serviceName;
this.LoadBalancerDistribution = loadBalancerDistribution;
this.VirtualIPName = VirtualIPName;
}
// CustomProbe parameter set
public AzureEndPointConfigInfo(
ParameterSet paramset,
ProtocolInfo endpointProtocol,
int endpointLocalPort,
int endpointPublicPort,
string endpointName,
string lBSetName,
int probePort,
ProtocolInfo probeProtocol,
string probePath,
int?probeInterval,
int?probeTimeout,
NetworkAclObject aclObj = null,
bool directServerReturn = false,
string internalLoadBalancer = null,
string serviceName = null,
string loadBalancerDistribution = null,
string VirtualIPName = null)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
lBSetName,
probePort,
probeProtocol,
probePath,
probeInterval,
probeTimeout,
paramset,
aclObj,
directServerReturn,
internalLoadBalancer,
serviceName,
loadBalancerDistribution,
VirtualIPName);
}
public void AzureEndpointTest()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
string ep1Name = "tcp1";
int ep1LocalPort = 60010;
int ep1PublicPort = 60011;
string ep1LBSetName = "lbset1";
int ep1ProbePort = 60012;
string ep1ProbePath = string.Empty;
int? ep1ProbeInterval = 7;
int? ep1ProbeTimeout = null;
NetworkAclObject ep1AclObj = null;
bool ep1DirectServerReturn = false;
string ep2Name = "tcp2";
int ep2LocalPort = 60020;
int ep2PublicPort = 60021;
int ep2LocalPortChanged = 60030;
int ep2PublicPortChanged = 60031;
string ep2LBSetName = "lbset2";
int ep2ProbePort = 60022;
string ep2ProbePath = @"/";
int? ep2ProbeInterval = null;
int? ep2ProbeTimeout = 32;
NetworkAclObject ep2AclObj = null;
bool ep2DirectServerReturn = false;
AzureEndPointConfigInfo ep1Info = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustonProbe,
ProtocolInfo.tcp,
ep1LocalPort,
ep1PublicPort,
ep1Name,
ep1LBSetName,
ep1ProbePort,
ProtocolInfo.tcp,
ep1ProbePath,
ep1ProbeInterval,
ep1ProbeTimeout,
ep1AclObj,
ep1DirectServerReturn);
AzureEndPointConfigInfo ep2Info = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustonProbe,
ProtocolInfo.tcp,
ep2LocalPort,
ep2PublicPort,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
string defaultVm = Utilities.GetUniqueShortName(vmNamePrefix);
Assert.IsNull(vmPowershellCmdlets.GetAzureVM(defaultVm, serviceName));
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, defaultVm, serviceName, imageName, username, password, locationName);
Console.WriteLine("Service Name: {0} is created.", serviceName);
try
{
foreach (AzureEndPointConfigInfo.ParameterSet p in Enum.GetValues(typeof(AzureEndPointConfigInfo.ParameterSet)))
{
string pSetName = Enum.GetName(typeof(AzureEndPointConfigInfo.ParameterSet), p);
Console.WriteLine("--Begin Endpoint Test with '{0}' parameter set.", pSetName);
ep1Info.ParamSet = p;
ep2Info.ParamSet = p;
ep1Info.Acl = vmPowershellCmdlets.NewAzureAclConfig();
ep2Info.Acl = vmPowershellCmdlets.NewAzureAclConfig();
ep2Info.EndpointLocalPort = ep2LocalPort;
ep2Info.EndpointPublicPort = ep2PublicPort;
// Add two new endpoints
Console.WriteLine("-----Add 2 new endpoints.");
vmPowershellCmdlets.AddEndPoint(defaultVm, serviceName, new[] { ep1Info, ep2Info }); // Add-AzureEndpoint with Get-AzureVM and Update-AzureVm
CheckEndpoint(defaultVm, serviceName, new[] { ep1Info, ep2Info });
// Change the endpoint
if (p == AzureEndPointConfigInfo.ParameterSet.NoLB)
{
Console.WriteLine("-----Change the second endpoint.");
ep2Info.EndpointLocalPort = ep2LocalPortChanged;
ep2Info.EndpointPublicPort = ep2PublicPortChanged;
vmPowershellCmdlets.SetEndPoint(defaultVm, serviceName, ep2Info); // Set-AzureEndpoint with Get-AzureVM and Update-AzureVm
CheckEndpoint(defaultVm, serviceName, new[] { ep2Info });
}
else
{
Console.WriteLine("-----Change the second endpoint.");
ep2Info.ServiceName = serviceName;
ep2Info.EndpointLocalPort = ep2LocalPortChanged;
ep2Info.EndpointPublicPort = ep2PublicPortChanged;
vmPowershellCmdlets.SetLBEndPoint(defaultVm, serviceName, ep2Info, p);
CheckEndpoint(defaultVm, serviceName, new[] { ep2Info });
}
// Remove Endpoint
Console.WriteLine("-----Remove endpoints.");
vmPowershellCmdlets.RemoveEndPoint(defaultVm, serviceName, new[] { ep1Name, ep2Name }); // Remove-AzureEndpoint
CheckEndpointRemoved(defaultVm, serviceName, new[] { ep1Info, ep2Info });
Console.WriteLine("Endpoint Test passed with '{0}' parameter set.", pSetName);
}
pass = true;
}
catch (Exception e)
{
pass = false;
Assert.Fail("Exception occurred: {0}", e.ToString());
}
}
// CustomProbe parameter set
public AzureEndPointConfigInfo(
ParameterSet paramset,
ProtocolInfo endpointProtocol,
int endpointLocalPort,
int endpointPublicPort,
string endpointName,
string lBSetName,
int probePort,
ProtocolInfo probeProtocol,
string probePath,
int? probeInterval,
int? probeTimeout,
NetworkAclObject aclObj = null,
bool directServerReturn = false,
string internalLoadBalancer= null,
string serviceName = null,
string loadBalancerDistribution = null,
string VirtualIPName = null)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
lBSetName,
probePort,
probeProtocol,
probePath,
probeInterval,
probeTimeout,
paramset,
aclObj,
directServerReturn,
internalLoadBalancer,
serviceName,
loadBalancerDistribution,
VirtualIPName);
}
private void Initialize(ProtocolInfo protocol, int internalPort,
int? externalPort, string endpointName, string lBSetName, int probePort,
ProtocolInfo probeProtocol, string probePath,
int? probeInterval, int? probeTimeout, ParameterSet paramSet, NetworkAclObject aclObj, bool directServerReturn,string internalLoadBalancer,string serviceName)
{
this.EndpointLocalPort = internalPort;
this.EndpointProtocol = protocol;
this.EndpointPublicPort = externalPort;
this.EndpointName = endpointName;
this.LBSetName = lBSetName;
this.ProbePort = probePort;
this.ProbeProtocol = probeProtocol;
this.ProbeInterval = probeInterval;
this.ProbeTimeout = probeTimeout;
this.ParamSet = paramSet;
this.Acl = aclObj;
this.DirectServerReturn = directServerReturn;
if (this.ProbeProtocol.ToString().Equals("http"))
this.ProbePath = probePath;
this.InternalLoadBalancerName = internalLoadBalancer;
this.ServiceName = serviceName;
}
// CustoProbe
public AzureEndPointConfigInfo(ParameterSet paramset, ProtocolInfo endpointProtocol, int endpointLocalPort,
int endpointPublicPort, string endpointName, string lBSetName, int probePort,
ProtocolInfo probeProtocol, string probePath, int?probeInterval, int?probeTimeout, NetworkAclObject aclObj = null, bool directServerReturn = false)
{
this.Initialize(
endpointProtocol,
endpointLocalPort,
endpointPublicPort,
endpointName,
lBSetName,
probePort,
probeProtocol,
probePath,
probeInterval,
probeTimeout,
paramset,
aclObj,
directServerReturn);
}
public void AzureIaaSBVT()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
DateTime prevTime = DateTime.Now;
string diskLabel1 = "disk1";
int diskSize1 = 30;
int lunSlot1 = 0;
string diskLabel2 = "disk2";
int diskSize2 = 50;
int lunSlot2 = 2;
string ep1Name = "tcp1";
int ep1LocalPort = 60010;
int ep1PublicPort = 60011;
string ep1LBSetName = "lbset1";
int ep1ProbePort = 60012;
string ep1ProbePath = string.Empty;
int? ep1ProbeInterval = 7;
int? ep1ProbeTimeout = null;
NetworkAclObject ep1AclObj = vmPowershellCmdlets.NewAzureAclConfig();
bool ep1DirectServerReturn = false;
string ep2Name = "tcp2";
int ep2LocalPort = 60020;
int ep2PublicPort = 60021;
int ep2LocalPortChanged = 60030;
int ep2PublicPortChanged = 60031;
string ep2LBSetName = "lbset2";
int ep2ProbePort = 60022;
string ep2ProbePath = @"/";
int? ep2ProbeInterval = null;
int? ep2ProbeTimeout = 32;
NetworkAclObject ep2AclObj = vmPowershellCmdlets.NewAzureAclConfig();
bool ep2DirectServerReturn = false;
string cerFileName = "testcert.cer";
string thumbprintAlgorithm = "sha1";
try
{
// Create a certificate
X509Certificate2 certCreated = Utilities.CreateCertificate(password);
byte[] certData2 = certCreated.Export(X509ContentType.Cert);
File.WriteAllBytes(cerFileName, certData2);
// Install the .cer file to local machine.
StoreLocation certStoreLocation = StoreLocation.CurrentUser;
StoreName certStoreName = StoreName.My;
X509Certificate2 installedCert = Utilities.InstallCert(cerFileName, certStoreLocation, certStoreName);
PSObject certToUpload = vmPowershellCmdlets.RunPSScript(
String.Format("Get-Item cert:\\{0}\\{1}\\{2}", certStoreLocation.ToString(), certStoreName.ToString(), installedCert.Thumbprint))[0];
string certData = Convert.ToBase64String(((X509Certificate2)certToUpload.BaseObject).RawData);
string newAzureVMName = Utilities.GetUniqueShortName(vmNamePrefix);
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows" }, false);
}
RecordTimeTaken(ref prevTime);
//
// New-AzureService and verify with Get-AzureService
//
vmPowershellCmdlets.NewAzureService(serviceName, serviceName, locationName);
Assert.IsTrue(Verify.AzureService(serviceName, serviceName, locationName));
RecordTimeTaken(ref prevTime);
//
// Add-AzureCertificate and verify with Get-AzureCertificate
//
vmPowershellCmdlets.AddAzureCertificate(serviceName, certToUpload);
Assert.IsTrue(Verify.AzureCertificate(serviceName, certCreated.Thumbprint, thumbprintAlgorithm, certData));
RecordTimeTaken(ref prevTime);
//
// Remove-AzureCertificate
//
vmPowershellCmdlets.RemoveAzureCertificate(serviceName, certCreated.Thumbprint, thumbprintAlgorithm);
Assert.IsTrue(Utilities.CheckRemove(vmPowershellCmdlets.GetAzureCertificate, serviceName, certCreated.Thumbprint, thumbprintAlgorithm));
RecordTimeTaken(ref prevTime);
//
// New-AzureVMConfig
//
var azureVMConfigInfo = new AzureVMConfigInfo(newAzureVMName, InstanceSize.Small.ToString(), imageName);
PersistentVM vm = vmPowershellCmdlets.NewAzureVMConfig(azureVMConfigInfo);
RecordTimeTaken(ref prevTime);
//
// Add-AzureCertificate
//
vmPowershellCmdlets.AddAzureCertificate(serviceName, certToUpload);
//
// New-AzureCertificateSetting
//
CertificateSettingList certList = new CertificateSettingList();
certList.Add(vmPowershellCmdlets.NewAzureCertificateSetting(certStoreName.ToString(), installedCert.Thumbprint));
RecordTimeTaken(ref prevTime);
//
// Add-AzureProvisioningConfig
//
AzureProvisioningConfigInfo azureProvisioningConfig = new AzureProvisioningConfigInfo(OS.Windows, certList, username, password);
azureProvisioningConfig.Vm = vm;
vm = vmPowershellCmdlets.AddAzureProvisioningConfig(azureProvisioningConfig);
RecordTimeTaken(ref prevTime);
//
// Add-AzureDataDisk (two disks)
//
AddAzureDataDiskConfig azureDataDiskConfigInfo1 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize1, diskLabel1, lunSlot1);
azureDataDiskConfigInfo1.Vm = vm;
vm = vmPowershellCmdlets.AddAzureDataDisk(azureDataDiskConfigInfo1);
AddAzureDataDiskConfig azureDataDiskConfigInfo2 = new AddAzureDataDiskConfig(DiskCreateOption.CreateNew, diskSize2, diskLabel2, lunSlot2);
azureDataDiskConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.AddAzureDataDisk(azureDataDiskConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Add-AzureEndpoint (two endpoints)
//
AzureEndPointConfigInfo azureEndPointConfigInfo1 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep1LocalPort,
ep1PublicPort,
ep1Name,
ep1LBSetName,
ep1ProbePort,
ProtocolInfo.tcp,
ep1ProbePath,
ep1ProbeInterval,
ep1ProbeTimeout,
ep1AclObj,
ep1DirectServerReturn,
null,
null,
LoadBalancerDistribution.SourceIP);
azureEndPointConfigInfo1.Vm = vm;
vm = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo1);
AzureEndPointConfigInfo azureEndPointConfigInfo2 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep2LocalPort,
ep2PublicPort,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
azureEndPointConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.AddAzureEndPoint(azureEndPointConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Set-AzureAvailabilitySet
//
string testAVSetName = "testAVSet1";
vm = vmPowershellCmdlets.SetAzureAvailabilitySet(testAVSetName, vm);
RecordTimeTaken(ref prevTime);
//
// New-AzureDns
//
string dnsName = "OpenDns1";
string ipAddress = "208.67.222.222";
DnsServer dns = vmPowershellCmdlets.NewAzureDns(dnsName, ipAddress);
RecordTimeTaken(ref prevTime);
//
// New-AzureVM
//
vmPowershellCmdlets.NewAzureVM(serviceName, new[] { vm }, null, new[] { dns }, null, null, null, null);
RecordTimeTaken(ref prevTime);
//
// Get-AzureVM without any parameter (List VMs)
//
var vmlist = vmPowershellCmdlets.GetAzureVM();
Console.WriteLine("The number of VMs: {0}", vmlist.Count);
Assert.AreNotSame(0, vmlist.Count, "No VM exists!!!");
PersistentVMRoleListContext returnedVMlist =
vmlist.First(item => item.ServiceName.Equals(serviceName) && item.Name.Equals(newAzureVMName));
Assert.IsNotNull(returnedVMlist, "Created VM does not exist!!!");
Utilities.PrintContext((PersistentVMRoleContext)returnedVMlist);
//
// Get-AzureVM
//
PersistentVMRoleContext returnedVM = vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName);
vm = returnedVM.VM;
RecordTimeTaken(ref prevTime);
//
// Verify AzureDataDisk
//
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel1, diskSize1, lunSlot1, HostCaching.None), "Data disk is not properly added");
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel2, diskSize2, lunSlot2, HostCaching.None), "Data disk is not properly added");
Console.WriteLine("Data disk added correctly.");
RecordTimeTaken(ref prevTime);
//
// Verify AzureEndpoint
//
Assert.IsTrue(Verify.AzureEndpoint(vm, new[] { azureEndPointConfigInfo1, azureEndPointConfigInfo2 }));
//
// Verify RDP & PowerShell Endpoints
//
var endpoints = vmPowershellCmdlets.GetAzureEndPoint(vm);
Assert.IsTrue(endpoints.Count(e => e.Name == "PowerShell" && e.LocalPort == 5986 && e.Protocol == "tcp") == 1);
Assert.IsTrue(endpoints.Count(e => e.Name == "RemoteDesktop" && e.LocalPort == 3389 && e.Protocol == "tcp") == 1);
//
// Verify AzureDns
//
Assert.IsTrue(Verify.AzureDns(vmPowershellCmdlets.GetAzureDeployment(serviceName).DnsSettings, dns));
//
// Verify AzureAvailibilitySet
//
Assert.IsTrue(Verify.AzureAvailabilitySet(vm, testAVSetName));
//
// Verify AzureOsDisk
//
Assert.IsTrue(Verify.AzureOsDisk(vm, "Windows", HostCaching.ReadWrite));
//
// Set-AzureDataDisk
//
SetAzureDataDiskConfig setAzureDataDiskConfigInfo = new SetAzureDataDiskConfig(HostCaching.ReadOnly, lunSlot1);
setAzureDataDiskConfigInfo.Vm = vm;
vm = vmPowershellCmdlets.SetAzureDataDisk(setAzureDataDiskConfigInfo);
RecordTimeTaken(ref prevTime);
//
// Remove-AzureDataDisk
//
RemoveAzureDataDiskConfig removeAzureDataDiskConfig = new RemoveAzureDataDiskConfig(lunSlot2, vm);
vm = vmPowershellCmdlets.RemoveAzureDataDisk(removeAzureDataDiskConfig);
RecordTimeTaken(ref prevTime);
//
// Set-AzureEndpoint
//
azureEndPointConfigInfo2 = new AzureEndPointConfigInfo(
AzureEndPointConfigInfo.ParameterSet.CustomProbe,
ProtocolInfo.tcp,
ep2LocalPortChanged,
ep2PublicPortChanged,
ep2Name,
ep2LBSetName,
ep2ProbePort,
ProtocolInfo.http,
ep2ProbePath,
ep2ProbeInterval,
ep2ProbeTimeout,
ep2AclObj,
ep2DirectServerReturn);
azureEndPointConfigInfo2.Vm = vm;
vm = vmPowershellCmdlets.SetAzureEndPoint(azureEndPointConfigInfo2);
RecordTimeTaken(ref prevTime);
//
// Remove-AzureEndpoint
//
vm = vmPowershellCmdlets.RemoveAzureEndPoint(azureEndPointConfigInfo1.EndpointName, vm);
RecordTimeTaken(ref prevTime);
//
// Set-AzureVMSize
//
var vmSizeConfig = new SetAzureVMSizeConfig(InstanceSize.Medium.ToString());
vmSizeConfig.Vm = vm;
vm = vmPowershellCmdlets.SetAzureVMSize(vmSizeConfig);
RecordTimeTaken(ref prevTime);
//
// Set-AzureOSDisk
//
vm = vmPowershellCmdlets.SetAzureOSDisk(HostCaching.ReadOnly, vm);
//
// Update-AzureVM
//
vmPowershellCmdlets.UpdateAzureVM(newAzureVMName, serviceName, vm);
RecordTimeTaken(ref prevTime);
//
// Get-AzureVM and Verify the VM
//
vm = vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName).VM;
// Verify setting data disk
Assert.IsTrue(Verify.AzureDataDisk(vm, diskLabel1, diskSize1, lunSlot1, HostCaching.ReadOnly), "Data disk is not properly added");
// Verify removing a data disk
Assert.AreEqual(1, vmPowershellCmdlets.GetAzureDataDisk(vm).Count, "DataDisk is not removed.");
// Verify setting an endpoint
Assert.IsTrue(Verify.AzureEndpoint(vm, new[] { azureEndPointConfigInfo2 }));
// Verify removing an endpoint
Assert.IsFalse(Verify.AzureEndpoint(vm, new[] { azureEndPointConfigInfo1 }));
// Verify os disk
Assert.IsTrue(Verify.AzureOsDisk(vm, "Windows", HostCaching.ReadOnly));
//
// Remove-AzureVM
//
vmPowershellCmdlets.RemoveAzureVM(newAzureVMName, serviceName);
RecordTimeTaken(ref prevTime);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureVMName, serviceName));
pass = true;
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
throw;
}
}
