public static void Upload(this Libvirt.CS_Objects.Storage_Volume s, Libvirt.CS_Objects.Host host, System.IO.Stream stream)
{
using (var st = host.virStreamNew(Libvirt.virStreamFlags.VIR_STREAM_NONBLOCK))
{
var stupload = s.virStorageVolUpload(st, 0, (ulong)stream.Length);
long chunksize = 65000;
var dat = new byte[chunksize];
var totalbytes = stream.Length;
while (totalbytes > 0)
{
var bytestoread = chunksize;
if (totalbytes < bytestoread)
{
bytestoread = totalbytes;
}
var bread = (uint)stream.Read(dat, 0, (int)bytestoread);
var bytessent = st.virStreamSend(dat, bread);
if (bytessent < 0)
{
st.virStreamAbort();
break;//get out!!
}
totalbytes -= (long)bread;
}
st.virStreamFinish();
}
}
public static List<Libvirt_WebManager.ViewModels.TreeViewModel> Build(List<string> path_parts, Libvirt.CS_Objects.Host host)
{
var ret = new List<Libvirt_WebManager.ViewModels.TreeViewModel>();
var nodeh = new nodehelper { currentpath = "", host = host, hostname = path_parts[0].ToLower() };
Libvirt_WebManager.ViewModels.TreeViewModel.Node_Types node_type = TreeViewModel.Node_Types.Host;
if (path_parts.Count >= 2)
{
if (!Enum.TryParse(path_parts[1], out node_type)) return ret;
nodeh.currentpath = "/" + nodeh.hostname + "/" + node_type.ToString() + "/";
}
if (path_parts.Count == 3)
{
nodeh.currentpath += path_parts[2] + "/";
if (node_type == TreeViewModel.Node_Types.Domains)
{
}
else if (node_type == TreeViewModel.Node_Types.Interfaces)
{
}
else if (node_type == TreeViewModel.Node_Types.Storage_Pools)
{
return Populate_StorageVolumes(nodeh, path_parts[2]);
}
}
else if (path_parts.Count == 2)
{
if (node_type == TreeViewModel.Node_Types.Domains)
{
return Populate_Domains(nodeh);
}
else if (node_type == TreeViewModel.Node_Types.Interfaces)
{
}
else if (node_type == TreeViewModel.Node_Types.Storage_Pools)
{
return Populate_StoragePools(nodeh);
}
}
else if (path_parts.Count == 1)
{
nodeh.currentpath = "/" + nodeh.hostname + "/";
ret.Add(new TreeViewModel { IsDirectory = true, Node_Type = TreeViewModel.Node_Types.Domains, Name = "Domains", Path = nodeh.currentpath + "Domains/", Host = nodeh.hostname });
ret.Add(new TreeViewModel { IsDirectory = true, Node_Type = TreeViewModel.Node_Types.Interfaces, Name = "Interfaces", Path = nodeh.currentpath + "Interfaces/", Host = nodeh.hostname });
ret.Add(new TreeViewModel { IsDirectory = true, Node_Type = TreeViewModel.Node_Types.Storage_Pools, Name = "Storage_Pools", Path = nodeh.currentpath + "Storage_Pools/", Host = nodeh.hostname });
}
else
{
ret.Add(new TreeViewModel { IsDirectory = true, Node_Type = TreeViewModel.Node_Types.Host, Name = nodeh.hostname, Path = nodeh.currentpath + "/" + nodeh.hostname + "/", Host = nodeh.hostname });
}
return ret;
}
public static Models.Domain_Details_Down Build_Domain_Details_Down(string host, string domain, out Libvirt.Models.Concrete.Virtual_Machine machine)
{
machine = GetMachine(host, domain, null);
var vm = new Models.Domain_Details_Down();
vm.type = machine.type;
vm.Bios = machine.BootLoader;
vm.MetaData = Utilities.AutoMapper.Mapper<Models.General_Metadata_VM>.Map(machine.Metadata);
vm.MetaData.Host = host;
vm.MetaData.Parent = domain;
return vm;
}
public static Models.Domain_CPU_Down Build_Domain_CPU_Down(string host, string domain, out Libvirt.Models.Concrete.Virtual_Machine machine)
{
machine = GetMachine(host, domain, null);
Libvirt._virNodeInfo info;
Service.VM_Manager.Instance.virConnectOpen(host).virNodeGetInfo(out info);
var vm = new Models.Domain_CPU_Down();
vm.NodeCpuInfo = info;
vm.CpuInfo = Utilities.AutoMapper.Mapper<Models.Domain_CPU_Down_VM>.Map(machine.CPU);
vm.CpuInfo.Host = host;
vm.CpuInfo.Parent = domain;
return vm;
}
public static Models.Domain_Graphics_Down Build_Domain_Graphics_Down(string host, string domain, out Libvirt.Models.Concrete.Virtual_Machine machine)
{
machine = GetMachine(host, domain, null);
var vm = new Models.Domain_Graphics_Down();
vm.Domain_Graphics = new Models.Domain_Graphics_Down_VM();
vm.Domain_Graphics.Graphic_Type = machine.graphics.Graphic_Type;
vm.Domain_Graphics.Listen_Address_Type = Models.Listen_Address_Types.LocalHost;
if (!string.IsNullOrWhiteSpace(machine.graphics.listen))
{
vm.Domain_Graphics.Listen_Address_Type = (machine.graphics.listen == "0.0.0.0" ? Models.Listen_Address_Types.All_Interfaces : Models.Listen_Address_Types.LocalHost);
}
vm.Domain_Graphics.passwd = machine.graphics.passwd;
vm.Domain_Graphics.passwdValidTo = machine.graphics.passwdValidTo;
vm.Domain_Graphics.WebSocket = machine.graphics.websocket.HasValue;
vm.Domain_Graphics.Host = host;
vm.Domain_Graphics.Parent = domain;
return vm;
}
public static Models.Domain_Bios_Down Build_Domain_Bios_Down(string host, string domain, out Libvirt.Models.Concrete.Virtual_Machine machine)
{
machine = GetMachine(host, domain, null);
var h = Service.VM_Manager.Instance.virConnectOpen(host);
using (var d = h.virDomainLookupByName(domain))
{
var vm = new Models.Domain_Bios_Down();
vm.BiosInfo = new Models.Domain_Bios_Down_VM();
vm.BiosInfo.BootOrder = machine.BootLoader.BootOrder.Select(a => new Models.BootOrder_VM { BootType = a, Enabled = true }).ToList();
vm.BiosInfo.ShowBootMenu = machine.BootLoader.ShowBootMenu;
var autostart = 0;
d.virDomainGetAutostart(ref autostart);
vm.BiosInfo.StartGuestAutomatically = autostart == 1;
vm.BiosInfo.Host = host;
vm.BiosInfo.Parent = domain;
return vm;
}
}
private static Libvirt.Models.Concrete.Virtual_Machine GetMachine(string host, string domain, Libvirt.Models.Concrete.Virtual_Machine machine = null)
{
if (machine == null)
{
var h = Service.VM_Manager.Instance.virConnectOpen(host);
using (var d = h.virDomainLookupByName(domain))
{
machine = d.virDomainGetXMLDesc(Libvirt.virDomainXMLFlags.VIR_DOMAIN_XML_INACTIVE | Libvirt.virDomainXMLFlags.VIR_DOMAIN_XML_SECURE);
}
}
return machine;
}
public static Models.Domain_Drive_Down Domain_Drive_Down(string host, string domain, char letter, out Libvirt.Models.Concrete.Virtual_Machine machine)
{
machine = GetMachine(host, domain, null);
var h = Service.VM_Manager.Instance.virConnectOpen(host);
using (var d = h.virDomainLookupByName(domain))
{
var vm = new Models.Domain_Drive_Down();
vm.Domain_Drive = new Models.Domain_Drive_Down_VM();
vm.Domain_Drive = Utilities.AutoMapper.Mapper<Models.Domain_Drive_Down_VM>.Map(machine.Drives.Disks.FirstOrDefault(a => a.Letter == letter));
vm.Disk = machine.Drives.Disks.FirstOrDefault(a => a.Letter == letter);
var volthingy = vm.Disk.Source as Libvirt.Models.Concrete.Device_Source_Volume;
if (volthingy != null)
{
vm.Domain_Drive.Pool = volthingy.pool;
vm.Domain_Drive.Volume = volthingy.volume;
}
vm.Domain_Drive.Source_Startup_Policy = vm.Disk.Source.Source_Startup_Policy;
vm.Domain_Drive.Host = host;
vm.Domain_Drive.Parent = domain;
return vm;
}
}
public Stream(Libvirt.virStreamPtr ptr)
{
_StreamPtr = ptr;
}
public Domain virDomainCreateXMLWithFiles(Libvirt.Models.Concrete.Virtual_Machine machine_def, int[] files, virDomainCreateFlags flags)
{
return new Domain(API.virDomainCreateXMLWithFiles(_ConnectPtr, machine_def.To_XML(), Convert.ToUInt32(files.Length), files, flags));
}
public Host(Libvirt.virConnectPtr ptr)
{
_ConnectPtr = ptr;
}
public Domain virDomainDefineXMLFlags(Libvirt.Models.Concrete.Virtual_Machine machine_def, virDomainDefineFlags flags)
{
return new Domain(API.virDomainDefineXMLFlags(_ConnectPtr, machine_def.To_XML(), flags));
}
public IService(Libvirt.Models.Interface.IValdiator v)
{
_Validator = v;
}
public Network_Service(Libvirt.Models.Interface.IValdiator v)
: base(v)
{
}
private void virDomainDefineXML(Libvirt.Models.Concrete.Virtual_Machine machine, Libvirt.CS_Objects.Host h)
{
if (ModelState.IsValid)
{
using (var newd = h.virDomainDefineXML(machine))
{
Debug.WriteLine("virDomainDefineXML Called");
}
}
}
private void BuildBootOrder(Models.Domain_Bios_Down_VM BiosInfo, Libvirt.Models.Concrete.Virtual_Machine machine)
{
BiosInfo.BootOrder.Clear();
if (machine.Drives.Disks.Any(a => a.Disk_Device_Type == Libvirt.Models.Concrete.Disk.Disk_Device_Types.cdrom))
{
BiosInfo.BootOrder.Add(new Models.BootOrder_VM
{
Enabled = machine.BootLoader.BootOrder.Any(b => b == Libvirt.Models.Concrete.BIOS_Bootloader.Boot_Types.cdrom),
BootType = Libvirt.Models.Concrete.BIOS_Bootloader.Boot_Types.cdrom
});
}
if (machine.Drives.Disks.Any(a => a.Disk_Device_Type == Libvirt.Models.Concrete.Disk.Disk_Device_Types.disk))
{
BiosInfo.BootOrder.Add(new Models.BootOrder_VM
{
Enabled = machine.BootLoader.BootOrder.Any(b => b == Libvirt.Models.Concrete.BIOS_Bootloader.Boot_Types.hd),
BootType = Libvirt.Models.Concrete.BIOS_Bootloader.Boot_Types.hd
});
}
BiosInfo.BootOrder.Add(new Models.BootOrder_VM
{
Enabled = machine.BootLoader.BootOrder.Any(b => b == Libvirt.Models.Concrete.BIOS_Bootloader.Boot_Types.network),
BootType = Libvirt.Models.Concrete.BIOS_Bootloader.Boot_Types.network
});
}
public Storage_Pool virStoragePoolDefineXML(Libvirt.Models.Concrete.Storage_Pool pool_def)
{
return new Storage_Pool(API.virStoragePoolDefineXML(_ConnectPtr, pool_def.To_XML()));
}
public Network virNetworkDefineXML(Libvirt.Models.Concrete.Network xmlDesc)
{
return new Network(API.virNetworkDefineXML(_ConnectPtr, xmlDesc.To_XML()));
}
public int virDomainAttachDevice(Libvirt.Models.Interface.IXML device)
{
return API.virDomainAttachDevice(_DomainPtr, device.To_XML());
}
public Storage_Pool(Libvirt.virStoragePoolPtr ptr)
{
_Storage_PoolPtr = ptr;
}
public Domain virDomainDefineXML(Libvirt.Models.Concrete.Virtual_Machine machine_def)
{
return new Domain(API.virDomainDefineXML(_ConnectPtr, machine_def.To_XML()));
}
public static Models.Domain_Network_Down Build_Domain_Network_Down(string host, string domain, out Libvirt.Models.Concrete.Virtual_Machine machine)
{
machine = GetMachine(host, domain, null);
var h = Service.VM_Manager.Instance.virConnectOpen(host);
var vm = new Models.Domain_Network_Down();
vm.Network = Utilities.AutoMapper.Mapper<Models.Domain_Network_Down_VM>.Map(machine.Iface);
using (var ns = h.virConnectListAllNetworks(Libvirt.virConnectListAllNetworksFlags.VIR_DEFAULT))
{
vm.Networks = ns.Select(a => a.virNetworkGetXMLDesc(Libvirt.virNetworkXMLFlags.VIR_DEFAULT)).ToList();
}
return vm;
}
public Domain_Service(Libvirt.Models.Interface.IValdiator v)
: base(v)
{
}
public Domain(Libvirt.virDomainPtr ptr)
{
_DomainPtr = ptr;
}
public Storage_Volume(Libvirt.virStorageVolPtr ptr)
{
_Storage_VolumePtr = ptr;
}
public int virDomainAttachDeviceFlags(Libvirt.Models.Interface.IXML device, virDomainDeviceModifyFlags flags)
{
return API.virDomainAttachDeviceFlags(_DomainPtr, device.To_XML(), flags);
}
void virErrorFunc(IntPtr userData, Libvirt.virErrorPtr error)
{
var msg = Libvirt.API.MarshalErrorPtr(error);
var errmsg = new Libvirt_WebManager.Models.Message.ErrorMessage
{
Additional_Info_1 = msg.str1,
Additional_Info_2 = msg.str2,
Additional_Info_3 = msg.str3,
Body = msg.message,
Code = msg.code,
Message_Type = Models.Message_Types.danger,
Time = DateTime.Now,
Title = "Libvirt Error"
};
Message_Manager.Send(errmsg);
}
