//*********************************************************************
///
/// <summary>
/// This method is used to add disk to a VM.
/// </summary>
/// <param name="vMId"></param>
/// <param name="disks"></param>
///
//*********************************************************************
private void AddDisk(int vMId, List <object> disks)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(vMId);
if (null != foundVmDepRequest)
{
if (null != foundVmDepRequest.CmpRequestID)
{
if (!CanAddDisks((int)foundVmDepRequest.CmpRequestID, disks.Count))
{
throw new Exception("Role size of given VM does not support the requested number of data disks");
}
var cmpi = new VMServiceRepository(_eventLog);
cmpi.AddDisk(Convert.ToInt32(foundVmDepRequest.CmpRequestID), BuildDiskObject(disks, foundVmDepRequest).ToList());
}
}
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.AddDisk()", 100, 1);
throw;
}
}
//*********************************************************************
///
/// <summary>
/// This method is used to check whether a disk can be added to a VM
/// </summary>
/// <param name="cmpRequestId"></param>
/// <param name="addDiskCount"></param>
/// <returns>boolean</returns>
///
//*********************************************************************
private bool CanAddDisks(int cmpRequestId, int addDiskCount)
{
try
{
string roleSizeName;
//*** Fetch disk count from Azure ***
var cmpi = new VMServiceRepository(_eventLog);
var count = cmpi.FetchDiskCount(cmpRequestId, out roleSizeName);
//*** fetch role size disc capacity info ***
var cwdb = new CmpWapDb();
var roleSizeInfo = cwdb.FetchVmSizeInfo(roleSizeName);
if (null == roleSizeInfo)
{
throw new Exception(string.Format(
"Could not locate given VM role size: '{0}' in server Role Size table", roleSizeName));
}
//*** Check capacity ***
return(count + addDiskCount <= roleSizeInfo.MaxDataDiskCount);
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.CanAddDisks()", 100, 1);
throw;
}
}
public VmDashboardInfo GetVm(string subscriptionId, int Id)
{
try
{
ICmpWapDb cwdb = new CmpWapDb();
ICmpWapDbTenantRepository cwdbTenant = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(Id);
var vmsizes = cwdbTenant.FetchVmSizeInfoList(subscriptionId);
if (null != foundVmDepRequest && null != foundVmDepRequest.CmpRequestID)
{
var cmpi = new VMServiceRepository(_eventLog);
//when we solve the big 'method not returning' bug: uncomment line below, delete second line below
//var vm = cmpi.GetVm(Convert.ToInt32(foundVmDepRequest.CmpRequestID),
// CmpInterfaceModel.Constants.FetchType.AzureStatus);
var vm = GetLocalvmDBI(foundVmDepRequest);
cwdb.UpdateVmIp(Id, vm.InternalIP);
vm.Cores = vmsizes.Where(x => x.Name == vm.RoleSize).Select(x => x.Cores).FirstOrDefault().ToString();
vm.OSVirtualHardDisk.Type = "OS Disk";
if (vm.DataVirtualHardDisks != null)
{
vm.DataVirtualHardDisks.Select(d => { d.Type = "Data Disk"; return(d); }).ToList();
}
return(vm);
}
return(null);
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.GetVm()", 100, 1);
throw;
}
}
public void BuildVerificationTest_01()
{
//Initialize values
var vmList = VmDeploymentSetup();
// starting CMP service
var cmpService = StartCmpServiceTest();
// Create VM as Async Tasks
Task[] taskArray = new Task[vmList.Count];
for (int i = 0; i < vmList.Count; i++)
{
// Start VM Provisioning
int depId = CreateVmTest(_eventLog, vmList[i]);
taskArray[i] = Task.Factory.StartNew((Object obj) =>
{
VmDeploymentRequest vmd = obj as VmDeploymentRequest;
// Check VM Provisioning Status
var cmpi = new VMServiceRepository(_eventLog);
var vmDepReq = cmpi.FetchCmpRequest(depId);
string statusCode = null;
while (!vmDepReq.Status.Equals("Complete") && !vmDepReq.Status.Equals("Exception"))
{
vmDepReq = cmpi.FetchCmpRequest(depId);
statusCode = vmDepReq.Status;
}
if (vmd != null)
{
vmd.Status = statusCode;
vmd.StatusMessage = vmDepReq.StatusMessage;
}
}, new VmDeploymentRequest()
{
});
}
Task.WaitAll(taskArray);
//Assert
foreach (var task in taskArray)
{
var data = task.AsyncState as VmDeploymentRequest;
Assert.AreNotEqual(data.Status, null);
Assert.AreNotEqual(data.Status, "Exception", data.StatusMessage);
Assert.AreEqual(data.Status, "Complete", data.StatusMessage);
}
DeleteVmTest(_eventLog, vmList);
// Stop CMP Service
StopCmpServiceTest(cmpService);
}
//*********************************************************************
///
/// <summary>
/// This method fetches Service Provider Account from WAP DB.
/// </summary>
///
//*********************************************************************
private void FetchSpaListFromDb(string groupName)
{
var cmp = new VMServiceRepository(EventLog);
var spaList = cmp.FetchServiceProviderAccountList(groupName);
SpaList.Clear();
foreach (var spa in spaList)
{
AddSpaToList(spa);
}
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="sPa"></param>
/// <returns></returns>
///
//*********************************************************************
private List <ServiceProviderAccount> UpdateSpaInDb(ServiceProviderAccount sPa)
{
var cmp = new VMServiceRepository(EventLog);
var spaList = cmp.UpdateServiceProviderAccount(sPa);
SpaList.Clear();
foreach (var spa in spaList)
{
AddSpaToList(spa);
}
return(spaList);
}
public void GetVm_OnExecuteWithInValidValue_ReturnsNull()
{
//Arrange
var repo = new VMServiceRepository()
{
CmpSvProxy = _cmpApiServiceMock.Object
};
//Act
var output = repo.GetDetachedDisks(124);
//Assert
Assert.IsNull(output);
}
public void GetVm_OnExecuteWithValidValue_VmInfo()
{
//Arrange
var repo = new VMServiceRepository()
{
CmpSvProxy = _cmpApiServiceMock.Object
};
//Act
var output = repo.GetVm(123, CmpInterfaceModel.Constants.FetchType.AzureFull);
//Assert
Assert.IsNotNull(output);
}
public void GetDetachedDisks_OnExecuteWithValidValue_VhdInfoList()
{
//Arrange
var repo = new VMServiceRepository()
{
CmpSvProxy = _cmpApiServiceMock.Object
};
//Act
var output = repo.GetDetachedDisks(123);
//Assert
Assert.AreNotEqual(output.ToList().Count, 0);
}
public void FetchServiceProviderAccountList_OnExecuteWithValidValue_ServiceProviderAccountList()
{
//Arrange
var repo = new VMServiceRepository()
{
CmpSvProxy = _cmpApiServiceMock.Object
};
//Act
var output = repo.FetchServiceProviderAccountList("RGroup1");
//Assert
Assert.AreNotEqual(output.Count, 0);
}
public void FetchCmpRequest_OnExecuteWithInvalidValue_ReturnsNull()
{
//Arrange
var repo = new VMServiceRepository()
{
CmpSvProxy = _cmpApiServiceMock.Object
};
//Act
var output = repo.FetchCmpRequest(34565);
//Assert
Assert.IsNull(output);
}
public void FetchCmpRequest_OnExecuteWithValidValue_ReturnsDepRequests()
{
//Arrange
var repo = new VMServiceRepository()
{
CmpSvProxy = _cmpApiServiceMock.Object
};
//Act
var output = repo.FetchCmpRequest(345);
//Assert
Assert.IsNotNull(output);
Assert.AreEqual("MockVM1", output.TargetVmName);
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="_eventLog"></param>
/// <param name="vM"></param>
/// <returns></returns>
///
//*********************************************************************
private int CreateVmTest(EventLog _eventLog, CreateVm vM)
{
var cmpi = new VMServiceRepository(_eventLog);
//Insert app data to the DB
cmpi.PerformAppDataOps(new CreateVm
{
VmAppName = vM.VmAppName,
VmAppId = vM.VmAppId,
SubscriptionId = vM.SubscriptionId,
AccountAdminLiveEmailId = vM.AccountAdminLiveEmailId
});
//Submit VM information to the WAP DB
vM = cmpi.SubmitVmRequest(vM);
return(vM.CmpRequestId);
}
public IQueryable <DataVirtualHardDisk> GetDetachedDisks(string subscriptionId, int vmId)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(vmId);
var cmpi = new VMServiceRepository(_eventLog);
return(cmpi.GetDetachedDisks(foundVmDepRequest.CmpRequestID).Select(d => new DataVirtualHardDisk
{
DiskName = d.DiskName,
}).AsQueryable());
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.DisksController.GetDetachedDisks()", 100, 1);
throw;
}
}
//*********************************************************************
///
/// <summary>
/// This method is used to delete a VM.
/// </summary>
/// <param name="vMId"></param>
/// <param name="deleteFromStorage"></param>
///
//*********************************************************************
private void DeleteVm(int vMId, bool deleteFromStorage)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(vMId);
if (null != foundVmDepRequest)
{
var cmpi = new VMServiceRepository(_eventLog);
cmpi.DeleteVm(Convert.ToInt32(foundVmDepRequest.CmpRequestID), deleteFromStorage);
}
DeleteWapdbRecord(vMId, cwdb);
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.DeleteVm()", 100, 1);
throw;
}
}
//*********************************************************************
///
/// <summary>
/// This method fetches Resource Group information from WAP DB.
/// </summary>
///
//*********************************************************************
private IEnumerable <ResourceProviderAcctGroup> FetchResourceGroupFromDb()
{
var vmsRepo = new VMServiceRepository();
return(vmsRepo.FetchServiceProviderAccountList().Select(spa => new ResourceProviderAcctGroup()
{
AdDomainMap = null,
Name = spa.ResourceGroup,
CreatedBy = "CmpWapExtension",
CreatedOn = DateTime.Now,
DomainId = 1,
EnvironmentType = null,
EnvironmentTypeId = 1,
IsActive = true,
LastUpdatedBy = "CmpWapExtension",
LastUpdatedOn = DateTime.Now,
NetworkNIC = null,
NetworkNICId = 0,
ResourceProviderAcctGroupId = 1
}).ToList());
}
//*********************************************************************
///
/// <summary>
/// This method is used to restart a VM.
/// </summary>
/// <param name="vMId"></param>
///
//*********************************************************************
private void RestartVm(int vMId)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(vMId);
if (null != foundVmDepRequest)
{
if (null != foundVmDepRequest.CmpRequestID)
{
var cmpi = new VMServiceRepository(_eventLog);
cmpi.RebootVm((int)foundVmDepRequest.CmpRequestID);
}
}
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.ResetVm()", 100, 1);
throw;
}
}
private void AttachExistingDisks(int vMId, IList <object> disks)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(vMId);
if (foundVmDepRequest != null)
{
var cmpi = new VMServiceRepository(_eventLog);
var disk = disks.Select(d => new VhdInfo {
DiskName = d.ToString()
}).FirstOrDefault();
cmpi.AttachExistingDisk(foundVmDepRequest.CmpRequestID, disk);
}
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.AttachExistingDisks()", 100, 1);
throw;
}
}
private void DeleteVmTest(EventLog _eventLog, List <CreateVm> vmList)
{
VmOp vmOp = new VmOp()
{
Opcode = CmpInterfaceModel.Constants.VmOpcodeEnum.DELETEFROMSTORAGE.ToString(),
iData = 0,
sData = null
};
Task[] taskArray = new Task[vmList.Count];
var cmpi = new VMServiceRepository(_eventLog);
for (int i = 0; i < vmList.Count; i++)
{
var opSpec = VmOpsController.Translate(new VmOp {
Opcode = vmOp.Opcode, VmId = vmList[i].Id, sData = vmOp.sData, iData = vmOp.iData
});
taskArray[i] = Task.Factory.StartNew(() =>
{
opSpec = cmpi.SubmitOperation(opSpec);
while (!opSpec.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Complete.ToString()) &&
!opSpec.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Exception.ToString()))
{
opSpec = cmpi.GetVmOpsRequestSpec(vmList[i].Name);
}
});
}
Task.WaitAll(taskArray);
for (int i = 0; i < vmList.Count; i++)
{
var opSpec = cmpi.GetVmOpsRequestSpec(vmList[i].Name);
//Assert.AreNotEqual(opSpec, null);
//Assert.AreEqual(opSpec.StatusCode, CmpInterfaceModel.Constants.StatusEnum.Complete);
}
}
public IHttpActionResult GetVmOpsQueueStatus(string subscriptionId, int Id)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(Id);
if (null != foundVmDepRequest)
{
var cmpi = new VMServiceRepository(_eventLog);
var vmOpsInfo = cmpi.GetVmOpsRequestSpec(foundVmDepRequest.TargetVmName);
if (vmOpsInfo == null)
{
BadRequest("Can't retrieve ops queue status");
}
else
{
if (vmOpsInfo.StatusCode == CmpInterfaceModel.Constants.StatusEnum.Complete.ToString())
{
if (vmOpsInfo.Opcode == CmpInterfaceModel.Constants.VmOpcodeEnum.DELETE.ToString() || // Delete VM record from wap db if delete operation is selected
vmOpsInfo.Opcode == CmpInterfaceModel.Constants.VmOpcodeEnum.DELETEFROMSTORAGE.ToString())
{
DeleteWapdbRecord(Id, cwdb);
}
}
return(Ok(vmOpsInfo));
}
}
return(BadRequest("Can't find VM deployment request data"));
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VMOpsController.GetVMOpsQueueStatus()", 100, 1);
return(BadRequest(ex.Message));
}
}
public void PerformAppDataOps_OnExecutionWithAbsentValue_ReturnsVoid()
{
//Arrange
var repo = new VMServiceRepository {
WapDbContract = _cmpWapDbMock.Object
};
Exception exObject = null;
//Act
try
{
repo.PerformAppDataOps(new CreateVm
{
VmAppName = "App231",
VmAppId = "App231"
});
}
catch (Exception ex)
{
exObject = ex;
}
Assert.IsNull(exObject);
}
//*********************************************************************
///
/// <summary>
/// This method is used to resize a VM.
/// </summary>
/// <param name="vMId"></param>
/// <param name="size"></param>
///
//*********************************************************************
private void ResizeVm(int vMId, string size)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(vMId);
if (null != foundVmDepRequest)
{
if (null != foundVmDepRequest.CmpRequestID)
{
var cmpi = new VMServiceRepository(_eventLog);
cmpi.ResizeVM(Convert.ToInt32(foundVmDepRequest.CmpRequestID), size);
}
}
cwdb.UpdateVmSize(vMId, size);
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.ResizeVM()", 100, 1);
throw;
}
}
//*********************************************************************
///
/// <summary>
/// This method is used to deallocate a VM.
/// </summary>
/// <param name="vMId"></param>
///
//*********************************************************************
private void DeallocateVm(int vMId)
{
try
{
var cwdb = new CmpWapDb();
var foundVmDepRequest = cwdb.FetchVmDepRequest(vMId);
if (null != foundVmDepRequest)
{
if (null != foundVmDepRequest.CmpRequestID)
{
var cmpi = new VMServiceRepository(_eventLog);
cmpi.DeallocateVm(Convert.ToInt32(foundVmDepRequest.CmpRequestID));
//cmpi.SubmitOpToQueue()
}
}
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.DeallocateVm()", 100, 1);
throw;
}
}
private void performResourceGroupOps(string resGroup)
{
var cmpi = new VMServiceRepository(EventLog);
cmpi.PerformResourceGroupOps(resGroup);
}
//*********************************************************************
///
/// <summary>
/// This method is used to Sync VM Object with CMP.
/// </summary>
///
//*********************************************************************
void SyncWithCmp()
{
var cmpi = new VMServiceRepository(_eventLog);
var cwdb = new CmpWapDb();
foreach (CreateVm vM in VmList.ToList())
{
//*** If status is complete or exception then don't process ***
//if (vM.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Complete.ToString()) ||
// vM.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Exception.ToString()))
if (vM.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Complete.ToString()))
{
continue;
}
try
{
//*** Access the CMP service ***
var fetchedVm = cmpi.FetchCmpRequest(vM.CmpRequestId);
//*** update CmpWapDb if status has changed ***
//if (!vM.StatusCode.Equals(fetchedVm.Status))
if (true)
{
vM.StatusCode = fetchedVm.Status;
vM.StatusMessage = fetchedVm.StatusMessage;
var cmpWapReq = new Models.CmpRequest
{
StatusCode = fetchedVm.Status,
StatusMessage = GetStatusMessage(fetchedVm),
ExceptionMessage = fetchedVm.ExceptionMessage,
Id = vM.Id,
Config = fetchedVm.Config
};
if (null != fetchedVm.Config)
{
var vmc = CmpInterfaceModel.Models.VmConfig.Deserialize(fetchedVm.Config);
if (null != vmc)
{
if (null != vmc.InfoFromVM)
{
cmpWapReq.AddressFromVm = vmc.InfoFromVM.VmAddress;
}
}
}
cwdb.SetVmDepRequestStatus(cmpWapReq, null);
}
}
catch (Exception)
{
vM.StatusCode = "NoCmpContact";
vM.StatusMessage = "Temporarily unable to contact CMP for status";
}
}
}
public async Task <HttpResponseMessage> CreateVm([FromBody] CreateVm vM)
{
try
{
if (!ModelState.IsValid)
{
var result = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.BadRequest,
Content = new StringContent(
"Model State is not valid", Encoding.UTF8,
"application/json"),
ReasonPhrase = "ModelState is not valid"
};
return(result);
}
LogThis(EventLogEntryType.Information, "VM Create Request Submitted", 2, 1);
vM.CreatedBy = await GetWapAdmin(vM.SubscriptionId);
var cwdb = new CmpWapDb();
//*** Map WAP sub to ResProvGroupId
var resourceProviderGroupName =
cwdb.FetchDefaultResourceProviderGroupName(vM.SubscriptionId);
if (null == resourceProviderGroupName)
{
throw new Exception("Could not locate DefaultResourceProviderGroupName for WAP subscription");
}
vM.EnvResourceGroupName = resourceProviderGroupName;
var cmpi = new VMServiceRepository(_eventLog);
lock (vM)
{
//Insert app data to the DB
cmpi.PerformAppDataOps(new CreateVm {
VmAppName = vM.VmAppName,
VmAppId = vM.VmAppId,
SubscriptionId = vM.SubscriptionId,
AccountAdminLiveEmailId = vM.AccountAdminLiveEmailId,
VmRegion = vM.VmRegion
});
//Submit VM information to the WAP DB
vM = cmpi.SubmitVmRequest(vM);
AddVmToList(vM);
}
LogThis(EventLogEntryType.Information, "VM Create Request Submitted OK", 2, 2);
//return Ok(vM);
return(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK
});
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.CreateVm()", 100, 1);
//return InternalServerError(ex);
//throw new Microsoft.WindowsAzurePack.CmpWapExtension.Common.PortalException(ex.Message);
var reason = "Exception while submitting request to Create VM : " +
Regex.Replace(CmpCommon.Utilities.UnwindExceptionMessages(ex), @"\t|\n|\r", "");
// Making this as a bad request instead of Internal Server error because the reason phrase for Internal Server error is not able to be customized.
var result = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.BadRequest, ReasonPhrase = reason
};
return(result);
}
}
//*********************************************************************
///
/// <summary>
///
/// </summary>
/// <param name="_eventLog"></param>
/// <param name="vmList"></param>
///
//*********************************************************************
private void DeleteVmTest(EventLog _eventLog, List <CreateVm> vmList)
{
VmOp vmOp = new VmOp()
{
Opcode = CmpInterfaceModel.Constants.VmOpcodeEnum.DELETEFROMSTORAGE.ToString(),
iData = 0,
sData = null
};
List <OpSpec> opsList = new List <OpSpec>();
var cmpi = new VMServiceRepository(_eventLog);
for (int i = 0; i < vmList.Count; i++)
{
var opSpec = VmOpsController.Translate(new VmOp {
Opcode = vmOp.Opcode, VmId = vmList[i].Id, sData = vmOp.sData, iData = vmOp.iData
});
opSpec = cmpi.SubmitOperation(opSpec);
opSpec = cmpi.GetVmOpsRequestSpec(vmList[i].Name);
while (!opSpec.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Complete.ToString()) &&
!opSpec.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Exception.ToString()))
{
opSpec = cmpi.GetVmOpsRequestSpec(vmList[i].Name);
}
opsList.Add(opSpec);
if (opSpec.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Exception.ToString()))
{
break;
}
}
foreach (var ops in opsList)
{
Assert.AreNotEqual(ops.StatusCode, null);
Assert.AreNotEqual(ops.StatusCode, "Exception", ops.StatusMessage);
Assert.AreEqual(ops.StatusCode, "Complete", ops.StatusMessage);
}
/*
* Task[] taskArray = new Task[vmList.Count];
* for (int i = 0; i < vmList.Count; i++)
* {
* var i1 = i;
* taskArray[i] = Task.Factory.StartNew((Object ob) =>
* {
* OpRequest op = ob as OpRequest;
* var opSpec = cmpi.GetVmOpsRequestSpec(vmList[i1].Name);
* while (!opSpec.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Complete.ToString())
* && !opSpec.StatusCode.Equals(CmpInterfaceModel.Constants.StatusEnum.Exception.ToString()))
* {
* opSpec = cmpi.GetVmOpsRequestSpec(vmList[i1].Name);
* }
*
* op.StatusCode = opSpec.StatusCode;
* op.StatusMessage = opSpec.StatusMessage;
*
* }, new OpRequest(){});
* }
* Task.WaitAll(taskArray);
*
* foreach (var task in taskArray)
* {
* var data = task.AsyncState as OpRequest;
* Assert.AreNotEqual(data.StatusCode, null);
* Assert.AreNotEqual(data.StatusCode, "Exception", data.StatusMessage);
* Assert.AreEqual(data.StatusCode, "Complete", data.StatusMessage);
* }
*
* for (int i = 0; i < vmList.Count; i++ )
* {
* var opSpec = cmpi.GetVmOpsRequestSpec(vmList[i].Name);
* Assert.AreNotEqual(opSpec , null);
* Assert.AreEqual(opSpec.StatusCode, CmpInterfaceModel.Constants.StatusEnum.Complete.ToString());
* }*/
}
public HttpResponseMessage SubmitOp(string subscriptionId, [FromBody] VmOp vmOp)
{
try
{
LogThis(EventLogEntryType.Information, "VmOp Request Submitted", 2, 1);
if (!ModelState.IsValid)
{
//return BadRequest(ModelState);
var result = new HttpResponseMessage()
{
StatusCode = HttpStatusCode.BadRequest,
Content = new StringContent("Model State is not valid", Encoding.UTF8, "application/json"),
ReasonPhrase = "ModelState is not valid"
};
return(result);
}
CmpInterfaceModel.Constants.VmOpcodeEnum opCode;
if (!Enum.TryParse(vmOp.Opcode, true, out opCode))
{
throw new Exception("Unknown opcode '" + vmOp.Opcode + "'");
}
if (vmOp.IsMultiOp) // If is Multiple Operation
{
vmList = _vmgr.FetchVms(subscriptionId);
foreach (var vm in vmList)
{
var opSpec = Translate(new VmOp {
Opcode = vmOp.Opcode, VmId = vm.Id, sData = vmOp.sData, iData = vmOp.iData
});
opSpec = new VMServiceRepository(_eventLog).SubmitOperation(opSpec);
}
}
else
{
if (vmOp.Opcode != CmpInterfaceModel.Constants.VmOpcodeEnum.DELETEONEXCEPTION.ToString())
{
var opSpec = Translate(vmOp);
opSpec = new VMServiceRepository(_eventLog).SubmitOperation(opSpec);
}
else
{
DeleteWapdbRecord(vmOp.VmId);
}
}
LogThis(EventLogEntryType.Information, "VmOp Request Submitted OK", 2, 2);
return(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK
});
}
catch (Exception ex)
{
LogThis(ex, EventLogEntryType.Error, "CmpWapExtension.VmsController.SubmitOp()", 100, 1);
return(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.BadRequest,
ReasonPhrase = "Exception while submitting request to OPS queue : " +
Regex.Replace(CmpCommon.Utilities.UnwindExceptionMessages(ex), @"\t|\n|\r", "")
});
}
}
