public bool CheckInputEndpointContext(InputEndpointContext context)
{
bool ret = context.Protocol == this.EndpointProtocol.ToString() &&
context.LocalPort == this.EndpointLocalPort &&
context.Port == this.EndpointPublicPort &&
context.Name == this.EndpointName;
if (ParamSet == ParameterSet.LoadBalanced)
{
ret = ret && context.LBSetName == this.LBSetName;
}
if (ParamSet == ParameterSet.LoadBalancedProbe)
{
ret = ret && context.LBSetName == this.LBSetName &&
context.ProbePort == this.ProbePort &&
context.ProbeProtocol == this.ProbeProtocol.ToString();
ret = ret && (this.ProbeInterval.HasValue
? context.ProbeIntervalInSeconds == this.ProbeInterval
: context.ProbeIntervalInSeconds == 15);
ret = ret && (this.ProbeTimeout.HasValue
? context.ProbeTimeoutInSeconds == this.ProbeTimeout
: context.ProbeTimeoutInSeconds == 31);
}
return(ret);
}
public bool CheckInputEndpointContext(InputEndpointContext context)
{
bool ret = false;
if (ParamSet == ParameterSet.NoLB)
{
ret = (context.Name == this.EndpointName);
}
else
{
ret = (context.LBSetName == this.LBSetName);
}
ret = ret && context.Protocol == this.EndpointProtocol.ToString() &&
context.LocalPort == this.EndpointLocalPort &&
context.Port == this.EndpointPublicPort &&
context.EnableDirectServerReturn == this.DirectServerReturn;
if (context.Acl == null)
{
if (this.Acl != null &&
this.Acl != new NetworkAclObject())
{
ret = false;
}
}
else if (this.Acl != null)
{
foreach (var rule in this.Acl)
{
if (!context.Acl.Rules.Contains(rule))
{
ret = false;
}
}
}
else
{
ret = false;
}
if (ParamSet == ParameterSet.CustomProbe)
{
ret = ret && context.LBSetName == this.LBSetName &&
context.ProbePort == this.ProbePort &&
context.ProbeProtocol == this.ProbeProtocol.ToString();
ret = ret && (this.ProbeInterval.HasValue
? context.ProbeIntervalInSeconds == this.ProbeInterval
: context.ProbeIntervalInSeconds == 15);
ret = ret && (this.ProbeTimeout.HasValue
? context.ProbeTimeoutInSeconds == this.ProbeTimeout
: context.ProbeTimeoutInSeconds == 31);
}
return(ret);
}
protected Collection <InputEndpointContext> GetInputEndpoints()
{
var role = VM.GetInstance();
var networkConfiguration = role.ConfigurationSets
.OfType <NetworkConfigurationSet>()
.SingleOrDefault();
if (networkConfiguration == null)
{
networkConfiguration = new NetworkConfigurationSet();
role.ConfigurationSets.Add(networkConfiguration);
}
if (networkConfiguration.InputEndpoints == null)
{
networkConfiguration.InputEndpoints = new Collection <InputEndpoint>();
}
var inputEndpoints = networkConfiguration.InputEndpoints;
Collection <InputEndpointContext> endpoints = new Collection <InputEndpointContext>();
foreach (InputEndpoint ep in inputEndpoints)
{
InputEndpointContext endpointCtx = new InputEndpointContext
{
LBSetName = ep.LoadBalancedEndpointSetName,
LocalPort = ep.LocalPort,
Name = ep.Name,
Port = ep.Port,
Protocol = ep.Protocol,
Vip = ep.Vip,
Acl = ep.EndpointAccessControlList,
EnableDirectServerReturn = ep.EnableDirectServerReturn,
InternalLoadBalancerName = ep.LoadBalancerName,
IdleTimeoutInMinutes = ep.IdleTimeoutInMinutes,
LoadBalancerDistribution = ep.LoadBalancerDistribution,
VirtualIPName = ep.VirtualIPName
};
if (ep.LoadBalancerProbe != null && string.IsNullOrEmpty(endpointCtx.LBSetName) == false)
{
endpointCtx.ProbePath = ep.LoadBalancerProbe.Path;
endpointCtx.ProbePort = ep.LoadBalancerProbe.Port;
endpointCtx.ProbeProtocol = ep.LoadBalancerProbe.Protocol;
endpointCtx.ProbeIntervalInSeconds = ep.LoadBalancerProbe.IntervalInSeconds;
endpointCtx.ProbeTimeoutInSeconds = ep.LoadBalancerProbe.TimeoutInSeconds;
}
endpoints.Add(endpointCtx);
}
return(endpoints);
}
protected Collection<InputEndpointContext> GetInputEndpoints()
{
var role = VM.GetInstance();
var networkConfiguration = role.ConfigurationSets
.OfType<NetworkConfigurationSet>()
.SingleOrDefault();
if (networkConfiguration == null)
{
networkConfiguration = new NetworkConfigurationSet();
role.ConfigurationSets.Add(networkConfiguration);
}
if (networkConfiguration.InputEndpoints == null)
{
networkConfiguration.InputEndpoints = new Collection<InputEndpoint>();
}
var inputEndpoints = networkConfiguration.InputEndpoints;
Collection<InputEndpointContext> endpoints = new Collection<InputEndpointContext>();
foreach (InputEndpoint ep in inputEndpoints)
{
InputEndpointContext endpointCtx = new InputEndpointContext
{
LBSetName = ep.LoadBalancedEndpointSetName,
LocalPort = ep.LocalPort,
Name = ep.Name,
Port = ep.Port,
Protocol = ep.Protocol,
Vip = ep.Vip,
Acl = ep.EndpointAccessControlList,
EnableDirectServerReturn = ep.EnableDirectServerReturn,
InternalLoadBalancerName = ep.LoadBalancerName,
IdleTimeoutInMinutes = ep.IdleTimeoutInMinutes,
};
if (ep.LoadBalancerProbe != null && string.IsNullOrEmpty(endpointCtx.LBSetName) == false)
{
endpointCtx.ProbePath = ep.LoadBalancerProbe.Path;
endpointCtx.ProbePort = ep.LoadBalancerProbe.Port;
endpointCtx.ProbeProtocol = ep.LoadBalancerProbe.Protocol;
endpointCtx.ProbeIntervalInSeconds = ep.LoadBalancerProbe.IntervalInSeconds;
endpointCtx.ProbeTimeoutInSeconds = ep.LoadBalancerProbe.TimeoutInSeconds;
}
endpoints.Add(endpointCtx);
}
return endpoints;
}
public void ManagingRDPSSHConnectivity()
{
StartTest(MethodBase.GetCurrentMethod().Name, testStartTime);
// Create a new Azure quick VM
string newAzureQuickVMName = Utilities.GetUniqueShortName("PSTestVM");
if (string.IsNullOrEmpty(imageName))
{
imageName = vmPowershellCmdlets.GetAzureVMImageName(new[] { "Windows", "testvmimage" }, false);
}
vmPowershellCmdlets.NewAzureQuickVM(OS.Windows, newAzureQuickVMName, serviceName, imageName, username, password, locationName); // New-AzureQuickVM
Console.WriteLine("VM is created successfully: -Name {0} -ServiceName {1}", newAzureQuickVMName, serviceName);
// starting the test.
PersistentVMRoleContext vmRoleCtxt = vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName); // Get-AzureVM
InputEndpointContext inputEndpointCtxt = vmPowershellCmdlets.GetAzureEndPoint(vmRoleCtxt)[0]; // Get-AzureEndpoint
Console.WriteLine("InputEndpointContext Name: {0}", inputEndpointCtxt.Name);
Console.WriteLine("InputEndpointContext port: {0}", inputEndpointCtxt.Port);
Console.WriteLine("InputEndpointContext protocol: {0}", inputEndpointCtxt.Protocol);
Assert.AreEqual(inputEndpointCtxt.Name, "RemoteDesktop", true);
string path = ".\\myvmconnection.rdp";
vmPowershellCmdlets.GetAzureRemoteDesktopFile(newAzureQuickVMName, serviceName, path, false); // Get-AzureRemoteDesktopFile
Console.WriteLine("RDP file is successfully created at: {0}", path);
// ToDo: Automate RDP.
//vmPowershellCmdlets.GetAzureRemoteDesktopFile(newAzureQuickVMName, newAzureQuickVMSvcName, path, true); // Get-AzureRemoteDesktopFile -Launch
Console.WriteLine("Test passed");
// Cleanup
vmPowershellCmdlets.RemoveAzureVM(newAzureQuickVMName, serviceName);
Assert.AreEqual(null, vmPowershellCmdlets.GetAzureVM(newAzureQuickVMName, serviceName));
pass = true;
}
protected override void ProcessRecord()
{
Func <InputEndpointContext, bool> func = null;
Collection <InputEndpointContext> inputEndpoints = this.GetInputEndpoints();
if (!string.IsNullOrEmpty(this.Name))
{
Collection <InputEndpointContext> inputEndpointContexts = inputEndpoints;
if (func == null)
{
func = (InputEndpointContext ep) => string.Compare(ep.Name, this.Name, true) == 0;
}
InputEndpointContext inputEndpointContext = inputEndpointContexts.Where <InputEndpointContext>(func).SingleOrDefault <InputEndpointContext>();
base.WriteObject(inputEndpointContext, true);
return;
}
else
{
base.WriteObject(inputEndpoints, true);
return;
}
}
protected Collection <InputEndpointContext> GetInputEndpoints()
{
PersistentVM instance = base.VM.GetInstance();
NetworkConfigurationSet networkConfigurationSet = instance.ConfigurationSets.OfType <NetworkConfigurationSet>().SingleOrDefault <NetworkConfigurationSet>();
if (networkConfigurationSet == null)
{
networkConfigurationSet = new NetworkConfigurationSet();
instance.ConfigurationSets.Add(networkConfigurationSet);
}
if (networkConfigurationSet.InputEndpoints == null)
{
networkConfigurationSet.InputEndpoints = new Collection <InputEndpoint>();
}
Collection <InputEndpoint> inputEndpoints = networkConfigurationSet.InputEndpoints;
Collection <InputEndpointContext> inputEndpointContexts = new Collection <InputEndpointContext>();
foreach (InputEndpoint inputEndpoint in inputEndpoints)
{
InputEndpointContext inputEndpointContext = new InputEndpointContext();
inputEndpointContext.LBSetName = inputEndpoint.LoadBalancedEndpointSetName;
inputEndpointContext.LocalPort = inputEndpoint.LocalPort;
inputEndpointContext.Name = inputEndpoint.Name;
inputEndpointContext.Port = inputEndpoint.Port;
inputEndpointContext.Protocol = inputEndpoint.Protocol;
inputEndpointContext.Vip = inputEndpoint.Vip;
if (inputEndpoint.LoadBalancerProbe != null && !string.IsNullOrEmpty(inputEndpointContext.LBSetName))
{
inputEndpointContext.ProbePath = inputEndpoint.LoadBalancerProbe.Path;
inputEndpointContext.ProbePort = inputEndpoint.LoadBalancerProbe.Port;
inputEndpointContext.ProbeProtocol = inputEndpoint.LoadBalancerProbe.Protocol;
}
inputEndpointContexts.Add(inputEndpointContext);
}
return(inputEndpointContexts);
}
protected Collection<InputEndpointContext> GetInputEndpoints()
{
var role = VM.GetInstance();
var networkConfiguration = role.ConfigurationSets
.OfType<NetworkConfigurationSet>()
.SingleOrDefault();
if (networkConfiguration == null)
{
networkConfiguration = new NetworkConfigurationSet();
role.ConfigurationSets.Add(networkConfiguration);
}
if (networkConfiguration.InputEndpoints == null)
{
networkConfiguration.InputEndpoints = new Collection<InputEndpoint>();
}
var inputEndpoints = networkConfiguration.InputEndpoints;
Collection<InputEndpointContext> endpoints = new Collection<InputEndpointContext>();
foreach (InputEndpoint ep in inputEndpoints)
{
InputEndpointContext endpointCtx = new InputEndpointContext
{
LBSetName = ep.LoadBalancedEndpointSetName,
LocalPort = ep.LocalPort,
Name = ep.Name,
Port = ep.Port,
Protocol = ep.Protocol,
Vip = ep.Vip
};
if (ep.LoadBalancerProbe != null && string.IsNullOrEmpty(endpointCtx.LBSetName) == false)
{
endpointCtx.ProbePath = ep.LoadBalancerProbe.Path;
endpointCtx.ProbePort = ep.LoadBalancerProbe.Port;
endpointCtx.ProbeProtocol = ep.LoadBalancerProbe.Protocol;
}
endpoints.Add(endpointCtx);
}
return endpoints;
}
public bool CheckInputEndpointContext(InputEndpointContext context)
{
bool ret = false;
if (ParamSet == ParameterSet.NoLB)
{
ret = (context.Name == this.EndpointName);
}
else
{
ret = (context.LBSetName == this.LBSetName);
}
ret = ret && context.Protocol == this.EndpointProtocol.ToString()
&& context.LocalPort == this.EndpointLocalPort
&& context.Port == this.EndpointPublicPort
&& context.EnableDirectServerReturn == this.DirectServerReturn;
if(context.Acl == null)
{
if(this.Acl != null
&& this.Acl != new NetworkAclObject())
{
ret = false;
}
}
else if (this.Acl != null)
{
foreach (var rule in this.Acl)
{
if(!context.Acl.Rules.Contains(rule))
{
ret = false;
}
}
}
else
{
ret = false;
}
if (ParamSet == ParameterSet.CustomProbe)
{
ret = ret && context.LBSetName == this.LBSetName
&& context.ProbePort == this.ProbePort
&& context.ProbeProtocol == this.ProbeProtocol.ToString();
ret = ret && ( this.ProbeInterval.HasValue
? context.ProbeIntervalInSeconds == this.ProbeInterval
: context.ProbeIntervalInSeconds == 15 );
ret = ret && ( this.ProbeTimeout.HasValue
? context.ProbeTimeoutInSeconds == this.ProbeTimeout
: context.ProbeTimeoutInSeconds == 31 );
}
return ret;
}
