/// <summary>
/// Verify whether the specified VMNetwork is HNV resource or not.
/// </summary>
/// <param name="vmnetwork">VMNetwork instance.</param>
/// <returns>True if HNV resource, else false.</returns>
public bool IsHNVVMNetwork(VMNetwork vmnetwork)
{
if (vmnetwork == null) {
return false;
}
// Create txn and read configuration.
var txnMng = new TransactionManager();
txnMng.StartTransaction();
var logicalNetworkConfig = new LogicalNetworkConfig(this.VtnHostName);
txnMng.SetConfigManager(logicalNetworkConfig, TransactionManager.OpenMode.ReadMode);
bool ret;
// Get LogicalNetowork that Guid equals vmnetwork.LogicalNetwork.
LogicalNetwork logicalnetwork = logicalNetworkConfig.GetLogicalNetworkById(vmnetwork.LogicalNetwork);
if (logicalnetwork == null) {
ret = false;
goto txnEnd;
}
var hnvLogicalNetworkManagement = new HNVLogicalNetworkManagement(this.VtnHostName);
ret = hnvLogicalNetworkManagement.IsHNVLogicalNetwork(logicalnetwork);
if (ret == false) {
ODLVSEMETW.EventWriteNotHNVVMNetwork(
MethodBase.GetCurrentMethod().Name,
string.Format("VMNetwork name is {0}", vmnetwork.Name));
}
txnEnd:
txnMng.EndTransaction(TransactionManager.Operation.None);
return ret;
}
/// <summary>
/// Update the VSEM repository.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
public void UpdateConnection(TransactionManager txnMng)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"TransactionManager\":" + JavaScriptSerializer.Serialize(txnMng));
ODLVSEMETW.EventWriteStartLibrary(MethodBase.GetCurrentMethod().Name, json.ToString());
if (txnMng == null) {
throw new ArgumentException(
"txnMng' is null or invalid.");
}
string VtnHostName = this.ConnectionString;
if (VtnHostName.StartsWith(@"https://", StringComparison.Ordinal)) {
VtnHostName = VtnHostName.Substring(8);
}
VtnHostName = VtnHostName.Split('.', ':').First();
var vseminformation = this.CreateVSEMInfo();
// Make sure we can connect to the ODL
if (!this.VerifyConnection(vseminformation.MinVTNCoVersion)) {
ODLVSEMETW.EventWriteProcesOdlLibraryError(MethodBase.GetCurrentMethod().Name,
"WebAPI version is not supported.");
throw new ArgumentException("WebAPI version is not supported.");
}
Controller odl_ctr = new Controller(this.ConnectionString, this.controllers, this.Credential);
odl_ctr.Create_ctr(Constants.CTR_NAME);
ODLVSEMETW.EventWriteCreateODLData(
MethodBase.GetCurrentMethod().Name, "Creating VSEM repository.");
VSEMConfig vsemConfig = new VSEMConfig();
txnMng.SetConfigManager(vsemConfig, TransactionManager.OpenMode.WriteMode);
// Update Configuration Data;
vsemConfig.Info = vseminformation;
vsemConfig.Controller = new VSEMController();
vsemConfig.Controller.ControllerInfo = this.controllers;
if (vsemConfig.NetworkServiceSystemInformation.Id.CompareTo(Guid.Empty) == 0) {
vsemConfig.NetworkServiceSystemInformation = VSEMConnection.CreateSystemInfo();
} else {
VSEMODLConstants.SYSTEM_INFO_ID = vsemConfig.NetworkServiceSystemInformation.Id;
}
if (vsemConfig.SwitchExtensionInfo.Count == 0) {
vsemConfig.SwitchExtensionInfo = VSEMConnection.CreateSwitchExtensionInfos();
} else {
VSEMODLConstants.SWITCH_EXTENSION_INFO_ID = vsemConfig.SwitchExtensionInfo[0].Id;
}
vsemConfig.SwitchExtensionInfo.ForEach((i) =>
VSEMConnection.AddSwitchFeatureToSwitchExtInfos(i, this.controllers));
LogicalNetworkConfig logicalNetworkConfig = new LogicalNetworkConfig(VtnHostName);
txnMng.SetConfigManager(logicalNetworkConfig, TransactionManager.OpenMode.WriteMode);
if (logicalNetworkConfig.LogicalNetworks.Count == 0) {
logicalNetworkConfig.LogicalNetworks =
this.CreateLogicalNetworks();
}
PortProfileConfig portProfileConfig = new PortProfileConfig();
txnMng.SetConfigManager(portProfileConfig, TransactionManager.OpenMode.WriteMode);
if (portProfileConfig.UplinkPortProfiles.Count == 0) {
portProfileConfig.UplinkPortProfiles =
VSEMConnection.CreateUplinkPortProfiles();
} else {
VSEMODLConstants.UPLINK_PORT_PROFILE_ID = portProfileConfig.UplinkPortProfiles[0].Id;
}
if (portProfileConfig.VirtualPortProfiles.Count == 0) {
portProfileConfig.VirtualPortProfiles =
VSEMConnection.CreateVirtualPortProfiles();
}
// Create HNV default resource.
HNVLogicalNetworkManagement hnvMgmt = new HNVLogicalNetworkManagement(this.VtnHostName);
hnvMgmt.CreateHNVLogicalNetwork(logicalNetworkConfig);
hnvMgmt.AssociatePortProfileWithHNV(portProfileConfig);
this.SaveVtncoInfo(txnMng, VtnHostName);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, string.Empty);
}
/// <summary>
/// This method is responsible for extracting the LogicalNetwork
/// from the VSEM repository for the corresponding connection for the specified id.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <param name="id">Id of the LogicalNetwork.</param>
/// <returns>LogicalNetwork instance attached with the connection.</returns>
public LogicalNetwork GetVSEMLogicalNetworkById(
TransactionManager txnMng,
Guid id)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"TransactionManager\":" + JavaScriptSerializer.Serialize(txnMng));
json.Append(" \"id\":" + id.ToString("B"));
ODLVSEMETW.EventWriteStartLibrary(
MethodBase.GetCurrentMethod().Name,
json.ToString());
ODLVSEMETW.EventWriteExtractFabricNetworkDefinition(
"Extracting LogicalNetwork Info.",
string.Empty);
if (id == Guid.Empty) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'id' is null or invalid.");
throw new ArgumentException("The parameter 'id' is null or invalid.");
}
string VtnHostName = this.ConnectionString;
if (VtnHostName.StartsWith(@"https://", StringComparison.Ordinal)) {
VtnHostName = VtnHostName.Substring(8);
}
VtnHostName = VtnHostName.Split('.', ':').First();
var logicalNetworkConfig = new LogicalNetworkConfig(VtnHostName);
try {
txnMng.SetConfigManager(logicalNetworkConfig, TransactionManager.OpenMode.ReadMode);
var ret = logicalNetworkConfig.LogicalNetworks.FirstOrDefault(
(x) => x.Id == id);
string output = "\"LogicalNetwork\":" + JavaScriptSerializer.Serialize(ret);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, output);
return ret;
} catch (Exception ex) {
ODLVSEMETW.EventWriteConfigManagerFileIOError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}\n{1}",
configFileIOErrorValidationMessage,
ex.Message));
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, string.Empty);
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}",
configFileIOErrorValidationMessage));
}
}
/// <summary>
/// This method is responsible for extracting the list of VSEMLogicalNetworkDefinition
/// from the VSEM repository for the corresponding connection.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <returns>List of VSEMLogicalNetworkDefinition instances
/// attached with the connection.</returns>
public List<LogicalNetwork> GetVSEMLogicalNetwork(
TransactionManager txnMng)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"TransactionManager\":" + JavaScriptSerializer.Serialize(txnMng));
ODLVSEMETW.EventWriteStartLibrary(
MethodBase.GetCurrentMethod().Name,
json.ToString());
ODLVSEMETW.EventWriteExtractFabricNetworkDefinitionlist(
"Extracting list of Logical Network Info.",
string.Empty);
string VtnHostName = this.ConnectionString;
if (VtnHostName.StartsWith(@"https://", StringComparison.Ordinal)) {
VtnHostName = VtnHostName.Substring(8);
}
VtnHostName = VtnHostName.Split('.', ':').First();
var logicalNetworkConfig = new LogicalNetworkConfig(VtnHostName);
try {
txnMng.SetConfigManager(logicalNetworkConfig, TransactionManager.OpenMode.ReadMode);
} catch (Exception ex) {
ODLVSEMETW.EventWriteConfigManagerFileIOError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}\n{1}",
configFileIOErrorValidationMessage,
ex.Message));
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}",
configFileIOErrorValidationMessage));
}
string output = "\"LogicalNetwork\":" + JavaScriptSerializer.Serialize(logicalNetworkConfig.LogicalNetworks);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, output);
return logicalNetworkConfig.LogicalNetworks;
}
/// <summary>
/// This method is responsible to synchronize the network configuration between ODL and SCVMM.
/// </summary>
/// <param name="txnMng">TransactionManager instance.</param>
public void SynchronizeVTNObjects(TransactionManager txnMng)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"txnMng\":" + JavaScriptSerializer.Serialize(txnMng));
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.");
}
Controller odl = new Controller(this.ConnectionString, this.Credential);
List<Vtn> vtns = odl.ReadVTNObjects(string.Empty);
ODLVSEMETW.EventWriteReturnODLLibrary("Return from ODL Library.", string.Empty);
string VtnHostName = this.ConnectionString;
if (VtnHostName.StartsWith(@"https://", StringComparison.Ordinal)) {
VtnHostName = VtnHostName.Substring(8);
}
VtnHostName = VtnHostName.Split('.', ':').First();
var vMNetworkConfig = new VMNetworkConfig(VtnHostName);
try {
txnMng.SetConfigManager(vMNetworkConfig, TransactionManager.OpenMode.WriteMode);
} catch (Exception ex) {
ODLVSEMETW.EventWriteConfigManagerFileIOError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"VMNetwork.config {0}\n{1}",
configFileIOErrorValidationMessage,
ex.Message));
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, string.Empty);
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
"VMNetwork.config {0}",
configFileIOErrorValidationMessage));
}
var logicalNetworkConfig = new LogicalNetworkConfig(VtnHostName);
try {
txnMng.SetConfigManager(logicalNetworkConfig, TransactionManager.OpenMode.ReadMode);
} catch (Exception ex) {
ODLVSEMETW.EventWriteConfigManagerFileIOError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}\n{1}",
configFileIOErrorValidationMessage,
ex.Message));
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, string.Empty);
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
"LogicalNetwork.config {0}",
configFileIOErrorValidationMessage));
} string logicalNetworkName = VSEMODLConstants.LOGICAL_NETWORK_NAME;
logicalNetworkName += VtnHostName;
var logicalNetwork = logicalNetworkConfig.LogicalNetworks.FirstOrDefault(logicalnw => logicalnw.Name.Equals(logicalNetworkName));
if (logicalNetwork == null) {
ODLVSEMETW.EventWriteGetFabricNetworkDefinitionError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"Logical network '{0}' not found.",
logicalNetworkName));
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
"Logical network definition '{0}' not found.",
logicalNetworkName));
}
Guid logicalNetworkId = logicalNetwork.Id;
Guid logicalNetworkDefinitionId = logicalNetwork.LogicalNetworkDefinitions.First().Id;
////for creation.
this.CompareVTNObjects(vtns, vMNetworkConfig, logicalNetworkId, logicalNetworkDefinitionId, txnMng, VtnHostName);
////for removal.
this.CompareVMNetworkObjects(vtns, vMNetworkConfig);
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.LastModifiedTimeStamp =
DateTime.Now;
}
/// <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;
}
/// <summary>
/// Create a new VM network with specified parameters using VTN on demand.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <param name="LogicalNetworkConfig">Config file of logical network.</param>
/// <param name="vMNetworkConfig">Config file of vm network.</param>
/// <param name="name">Name of VM Subnet to create.</param>
/// <param name="vMNetworkId">Id of VM network to create.</param>
/// <param name="maxNumberOfPorts">Maximum number of ports.</param>
/// <param name="ipSubnet">IP pools to use.</param>
/// <param name="logicalNetworkDefinitionId">ID of logical network definition
/// to associate with.</param>
/// <param name="conn">VSEM connection.</param>
/// <param name="vtnName">VTN name.</param>
/// <param name="vbrName">Vbridge name.</param>
/// <returns>VM network if successful, else null.</returns>
public VMSubnet CreateVMNetworkDefinitionforVtn(
TransactionManager txnMng,
LogicalNetworkConfig LogicalNetworkConfig,
VMNetworkConfig vMNetworkConfig,
string name,
Guid vMNetworkId,
long? maxNumberOfPorts,
IPSubnet[] ipSubnet,
Guid logicalNetworkDefinitionId,
VSEMConnection conn,
out string vtnName,
out string vbrName)
{
ODLVSEMETW.EventWriteCreateVMsubNetwork(MethodBase.GetCurrentMethod().Name,
"Creating VM SubNetwork.");
if (txnMng == null) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'txnMng' is null or invalid.");
throw new ArgumentException("The parameter 'txnMng' is null or invalid.");
}
if (LogicalNetworkConfig == null) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'LogicalNetworkConfig' is null or invalid.");
throw new ArgumentException(
"The parameter 'LogicalNetworkConfig' is null or invalid.");
}
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 (string.IsNullOrEmpty(name)) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'name' is null or invalid.");
throw new ArgumentException("The parameter 'name' is null or invalid.");
}
if (vMNetworkId == Guid.Empty) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vMNetworkId' is null or invalid.");
throw new ArgumentException("The parameter 'vMNetworkId' 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 (conn == null) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'conn' is null or invalid.");
throw new ArgumentException("The parameter 'conn' is null or invalid.");
}
string VtnHostName = this.ConnectionString;
if (VtnHostName.StartsWith(@"https://", StringComparison.Ordinal)) {
VtnHostName = VtnHostName.Substring(8);
}
VtnHostName = VtnHostName.Split('.', ':').First();
if (vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo == null) {
ODLVSEMETW.EventWriteProcessLibraryError(MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"VM network '{0}' not found.",
vMNetworkId.ToString("B")));
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"VM network '{0}' not found.",
vMNetworkId.ToString("B")));
}
var vmNetInfo =
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Where(
vmNw => vmNw.VMNetworkID == vMNetworkId).FirstOrDefault();
if (vmNetInfo == null) {
ODLVSEMETW.EventWriteProcessLibraryError(MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"VM network {0} not found.",
vMNetworkId.ToString("B")));
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"VM network '{0}' not found.",
vMNetworkId.ToString("B")));
}
vtnName = vmNetInfo.VTNName;
vbrName = this.CreateUniqueNameForVBridge(name, vmNetInfo.VTNName);
VLANIDMap vLANIDMap = new VLANIDMap(txnMng,
VtnHostName,
TransactionManager.OpenMode.ReadMode);
string vlanIdRange = vLANIDMap.GetVlanId(vmNetInfo.VMNetworkOriginalName, name);
if (string.IsNullOrEmpty(vlanIdRange)) {
ODLVSEMETW.EventWriteFoundNoVlanError(MethodBase.GetCurrentMethod().Name,
"No VLAN ID found.");
throw new ItemNotFoundException("No VLAN ID found.");
}
long vlanId = this.SelectVlanId(vlanIdRange,
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo);
if (vlanId == 0) {
ODLVSEMETW.EventWriteFoundNoUnusedVlanError(MethodBase.GetCurrentMethod().Name,
"No unused VLAN ID found.");
throw new ItemNotFoundException("No unused VLAN ID found.");
}
VMSubnet vmNetworkDef = CreateVbrVmNetworkDefinition(
vMNetworkId,
maxNumberOfPorts,
ipSubnet,
name,
logicalNetworkDefinitionId,
vbrName,
vlanId);
if (vmNetworkDef == null) {
ODLVSEMETW.EventWriteProcessFailedVMNetworkError(
MethodBase.GetCurrentMethod().Name,
"Failed to create VM Subnet.");
throw new InvalidOperationException("Failed to create VM Subnet.");
}
Vbridge vBridge = new Vbridge(this.ConnectionString, this.Credential);
ODLVSEMETW.EventWriteReturnODLLibrary("Return from ODL Library.", string.Empty);
Controller odl_ctr = new Controller(this.ConnectionString, this.Credential);
if (odl_ctr.Get_status(Constants.CTR_NAME)) {
vBridge.AddVbridge(vbrName, vmNetInfo.VTNName, vlanId);
ODLVSEMETW.EventWriteReturnODLLibrary("Return from ODL Library.", string.Empty);
} else {
ODLVSEMETW.EventWriteProcessFailedVMNetworkError(
MethodBase.GetCurrentMethod().Name,
"Failed to create VBR controller status is down.");
throw new InvalidOperationException("Failed to create VBR.");
}
var vmNet = vMNetworkConfig.VMNetwork.VmNetworks.Where(nwk =>
nwk.Id == vMNetworkId).FirstOrDefault();
Array.Resize(ref vmNet.VMSubnets, vmNet.VMSubnets.Length + 1);
vmNet.VMSubnets[vmNet.VMSubnets.Length - 1] = vmNetworkDef;
vmNetInfo.VMSubnetInfo.Add(new VMSubnetInfo {
VBridgeName = vbrName,
VMSubnetVlanId = vlanId,
VMSubnetID = vmNetworkDef.Id,
VMSubnetName = vmNetworkDef.Name,
CreatedFrom = "SCVMM",
VBridgeVlanId = vlanId
});
return vmNetworkDef;
}
/// <summary>
/// Create a new VM subnet with specified parameters using VTN on demand.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <param name="name">Name of VM Subnet to create.</param>
/// <param name="vMNetworkId">Id 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>
/// <param name="vbrName">Vbridge name.</param>
/// <returns>VM network if successful, else null.</returns>
public VMSubnet CreateVMNetworkDefinition(TransactionManager txnMng,
string name,
Guid vMNetworkId,
long? maxNumberOfPorts,
IPSubnet[] ipSubnets,
Guid logicalNetworkDefinitionId,
VSEMConnection connection,
out string vtnName,
out string vbrName)
{
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("\"name\":\"" + name + "\"");
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 'txnMng' is null or invalid.");
throw new ArgumentException("The parameter 'txnMng' is null or invalid.");
}
if (string.IsNullOrEmpty(name)) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'name' is null or invalid.");
throw new ArgumentException("The parameter 'name' is null or invalid.");
}
if (vMNetworkId == Guid.Empty) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vMNetworkId' is null or invalid.");
throw new ArgumentException("The parameter 'vMNetworkId' 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);
if (vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Count == 0) {
ODLVSEMETW.EventWriteConfigManagerFileIOError(MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"VMNetwork.config {0}",
configFileIOErrorValidationMessage));
throw new InvalidOperationException(
string.Format(CultureInfo.CurrentCulture,
"VMNetwork.config {0}",
configFileIOErrorValidationMessage));
}
var vmNw = vMNetworkConfig.VMNetwork.VmNetworks.FirstOrDefault(
nwk => nwk.Id == vMNetworkId);
if (vmNw == null) {
ODLVSEMETW.EventWriteGetFabricNetworkDefinitionError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"VM network '{0}' not found.",
vMNetworkId.ToString("B")));
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"VM network '{0}' not found. VTN corresponding to this VM network may have been deleted from ODL.\nRefer Network Object Mapping screen.",
vMNetworkId.ToString("B")));
}
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 logicalNwDef = LogicalNetworkConfig.LogicalNetworks.First().LogicalNetworkDefinitions.FirstOrDefault(
fabnw => fabnw.Id == logicalNetworkDefinitionId);
if (logicalNwDef == 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")));
}
string output = "\"logicalNwDef\":" + JavaScriptSerializer.Serialize(logicalNwDef);
if (!logicalNwDef.SupportsVMNetworkProvisioning) {
ODLVSEMETW.EventWriteSupportsVMNetworkProvisioningError(
"Logical does not support VM network creation.",
output);
throw new InvalidOperationException(
"Logical does not support VM network creation.");
}
VMNetworkInfo vmnetworkInfo = vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.First(vmn => vmn.VMNetworkID.CompareTo(vmNw.Id) == 0);
VSEMSynchronization vSEMSynchronization =
new VSEMSynchronization(this.ConnectionString, this.Credential);
Controller odl = new Controller(this.ConnectionString, this.Credential);
List<Vtn> vtns = odl.ReadVTNObjects(vmnetworkInfo.VTNName);
if (vtns.Count == 0) {
ODLVSEMETW.EventWriteValidateVMNetDefinitionError(
MethodBase.GetCurrentMethod().Name,
"Corresponding VTN is not found on ODL.");
throw new DataMisalignedException("Corresponding VTN is not found on ODL.\nRefresh the Odl configuration and then retry.");
}
VMSubnet nw = this.CreateVMNetworkDefinitionforVtn(txnMng,
LogicalNetworkConfig,
vMNetworkConfig,
name,
vMNetworkId,
maxNumberOfPorts,
ipSubnets,
logicalNetworkDefinitionId,
connection,
out vtnName,
out vbrName);
if (nw == null) {
ODLVSEMETW.EventWriteProcessFailedVMSubNetworkError(
MethodBase.GetCurrentMethod().Name,
"Failed to create VM Subnet.");
throw new InvalidOperationException("Failed to create VM Subnet.");
}
odl = new Controller(this.ConnectionString, this.Credential);
odl.UpdateStartupConfiguration();
ODLVSEMETW.EventWriteReturnODLLibrary("Return from ODL Library.", string.Empty);
string outputLib = "\"nw\":" + JavaScriptSerializer.Serialize(nw);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, outputLib);
return nw;
}
/// <summary>
/// Update the existing logical network.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <param name="logicalNetwork">Updated logical network.</param>
public void UpdateLogicalNetwork(TransactionManager txnMng, LogicalNetwork logicalNetwork)
{
var logicalNetworkConfig = new LogicalNetworkConfig(this.VtnHostName);
txnMng.SetConfigManager(logicalNetworkConfig, TransactionManager.OpenMode.WriteMode);
int target;
target = logicalNetworkConfig.ReplaceLogicalNetwork(logicalNetwork);
if (target == -1) {
ODLVSEMETW.EventWriteGetHNVLogicalNetworkNotFound(MethodBase.GetCurrentMethod().Name,
string.Format("LogicalNetwork name is {0}", logicalNetwork.Name));
}
}
/// <summary>
/// Create default LogicalNetwork and add to configuration.
/// </summary>
/// <param name="logicalNetworkConfig">FabricNetworkConfig instance.</param>
public void CreateHNVLogicalNetwork(LogicalNetworkConfig logicalNetworkConfig)
{
// Verify arguments.
if (logicalNetworkConfig == null) {
return;
}
if (logicalNetworkConfig.GetLogicalNetworkById(HNVODLConstants.LOGICAL_NETWORK.LOGICALNETWORK_ID) != null) {
// If exists, nothing to do.
return;
}
ODLVSEMETW.EventWriteGetHNVLogicalNetworkNotFound(MethodBase.GetCurrentMethod().Name,
string.Format("Create LogicalNetwork that Guid is {0}", HNVODLConstants.LOGICAL_NETWORK.LOGICALNETWORK_ID));
// Create LogicalNetwork instance.
var logicalNetwork = new LogicalNetwork() {
AreLogicalNetworkDefinitionsIsolated =
HNVODLConstants.LOGICAL_NETWORK.ARE_LOGICALNETWORK_DEFINITIONS_ISOLATED,
Description = HNVODLConstants.LOGICAL_NETWORK.DESCRIPTION,
Id = HNVODLConstants.LOGICAL_NETWORK.LOGICALNETWORK_ID,
LastModifiedTimeStamp = DateTime.Now,
LogicalNetworkDefinitions = new LogicalNetworkDefinition[1],
Name = string.Format(HNVODLConstants.LOGICAL_NETWORK.NAME, this.VtnHostName)
};
logicalNetwork.LogicalNetworkDefinitions[0] = this.CreateDefaultLogicalNetworkDefinition();
// Add created logical network to the configuration.
logicalNetworkConfig.LogicalNetworks.Add(logicalNetwork);
}
