/**
* gvir_config_domain_set_devices:
* @domain: a #GVirConfigDomain
* @devices: (in) (element-type LibvirtGConfig.DomainDevice):
*/
void gvir_config_domain_set_devices(GVirConfigDomain *domain,
GList *devices)
{
GVirConfigObject *devices_node;
GList *it;
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));
if (devices == NULL) {
gvir_config_object_delete_children(GVIR_CONFIG_OBJECT(domain),
"devices",
NULL);
return;
}
devices_node = gvir_config_object_new(GVIR_CONFIG_TYPE_OBJECT,
"devices", NULL);
for (it = devices; it != NULL; it = it->next) {
if (!GVIR_CONFIG_IS_DOMAIN_DEVICE(it->data)) {
g_warn_if_reached();
continue;
}
gvir_config_object_attach_add(devices_node,
GVIR_CONFIG_OBJECT(it->data));
}
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(domain),
"devices",
devices_node);
g_object_unref(G_OBJECT(devices_node));
}
/**
* gvir_config_domain_set_os:
* @domain: a #GVirConfigDomain
* @os: (allow-none): the os configuration to set
*/
void gvir_config_domain_set_os(GVirConfigDomain *domain,
GVirConfigDomainOs *os)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));
g_return_if_fail(os == NULL || GVIR_CONFIG_IS_DOMAIN_OS(os));
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(domain),
"os",
GVIR_CONFIG_OBJECT(os));
}
/**
* gvir_config_domain_set_clock:
* @domain: a #GVirConfigDomain
* @klock: (allow-none):
*/
void gvir_config_domain_set_clock(GVirConfigDomain *domain,
GVirConfigDomainClock *klock)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));
g_return_if_fail(klock != NULL || GVIR_CONFIG_IS_DOMAIN_CLOCK(klock));
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(domain),
"clock",
GVIR_CONFIG_OBJECT(klock));
}
/**
* gvir_config_domain_smartcard_set_address:
* @address: (allow-none):
*/
void gvir_config_domain_smartcard_set_address(GVirConfigDomainRedirdev *redirdev,
GVirConfigDomainAddress *address)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_REDIRDEV(redirdev));
g_return_if_fail(address == NULL || GVIR_CONFIG_IS_DOMAIN_ADDRESS(address));
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(redirdev),
"address",
GVIR_CONFIG_OBJECT(address));
}
/**
* gvir_config_domain_controller_set_address:
* @address: (allow-none):
*/
void gvir_config_domain_controller_set_address(GVirConfigDomainController *controller,
GVirConfigDomainAddress *address)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_CONTROLLER(controller));
g_return_if_fail(address == NULL || GVIR_CONFIG_IS_DOMAIN_ADDRESS(address));
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(controller),
"address",
GVIR_CONFIG_OBJECT(address));
}
/**
* gvir_config_domain_set_seclabel:
* @domain: a #GVirConfigDomain
* @seclabel: (allow-none): the security label configuration to set
*/
void gvir_config_domain_set_seclabel(GVirConfigDomain *domain,
GVirConfigDomainSeclabel *seclabel)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));
g_return_if_fail(seclabel == NULL ||
GVIR_CONFIG_IS_DOMAIN_SECLABEL(seclabel));
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(domain),
"seclabel",
GVIR_CONFIG_OBJECT(seclabel));
}
/**
* gvir_config_storage_vol_set_target:
* @target: (allow-none):
*/
void gvir_config_storage_vol_set_target(GVirConfigStorageVol *vol,
GVirConfigStorageVolTarget *target)
{
g_return_if_fail(GVIR_CONFIG_IS_STORAGE_VOL(vol));
g_return_if_fail(target == NULL ||
GVIR_CONFIG_IS_STORAGE_VOL_TARGET(target));
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(vol),
"target",
GVIR_CONFIG_OBJECT(target));
}
/**
* gvir_config_storage_vol_set_backing_store:
* @backing_store: (allow-none):
*/
void gvir_config_storage_vol_set_backing_store(GVirConfigStorageVol *vol,
GVirConfigStorageVolBackingStore *backing_store)
{
g_return_if_fail(GVIR_CONFIG_IS_STORAGE_VOL(vol));
g_return_if_fail(backing_store == NULL ||
GVIR_CONFIG_IS_STORAGE_VOL_BACKING_STORE(backing_store));
gvir_config_object_attach_replace(GVIR_CONFIG_OBJECT(vol),
"backingStore",
GVIR_CONFIG_OBJECT(backing_store));
}
void gvir_config_domain_video_set_vgamem(GVirConfigDomainVideo *video,
guint kbytes)
{
GVirConfigObject *node;
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_VIDEO(video));
node = gvir_config_object_add_child(GVIR_CONFIG_OBJECT(video), "model");
g_return_if_fail(GVIR_CONFIG_OBJECT(node));
gvir_config_object_set_attribute_with_type(node, "vgamem", G_TYPE_UINT,
kbytes, NULL);
g_object_unref(G_OBJECT(node));
}
int main(int argc, char **argv)
{
GVirConfigDomain *domain;
const char *name;
GStrv features;
char *xml;
GError *error = NULL;
gvir_config_init(&argc, &argv);
if (argc != 2) {
g_print("Usage: %s filename\n", argv[0]);
g_print("Attempt to parse the libvirt XML definition from filename\n");
return 1;
}
g_file_get_contents(argv[1], &xml, NULL, &error);
if (error != NULL) {
g_print("Couldn't read %s: %s\n", argv[1], error->message);
return 2;
}
domain = gvir_config_domain_new_from_xml(xml, &error);
if (error != NULL) {
g_print("Couldn't parse %s: %s\n", argv[1], error->message);
return 3;
}
g_assert(domain != NULL);
gvir_config_object_validate(GVIR_CONFIG_OBJECT(domain), &error);
if (error != NULL) {
g_print("%s format is invalid: %s\n", argv[1], error->message);
g_clear_error(&error);
}
name = gvir_config_domain_get_name(domain);
g_assert(name != NULL);
g_assert(strcmp(name, "foo") == 0);
g_assert(gvir_config_domain_get_memory(domain) == 987654321);
features = gvir_config_domain_get_features(domain);
g_assert(g_strv_length(features) == 2);
g_assert(strcmp(features[0], "f1") == 0);
g_assert(strcmp(features[1], "f2") == 0);
g_strfreev(features);
g_free(xml);
xml = gvir_config_object_to_xml(GVIR_CONFIG_OBJECT(domain));
g_print("%s\n", xml);
g_free(xml);
g_object_unref(G_OBJECT(domain));
return 0;
}
void gvir_config_domain_add_device(GVirConfigDomain *domain,
GVirConfigDomainDevice *device)
{
GVirConfigObject *devices_node;
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_DEVICE(device));
devices_node = gvir_config_object_add_child(GVIR_CONFIG_OBJECT(domain),
"devices");
gvir_config_object_attach_add(devices_node, GVIR_CONFIG_OBJECT(device));
g_object_unref(G_OBJECT(devices_node));
}
void gvir_config_domain_address_pci_set_multifunction(GVirConfigDomainAddressPci *address,
gboolean multifunction)
{
gvir_config_object_set_attribute(GVIR_CONFIG_OBJECT(address),
"multifunction",
multifunction?"on":"off", NULL);
}
gboolean gvir_config_domain_set_custom_xml(GVirConfigDomain *domain,
const gchar *xml,
const gchar *ns,
const gchar *ns_uri,
GError **error)
{
GVirConfigObject *metadata;
GVirConfigObject *custom_xml;
g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), FALSE);
g_return_val_if_fail(xml != NULL, FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
metadata = gvir_config_object_add_child(GVIR_CONFIG_OBJECT(domain),
"metadata");
custom_xml = gvir_config_object_new_from_xml(GVIR_CONFIG_TYPE_OBJECT,
NULL, NULL, xml, error);
if (custom_xml == NULL) {
g_assert_not_reached();
g_object_unref(G_OBJECT(metadata));
return FALSE;
}
gvir_config_object_set_namespace(custom_xml, ns, ns_uri);
gvir_config_object_delete_children(metadata, NULL, ns_uri);
gvir_config_object_attach_add(metadata, custom_xml);
g_object_unref(G_OBJECT(metadata));
g_object_unref(G_OBJECT(custom_xml));
return TRUE;
}
const gchar *gvir_config_domain_device_get_alias(GVirConfigDomainDevice *dev)
{
g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN_DEVICE(dev), NULL);
return gvir_config_object_get_attribute(GVIR_CONFIG_OBJECT(dev),
"alias", "name");
}
/**
* gvir_config_storage_pool_source_set_name:
* @name: (allow-none):
*/
void gvir_config_storage_pool_source_set_name(GVirConfigStoragePoolSource *source,
const char *name)
{
g_return_if_fail(GVIR_CONFIG_IS_STORAGE_POOL_SOURCE(source));
gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(source),
"name", name);
}
/**
* gvir_config_storage_vol_backing_store_set_path:
* @path: (allow-none):
*/
void gvir_config_storage_vol_backing_store_set_path(GVirConfigStorageVolBackingStore *backing_store,
const char *path)
{
g_return_if_fail(GVIR_CONFIG_IS_STORAGE_VOL_BACKING_STORE(backing_store));
gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(backing_store),
"path", path);
}
int gvir_config_domain_address_pci_get_domain(GVirConfigDomainAddressPci *address)
{
g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN_ADDRESS_PCI(address), -1);
return gvir_config_object_get_attribute_uint64(GVIR_CONFIG_OBJECT(address),
NULL, "domain",
-1);
}
void
gvir_config_capabilities_cpu_topology_set_sockets(GVirConfigCapabilitiesCpuTopology *topology,
guint64 sockets)
{
gvir_config_object_set_attribute_with_type(GVIR_CONFIG_OBJECT(topology),
"sockets", G_TYPE_UINT64, sockets,
NULL);
}
void gvir_config_storage_vol_set_allocation(GVirConfigStorageVol *vol,
guint64 allocation)
{
g_return_if_fail(GVIR_CONFIG_IS_STORAGE_VOL(vol));
gvir_config_object_set_node_content_uint64(GVIR_CONFIG_OBJECT(vol),
"allocation", allocation);
}
void gvir_config_storage_vol_set_capacity(GVirConfigStorageVol *vol,
guint64 capacity)
{
g_return_if_fail(GVIR_CONFIG_IS_STORAGE_VOL(vol));
gvir_config_object_set_node_content_uint64(GVIR_CONFIG_OBJECT(vol),
"capacity", capacity);
}
void gvir_config_domain_interface_bridge_set_source(GVirConfigDomainInterfaceBridge *interface,
const char *brname)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_INTERFACE_BRIDGE(interface));
gvir_config_object_replace_child_with_attribute(GVIR_CONFIG_OBJECT(interface),
"source", "bridge", brname);
}
void gvir_config_domain_set_virt_type(GVirConfigDomain *domain, GVirConfigDomainVirtType type)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));
gvir_config_object_set_attribute_with_type(GVIR_CONFIG_OBJECT(domain),
"type",
GVIR_CONFIG_TYPE_DOMAIN_VIRT_TYPE,
type, NULL);
}
/**
* gvir_config_storage_vol_set_name:
* @name: (allow-none):
*/
void gvir_config_storage_vol_set_name(GVirConfigStorageVol *vol,
const char *name)
{
g_return_if_fail(GVIR_CONFIG_IS_STORAGE_VOL(vol));
gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(vol),
"name", name);
}
const gchar *
gvir_config_capabilities_guest_arch_get_emulator(GVirConfigCapabilitiesGuestArch *arch)
{
g_return_val_if_fail(GVIR_CONFIG_IS_CAPABILITIES_GUEST_ARCH(arch), NULL);
return gvir_config_object_get_node_content(GVIR_CONFIG_OBJECT(arch),
"emulator");
}
gboolean gvir_config_domain_address_pci_get_multifunction(GVirConfigDomainAddressPci *address)
{
g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN_ADDRESS_PCI(address), FALSE);
return gvir_config_object_get_attribute_boolean(GVIR_CONFIG_OBJECT(address),
NULL, "multifunction",
FALSE);
}
const gchar *
gvir_config_capabilities_guest_arch_get_name(GVirConfigCapabilitiesGuestArch *arch)
{
g_return_val_if_fail(GVIR_CONFIG_IS_CAPABILITIES_GUEST_ARCH(arch), NULL);
return gvir_config_object_get_attribute(GVIR_CONFIG_OBJECT(arch),
NULL,
"name");
}
void gvir_config_domain_graphics_sdl_set_display(GVirConfigDomainGraphicsSdl *graphics,
const gchar *disp)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_GRAPHICS_SDL(graphics));
gvir_config_object_set_attribute(GVIR_CONFIG_OBJECT(graphics),
"display", disp,
NULL);
}
void gvir_config_domain_graphics_sdl_set_xauthority(GVirConfigDomainGraphicsSdl *graphics,
const gchar *path)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_GRAPHICS_SDL(graphics));
gvir_config_object_set_attribute(GVIR_CONFIG_OBJECT(graphics),
"xauth", path,
NULL);
}
void gvir_config_domain_controller_set_index(GVirConfigDomainController *controller,
guint index)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_CONTROLLER(controller));
gvir_config_object_set_attribute_with_type(GVIR_CONFIG_OBJECT(controller),
"index", G_TYPE_UINT,
index, NULL);
}
void gvir_config_domain_graphics_vnc_set_password(GVirConfigDomainGraphicsVnc *graphics,
const char *password)
{
g_return_if_fail(GVIR_CONFIG_IS_DOMAIN_GRAPHICS_VNC(graphics));
gvir_config_object_set_attribute(GVIR_CONFIG_OBJECT(graphics),
"passwd", password,
NULL);
}
