public async Task <Operation> StartNew(OperationCommand operationCommand, Guid vmId)
{
if (operationCommand == null)
{
throw new ArgumentNullException(nameof(operationCommand));
}
var operation = new Operation
{
Id = Guid.NewGuid(),
MachineGuid = vmId,
Status = OperationStatus.Queued
};
_db.Add(operation);
await _db.SaveChangesAsync().ConfigureAwait(false);
if (vmId != Guid.Empty && (operationCommand is IMachineCommand machineCommand) &&
machineCommand.MachineId != vmId)
{
machineCommand.MachineId = vmId;
}
operationCommand.OperationId = operation.Id;
var commandJson = JsonConvert.SerializeObject(operationCommand);
await _bus.Send(
new StartOperation(operationCommand.GetType().AssemblyQualifiedName, commandJson, operation.Id)
).ConfigureAwait(false);
return(operation);
}
public Task Handle(OperationTaskProgressEvent message)
{
var operation = _dbContext.Operations.FirstOrDefault(op => op.Id == message.OperationId);
var task = _dbContext.OperationTasks.FirstOrDefault(op => op.Id == message.TaskId);
if (operation != null)
{
var opLogEntry =
new OperationLogEntry
{
Id = message.Id,
Message = message.Message,
Operation = operation,
Task = task,
Timestamp = message.Timestamp
};
_dbContext.Add(opLogEntry);
_dbContext.SaveChanges();
}
Console.WriteLine(message.Message);
return(Task.CompletedTask);
}
public async Task Handle(VirtualMachineNetworkChangedEvent message)
{
var machine = await _stateStoreContext.Machines
.Include(x => x.VM)
.ThenInclude(vm => vm.NetworkAdapters)
.Include(x => x.Networks)
.FirstOrDefaultAsync(x => x.Id == message.MachineId);
if (machine?.VM == null)
{
return;
}
var adapter = machine.VM.NetworkAdapters
.FirstOrDefault(a => a.Name == message.ChangedAdapter.AdapterName);
if (adapter == null)
{
adapter = new VirtualMachineNetworkAdapter {
Name = message.ChangedAdapter.AdapterName, Vm = machine.VM
};
_stateStoreContext.Add(adapter);
}
adapter.SwitchName = message.ChangedAdapter.VirtualSwitchName;
var network = machine.Networks.FirstOrDefault(x => x.AdapterName == message.ChangedNetwork.AdapterName);
if (network == null)
{
network = new MachineNetwork {
AdapterName = message.ChangedNetwork.AdapterName
};
machine.Networks.Add(network);
}
network.DnsServerAddresses = message.ChangedNetwork.DnsServers;
network.IpV4Addresses = message.ChangedNetwork.IPAddresses.Select(IPAddress.Parse)
.Where(n => n.AddressFamily == AddressFamily.InterNetwork)
.Select(n => n.ToString()).ToArray();
network.IpV6Addresses = message.ChangedNetwork.IPAddresses.Select(IPAddress.Parse)
.Where(n => n.AddressFamily == AddressFamily.InterNetworkV6)
.Select(n => n.ToString()).ToArray();
network.IPv4DefaultGateway = message.ChangedNetwork.DefaultGateways.Select(IPAddress.Parse)
.FirstOrDefault(n => n.AddressFamily == AddressFamily.InterNetwork)?.ToString();
network.IPv6DefaultGateway = message.ChangedNetwork.DefaultGateways.Select(IPAddress.Parse)
.FirstOrDefault(n => n.AddressFamily == AddressFamily.InterNetworkV6)?.ToString();
network.IpV4Subnets = message.ChangedNetwork.IPAddresses.Select(IPNetwork.Parse)
.Where(n => n.AddressFamily == AddressFamily.InterNetwork)
.Select(n => n.ToString()).ToArray();
network.IpV6Subnets = message.ChangedNetwork.IPAddresses.Select(IPNetwork.Parse)
.Where(n => n.AddressFamily == AddressFamily.InterNetworkV6)
.Select(n => n.ToString()).ToArray();
await _stateStoreContext.SaveChangesAsync().ConfigureAwait(false);
}
public Task Handle(ConvergeVirtualMachineProgressEvent message)
{
var operation = _dbContext.Operations.FirstOrDefault(op => op.Id == message.OperationId);
if (operation != null)
{
var opLogEntry =
new OperationLog
{
Id = Guid.NewGuid(),
Message = message.Message,
Operation = operation,
Timestamp = DateTime.Now
};
_dbContext.Add(opLogEntry);
_dbContext.SaveChanges();
}
Console.WriteLine(message.Message);
return(Task.CompletedTask);
}
public async Task Handle(CreateNewOperationTaskCommand message)
{
var command = JsonConvert.DeserializeObject(message.CommandData, Type.GetType(message.CommandType));
var op = await _dbContext.Operations.FindAsync(message.OperationId).ConfigureAwait(false);
if (op == null)
{
MarkAsComplete();
return;
}
var task = await _dbContext.OperationTasks.FindAsync(message.TaskId).ConfigureAwait(false);
if (task == null)
{
task = new OperationTask
{
Id = message.TaskId,
Operation = op,
};
_dbContext.Add(task);
}
task.Name = command.GetType().Name;
Data.Tasks.Add(message.TaskId, command.GetType().AssemblyQualifiedName);
await _dbContext.SaveChangesAsync().ConfigureAwait(false);
var sendCommandAttribute = command.GetType().GetCustomAttribute <SendMessageToAttribute>();
switch (sendCommandAttribute.Recipient)
{
case MessageRecipient.VMHostAgent:
{
switch (command)
{
case IMachineCommand machineCommand:
{
var machine = await _dbContext.Machines.FindAsync(machineCommand.MachineId).ConfigureAwait(false);
if (machine == null)
{
if (command.GetType().GetCustomAttribute(typeof(MachineMayNotExistsAttribute)) != null)
{
await Handle(OperationTaskStatusEvent.Completed(message.OperationId, message.TaskId));
}
else
{
await Handle(OperationTaskStatusEvent.Failed(message.OperationId, message.TaskId,
new ErrorData {
ErrorMessage = "Machine not found"
}));
}
return;
}
await _bus.Advanced.Routing.Send($"{QueueNames.VMHostAgent}.{machine.AgentName}", command)
.ConfigureAwait(false);
return;
}
case IHostAgentCommand agentCommand:
await _bus.Advanced.Routing.Send($"{QueueNames.VMHostAgent}.{agentCommand.AgentName}", command)
.ConfigureAwait(false);
return;
default:
throw new InvalidDataException($"Don't know how to route operation task command of type {command.GetType()}");
}
}
case MessageRecipient.Controllers:
await _bus.Send(command);
return;
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task Handle(UpdateInventoryCommand message)
{
var agentData = await _stateStoreContext.Agents
.Include(a => a.Machines).FirstOrDefaultAsync(x => x.Name == message.AgentName).ConfigureAwait(false);
if (agentData == null)
{
agentData = new Agent {
Name = message.AgentName
};
}
var newMachines = message.Inventory.Select(x =>
{
return(new Machine
{
Id = x.MachineId,
Name = x.Name,
Status = MapVmStatusToMachineStatus(x.Status),
Agent = agentData,
VM = new VirtualMachine
{
NetworkAdapters = x.NetworkAdapters.Select(a => new VirtualMachineNetworkAdapter
{
MachineId = x.MachineId,
Name = a.AdapterName,
SwitchName = a.VirtualSwitchName
}).ToList(),
},
Networks = x.Networks?.Select(mn => new MachineNetwork
{
MachineId = x.MachineId,
AdapterName = mn.AdapterName,
DnsServerAddresses = mn.DnsServers,
IpV4Addresses = mn.IPAddresses.Select(IPAddress.Parse).Where(n => n.AddressFamily == AddressFamily.InterNetwork)
.Select(n => n.ToString()).ToArray(),
IpV6Addresses = mn.IPAddresses.Select(IPAddress.Parse).Where(n => n.AddressFamily == AddressFamily.InterNetworkV6)
.Select(n => n.ToString()).ToArray(),
IPv4DefaultGateway = mn.DefaultGateways.Select(IPAddress.Parse).FirstOrDefault(n => n.AddressFamily == AddressFamily.InterNetwork)?.ToString(),
IPv6DefaultGateway = mn.DefaultGateways.Select(IPAddress.Parse).FirstOrDefault(n => n.AddressFamily == AddressFamily.InterNetworkV6)?.ToString(),
IpV4Subnets = mn.IPAddresses.Select(IPNetwork.Parse).Where(n => n.AddressFamily == AddressFamily.InterNetwork)
.Select(n => n.ToString()).ToArray(),
IpV6Subnets = mn.IPAddresses.Select(IPNetwork.Parse).Where(n => n.AddressFamily == AddressFamily.InterNetworkV6)
.Select(n => n.ToString()).ToArray(),
}).ToList()
});
});
foreach (var newMachine in newMachines)
{
var existingMachine = await _stateStoreContext.Machines.Where(x => x.Id == newMachine.Id)
.Include(x => x.VM)
.ThenInclude(x => x.NetworkAdapters)
.Include(x => x.Networks).FirstOrDefaultAsync().ConfigureAwait(false);
if (existingMachine == null)
{
_stateStoreContext.Add(newMachine);
continue;
}
existingMachine.Name = newMachine.Name;
existingMachine.Status = newMachine.Status;
existingMachine.Agent = agentData;
if (existingMachine.VM == null)
{
existingMachine.VM = new VirtualMachine();
}
existingMachine.VM.NetworkAdapters = newMachine.VM.NetworkAdapters;
existingMachine.Networks = newMachine.Networks;
}
await _stateStoreContext.SaveChangesAsync().ConfigureAwait(false);
}
