/// <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);
}
/// <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>
/// 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>
/// 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);
}
