public override void ExecuteCmdlet()
{
IEnumerable <VMNetwork> results = null;
var vmNetworkOperations = new VMNetworkOperations(this.WebClientFactory);
if (this.ParameterSetName == WAPackCmdletParameterSets.Empty)
{
results = vmNetworkOperations.Read();
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromId)
{
VMNetwork vmNetwork = null;
vmNetwork = vmNetworkOperations.Read(ID);
results = new List <VMNetwork>()
{
vmNetwork
};
}
else if (this.ParameterSetName == WAPackCmdletParameterSets.FromName)
{
results = vmNetworkOperations.Read(new Dictionary <string, string>()
{
{ "Name", Name }
});
}
this.GenerateCmdletOutput(results);
}
public void ShouldReturnOneVMNetworkByID()
{
var mockChannel = new MockRequestChannel();
var vmNetworkToReturn = new VMNetwork()
{
Name = vNetName,
Description = vNetDescription,
LogicalNetworkId = Guid.Empty,
StampId = Guid.Empty,
};
mockChannel.AddReturnObject(vmNetworkToReturn);
var VMNetworkOperations = new VMNetworkOperations(new WebClientFactory(new Subscription(), mockChannel));
var readVMNetwork = VMNetworkOperations.Read(Guid.Empty);
Assert.Equal(Guid.Empty, readVMNetwork.ID);
// 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 void ShouldReturnOneVMNetworkByName()
{
var mockChannel = new MockRequestChannel();
var vmNetworkToReturn = new VMNetwork()
{
Name = vNetName,
Description = vNetDescription,
LogicalNetworkId = Guid.Empty,
StampId = Guid.Empty,
};
mockChannel.AddReturnObject(vmNetworkToReturn);
var filter = new Dictionary <string, string>()
{
{ "Name", vNetName }
};
var VMNetworkOperations = new VMNetworkOperations(new WebClientFactory(new Subscription(), mockChannel));
var readVMNetwork = VMNetworkOperations.Read(filter);
Assert.AreEqual(1, readVMNetwork.Count);
Assert.AreEqual(vNetName, readVMNetwork.First().Name);
// Check the URI
var requestList = mockChannel.ClientRequests;
Assert.AreEqual(1, requestList.Count);
Assert.AreEqual(baseURI, mockChannel.ClientRequests[0].Item1.Address.AbsolutePath.Substring(1));
}
public void ShouldDeleteStaticVMNetwork()
{
var mockChannel = new MockRequestChannel();
var existingVmNetwork = new VMNetwork()
{
Name = vNetName,
Description = vNetDescription,
LogicalNetworkId = Guid.Empty,
StampId = Guid.Empty,
};
mockChannel.AddReturnObject(new Cloud()
{
StampId = Guid.NewGuid()
});
mockChannel.AddReturnObject(existingVmNetwork, new WebHeaderCollection {
"x-ms-request-id:" + Guid.NewGuid()
});
Guid?jobOut;
var VMNetworkOperations = new VMNetworkOperations(new WebClientFactory(new Subscription(), mockChannel));
VMNetworkOperations.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));
}
/// <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 function is responsible for creating a VM Network
/// with one VM Subnet on the VSEM.
/// </summary>
protected override void DoODLVSEMCmdlet()
{
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder(" \"VMNetwork\":" + JavaScriptSerializer.Serialize(this.VMNetwork));
json.Append(" \"OperationType\":" + JavaScriptSerializer.Serialize(this.OperationType));
ODLVSEMETW.EventWriteDoCmdlet(this.CmdletName,
"VM Network creation process started.",
json.ToString());
// If VMNetwork is HNV resource, return immediately.
var mgmt = new HNVVMNetworkManagement(this.conn.GetVtnHostName());
if (mgmt.IsHNVVMNetwork(this.VMNetwork) == true)
{
return;
}
TransactionManager txnMng = new TransactionManager();
txnMng.StartTransaction();
var ope = TransactionManager.Operation.None;
VMNetwork nw = null;
string connectionString =
this.conn.ConnectionString.Split(',').FirstOrDefault();
VSEMSynchronization vSEMSynchronization =
new VSEMSynchronization(connectionString, this.conn.Credential);
try {
bool needRefresh = vSEMSynchronization.PublishVMNetwork(txnMng,
this.VMNetwork,
this.OperationType,
this.conn);
ODLVSEMETW.EventWriteReturnLibrary("VM network is updated.",
string.Empty);
if (needRefresh)
{
this.conn.RefreshConnection();
}
ope = TransactionManager.Operation.Commit;
} catch (Exception ex) {
Exception exception = VSEMODLExceptionUtil.ConvertExceptionToVSEMException(ex);
ODLVSEMETW.EventWriteFailedCmdlet(this.CmdletName, exception.GetType() + " : " + ex.Message);
ope = TransactionManager.Operation.Rollback;
throw exception;
} finally {
txnMng.EndTransaction(ope);
string output = "\"VM Network\":" + JavaScriptSerializer.Serialize(nw);
ODLVSEMETW.EventWriteEndCmdlet(this.CmdletName, output);
this.WriteObject(this.VMNetwork);
}
}
public List <VMSubnet> Read(VMNetwork vmNetwork)
{
var filter = new Dictionary <string, string>
{
{ "StampId", vmNetwork.StampId.ToString() },
{ "VMNetworkId ", vmNetwork.ID.ToString() }
};
var resultList = Read(filter);
return(resultList);
}
public void ShouldCreateOneVMNetwork()
{
Guid VNetLogicalNetworkId = Guid.NewGuid();
Guid StampId = Guid.NewGuid();
var mockChannel = new MockRequestChannel();
var vmNetworkToCreate = new VMNetwork()
{
Name = vNetName,
Description = vNetDescription,
LogicalNetworkId = VNetLogicalNetworkId,
StampId = StampId,
};
var vmNetworkToReturn = new VMNetwork()
{
Name = vNetName,
Description = vNetDescription,
LogicalNetworkId = VNetLogicalNetworkId,
StampId = StampId,
};
mockChannel.AddReturnObject(vmNetworkToReturn, new WebHeaderCollection {
"x-ms-request-id:" + Guid.NewGuid()
});
Guid?jobOut;
var VMNetworkOperations = new VMNetworkOperations(new WebClientFactory(new Subscription(), mockChannel));
var createdVMNetwork = VMNetworkOperations.Create(vmNetworkToCreate, out jobOut);
Assert.IsNotNull(createdVMNetwork);
Assert.IsInstanceOfType(createdVMNetwork, typeof(VMNetwork));
Assert.AreEqual(vmNetworkToReturn.Name, vmNetworkToCreate.Name);
Assert.AreEqual(vmNetworkToReturn.Description, vmNetworkToCreate.Description);
Assert.AreEqual(vmNetworkToReturn.LogicalNetworkId, vmNetworkToCreate.LogicalNetworkId);
Assert.AreEqual(vmNetworkToReturn.StampId, vmNetworkToCreate.StampId);
var requestList = mockChannel.ClientRequests;
Assert.AreEqual(1, requestList.Count);
Assert.AreEqual(HttpMethod.Post.ToString(), requestList[0].Item1.Method);
// Check the URI
Assert.AreEqual(baseURI, mockChannel.ClientRequests[0].Item1.Address.AbsolutePath.Substring(1));
}
/// <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>
/// <param name="logicalNetworkId">Logical network ID.</param>
/// <param name="logicalNetworkDefinitionId">Logical network definition ID.</param>
/// <param name="txnMng">Transaction manager instance.</param>
/// <param name="VtnHostName">Host name of the VTNCoordinator.</param>
private void CompareVTNObjects(List <Vtn> vtns, VMNetworkConfig vMNetworkConfig, Guid logicalNetworkId, Guid?logicalNetworkDefinitionId, TransactionManager txnMng, string VtnHostName)
{
var vmnetworks = vMNetworkConfig.VMNetwork;
foreach (Vtn vtn in vtns)
{
var vmnetworkInfo = vmnetworks.VMNetworkMappingInformation.VMNetworkInfo.FirstOrDefault(vmnet => vmnet.VTNName.Equals(vtn.Name));
if (vmnetworkInfo != null)
{
VMNetwork vmnetwork = vmnetworks.VmNetworks.FirstOrDefault(vmn => vmn.Id == vmnetworkInfo.VMNetworkID);
this.SyncVTN(logicalNetworkDefinitionId, vmnetwork, vtn, vmnetworkInfo, txnMng, VtnHostName);
}
else
{
VMNetwork vMNetwork = VSEMVMNetworkManagement.CreateVtnVmNetwork(vtn.Name);
vMNetwork.LogicalNetwork = logicalNetworkId;
vMNetworkConfig.VMNetwork.VmNetworks.Add(vMNetwork);
if (vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo == null)
{
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo =
new List <VMNetworkInfo>();
}
var vmnetInfo = new VMNetworkInfo {
VMNetworkID = vMNetwork.Id,
VMNetworkName = string.Empty,
VTNName = vtn.Name,
VMSubnetInfo = new List <VMSubnetInfo>(),
CreatedFrom = "ODL",
Description = "VM Network corresponding to this VTN is not created on SCVMM",
VMNetworkOriginalName = vMNetwork.Name
};
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Add(
vmnetInfo);
foreach (Vbridge vbr in vtn.Vbridges)
{
this.AddVMSubnet(vmnetInfo, vbr, vMNetwork, logicalNetworkDefinitionId);
}
////--------VTN is added on ODL
}
}
}
/// <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>
/// Create vm network.
/// </summary>
/// <param name="name">Vm network name.</param>
/// <returns>Vm network.</returns>
public static VMNetwork CreateVtnVmNetwork(string name)
{
ODLVSEMETW.EventWriteCreateVtnVMNetwork(MethodBase.GetCurrentMethod().Name,
"Creating VMNetwork.");
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.");
}
VMNetwork vmNet = new VMNetwork();
vmNet.Id = Guid.NewGuid();
vmNet.Name = name;
vmNet.VMSubnets = new VMSubnet[0];
vmNet.LastModifiedTimeStamp = DateTime.Now;
vmNet.ManagedByNetworkServiceId = VSEMODLConstants.SYSTEM_INFO_ID;
return(vmNet);
}
public override void ExecuteCmdlet()
{
var vmNetwork = new VMNetwork()
{
Name = this.Name,
Description = this.Description,
LogicalNetworkId = this.LogicalNetwork.ID,
StampId = this.LogicalNetwork.StampId,
};
Guid?jobId = Guid.Empty;
var vmNetworkOperations = new VMNetworkOperations(this.WebClientFactory);
var createdVmNetwork = vmNetworkOperations.Create(vmNetwork, out jobId);
WaitForJobCompletion(jobId);
createdVmNetwork = vmNetworkOperations.Read(createdVmNetwork.ID);
var results = new List <VMNetwork>()
{
createdVmNetwork
};
this.GenerateCmdletOutput(results);
}
/// <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>
/// Publish VM Network.
/// </summary>
/// <param name="txnMng">TransactionManager instance.</param>
/// <param name="vMNetwork">VM Network.</param>
/// <param name="operationType">Operation type performed on SCVMM.</param>
/// <param name="connection">Connection object.</param>
/// <returns>Boolean indicating whether network service refresh is needed..</returns>
public bool PublishVMNetwork(TransactionManager txnMng,
VMNetwork vMNetwork,
NetworkEntityPublishType operationType,
VSEMConnection connection)
{
bool needRefresh = false;
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"txnMng\":" + JavaScriptSerializer.Serialize(txnMng));
json.Append(" \"vMNetwork\":" + JavaScriptSerializer.Serialize(vMNetwork));
json.Append(" \"operationType\":" + JavaScriptSerializer.Serialize(operationType));
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 (vMNetwork == null)
{
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vMNetwork' is null or invalid.");
throw new ArgumentException("The parameter 'vMNetworkName' 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 vmnetworkFound = vMNetworkConfig.VMNetwork.VmNetworks.FirstOrDefault(
nw => nw.Id == vMNetwork.Id);
var vmnetworkMappigInfoFound = vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.FirstOrDefault(
nw => nw.VMNetworkID == vMNetwork.Id);
if (vmnetworkMappigInfoFound == null)
{
return(needRefresh);
}
if (operationType != NetworkEntityPublishType.Delete)
{
vmnetworkMappigInfoFound.VMNetworkName = vMNetwork.Name;
if (vmnetworkMappigInfoFound.VTNName.CompareTo(string.Empty) == 0)
{
return(needRefresh);
}
vmnetworkFound.OwnerName = vMNetwork.OwnerName;
vmnetworkFound.RoutingDomainId = vMNetwork.RoutingDomainId;
if (operationType == NetworkEntityPublishType.Create)
{
foreach (var subnetinfo in vmnetworkMappigInfoFound.VMSubnetInfo)
{
subnetinfo.VMSubnetName = subnetinfo.VBridgeName;
subnetinfo.VMSubnetVlanId = subnetinfo.VBridgeVlanId;
}
Controller odl = new Controller(this.ConnectionString, this.Credential);
List <Vtn> vtns = odl.ReadVTNObjects(vmnetworkMappigInfoFound.VTNName);
if (vtns.Count == 0)
{
needRefresh = true;
vMNetworkConfig.VMNetwork.VmNetworks.Remove(vmnetworkFound);
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Remove(vmnetworkMappigInfoFound);
}
if (vtns.Count != 0)
{
needRefresh = this.SyncVTN(vmnetworkFound.VMSubnets.First().LogicalNetworkDefinitionId,
vmnetworkFound,
vtns.First(),
vmnetworkMappigInfoFound,
txnMng,
VtnHostName);
}
}
vmnetworkMappigInfoFound.Description = string.Empty;
}
else
{
if (vmnetworkMappigInfoFound.VTNName.CompareTo(string.Empty) == 0)
{
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Remove(vmnetworkMappigInfoFound);
return(needRefresh);
}
vmnetworkMappigInfoFound.VMNetworkName = string.Empty;
vmnetworkMappigInfoFound.VMSubnetInfo.ForEach(subnet => { subnet.VMSubnetName = string.Empty; subnet.VMSubnetVlanId = 0; });
vmnetworkMappigInfoFound.Description = "VM Network corresponding to this VTN is not created on SCVMM";
vmnetworkFound.Name = vmnetworkMappigInfoFound.VTNName;
vmnetworkFound.RoutingDomainId = null;
vmnetworkFound.OwnerName = string.Empty;
}
string output = "\"VMNetwork\":" + JavaScriptSerializer.Serialize(vmnetworkFound);
string outputMappingInfo = "\"VMNetworkInfo\":" + JavaScriptSerializer.Serialize(vmnetworkMappigInfoFound);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name,
output);
return(needRefresh);
}
/// <summary>
/// Remove the VMSubnet corresponding to the removed vBridge from ODL.
/// </summary>
/// <param name="vMNetworkConfig">VMNetwork.config file instance.</param>
/// <param name="vmSubnetId">Id of the VMSubnet.</param>
/// <param name="vmnetwork">Parent VM Network.</param>
/// <param name="vmnetworkInfo">Corresponding VM netrok info.</param>
public static void RemoveVMSubnetSync(VMNetworkConfig vMNetworkConfig, Guid vmSubnetId, VMNetwork vmnetwork, VMNetworkInfo vmnetworkInfo)
{
if (vMNetworkConfig == null && (vmnetwork == null || vmnetworkInfo == 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 (vmnetwork == null)
{
vmnetwork = vMNetworkConfig.VMNetwork.VmNetworks.FirstOrDefault(net => net.VMSubnets.Any(vms => vms.Id.CompareTo(vmSubnetId) == 0));
}
if (vmnetwork != null)
{
var temp = vmnetwork.VMSubnets.ToList();
temp.RemoveAll(net => net.Id.CompareTo(vmSubnetId) == 0);
vmnetwork.VMSubnets = temp.ToArray();
if (vmnetworkInfo == null)
{
vmnetworkInfo = vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.FirstOrDefault(vmn => vmn.VMNetworkID.CompareTo(vmnetwork.Id) == 0);
}
vmnetworkInfo.VMSubnetInfo.ForEach(vms => {
if (vms.VMSubnetID.CompareTo(vmSubnetId) == 0)
{
vms.Description = "Corresponding vBridge is deleted on ODL.";
vms.VBridgeName = string.Empty;
vms.VBridgeVlanId = 0;
}
});
}
}
/// <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);
}
public static VMNetwork CreateVMNetwork(global::System.Guid stampId, global::System.Guid ID, global::System.Collections.ObjectModel.ObservableCollection<UserAndRole> grantedToList)
{
VMNetwork vMNetwork = new VMNetwork();
vMNetwork.StampId = stampId;
vMNetwork.ID = ID;
if ((grantedToList == null))
{
throw new global::System.ArgumentNullException("grantedToList");
}
vMNetwork.GrantedToList = grantedToList;
return vMNetwork;
}
/// <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
});
}
/// <summary>
/// This function is responsible for creating a VM Network
/// with one VM Subnet on the VSEM.
/// </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("\"VMSubnetName\":\"" + this.VMSubnetName + "\"");
json.Append("\"VMNetworkName\":\"" + this.VMNetworkName + "\"");
json.Append("\"LogicalNetworkDefinitionId\":\"" + this.LogicalNetworkDefinitionId + "\"");
ODLVSEMETW.EventWriteDoCmdlet(this.CmdletName,
"VM Network creation process started.",
json.ToString());
TransactionManager txnMng = new TransactionManager();
txnMng.StartTransaction();
var ope = TransactionManager.Operation.None;
VMNetwork nw = null;
string vtnName = string.Empty;
string connectionString =
this.conn.ConnectionString.Split(',').FirstOrDefault();
VSEMVMNetworkManagement vSEMVmNetworkManagement =
new VSEMVMNetworkManagement(connectionString, this.conn.Credential);
try {
nw = vSEMVmNetworkManagement.CreateVMNetwork(txnMng,
this.VMSubnetName,
this.VMNetworkName,
this.MaxNumberOfPorts,
this.IPSubnets,
this.LogicalNetworkDefinitionId,
this.conn,
out vtnName);
ODLVSEMETW.EventWriteReturnLibrary("VM network is created.",
string.Empty);
ope = TransactionManager.Operation.Commit;
} catch (Exception ex) {
Exception userException = ex;
ODLVSEMETW.EventWriteFailedCmdlet(
"VM network creation is failed. ODL changes rollback is started.",
string.Empty);
ope = TransactionManager.Operation.Rollback;
try {
if (!string.IsNullOrEmpty(vtnName))
{
vSEMVmNetworkManagement.RemoveVmNetwork(vtnName);
ODLVSEMETW.EventWriteFailedCmdlet(
"VM network creation is failed. ODL changes are successfully rolled back.",
string.Empty);
}
} catch (Exception except) {
ODLVSEMETW.EventWriteFailedCmdlet(
string.Format(CultureInfo.CurrentCulture,
"Due to some problem in connection with ODL, VSEM VM Network creation process is terminated in the middle of the request. VTN '{0}' may have been created on ODL, Please check. Please delete the VTN from ODL to maintain the consistency between ODL and SCVMM.\n{1}",
vtnName,
except.Message),
string.Empty);
userException =
new System.Net.WebException(string.Format(CultureInfo.CurrentCulture,
"Due to some problem in connection with ODL, VSEM VM Network creation process is terminated in the middle of the request. VTN '{0}' may have been created on ODL, Please check. Please delete the VTN from ODL to maintain the consistency between ODL and SCVMM.",
vtnName),
ex);
}
Exception exception = VSEMODLExceptionUtil.ConvertExceptionToVSEMException(userException);
ODLVSEMETW.EventWriteFailedCmdlet(this.CmdletName, exception.GetType() + " : " + ex.Message);
ope = TransactionManager.Operation.Rollback;
throw exception;
} finally {
txnMng.EndTransaction(ope);
string output = "\"VM Network\":" + JavaScriptSerializer.Serialize(nw);
ODLVSEMETW.EventWriteEndCmdlet(this.CmdletName, output);
this.WriteObject(nw);
}
}
/// <summary>
/// Publish VM Network.
/// </summary>
/// <param name="txnMng">TransactionManager instance.</param>
/// <param name="vMNetwork">VM Network.</param>
/// <param name="operationType">Operation type performed on SCVMM.</param>
/// <param name="connection">Connection object.</param>
/// <returns>Boolean indicating whether network service refresh is needed..</returns>
public bool PublishVMNetwork(TransactionManager txnMng,
VMNetwork vMNetwork,
NetworkEntityPublishType operationType,
VSEMConnection connection)
{
bool needRefresh = false;
var JavaScriptSerializer = new JavaScriptSerializer();
JavaScriptSerializer.MaxJsonLength = int.MaxValue;
StringBuilder json = new StringBuilder("\"txnMng\":" + JavaScriptSerializer.Serialize(txnMng));
json.Append(" \"vMNetwork\":" + JavaScriptSerializer.Serialize(vMNetwork));
json.Append(" \"operationType\":" + JavaScriptSerializer.Serialize(operationType));
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 (vMNetwork == null) {
ODLVSEMETW.EventWriteArgumentError(
MethodBase.GetCurrentMethod().DeclaringType.Name.ToString(),
MethodBase.GetCurrentMethod().Name,
"The parameter 'vMNetwork' is null or invalid.");
throw new ArgumentException("The parameter 'vMNetworkName' 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 vmnetworkFound = vMNetworkConfig.VMNetwork.VmNetworks.FirstOrDefault(
nw => nw.Id == vMNetwork.Id);
var vmnetworkMappigInfoFound = vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.FirstOrDefault(
nw => nw.VMNetworkID == vMNetwork.Id);
if (vmnetworkMappigInfoFound == null) {
return needRefresh;
}
if (operationType != NetworkEntityPublishType.Delete) {
vmnetworkMappigInfoFound.VMNetworkName = vMNetwork.Name;
if (vmnetworkMappigInfoFound.VTNName.CompareTo(string.Empty) == 0) {
return needRefresh;
}
vmnetworkFound.OwnerName = vMNetwork.OwnerName;
vmnetworkFound.RoutingDomainId = vMNetwork.RoutingDomainId;
if (operationType == NetworkEntityPublishType.Create) {
foreach (var subnetinfo in vmnetworkMappigInfoFound.VMSubnetInfo) {
subnetinfo.VMSubnetName = subnetinfo.VBridgeName;
subnetinfo.VMSubnetVlanId = subnetinfo.VBridgeVlanId;
}
Controller odl = new Controller(this.ConnectionString, this.Credential);
List<Vtn> vtns = odl.ReadVTNObjects(vmnetworkMappigInfoFound.VTNName);
if (vtns.Count == 0) {
needRefresh = true;
vMNetworkConfig.VMNetwork.VmNetworks.Remove(vmnetworkFound);
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Remove(vmnetworkMappigInfoFound);
} if (vtns.Count != 0) {
needRefresh = this.SyncVTN(vmnetworkFound.VMSubnets.First().LogicalNetworkDefinitionId,
vmnetworkFound,
vtns.First(),
vmnetworkMappigInfoFound,
txnMng,
VtnHostName);
}
}
vmnetworkMappigInfoFound.Description = string.Empty;
} else {
if (vmnetworkMappigInfoFound.VTNName.CompareTo(string.Empty) == 0) {
vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.Remove(vmnetworkMappigInfoFound);
return needRefresh;
}
vmnetworkMappigInfoFound.VMNetworkName = string.Empty;
vmnetworkMappigInfoFound.VMSubnetInfo.ForEach(subnet => { subnet.VMSubnetName = string.Empty; subnet.VMSubnetVlanId = 0; });
vmnetworkMappigInfoFound.Description = "VM Network corresponding to this VTN is not created on SCVMM";
vmnetworkFound.Name = vmnetworkMappigInfoFound.VTNName;
vmnetworkFound.RoutingDomainId = null;
vmnetworkFound.OwnerName = string.Empty;
}
string output = "\"VMNetwork\":" + JavaScriptSerializer.Serialize(vmnetworkFound);
string outputMappingInfo = "\"VMNetworkInfo\":" + JavaScriptSerializer.Serialize(vmnetworkMappigInfoFound);
ODLVSEMETW.EventWriteEndLibrary(MethodBase.GetCurrentMethod().Name,
output);
return needRefresh;
}
/// <summary>
/// Remove the VMSubnet corresponding to the removed vBridge from ODL.
/// </summary>
/// <param name="vMNetworkConfig">VMNetwork.config file instance.</param>
/// <param name="vmSubnetId">Id of the VMSubnet.</param>
/// <param name="vmnetwork">Parent VM Network.</param>
/// <param name="vmnetworkInfo">Corresponding VM netrok info.</param>
public static void RemoveVMSubnetSync(VMNetworkConfig vMNetworkConfig, Guid vmSubnetId, VMNetwork vmnetwork, VMNetworkInfo vmnetworkInfo)
{
if (vMNetworkConfig == null && (vmnetwork == null || vmnetworkInfo == 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 (vmnetwork == null) {
vmnetwork = vMNetworkConfig.VMNetwork.VmNetworks.FirstOrDefault(net => net.VMSubnets.Any(vms => vms.Id.CompareTo(vmSubnetId) == 0));
}
if (vmnetwork != null) {
var temp = vmnetwork.VMSubnets.ToList();
temp.RemoveAll(net => net.Id.CompareTo(vmSubnetId) == 0);
vmnetwork.VMSubnets = temp.ToArray();
if (vmnetworkInfo == null) {
vmnetworkInfo = vMNetworkConfig.VMNetwork.VMNetworkMappingInformation.VMNetworkInfo.FirstOrDefault(vmn => vmn.VMNetworkID.CompareTo(vmnetwork.Id) == 0);
}
vmnetworkInfo.VMSubnetInfo.ForEach(vms => {
if (vms.VMSubnetID.CompareTo(vmSubnetId) == 0) {
vms.Description = "Corresponding vBridge is deleted on ODL.";
vms.VBridgeName = string.Empty;
vms.VBridgeVlanId = 0;
}
});
}
}
/// <summary>
/// Create vm network.
/// </summary>
/// <param name="name">Vm network name.</param>
/// <returns>Vm network.</returns>
public static VMNetwork CreateVtnVmNetwork(string name)
{
ODLVSEMETW.EventWriteCreateVtnVMNetwork(MethodBase.GetCurrentMethod().Name,
"Creating VMNetwork.");
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.");
}
VMNetwork vmNet = new VMNetwork();
vmNet.Id = Guid.NewGuid();
vmNet.Name = name;
vmNet.VMSubnets = new VMSubnet[0];
vmNet.LastModifiedTimeStamp = DateTime.Now;
vmNet.ManagedByNetworkServiceId = VSEMODLConstants.SYSTEM_INFO_ID;
return vmNet;
}
