/// <summary>
/// Acquires all available information of each cluster-node.
/// </summary>
/// <returns>List of WorkstationInfos conataining the node-information.</returns>
public override List <WorkstationInfo> GetNodes()
{
List <Core.WorkstationInfo> nodes = new List <WorkstationInfo>();
string utilityAddress = url.Substring(7, url.Length - 7);
utilityAddress = utilityAddress.Split(':')[0];
utilityAddress = utilityAddress.Split('.')[0];
HpcPipelineObject pipelineObject = this.getPipeline();
Dictionary <string, string> nodeInformation = HpcUtility.getSubnetInformation(utilityAddress, this);
this.freePipeline(pipelineObject);
Dictionary <string, NodeState> hpcNodesAvailability = new Dictionary <string, NodeState>();
foreach (ISchedulerNode node in ((IScheduler)this.CopyConnection().GetConnection()).GetNodeList(null, null))
{
hpcNodesAvailability.Add(node.Name, node.State);
}
foreach (KeyValuePair <String, String> entry in nodeInformation)
{
if (hpcNodesAvailability.ContainsKey(entry.Key))
{
WorkstationInfo workstationInfo = new WorkstationInfo();
workstationInfo.CurrentOS = (MISD.Core.Platform.HPC).ToString();
workstationInfo.Name = entry.Key;
workstationInfo.FQDN = entry.Key + ".visus.uni-stuttgart.de";
workstationInfo.MacAddress = entry.Value;
NodeState availability;
hpcNodesAvailability.TryGetValue(entry.Key, out availability);
if (availability.ToString().Equals("Online"))
{
workstationInfo.IsAvailable = true;
}
else
{
workstationInfo.IsAvailable = false;
}
workstationInfo.State = MISD.Core.MappingState.OK;
nodes.Add(workstationInfo);
}
}
return(nodes);
}
/// <summary>
/// Closes and disposes Pipeline. Releases semaphore.
/// </summary>
/// <param name="pipelineObject"></param>
public void freePipeline(HpcPipelineObject pipelineObject)
{
try
{
int pipelineNumber = pipelineObject.pipelineNumber;
pipelineObject.Dispose();
pipelineSemaphores[pipelineNumber].Release();
}
catch (Exception e)
{
Logger.Instance.WriteEntry("Failed to free pipeline", LogType.Exception);
}
}
/// <summary>
/// Retrieves the subnet of the client, that the pipeline is connected to.
/// </summary>
/// <param name="pipeline">Pipeline that is connected to the server</param>
/// <returns>the subnet-address</returns>
private static string calculatePrivateSubNet(HpcClusterConnection hpcClusterConnection)
{
string ipAddress = "";
string subnetMask = "";
string result = "";
//acquires ip and subnetmask
HpcPipelineObject pipelineObject = hpcClusterConnection.getPipeline();
pipelineObject.pipeline.Commands.AddScript("Add-PSSnapin Microsoft.Hpc");
pipelineObject.pipeline.Commands.AddScript("Get-HpcNetworkInterface -Type Private");
Collection <PSObject> results1 = pipelineObject.pipeline.Invoke();
hpcClusterConnection.freePipeline(pipelineObject);
PSObject obj = results1[0];
subnetMask = obj.Properties["Subnetmask"].Value.ToString();
ipAddress = obj.Properties["IpAddress"].Value.ToString();
string[] ipArray = ipAddress.Split('.');
string[] networkMaskArray = subnetMask.Split('.');
string[] subnetArray = new String[4];
for (int i = 0; i < 4; i++)
{
subnetArray[i] = (Convert.ToInt32(ipArray[i]) & Convert.ToInt32(networkMaskArray[i])).ToString();
}
for (int i = 0; i < subnetArray.Length; i++)
{
result += subnetArray[i];
if (i != subnetArray.Length - 1)
{
result += ".";
}
}
return(result);
}
/// <summary>
/// Creates a new Pipeline on one of the runspaces.
/// </summary>
/// <returns>New pipeline-object</returns>
public HpcPipelineObject getPipeline()
{
getPipelineSemaphore.WaitOne();
nextRunspaceForPipeline++;
if (nextRunspaceForPipeline > amountOfRunspaces - 1)
{
nextRunspaceForPipeline = 0;
}
try
{
if (!this.pipelineSemaphores[nextRunspaceForPipeline].WaitOne(200))
{
getPipelineSemaphore.Release();
return(getPipeline());
}
if (this.runspaces[nextRunspaceForPipeline].RunspaceStateInfo.State != RunspaceState.Opened)
{
Logger.Instance.WriteEntry("Runspace #" + nextRunspaceForPipeline + " is not in the opened state. Refreshing..", LogType.Info);
try
{
this.runspaces[nextRunspaceForPipeline].Close();
}
catch (Exception)
{
//No Error handling neccessary
}
this.refreshRunspace(nextRunspaceForPipeline);
getPipelineSemaphore.Release();
Thread.Sleep(1000);
return(getPipeline());
}
var pipeline = this.runspaces[nextRunspaceForPipeline].CreatePipeline();
getPipelineSemaphore.Release();
HpcPipelineObject newPipelineObject = new HpcPipelineObject(nextRunspaceForPipeline, pipeline);
return(newPipelineObject);
}
catch (Exception e)
{
var messageEx = new StringBuilder();
messageEx.Append("HpcClusterConnection: ");
messageEx.Append("Runspace no. (" + nextRunspaceForPipeline + ") seems to be corrupted. Reinitialising...");
messageEx.Append(e.ToString());
Logger.Instance.WriteEntry(messageEx.ToString(), LogType.Warning);
refreshRunspace(nextRunspaceForPipeline);
return(getPipeline());
}
}