public async Task <bool> Handle(Command request, CancellationToken cancellationToken)
{
await _context.WebhookEvents.AddAsync(request.CallbackEvent);
if (await _context.SaveChangesAsync() > 0)
{
await _callbackBackgroundService.AddEvent(request.CallbackEvent);
return(true);
}
else
{
return(false);
}
}
public async Task <Vm> CreateAsync(VmCreateForm form, CancellationToken ct)
{
if (_context.Vms.Where(v => v.Id == form.Id).Any())
{
throw new ForbiddenException("Vm already exists");
}
var vmEntity = _mapper.Map <Domain.Models.Vm>(form);
var formTeams = vmEntity.VmTeams.Select(v => v.TeamId).Distinct();
if (!formTeams.Any())
{
throw new ForbiddenException("Must include at least 1 team");
}
if (!(await _playerService.CanManageTeamsAsync(formTeams, true, ct)))
{
throw new ForbiddenException();
}
if (!(await _permissionsService.CanWrite(formTeams, ct)))
{
throw new ForbiddenException();
}
var teamList = await _context.Teams
.Where(t => formTeams.Contains(t.Id))
.Select(t => t.Id)
.ToListAsync(ct);
foreach (var vmTeam in vmEntity.VmTeams)
{
if (!teamList.Contains(vmTeam.TeamId))
{
_context.Teams.Add(new Domain.Models.Team()
{
Id = vmTeam.TeamId
});
}
}
_context.Vms.Add(vmEntity);
await _context.SaveChangesAsync(ct);
return(_mapper.Map <Vm>(vmEntity));
}
private async Task ProcessEvents(IEnumerable <Event> events)
{
var eventDict = new Dictionary <Guid, Event>();
if (!events.Any())
{
return;
}
var filteredEvents = events.GroupBy(x => x.vm.vm)
.Select(g => g.OrderByDescending(l => l.createdTime).First())
.ToArray();
foreach (var evt in filteredEvents)
{
var id = _connectionService.GetVmIdByRef(evt.vm.vm.Value);
if (id.HasValue)
{
eventDict.Add(id.Value, evt);
}
}
var vms = await _dbContext.Vms
.Include(x => x.VmTeams)
.Where(x => eventDict.Select(y => y.Key).Contains(x.Id))
.ToListAsync();
foreach (var vm in vms)
{
Event evt;
if (eventDict.TryGetValue(vm.Id, out evt))
{
var type = evt.GetType();
if (new Type[] { typeof(VmPoweredOnEvent), typeof(DrsVmPoweredOnEvent) }.Contains(type))
{
vm.PowerState = PowerState.On;
}
else if (type == typeof(VmPoweredOffEvent))
{
vm.PowerState = PowerState.Off;
}
}
}
await _dbContext.SaveChangesAsync();
}
// Delete all maps associated with the deleted view
private async Task DeleteClonedMaps(Guid viewId, VmContext dbContext)
{
var toDelete = await dbContext.Maps
.Where(m => m.ViewId == viewId)
.Include(m => m.Coordinates)
.ToListAsync();
foreach (var map in toDelete)
{
foreach (var coord in map.Coordinates)
{
dbContext.Remove(coord);
}
dbContext.Remove(map);
}
await dbContext.SaveChangesAsync();
}
public async Task <Response> Handle(Command request, CancellationToken cancellationToken)
{
var errorsDict = new Dictionary <Guid, string>();
var acceptedList = new List <Guid>();
var vms = await _dbContext.Vms
.Include(x => x.VmTeams)
.Where(x => request.Ids.Contains(x.Id))
.ToListAsync(cancellationToken);
foreach (var id in request.Ids)
{
var vm = vms.Where(x => x.Id == id).FirstOrDefault();
if (vm == null)
{
errorsDict.Add(id, "Virtual Machine Not Found");
}
else if (vm.PowerState == PowerState.Unknown)
{
errorsDict.Add(id, "Unsupported Operation");
}
else if (!await _playerService.CanAccessTeamsAsync(vm.VmTeams.Select(x => x.TeamId), cancellationToken))
{
errorsDict.Add(id, "Unauthorized");
}
else if (!await _permissionsService.CanWrite(vm.VmTeams.Select(x => x.TeamId), cancellationToken))
{
errorsDict.Add(id, "Insufficient Permissions");
}
else
{
acceptedList.Add(id);
}
}
foreach (var vm in vms.Where(x => acceptedList.Contains(x.Id)))
{
vm.HasPendingTasks = true;
}
await _dbContext.SaveChangesAsync();
if (request.Operation == PowerOperation.Shutdown)
{
var results = await _vsphereService.BulkShutdown(acceptedList.ToArray());
errorsDict = errorsDict
.Concat(results)
.ToLookup(x => x.Key, x => x.Value)
.ToDictionary(x => x.Key, g => g.First());
}
else
{
await _vsphereService.BulkPowerOperation(acceptedList.ToArray(), request.Operation);
}
return(new Response
{
Accepted = acceptedList.ToArray(),
Errors = errorsDict.Where(x => !string.IsNullOrEmpty(x.Value)).ToDictionary(x => x.Key.ToString(), y => y.Value)
});
}
private async Task getRecentTasks()
{
if (_sic != null && _sic.taskManager != null)
{
var pendingVms = await _dbContext.Vms
.Include(x => x.VmTeams)
.Where(x => x.HasPendingTasks)
.ToArrayAsync();
var stillPendingVmIds = new List <Guid>();
PropertyFilterSpec[] filters = createPFSForRecentTasks(_sic.taskManager);
RetrievePropertiesResponse response = await _client.RetrievePropertiesAsync(_props, filters);
_runningTasks.Clear();
var forceCheckMachineState = false;
foreach (var task in response.returnval)
{
try
{
Guid?vmId = null;
var vmRef = task.GetProperty("info.entity") != null ? ((ManagedObjectReference)task.GetProperty("info.entity")).Value : null;
if (vmRef != null)
{
vmId = _connectionService.GetVmIdByRef(vmRef);
}
var broadcastTime = DateTime.UtcNow.ToString();
var taskId = task.GetProperty("info.key") != null?task.GetProperty("info.key").ToString() : "";
var taskType = task.GetProperty("info.descriptionId") != null?task.GetProperty("info.descriptionId").ToString() : "";
var progress = task.GetProperty("info.progress") != null?task.GetProperty("info.progress").ToString() : "";
var state = task.GetProperty("info.state") != null?task.GetProperty("info.state").ToString() : "";
var notification = new Notification()
{
broadcastTime = DateTime.UtcNow.ToString(),
taskId = taskId,
taskName = taskType.Replace("VirtualMachine.", ""),
taskType = taskType,
progress = progress,
state = state
};
if (vmId.HasValue)
{
var id = vmId.Value.ToString();
var vmTasks = _runningTasks.ContainsKey(id) ? _runningTasks[id] : new List <Notification>();
vmTasks.Add(notification);
_runningTasks.AddOrUpdate(id, vmTasks, (k, v) => (v = vmTasks));
}
if ((state == TaskInfoState.queued.ToString() || state == TaskInfoState.running.ToString()))
{
_tasksPending = true;
if (vmId.HasValue)
{
stillPendingVmIds.Add(vmId.Value);
}
}
if (state == TaskInfoState.success.ToString() &&
(this.GetPowerTaskTypes().Contains(taskType)))
{
if (vmId.HasValue)
{
forceCheckMachineState = true;
}
}
}
catch (Exception ex)
{
this._logger.LogError(ex, "Exception processing task");
}
}
foreach (var vm in pendingVms)
{
if (!stillPendingVmIds.Contains(vm.Id))
{
vm.HasPendingTasks = false;
}
}
var vmsToUpdate = await _dbContext.Vms
.Include(x => x.VmTeams)
.Where(x => stillPendingVmIds.Contains(x.Id))
.ToArrayAsync();
foreach (var vm in vmsToUpdate)
{
vm.HasPendingTasks = true;
}
await _dbContext.SaveChangesAsync();
if (forceCheckMachineState)
{
_machineStateService.CheckState();
}
}
}
private async Task CloneMaps(ViewCreated form, VmContext dbContext)
{
if (!form.ParentId.HasValue)
{
return;
}
var client = _clientFactory.CreateClient("player-admin");
client.BaseAddress = new Uri(_clientOptions.CurrentValue.urls.playerApi);
var playerClient = new PlayerApiClient(client);
// Get maps assigned to parent view
var maps = await dbContext.Maps
.Where(m => m.ViewId == form.ParentId)
.Include(m => m.Coordinates)
.ToListAsync();
if (maps.Count == 0)
{
return;
}
HashSet <Team> parentTeams = new HashSet <Team>();
HashSet <Team> childTeams = new HashSet <Team>();
// Views can't have duplicate teams, so use HashSet for constant time lookups
try
{
parentTeams = (await playerClient.GetViewTeamsAsync(form.ParentId.Value)).ToHashSet();
childTeams = (await playerClient.GetViewTeamsAsync(form.ViewId)).ToHashSet();
}
catch (ApiException ex)
{
// View no longer exists, so there is nothing to clone
if (ex.StatusCode == (int)HttpStatusCode.NotFound)
{
return;
}
}
var clonedMaps = new List <VmMap>();
// Create clones of maps assigned to the child view
foreach (var map in maps)
{
var clone = map.Clone();
clone.ViewId = form.ViewId;
var teamNames = parentTeams
.Where(t => map.TeamIds.Contains((Guid)t.Id))
.Select(t => t.Name);
var cloneTeamIds = childTeams
.Where(t => teamNames.Contains(t.Name))
.Select(t => (Guid)t.Id);
clone.TeamIds = cloneTeamIds.ToList();
dbContext.Maps.Add(clone);
}
await dbContext.SaveChangesAsync();
}