/// <summary>
/// Checks the status of vBridge on ODL.
/// </summary>
/// <param name="vtnName">Name of parent VTN.</param>
/// <param name="vbrName">Name of parent vBridge.</param>
/// <returns>VLAN ID.
/// -2 if VTN is deleted.
/// -1 if vBridge is deleted.
/// </returns>
public int CheckVbridgeStatus(string vtnName, string vbrName)
{
int status = -2;
Vtn vtns = this.ReadVTNObjects(vtnName).FirstOrDefault();
if (vtns != null)
{
Vbridge vbridge = vtns.Vbridges.FirstOrDefault(vbr => vbr.Name.CompareTo(vbrName) == 0);
if (vbridge != null)
{
long vlanID = vbridge.VlanId;
if (vlanID != 0)
{
status = Convert.ToInt32(vlanID);
}
else
{
status = -1;
}
}
else
{
status = -1;
}
}
else
{
status = -2;
}
return(status);
}
/// <summary>
/// Compare the VTN.
/// </summary>
/// <param name="vtn">VTN to compare.</param>
/// <param name="vmnetworkInfo">Corresponding VM network info.</param>
/// <returns>Indicates whether VTN is synchronized or not.</returns>
public bool CompareVTN(Vtn vtn, VMNetworkInfo vmnetworkInfo)
{
bool needRefresh = false;
List <Vbridge> vbridges = new List <Vbridge>();
foreach (Vbridge vbr in vtn.Vbridges)
{
var vmsubnetInfo = vmnetworkInfo.VMSubnetInfo.FirstOrDefault(vmsubnet => vmsubnet.VBridgeName.Equals(vbr.Name));
if (vmsubnetInfo != null)
{
if (vmsubnetInfo.VBridgeVlanId != vbr.VlanId)
{
needRefresh = true;
}
}
else
{
needRefresh = true;
}
}
foreach (var subnetInfo in vmnetworkInfo.VMSubnetInfo)
{
Vbridge vbr = vtn.Vbridges.FirstOrDefault(odlItem => odlItem.Name.CompareTo(subnetInfo.VBridgeName) == 0);
if (vbr == null)
{
needRefresh = true;
}
}
return(needRefresh);
}
/// <summary>
/// This method is responsible for making the connection with ODL through
/// http request and retrieve the list of VTNs.
/// </summary>
/// <param name="readVTN">Vtn name.</param>
/// <returns>Extracts list of vtns from the response and return.</returns>
public List <Vtn> ReadVTNObjects(string readVTN)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
ODLVSEMETW.EventWriteStartODLLibrary(
MethodBase.GetCurrentMethod().Name,
string.Empty);
List <Vtn> vtns = new List <Vtn>();
List <string> vtnNames = this.GetVtnList();
if (!string.IsNullOrEmpty(readVTN))
{
vtnNames.RemoveAll(vtn => vtn.CompareTo(readVTN) != 0);
}
foreach (string vtnName in vtnNames)
{
var vtn = new Vtn(this.Base_uri, this.Credential)
{
Name = vtnName
};
List <string> vbrNames = this.GetVbridgesListforVtn(vtnName);
foreach (string vbrName in vbrNames)
{
long vlanID = this.GetVLANIDforVbridge(vtnName, vbrName);
if (vlanID != 0)
{
var vbr = new Vbridge(this.Base_uri, this.Credential)
{
Name = vbrName,
VlanId = vlanID
};
vtn.Vbridges.Add(vbr);
}
}
if (vtn.Vbridges.Count() > 0)
{
vtns.Add(vtn);
}
}
string output = "\"vtns\":" + JavaScriptSerializer.Serialize(vtns.Select(vtn => vtn.Name));
ODLVSEMETW.EventWriteEndODLLibrary(MethodBase.GetCurrentMethod().Name, output);
return(vtns);
}
/// <summary>
/// Compare the VTN.
/// </summary>
/// <param name="logicalNetworkDefinitionId">Logfical network definition ID.</param>
/// <param name="vmnetwork">Corresponding VM network.</param>
/// <param name="vtn">VTN to compare.</param>
/// <param name="vmnetworkInfo">Corresponding VM network info.</param>
/// <param name="txnMng">Transaction manager instance.</param>
/// <param name="VtnHostName">Host name of the VTNCoordinator.</param>
/// <returns>Indicateds the need to refresh the network service.</returns>
public bool SyncVTN(Guid?logicalNetworkDefinitionId, VMNetwork vmnetwork, Vtn vtn, VMNetworkInfo vmnetworkInfo, TransactionManager txnMng, string VtnHostName)
{
bool needRefresh = false;
foreach (Vbridge vbr in vtn.Vbridges)
{
var vmsubnetInfo = vmnetworkInfo.VMSubnetInfo.FirstOrDefault(vmsubnet => vmsubnet.VBridgeName.Equals(vbr.Name));
if (vmsubnetInfo != null)
{
if (vmsubnetInfo.VBridgeVlanId != vbr.VlanId && !string.IsNullOrEmpty(vmsubnetInfo.VMSubnetName))
{
string vlanRange = CheckVlanRange(vmnetworkInfo, txnMng, VtnHostName, vmsubnetInfo);
if (vlanRange.CompareTo(string.Empty) == 0)
{
vmsubnetInfo.Description = string.Format("VLAN ID of this VM Subnet is changed from {0} to {1} on ODL. VM attached to this VM Subnet prior to this change (i.e, with VLAN ID {0}), will not be operable now.", vmsubnetInfo.VMSubnetVlanId, vbr.VlanId);
vmsubnetInfo.VMSubnetVlanId = vbr.VlanId;
var vmsubnet = vmnetwork.VMSubnets.FirstOrDefault(subnet => subnet.Id.Equals(vmsubnetInfo.VMSubnetID));
vmsubnet.SegmentId.PrimarySegmentIdentifier = Convert.ToUInt32(vbr.VlanId);
needRefresh = true;
}
else
{
vmsubnetInfo.Description = string.Format("VLAN ID of this VM Subnet is changed from {0} to {1} on ODL. But {1} does not lie in the specified range '{2}'. VM attached to this VM Subnet will not be operable now.", vmsubnetInfo.VMSubnetVlanId, vbr.VlanId, vlanRange);
}
}
vmsubnetInfo.VBridgeVlanId = vbr.VlanId;
}
else
{
this.AddVMSubnet(vmnetworkInfo, vbr, vmnetwork, logicalNetworkDefinitionId);
needRefresh = true;
}
}
foreach (var subnetInfo in vmnetworkInfo.VMSubnetInfo)
{
Vbridge vbr = vtn.Vbridges.FirstOrDefault(odlItem => odlItem.Name.CompareTo(subnetInfo.VBridgeName) == 0);
if (vbr == null)
{
RemoveVMSubnetSync(null, subnetInfo.VMSubnetID, vmnetwork, vmnetworkInfo);
needRefresh = true;
}
}
return(needRefresh);
}
/// <summary>
/// This function is responsible to synchronize the network configuration between ODL and SCVMM.
/// </summary>
/// <param name="vtns">List of VTNs on ODL.</param>
/// <param name="vMNetworkConfig">VMNetwork.config file instance.</param>
private void CompareVMNetworkObjects(List <Vtn> vtns, VMNetworkConfig vMNetworkConfig)
{
foreach (var networkInfo in vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo)
{
Vtn vtn = vtns.FirstOrDefault(odlItem => odlItem.Name.CompareTo(networkInfo.VTNName) == 0);
if (vtn == null)
{
RemoveVMNetworkSync(vMNetworkConfig, networkInfo);
}
else
{
foreach (var subnetInfo in networkInfo.VMSubnetInfo)
{
Vbridge vbr = vtn.Vbridges.FirstOrDefault(odlItem => odlItem.Name.CompareTo(subnetInfo.VBridgeName) == 0);
if (vbr == null)
{
RemoveVMSubnetSync(vMNetworkConfig, subnetInfo.VMSubnetID, null, null);
}
}
}
}
}
public override string ToString()
{
var sb = new StringBuilder();
sb.AppendLine($"Netlist: {NetList}");
sb.AppendLine("Transistor");
sb.AppendLine(
$" Vtn: (Threshold, Sigma, NumberOfSigma) {string.Join(", ", Vtn.Split('_').Where((_, i) => i % 2 == 1).Select(x => decimal.Parse(x, NumberStyles.Float)))}");
sb.AppendLine(
$" Vtp: (Threshold, Sigma, NumberOfSigma) {string.Join(", ", Vtp.Split('_').Where((_, i) => i % 2 == 1).Select(x => decimal.Parse(x, NumberStyles.Float)))}");
sb.AppendLine("Includes");
foreach (var s in Includes.Split(':'))
{
sb.AppendLine($" - {s}");
}
sb.AppendLine("Signals");
foreach (var signal in Signals.Split(':'))
{
sb.AppendLine($" - {signal}");
}
sb.AppendLine($"Simulation Time: {Time}");
sb.AppendLine($"Temperature: {Temperature}");
sb.AppendLine($"Voltage: \n VDD: {Vdd}\n GND: {Gnd}");
sb.AppendLine($".IC");
foreach (var s in IcCommand.Split(':'))
{
sb.AppendLine($" - {s}");
}
sb.AppendLine("Hspice");
sb.AppendLine($" Path: {Hspice}");
sb.AppendLine($" Options: {HspiceOption}");
return(sb.ToString());
}
/// <summary>
/// Remove the specified vtn.
/// </summary>
/// <param name="vtnName">VTN name.</param>
public void RemoveVmNetwork(string vtnName)
{
StringBuilder json = new StringBuilder("\"vtnName\":\"" + vtnName + "\"");
ODLVSEMETW.EventWriteStartLibrary(MethodBase.GetCurrentMethod().Name,
json.ToString());
ODLVSEMETW.EventWriteRemoveVMNetwork(MethodBase.GetCurrentMethod().Name,
"Removing VTN.");
if (string.IsNullOrWhiteSpace(vtnName))
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vtnName' is null or invalid.");
throw new ArgumentException("The parameter 'vtnName' is null or invalid.");
}
Vtn vtn = new Vtn(this.ConnectionString, this.Credential);
vtn.RemoveVtn(vtnName);
ODLVSEMETW.EventWriteReturnODLLibrary("Return from ODL Library.",
string.Empty);
}
/// <summary>
/// Remove the specified VM network.
/// </summary>
/// <param name="vMNetworkConfig">Vm network config.</param>
/// <param name="vmNetId">ID of VM network to remove.</param>
public void RemoveVmNetwork(VMNetworkConfig vMNetworkConfig, Guid vmNetId)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder(" \"vMNetworkConfig\":" + JavaScriptSerializer.Serialize(vMNetworkConfig));
json.Append("\"vmNetId\":\"" + vmNetId + "\"");
ODLVSEMETW.EventWriteStartLibrary(MethodBase.GetCurrentMethod().Name,
json.ToString());
ODLVSEMETW.EventWriteRemoveVMNetwork(MethodBase.GetCurrentMethod().Name,
"Removing VMNetwork.");
if (vMNetworkConfig == null)
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vMNetworkConfig' is null or invalid.");
throw new ArgumentException(
"The parameter 'vMNetworkConfig' is null or invalid.");
}
if (vmNetId == Guid.Empty)
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vmNetId' is null or invalid.");
throw new ArgumentException("The parameter 'vmNetId' is null or invalid.");
}
string vtnName = string.Empty;
foreach (var vmNet in
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo)
{
if (vmNet.VMNetworkID == vmNetId)
{
vtnName = vmNet.VTNName;
break;
}
}
Vtn vtn = new Vtn(this.ConnectionString, this.Credential);
try {
vtn.RemoveVtn(vtnName);
} catch (System.Net.WebException) {
//// If VSEM succeeded in vBridge deletion,
//// there will be no problem in further operations.
//// Garbage VTN will be abandoned.
}
ODLVSEMETW.EventWriteReturnODLLibrary("Return from ODL Library.", string.Empty);
var vmNwkInfo =
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo;
if (vmNwkInfo.First(vmNet => vmNet.VMNetworkID == vmNetId).VMSubnetInfo.Count == 0)
{
vmNwkInfo.RemoveAll(
vmNet => vmNet.VMNetworkID == vmNetId);
}
else
{
vmNwkInfo.First(vmNet => vmNet.VMNetworkID == vmNetId).Description =
"Corresponding VTN is deleted on ODL";
}
vMNetworkConfig.VMNetwork.VmNetworks.RemoveAll(
vmNet => vmNet.Id == vmNetId);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, string.Empty);
}
/// <summary>
/// Create a new VM network with specified parameters using VTN on demand.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <param name="vMSubnetName">Name of VM Subnet to create.</param>
/// <param name="vMNetworkName">Name of VM network to create.</param>
/// <param name="maxNumberOfPorts">Maximum number of ports.</param>
/// <param name="ipSubnets">IP pools to use.</param>
/// <param name="logicalNetworkDefinitionId">ID of logical network definition
/// to associate with.</param>
/// <param name="connection">VSEM connection.</param>
/// <param name="vtnName">VTN name.</param>
/// <returns>VM network if successful, else null.</returns>
public VMNetwork CreateVMNetwork(TransactionManager txnMng,
string vMSubnetName,
string vMNetworkName,
long?maxNumberOfPorts,
IPSubnet[] ipSubnets,
Guid logicalNetworkDefinitionId,
VSEMConnection connection,
out string vtnName)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"txnMng\":" + JavaScriptSerializer.Serialize(txnMng));
json.Append(" \"ipSubnets\":" + JavaScriptSerializer.Serialize(ipSubnets));
json.Append("\"maxNumberOfPorts\":\"" + maxNumberOfPorts + "\"");
json.Append("\"vMNetworkName\":\"" + vMNetworkName + "\"");
json.Append("\"vMSubnetName\":\"" + vMSubnetName + "\"");
json.Append("\"logicalNetworkDefinitionId\":\"" + logicalNetworkDefinitionId + "\"");
ODLVSEMETW.EventWriteStartLibrary(MethodBase.GetCurrentMethod().Name,
json.ToString());
if (txnMng == null)
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'transaction' is null or invalid.");
throw new ArgumentException("The parameter 'transaction' is null or invalid.");
}
if (string.IsNullOrEmpty(vMNetworkName))
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vMNetworkName' is null or invalid.");
throw new ArgumentException("The parameter 'vMNetworkName' is null or invalid.");
}
if (logicalNetworkDefinitionId == Guid.Empty)
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'logicalNetworkDefinitionId' is null or invalid.");
throw new ArgumentException(
"The parameter 'logicalNetworkDefinitionId' is null or invalid.");
}
if (connection == null)
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'connection' is null or invalid.");
throw new ArgumentException("The parameter 'connection' is null or invalid.");
}
string VtnHostName = this.ConnectionString;
if (VtnHostName.StartsWith(@"https://", StringComparison.Ordinal))
{
VtnHostName = VtnHostName.Substring(8);
}
VtnHostName = VtnHostName.Split('.', ':').First();
var vMNetworkConfig = new VMNetworkConfig(VtnHostName);
txnMng.SetConfigManager(vMNetworkConfig, TransactionManager.OpenMode.WriteMode);
var LogicalNetworkConfig = new LogicalNetworkConfig(VtnHostName);
txnMng.SetConfigManager(LogicalNetworkConfig, TransactionManager.OpenMode.ReadMode);
if (LogicalNetworkConfig.LogicalNetworks.Count == 0)
{
ODLVSEMETW.EventWriteConfigManagerFileIOError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}",
configFileIOErrorValidationMessage));
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}",
configFileIOErrorValidationMessage));
}
var logicalNetName = VSEMODLConstants.LOGICAL_NETWORK_NAME;
logicalNetName += VtnHostName;
var fabricNwDef = LogicalNetworkConfig.LogicalNetworks.First(
log => log.Name.Equals(logicalNetName)).LogicalNetworkDefinitions.FirstOrDefault(
fabnw => fabnw.Id == logicalNetworkDefinitionId);
if (fabricNwDef == null)
{
ODLVSEMETW.EventWriteGetFabricNetworkDefinitionError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"Logical network definition '{0}' not found.",
logicalNetworkDefinitionId.ToString("B")));
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"Logical network definition '{0}' not found.",
logicalNetworkDefinitionId.ToString("B")));
}
ODLVSEMETW.EventWriteReturnLibrary(string.Format(CultureInfo.CurrentCulture,
"VSEMLogicalNetworkDefinition is retrieved by ID: {0}",
logicalNetworkDefinitionId.ToString("B")),
string.Empty);
if (!fabricNwDef.SupportsVMNetworkProvisioning)
{
ODLVSEMETW.EventWriteSupportsVMNetworkProvisioningError(
"Logical network does not support VM network creation.",
string.Empty);
throw new InvalidOperationException(
"Logical network does not support VM network creation.");
}
vtnName = this.CreateUniqueNameForVTN(vMNetworkName);
Vtn vtn = new Vtn(this.ConnectionString, this.Credential);
vtn.AddVtn(vtnName);
ODLVSEMETW.EventWriteReturnODLLibrary(string.Format(CultureInfo.CurrentCulture,
"VTN '{0}' is created",
vtnName),
string.Empty);
VMNetwork vmNet = CreateVtnVmNetwork(vMNetworkName);
vmNet.LogicalNetwork = fabricNwDef.LogicalNetworkId;
if (vmNet == null)
{
ODLVSEMETW.EventWriteProcessFailedVMNetworkError(
MethodBase.GetCurrentMethod().Name,
"Failed to create VM Network.");
throw new InvalidOperationException("Failed to create VM Network.");
}
ODLVSEMETW.EventWriteSuccessVmNetwork(MethodBase.GetCurrentMethod().Name,
"VM Network Successfully Created.");
// Create the VM Subnet
vMNetworkConfig.VMNetwork.VmNetworks.Add(vmNet);
if (vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo == null)
{
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo =
new List <VMNetworkInfo>();
}
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Add(
new VMNetworkInfo {
VMNetworkID = vmNet.Id,
VMNetworkName = vmNet.Name,
VTNName = vtnName,
VMSubnetInfo = new List <VMSubnetInfo>(),
CreatedFrom = "SCVMM",
VMNetworkOriginalName = vmNet.Name
});
var vsemvmnetworkDefinition = new VSEMVMSubnetManagement(
this.ConnectionString, this.Credential);
ODLVSEMETW.EventWriteCreateVMsubNetwork(MethodBase.GetCurrentMethod().Name,
"VM Sub Network creation process started.");
string vbrName = string.Empty;
VMSubnet vmNetworkDef =
vsemvmnetworkDefinition.CreateVMNetworkDefinitionforVtn(
txnMng,
LogicalNetworkConfig,
vMNetworkConfig,
vMSubnetName,
vmNet.Id,
maxNumberOfPorts,
ipSubnets,
logicalNetworkDefinitionId,
connection,
out vtnName,
out vbrName);
Controller odl = new Controller(this.ConnectionString, this.Credential);
odl.UpdateStartupConfiguration();
string output = "\"vmNet\":" + JavaScriptSerializer.Serialize(vmNet);
ODLVSEMETW.EventWriteReturnODLLibrary("Return from ODL Library.", output);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name,
output);
return(vmNet);
}
