public void ShouldReturnOneVMSubnet()
{
const string subnet = "192.168.1.0/24";
const string vmNetworkName = "VNet01";
const string vmSubnetName = "VMSubnet01";
var mockChannel = new MockRequestChannel();
var vmSubnetToCreate = new VMSubnet()
{
Name = vmSubnetName,
VMNetworkName = vmNetworkName,
VMNetworkId = Guid.Empty,
Subnet = subnet,
StampId = Guid.Empty
};
mockChannel.AddReturnObject(vmSubnetToCreate);
var vmSubnetOperations = new VMSubnetOperations(new WebClientFactory(new Subscription(), mockChannel));
var readStaticIPAddressPool = vmSubnetOperations.Read(new VMNetwork()
{
StampId = Guid.Empty, ID = Guid.Empty
});
Assert.Equal(1, readStaticIPAddressPool.Count);
// Check the URI
var requestList = mockChannel.ClientRequests;
Assert.Equal(1, requestList.Count);
Assert.Equal(baseURI, mockChannel.ClientRequests[0].Item1.Address.AbsolutePath.Substring(1));
}
/// <summary>
/// Add the VMSubnet that corresponds the newly created vBridge on ODL.
/// </summary>
/// <param name="vmnetworkInfo">VM Network info.</param>
/// <param name="vbr">Newly created vBridge.</param>
/// <param name="vmnetwork">VM network that correspond the VTN in which vBridge is created.</param>
/// <param name="logicalNetworkDefinitionId">Logical network definition Id.</param>
private void AddVMSubnet(VMNetworkInfo vmnetworkInfo, Vbridge vbr, VMNetwork vmnetwork, Guid?logicalNetworkDefinitionId)
{
List <string> ipsubnets = new List <string>();
vmnetwork.VMSubnets.ToList().Where(item => item.Description.Contains("/")).ToList().ForEach(sub
=> sub.IPSubnets.ToList().ForEach(ipsub
=> ipsubnets.Add(ipsub.Subnet)));
string ipsubnet = this.CreateUniqueIPSubnet(ipsubnets);
VMSubnet vmsubnet = VSEMVMSubnetManagement.CreateVbrVmNetworkDefinition(vmnetworkInfo.VMNetworkID,
null,
new IPSubnet[] { new IPSubnet {
AddressFamily = AddressFamily.IPv4,
Subnet = ipsubnet,
Id = Guid.NewGuid(),
LastModifiedTimeStamp = DateTime.Now,
SupportsDHCP = true
} },
vbr.Name,
logicalNetworkDefinitionId,
vbr.Name,
vbr.VlanId);
vmsubnet.Description = vmsubnet.Description + " (" + ipsubnet + ")";
Array.Resize(ref vmnetwork.VMSubnets, vmnetwork.VMSubnets.Length + 1);
vmnetwork.VMSubnets[vmnetwork.VMSubnets.Length - 1] = vmsubnet;
vmnetworkInfo.VMSubnetInfo.Add(new VMSubnetInfo {
VBridgeName = vbr.Name,
VMSubnetVlanId = string.IsNullOrEmpty(vmnetworkInfo.VMNetworkName) ? 0 : vbr.VlanId,
VMSubnetID = vmsubnet.Id,
VMSubnetName = string.IsNullOrEmpty(vmnetworkInfo.VMNetworkName) ? string.Empty : vbr.Name,
CreatedFrom = "ODL",
VBridgeVlanId = vbr.VlanId
});
}
public override void ExecuteCmdlet()
{
var vmSubnet = new VMSubnet()
{
Name = this.Name,
VMNetworkName = this.VNet.Name,
VMNetworkId = this.VNet.ID,
Subnet = this.Subnet,
StampId = this.VNet.StampId,
};
Guid?jobId = Guid.Empty;
var vmSubnetOperations = new VMSubnetOperations(this.WebClientFactory);
var createdVMSubnet = vmSubnetOperations.Create(vmSubnet, out jobId);
WaitForJobCompletion(jobId);
var filter = new Dictionary <string, string>
{
{ "ID", createdVMSubnet.ID.ToString() },
{ "StampId ", createdVMSubnet.StampId.ToString() }
};
var results = vmSubnetOperations.Read(filter);
this.GenerateCmdletOutput(results);
}
public List <StaticIPAddressPool> Read(VMSubnet vmSubnet)
{
var filter = new Dictionary <string, string>
{
{ "StampId", vmSubnet.StampId.ToString() },
{ "VMSubnetId ", vmSubnet.ID.ToString() }
};
var resultList = Read(filter);
return(resultList);
}
public void ShouldCreateOneVMSubnet()
{
var mockChannel = new MockRequestChannel();
var vmSubnetToCreate = new VMSubnet()
{
Name = vmSubnetName,
VMNetworkName = vmNetworkName,
VMNetworkId = Guid.Empty,
Subnet = subnet,
StampId = Guid.Empty
};
var vmSubnetToReturn = new VMSubnet()
{
Name = vmSubnetName,
VMNetworkName = vmNetworkName,
VMNetworkId = Guid.Empty,
Subnet = subnet,
StampId = Guid.Empty
};
mockChannel.AddReturnObject(vmSubnetToReturn, new WebHeaderCollection {
"x-ms-request-id:" + Guid.NewGuid()
});
Guid?jobOut;
var vmSubnetOperations = new VMSubnetOperations(new WebClientFactory(new Subscription(), mockChannel));
var createdVMSubnet = vmSubnetOperations.Create(vmSubnetToCreate, out jobOut);
Assert.NotNull(createdVMSubnet);
Assert.True(createdVMSubnet is VMSubnet);
Assert.Equal(vmSubnetToReturn.Name, createdVMSubnet.Name);
Assert.Equal(vmSubnetToReturn.VMNetworkName, createdVMSubnet.VMNetworkName);
Assert.Equal(vmSubnetToReturn.VMNetworkId, createdVMSubnet.VMNetworkId);
Assert.Equal(vmSubnetToReturn.Subnet, createdVMSubnet.Subnet);
Assert.Equal(vmSubnetToReturn.StampId, createdVMSubnet.StampId);
var requestList = mockChannel.ClientRequests;
Assert.Equal(1, requestList.Count);
Assert.Equal(HttpMethod.Post.ToString(), requestList[0].Item1.Method);
// Check the URI
Assert.Equal(baseURI, mockChannel.ClientRequests[0].Item1.Address.AbsolutePath.Substring(1));
}
public void ShouldDeleteVMSubnet()
{
const string subnet = "192.168.1.0/24";
const string vmNetworkName = "VNet01";
const string vmSubnetName = "VMSubnet01";
var mockChannel = new MockRequestChannel();
var existingVMSubnet = new VMSubnet()
{
Name = vmSubnetName,
VMNetworkName = vmNetworkName,
VMNetworkId = Guid.Empty,
Subnet = subnet,
StampId = Guid.Empty
};
mockChannel.AddReturnObject(new Cloud()
{
StampId = Guid.NewGuid()
});
mockChannel.AddReturnObject(existingVMSubnet, new WebHeaderCollection {
"x-ms-request-id:" + Guid.NewGuid()
});
Guid?jobOut;
var vmSubnetOperations = new VMSubnetOperations(new WebClientFactory(new Subscription(), mockChannel));
vmSubnetOperations.Delete(Guid.Empty, out jobOut);
Assert.Equal(2, mockChannel.ClientRequests.Count);
Assert.Equal(HttpMethod.Delete.ToString(), mockChannel.ClientRequests[1].Item1.Method);
// Check the URI
var requestURI = mockChannel.ClientRequests[1].Item1.Address.AbsolutePath;
Assert.Equal("/Clouds", mockChannel.ClientRequests[0].Item1.Address.AbsolutePath.Substring(1));
Assert.Equal(baseURI, mockChannel.ClientRequests[1].Item1.Address.AbsolutePath.Substring(1).Remove(requestURI.IndexOf('(') - 1));
}
public static VMSubnet CreateVMSubnet(global::System.Guid stampId, global::System.Guid ID)
{
VMSubnet vMSubnet = new VMSubnet();
vMSubnet.StampId = stampId;
vMSubnet.ID = ID;
return vMSubnet;
}
/// <summary>
/// Create an IP Address Pool and add it to the specified VM Subnet.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <param name="name">Name of IP address pool.</param>
/// <param name="description">Description for IP address pool.</param>
/// <param name="subnet">IP address subnet.</param>
/// <param name="addressStart">Starting address for IP address pool.</param>
/// <param name="addressEnd">Ending address for IP address pool.</param>
/// <param name="gatewayInfo">Network gateway info.</param>
/// <param name="vmNetworkDefinitionId">VM Subnet ID.</param>
/// <returns>Newly created ip address pool.</returns>
public IPAddressPool CreateIpAddressPool(TransactionManager txnMng,
string name,
string description,
string subnet,
string addressStart,
string addressEnd,
NetworkGatewayInfo[] gatewayInfo,
Guid vmNetworkDefinitionId)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"txnMng\":" + JavaScriptSerializer.Serialize(txnMng));
json.Append(" \"gatewayInfo\":" + JavaScriptSerializer.Serialize(gatewayInfo));
json.Append("\"name\":\"" + name + "\"");
json.Append("\"description\":\"" + description + "\"");
json.Append("\"subnet\":\"" + subnet + "\"");
json.Append("\"addressStart\":\"" + addressStart + "\"");
json.Append("\"addressEnd\":\"" + addressEnd + "\"");
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 (string.IsNullOrEmpty(subnet))
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'subnet' is null or invalid.");
throw new ArgumentException("The parameter 'subnet' is null or invalid.");
}
if (string.IsNullOrEmpty(addressStart))
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'addressStart' is null or invalid.");
throw new ArgumentException("The parameter 'addressStart' is null or invalid.");
}
if (string.IsNullOrEmpty(addressEnd))
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'addressEnd' is null or invalid.");
throw new ArgumentException(
"The parameter 'addressEnd' 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));
}
VMSubnet vmNetDef = null;
foreach (var vmNet in vMNetworkConfig.VMNetwork.VmNetworks)
{
vmNetDef = vmNet.VMSubnets.FirstOrDefault(vmSubNet =>
vmSubNet.Id == vmNetworkDefinitionId);
if (vmNetDef != null)
{
break;
}
}
if (vmNetDef == null)
{
ODLVSEMETW.EventWriteValidateVMNetDefinitionError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"VM Subnet '{0}' not found.",
vmNetworkDefinitionId.ToString("B")));
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"VM Subnet '{0}' not found.",
vmNetworkDefinitionId.ToString("B")));
}
this.SyncVMSubnet(vmNetworkDefinitionId, vMNetworkConfig);
IPAddressPool poolAdd = null;
if (vmNetDef != null)
{
poolAdd = this.CreateIpAddressPool(name,
description,
subnet,
addressStart,
addressEnd,
gatewayInfo);
if (poolAdd != null)
{
AddressFamily addressFamily = AddressFamily.IPv4;
IPAddress address = null;
var parts = subnet.Split('/');
var parsingResult = IPAddress.TryParse(parts[0], out address);
if (parsingResult == false || address == null)
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'subnet' is null or invalid.");
throw new ArgumentException("The parameter 'subnet' is invalid.");
}
switch (address.AddressFamily)
{
case System.Net.Sockets.AddressFamily.InterNetwork:
addressFamily = AddressFamily.IPv4;
break;
case System.Net.Sockets.AddressFamily.InterNetworkV6:
addressFamily = AddressFamily.IPv6;
break;
default:
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'subnet' is null or invalid.");
throw new ArgumentException("The IP address family of subnet is invalid.");
}
IPSubnet ipsub = null;
if (vmNetDef.IPSubnets != null)
{
ipsub = vmNetDef.IPSubnets.FirstOrDefault(x => x.AddressFamily == addressFamily);
}
else
{
vmNetDef.IPSubnets = new IPSubnet[0];
}
if (ipsub == null)
{
IPSubnet ipSubnet = new IPSubnet();
ipSubnet.Id = Guid.NewGuid();
poolAdd.IPSubnetId = ipSubnet.Id;
ipSubnet.IPAddressPools = new IPAddressPool[] {
poolAdd
};
ipSubnet.AddressFamily = addressFamily;
ipSubnet.LastModifiedTimeStamp = DateTime.Now;
ipSubnet.Subnet = subnet;
ipSubnet.SupportsDHCP = true;
List <IPSubnet> subnets = vmNetDef.IPSubnets.ToList();
subnets.Add(ipSubnet);
vmNetDef.IPSubnets = subnets.ToArray();
}
else
{
List <IPAddressPool> pools = ipsub.IPAddressPools.ToList();
pools.Add(poolAdd);
poolAdd.IPSubnetId = ipsub.Id;
ipsub.IPAddressPools = pools.ToArray();
ipsub.LastModifiedTimeStamp = DateTime.Now;
}
vmNetDef.LastModifiedTimeStamp = DateTime.Now;
string error = Validations.IsIPSubnetListValid(
vmNetDef.IPSubnets.ToList(), poolAdd.Id);
if (!string.IsNullOrEmpty(error))
{
ODLVSEMETW.EventWriteValidateVMNetDefinitionError(
MethodBase.GetCurrentMethod().Name,
error);
throw new ArgumentException(error);
}
}
}
return(poolAdd);
}
/// <summary>
/// Update the specified IP Address Pool with the specified info.
/// </summary>
/// <param name="txnMng">Transaction manager.</param>
/// <param name="name">Name of IP Address Pool.</param>
/// <param name="description">Description for IP address Pool.</param>
/// <param name="subnet">IP address subnet.</param>
/// <param name="addressStart">Starting address for IP Address Pool.</param>
/// <param name="addressEnd">Ending address for IP Address Pool.</param>
/// <param name="gatewayInfo">Network gateway info.</param>
/// <param name="conn">VSEM connection object.</param>
/// <param name="ipAddressPoolId">IP address pool.</param>
/// <returns>Updated IP address pool.</returns>
public IPAddressPool UpdateIpAddressPool(TransactionManager txnMng,
string name,
string description,
string subnet,
string addressStart,
string addressEnd,
NetworkGatewayInfo[] gatewayInfo,
VSEMConnection conn,
Guid ipAddressPoolId)
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"txnMng\":" + JavaScriptSerializer.Serialize(txnMng));
json.Append(" \"gatewayInfo\":" + JavaScriptSerializer.Serialize(gatewayInfo));
json.Append("\"name\":\"" + name + "\"");
json.Append("\"description\":\"" + description + "\"");
json.Append("\"subnet\":\"" + subnet + "\"");
json.Append("\"addressStart\":\"" + addressStart + "\"");
json.Append("\"addressEnd\":\"" + addressEnd + "\"");
json.Append("\"ipAddressPoolId\":\"" + ipAddressPoolId + "\"");
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 (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.");
}
if (name != null)
{
if (string.IsNullOrWhiteSpace(name))
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'name' is invalid.");
throw new ArgumentException(
"The parameter 'name' is 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));
}
VMSubnet vmNetDefFrom = null;
IPAddressPool pool = null;
foreach (var vmNet in vMNetworkConfig.VMNetwork.VmNetworks)
{
foreach (var vmNetDef in vmNet.VMSubnets)
{
if (vmNetDef.IPSubnets != null)
{
foreach (var ipsunet in vmNetDef.IPSubnets)
{
pool = ipsunet.IPAddressPools.FirstOrDefault(p => p.Id == ipAddressPoolId);
if (pool != null)
{
vmNetDefFrom = vmNetDef;
break;
}
}
}
if (vmNetDefFrom != null)
{
break;
}
}
if (vmNetDefFrom != null)
{
break;
}
}
if (vmNetDefFrom == null)
{
ODLVSEMETW.EventWriteValidateIPAddressPoolError(
MethodBase.GetCurrentMethod().Name,
string.Format(CultureInfo.CurrentCulture,
"IP Address Pool '{0}' not found.",
ipAddressPoolId));
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
"IP Address Pool '{0}' not found.",
ipAddressPoolId));
}
this.SyncVMSubnet(vmNetDefFrom.Id, vMNetworkConfig);
if (pool != null)
{
// Update the IP Address Pool
if (name != null)
{
pool.Name = name;
}
if (description != null)
{
pool.Description = description;
}
if (subnet != null)
{
pool.IPAddressSubnet = subnet;
}
if (addressStart != null)
{
pool.AddressRangeStart = addressStart;
}
if (addressEnd != null)
{
pool.AddressRangeEnd = addressEnd;
}
if (gatewayInfo != null)
{
pool.NetworkGateways = gatewayInfo;
}
string error = Validations.IsIPSubnetListValid(
vmNetDefFrom.IPSubnets.ToList(),
ipAddressPoolId);
if (!string.IsNullOrEmpty(error))
{
ODLVSEMETW.EventWriteValidateVMNetDefinitionError(
MethodBase.GetCurrentMethod().Name,
error);
throw new ArgumentException(error);
}
}
string output = "\"pool\":" + JavaScriptSerializer.Serialize(pool);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name, output);
return(pool);
}
/// <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 VM Subnet for the specified vBridge.
/// </summary>
/// <param name="vmNetworkId">Id of VM network this definition belongs to.</param>
/// <param name="maxNumberOfPorts">Max number of ports.</param>
/// <param name="ipSubnet">IP address pool to use.</param>
/// <param name="name">Name for VM Subnet. If null, use the vBridge name.
/// </param>
/// <param name="logicalNetworkDefinitionId">Logical network definition ID to use.</param>
/// <param name="vbrName">Vbridge name to use.</param>
/// <param name="vlanId">Vlan ID to use.</param>
/// <returns>VM Subnet.</returns>
public static VMSubnet CreateVbrVmNetworkDefinition(Guid vmNetworkId,
long? maxNumberOfPorts,
IPSubnet[] ipSubnet,
string name,
Guid? logicalNetworkDefinitionId,
string vbrName,
long vlanId)
{
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 (string.IsNullOrEmpty(vbrName)) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vbrName' is null or invalid.");
throw new ArgumentException("The parameter 'vbrName' is null or invalid.");
}
VMSubnet def = new VMSubnet();
def.Id = Guid.NewGuid();
def.Name = name;
ODLVSEMETW.EventWriteValidateCreateVmNetworkDefinitionForvBr(
MethodBase.GetCurrentMethod().Name,
"VM Subnet for vBridge.");
def.Description = string.Format(CultureInfo.CurrentCulture,
"VM Subnet for vBridge {0}",
vbrName);
def.LogicalNetworkDefinitionId = logicalNetworkDefinitionId;
def.VMNetworkId = vmNetworkId;
def.AllowsIntraPortCommunication = true;
def.IsolationType = NetworkDefinitionIsolationType.Vlan;
if (ipSubnet != null) {
for (int cntr = 0; cntr < ipSubnet.Count(); cntr++) {
if (ipSubnet[cntr].Id == Guid.Empty && !string.IsNullOrEmpty(ipSubnet[cntr].Subnet)) {
ipSubnet[cntr].Id = Guid.NewGuid();
ipSubnet[cntr].LastModifiedTimeStamp = DateTime.Now;
}
if (ipSubnet[cntr].IPAddressPools == null) {
ipSubnet[cntr].IPAddressPools = new IPAddressPool[0];
}
}
def.IPSubnets = ipSubnet;
string error = Validations.IsIPSubnetListValid(
def.IPSubnets.ToList(), Guid.Empty);
if (!string.IsNullOrEmpty(error)) {
ODLVSEMETW.EventWriteValidateVMNetDefinitionError(
MethodBase.GetCurrentMethod().Name,
error);
throw new ArgumentException(error);
}
}
def.SegmentId = new NetworkSegmentIdentifier();
def.SegmentId.PrimarySegmentIdentifier = Convert.ToUInt32(vlanId);
def.LastModifiedTimeStamp = DateTime.Now;
def.MaxNumberOfPorts = maxNumberOfPorts;
return def;
}
/// <summary>
/// This function is responsible for creating a VM Subnet.
/// </summary>
protected override void DoODLVSEMCmdlet()
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder(" \"IPSubnets\":" + JavaScriptSerializer.Serialize(this.IPSubnets));
json.Append("\"MaxNumberOfPorts\":\"" + this.MaxNumberOfPorts + "\"");
json.Append("\"Name\":\"" + this.Name + "\"");
json.Append("\"VMNetworkId\":\"" + this.VMNetworkId + "\"");
json.Append("\"LogicalNetworkDefinitionId\":\"" + this.LogicalNetworkDefinitionId + "\"");
ODLVSEMETW.EventWriteDoCmdlet(this.CmdletName,
"Creating VM Subnet.",
json.ToString());
TransactionManager txnMng = new TransactionManager();
txnMng.StartTransaction();
var ope = TransactionManager.Operation.None;
string vtnName = string.Empty;
string vbrName = string.Empty;
VMSubnet nw = null;
string connectionString =
this.conn.ConnectionString.Split(',').FirstOrDefault();
VSEMVMSubnetManagement vSEMVMSubnetManagement =
new VSEMVMSubnetManagement(connectionString,
this.conn.Credential);
try {
nw = vSEMVMSubnetManagement.CreateVMNetworkDefinition(txnMng,
this.Name,
this.VMNetworkId,
this.MaxNumberOfPorts,
this.IPSubnets,
this.LogicalNetworkDefinitionId,
this.conn,
out vtnName,
out vbrName);
ODLVSEMETW.EventWriteReturnLibrary("VM Subnet is created.",
string.Empty);
ope = TransactionManager.Operation.Commit;
}
catch (Exception ex) {
Exception userException = ex;
ODLVSEMETW.EventWriteFailedCmdlet(
"VM Subnet creation is failed. ODL changes rollback is started.",
string.Empty);
ope = TransactionManager.Operation.Rollback;
try {
if (!string.IsNullOrEmpty(vtnName) && !string.IsNullOrEmpty(vbrName))
{
vSEMVMSubnetManagement.RemoveVmNetworkDefinition(
vtnName, vbrName);
ODLVSEMETW.EventWriteFailedCmdlet(
"VM Subnet creation is failed. ODL changes are successfully rolled back.",
string.Empty);
}
} catch (Exception excep) {
// VM Network Creation Process is terminated in the middle of the request. VTN
ODLVSEMETW.EventWriteFailedCmdlet(
string.Format(
CultureInfo.CurrentCulture,
"Due to some problem in connection with ODL, VSEM VM Subnet creation process terminated in the middle of the request. vBridge '{0}' may have been created on ODL, Please check. If inconsistency is created, Please delete the vBridge from ODL to maintain the consistency between ODL and SCVMM.\n{1}",
vbrName,
excep.Message),
string.Empty);
userException = new System.Net.WebException(string.Format(
CultureInfo.CurrentCulture,
"Due to some problem in connection with ODL, VSEM VM Subnet creation process terminated in the middle of the request. vBridge '{0}' may have been created on ODL, Please check. If inconsistency is created, Please delete the vBridge from ODL to maintain the consistency between ODL and SCVMM.",
vbrName),
ex);
}
Exception exception = VSEMODLExceptionUtil.ConvertExceptionToVSEMException(userException);
ODLVSEMETW.EventWriteFailedCmdlet(this.CmdletName, exception.GetType() + " : " + ex.Message);
throw exception;
} finally {
txnMng.EndTransaction(ope);
string output = "\"VMSubnet\":" + JavaScriptSerializer.Serialize(nw);
ODLVSEMETW.EventWriteEndCmdlet(this.CmdletName, output);
this.WriteObject(nw);
}
}
