/*

 * libvirt-gconfig-domain.c: libvirt domain configuration

 *

 * Copyright (C) 2008 Daniel P. Berrange

 * Copyright (C) 2010-2011 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see

 * <http://www.gnu.org/licenses/>.

 *

 * Author: Daniel P. Berrange <berrange@redhat.com>

 */

#include <config.h>

#include "libvirt-gconfig/libvirt-gconfig.h"

#include "libvirt-gconfig/libvirt-gconfig-private.h"

#define GVIR_CONFIG_DOMAIN_GET_PRIVATE(obj)                         \

        (G_TYPE_INSTANCE_GET_PRIVATE((obj), GVIR_CONFIG_TYPE_DOMAIN, GVirConfigDomainPrivate))

struct _GVirConfigDomainPrivate

{

    gboolean unused;

};

G_DEFINE_TYPE_WITH_PRIVATE(GVirConfigDomain, gvir_config_domain, GVIR_CONFIG_TYPE_OBJECT);

enum {

    PROP_0,

    PROP_NAME,

    PROP_UUID,

    PROP_TITLE,

    PROP_DESCRIPTION,

    PROP_MEMORY,

    PROP_VCPU,

    PROP_FEATURES,

    PROP_CURRENT_MEMORY

};

static void gvir_config_domain_get_property(GObject *object,

                                            guint prop_id,

                                            GValue *value,

                                            GParamSpec *pspec)

{

    GVirConfigDomain *domain = GVIR_CONFIG_DOMAIN(object);

    switch (prop_id) {

    case PROP_NAME:

        g_value_set_string(value, gvir_config_domain_get_name(domain));

        break;

    case PROP_UUID:

        g_value_set_string(value, gvir_config_domain_get_uuid(domain));

        break;

    case PROP_TITLE:

        g_value_set_string(value, gvir_config_domain_get_title(domain));

        break;

    case PROP_DESCRIPTION:

        g_value_set_string(value, gvir_config_domain_get_description(domain));

        break;

    case PROP_MEMORY:

        g_value_set_uint64(value, gvir_config_domain_get_memory(domain));

        break;

    case PROP_CURRENT_MEMORY:

        g_value_set_uint64(value, gvir_config_domain_get_current_memory(domain));

        break;

    case PROP_VCPU:

        g_value_set_uint64(value, gvir_config_domain_get_vcpus(domain));

        break;

    case PROP_FEATURES:

        g_value_take_boxed(value, gvir_config_domain_get_features(domain));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

    }

}

static void gvir_config_domain_set_property(GObject *object,

                                            guint prop_id,

                                            const GValue *value,

                                            GParamSpec *pspec)

{

    GVirConfigDomain *domain = GVIR_CONFIG_DOMAIN(object);

    switch (prop_id) {

    case PROP_NAME:

        gvir_config_domain_set_name(domain, g_value_get_string(value));

        break;

    case PROP_UUID:

        gvir_config_domain_set_uuid(domain, g_value_get_string(value));

        break;

    case PROP_TITLE:

        gvir_config_domain_set_title(domain, g_value_get_string(value));

        break;

    case PROP_DESCRIPTION:

        gvir_config_domain_set_description(domain, g_value_get_string(value));

        break;

    case PROP_MEMORY:

        gvir_config_domain_set_memory(domain, g_value_get_uint64(value));

        break;

    case PROP_CURRENT_MEMORY:

        gvir_config_domain_set_current_memory(domain, g_value_get_uint64(value));

        break;

    case PROP_VCPU:

        gvir_config_domain_set_vcpus(domain, g_value_get_uint64(value));

        break;

    case PROP_FEATURES:

        gvir_config_domain_set_features(domain, g_value_get_boxed(value));

        break;

    default:

        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

    }

}

static void gvir_config_domain_class_init(GVirConfigDomainClass *klass)

{

    GObjectClass *object_class = G_OBJECT_CLASS(klass);

    object_class->get_property = gvir_config_domain_get_property;

    object_class->set_property = gvir_config_domain_set_property;

    g_object_class_install_property(object_class,

                                    PROP_NAME,

                                    g_param_spec_string("name",

                                                        "Name",

                                                        "Domain Name",

                                                        NULL,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_UUID,

                                    g_param_spec_string("uuid",

                                                        "UUID",

                                                        "Domain UUID",

                                                        NULL,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_TITLE,

                                    g_param_spec_string("title",

                                                        "Title",

                                                        "A short description - title - of the domain",

                                                        NULL,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_DESCRIPTION,

                                    g_param_spec_string("description",

                                                        "Description",

                                                        "Some human readable description (could be anything).",

                                                        NULL,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_MEMORY,

                                    g_param_spec_uint64("memory",

                                                        "Memory",

                                                        "Maximum Guest Memory (in kilobytes)",

                                                        0, G_MAXUINT64,

                                                        0,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_CURRENT_MEMORY,

                                    g_param_spec_uint64("current-memory",

                                                        "Current memory",

                                                        "Current Guest Memory (in kilobytes)",

                                                        0, G_MAXUINT64,

                                                        0,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_VCPU,

                                    g_param_spec_uint64("vcpu",

                                                        "Virtual CPUs",

                                                        "Maximum Number of Guest Virtual CPUs",

                                                        0, G_MAXUINT64,

                                                        1,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

    g_object_class_install_property(object_class,

                                    PROP_FEATURES,

                                    g_param_spec_boxed("features",

                                                        "Features",

                                                        "Hypervisor Features",

                                                        G_TYPE_STRV,

                                                        G_PARAM_READWRITE |

                                                        G_PARAM_STATIC_STRINGS));

}

static void gvir_config_domain_init(GVirConfigDomain *domain)

{

    domain->priv = GVIR_CONFIG_DOMAIN_GET_PRIVATE(domain);

}

GVirConfigDomain *gvir_config_domain_new_from_xml(const gchar *xml,

                                                  GError **error)

{

    GVirConfigObject *object;

    object = gvir_config_object_new_from_xml(GVIR_CONFIG_TYPE_DOMAIN,

                                             "domain",

                                             DATADIR "/libvirt/schemas/domain.rng",

                                             xml, error);

    return GVIR_CONFIG_DOMAIN(object);

}

GVirConfigDomain *gvir_config_domain_new(void)

{

    GVirConfigObject *object;

    object = gvir_config_object_new(GVIR_CONFIG_TYPE_DOMAIN,

                                    "domain",

                                    DATADIR "/libvirt/schemas/domain.rng");

    return GVIR_CONFIG_DOMAIN(object);

}

GVirConfigDomainVirtType gvir_config_domain_get_virt_type(GVirConfigDomain *domain)

{

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain),

                         GVIR_CONFIG_DOMAIN_VIRT_QEMU);

    return gvir_config_object_get_attribute_genum

                                (GVIR_CONFIG_OBJECT(domain),

                                 NULL,

                                 "type",

                                 GVIR_CONFIG_TYPE_DOMAIN_VIRT_TYPE,

                                 GVIR_CONFIG_DOMAIN_VIRT_QEMU);

}

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);

}

const char *gvir_config_domain_get_name(GVirConfigDomain *domain)

{

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    return gvir_config_object_get_node_content(GVIR_CONFIG_OBJECT(domain),

                                               "name");

}

const char *gvir_config_domain_get_uuid(GVirConfigDomain *domain)

{

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    return gvir_config_object_get_node_content(GVIR_CONFIG_OBJECT(domain),

                                               "uuid");

}

const char *gvir_config_domain_get_title(GVirConfigDomain *domain)

{

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    return gvir_config_object_get_node_content(GVIR_CONFIG_OBJECT(domain),

                                               "title");

}

/**

 * gvir_config_domain_set_name:

 * @domain: a #GVirConfigDomain

 * @name: (allow-none):

 */

void gvir_config_domain_set_name(GVirConfigDomain *domain, const char *name)

{

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(domain),

                                        "name", name);

    g_object_notify(G_OBJECT(domain), "name");

}

/**

 * gvir_config_domain_set_uuid:

 * @domain: a #GVirConfigDomain

 * @uuid: (allow-none):

 */

void gvir_config_domain_set_uuid(GVirConfigDomain *domain, const char *uuid)

{

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(domain),

                                        "uuid", uuid);

    g_object_notify(G_OBJECT(domain), "uuid");

}

/**

 * gvir_config_domain_set_title:

 * @domain: a #GVirConfigDomain

 * @title: (allow-none): title of the domain

 *

 * Sets the title of the domain. This is an optional short textual description of the domain. Passing a NULL @title

 * unsets the current domain title.

 */

void gvir_config_domain_set_title(GVirConfigDomain *domain, const char *title)

{

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(domain),

                                        "title", title);

    g_object_notify(G_OBJECT(domain), "title");

}

const char *gvir_config_domain_get_description(GVirConfigDomain *domain)

{

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    return gvir_config_object_get_node_content(GVIR_CONFIG_OBJECT(domain),

                                               "description");

}

/**

 * gvir_config_domain_set_description:

 * @domain: a #GVirConfigDomain

 * @description: (allow-none):

 */

void gvir_config_domain_set_description(GVirConfigDomain *domain,

                                        const char *description)

{

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(domain),

                                        "description", description);

    g_object_notify(G_OBJECT(domain), "description");

}

static void insert_base(GHashTable *unit_bases,

                        const char *unit,

                        guint64 unit_base)

{

    guint64 *base;

    base = g_slice_alloc(sizeof(*base));

    *base = unit_base;

    g_hash_table_insert(unit_bases, (gpointer)unit, base);

}

static gpointer set_unit_bases(G_GNUC_UNUSED gpointer user_data)

{

    GHashTable *unit_bases;

    unit_bases = g_hash_table_new(g_str_hash, g_str_equal);

    insert_base(unit_bases, "b", 1);

    insert_base(unit_bases, "bytes", 1);

    insert_base(unit_bases, "KB", 1000);

    insert_base(unit_bases, "k", 1024);

    insert_base(unit_bases, "KiB", 1024);

    insert_base(unit_bases, "MB", 1000*1000);

    insert_base(unit_bases, "M", 1024*1024);

    insert_base(unit_bases, "MiB", 1024*1024);

    insert_base(unit_bases, "GB", 1000*1000*1000);

    insert_base(unit_bases, "G", 1024*1024*1024);

    insert_base(unit_bases, "GiB", 1024*1024*1024);

    insert_base(unit_bases, "TB", (guint64)1000*1000*1000*1000);

    insert_base(unit_bases, "T", (guint64)1024*1024*1024*1024);

    insert_base(unit_bases, "TiB", (guint64)1024*1024*1024*1024);

    return unit_bases;

}

static guint64 get_unit_base(const char *unit, guint64 default_base)

{

    static GOnce set_unit_bases_once = G_ONCE_INIT;

    GHashTable *unit_bases;

    guint64 *unit_base;

    if (unit == NULL) {

        return default_base;

    }

    unit_bases = g_once (&set_unit_bases_once, set_unit_bases, &unit_bases);

    g_return_val_if_fail (unit_bases != NULL, default_base);

    unit_base = g_hash_table_lookup(unit_bases, unit);

    if (unit_base == NULL) {

        /* unknown unit, fall back to the default unit */

        g_return_val_if_reached(default_base);

    }

    return *unit_base;

}

/**

 * gvir_config_domain_get_memory:

 * @domain: a #GVirConfigDomain

 *

 * Returns: maximum amount of RAM in kilobytes (i.e. blocks of 1024 bytes).

 */

guint64 gvir_config_domain_get_memory(GVirConfigDomain *domain)

{

    const char *unit;

    guint64 unit_base;

    guint64 memory;

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), 0);

    unit = gvir_config_object_get_attribute(GVIR_CONFIG_OBJECT(domain), "memory", "unit");

    unit_base = get_unit_base(unit, 1024);

    memory = gvir_config_object_get_node_content_uint64(GVIR_CONFIG_OBJECT(domain),

                                                        "memory");

    return memory * unit_base / 1024;

}

/**

 * gvir_config_domain_get_current_memory:

 * @domain: a #GVirConfigDomain

 *

 * Returns: current amount of RAM in kilobytes (i.e. blocks of 1024 bytes).

 */

guint64 gvir_config_domain_get_current_memory(GVirConfigDomain *domain)

{

    const char *unit;

    guint64 unit_base;

    guint64 memory;

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), 0);

    unit = gvir_config_object_get_attribute(GVIR_CONFIG_OBJECT(domain), "currentMemory", "unit");

    unit_base = get_unit_base(unit, 1024);

    memory = gvir_config_object_get_node_content_uint64(GVIR_CONFIG_OBJECT(domain),

                                                        "currentMemory");

    return memory * unit_base / 1024;

}

/**

 * gvir_config_domain_set_memory:

 * @domain: a #GVirConfigDomain

 * @memory: The maximum amount of RAM in kilobytes.

 *

 * Sets the maximum amount of RAM allocated to @domain in kilobytes (i.e.

 * blocks of 1024 bytes).

 */

void gvir_config_domain_set_memory(GVirConfigDomain *domain, guint64 memory)

{

    GVirConfigObject *node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    node = gvir_config_object_replace_child(GVIR_CONFIG_OBJECT(domain), "memory");

    gvir_config_object_set_node_content_uint64(GVIR_CONFIG_OBJECT(node), NULL, memory);

    gvir_config_object_set_attribute(GVIR_CONFIG_OBJECT(node),

                                     "unit", "KiB",

                                     NULL);

    g_object_unref(G_OBJECT(node));

    g_object_notify(G_OBJECT(domain), "memory");

}

/**

 * gvir_config_domain_set_current_memory:

 * @domain: a #GVirConfigDomain

 * @memory: The current amount of RAM in kilobytes.

 *

 * Sets the current amount of RAM allocated to @domain in kilobytes (i.e.

 * blocks of 1024 bytes). This can be set to less than the maximum domain

 * memory to allow to balloon the guest memory on the fly. Be aware that

 * libvirt will set it automatically if it's not explictly set, which means

 * you may need to set this value in addition to 'memory' if you want to

 * change the available domain memory after creation.

 */

void gvir_config_domain_set_current_memory(GVirConfigDomain *domain,

                                           guint64 memory)

{

    GVirConfigObject *node;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    node = gvir_config_object_replace_child(GVIR_CONFIG_OBJECT(domain), "currentMemory");

    gvir_config_object_set_node_content_uint64(GVIR_CONFIG_OBJECT(node), NULL, memory);

    gvir_config_object_set_attribute(GVIR_CONFIG_OBJECT(node),

                                     "unit", "KiB",

                                     NULL);

    g_object_unref(G_OBJECT(node));

    g_object_notify(G_OBJECT(domain), "current-memory");

}

guint64 gvir_config_domain_get_vcpus(GVirConfigDomain *domain)

{

    return gvir_config_object_get_node_content_uint64(GVIR_CONFIG_OBJECT(domain),

                                                      "vcpu");

}

void gvir_config_domain_set_vcpus(GVirConfigDomain *domain, guint64 vcpu_count)

{

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    gvir_config_object_set_node_content_uint64(GVIR_CONFIG_OBJECT(domain),

                                               "vcpu", vcpu_count);

    g_object_notify(G_OBJECT(domain), "vcpu");

}

static gboolean add_feature(xmlNodePtr node, gpointer opaque)

{

    GPtrArray *features;

    g_return_val_if_fail(opaque != NULL, FALSE);

    features = (GPtrArray *)opaque;

    g_ptr_array_add(features, g_strdup((char *)node->name));

    return TRUE;

}

/**

 * gvir_config_domain_get_features:

 * @domain: a #GVirConfigDomain

 *

 * Returns: (transfer full): The returned list should be freed with

 * g_strfreev() when no longer needed.

 */

GStrv gvir_config_domain_get_features(GVirConfigDomain *domain)

{

    GPtrArray *features;

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    features = g_ptr_array_new();

    gvir_config_object_foreach_child(GVIR_CONFIG_OBJECT(domain), "features",

                                     add_feature, features);

    g_ptr_array_add(features, NULL);

    return (GStrv)g_ptr_array_free(features, FALSE);

}

void gvir_config_domain_set_features(GVirConfigDomain *domain,

                                     const GStrv features)

{

    GVirConfigObject *features_node;

    GStrv it;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    features_node = gvir_config_object_replace_child(GVIR_CONFIG_OBJECT(domain),

                                                     "features");

    g_return_if_fail(GVIR_CONFIG_IS_OBJECT(features_node));

    for (it = features; *it != NULL; it++) {

        GVirConfigObject *feature;

        feature = gvir_config_object_replace_child(GVIR_CONFIG_OBJECT(features_node),

                                                   *it);

        g_object_unref(G_OBJECT(feature));

    }

    g_object_unref(G_OBJECT(features_node));

    g_object_notify(G_OBJECT(domain), "features");

}

/**

 * gvir_config_domain_get_clock:

 * @domain: a #GVirConfigDomain

 *

 * Gets the clock configuration of @domain

 *

 * Returns: (transfer full): A #GVirConfigDomainClock. The returned

 * object should be unreffed with g_object_unref() when no longer needed.

 */

GVirConfigDomainClock *gvir_config_domain_get_clock(GVirConfigDomain *domain)

{

    GVirConfigObject *object;

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    object = gvir_config_object_get_child_with_type(GVIR_CONFIG_OBJECT(domain),

                                                    "clock",

                                                    GVIR_CONFIG_TYPE_DOMAIN_CLOCK);

    return GVIR_CONFIG_DOMAIN_CLOCK(object);

}

/**

 * 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_get_os:

 * @domain: a #GVirConfigDomain

 *

 * Gets the operating system configuration of @domain

 *

 * Returns: (transfer full): A #GVirConfigDomainOs. The returned

 * object should be unreffed with g_object_unref() when no longer needed.

 */

GVirConfigDomainOs *gvir_config_domain_get_os(GVirConfigDomain *domain)

{

    GVirConfigObject *object;

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    object = gvir_config_object_get_child_with_type(GVIR_CONFIG_OBJECT(domain),

                                                    "os",

                                                    GVIR_CONFIG_TYPE_DOMAIN_OS);

    return GVIR_CONFIG_DOMAIN_OS(object);

}

/**

 * 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_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));

}

void gvir_config_domain_set_lifecycle(GVirConfigDomain *domain,

                                      GVirConfigDomainLifecycleEvent event,

                                      GVirConfigDomainLifecycleAction action)

{

    const char *event_str;

    const char *action_str;

    g_return_if_fail(GVIR_CONFIG_IS_DOMAIN(domain));

    g_return_if_fail((event == GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_CRASH) ||

                     ((action != GVIR_CONFIG_DOMAIN_LIFECYCLE_COREDUMP_DESTROY) &&

                      (action != GVIR_CONFIG_DOMAIN_LIFECYCLE_COREDUMP_RESTART)));

    event_str = gvir_config_genum_get_nick(GVIR_CONFIG_TYPE_DOMAIN_LIFECYCLE_EVENT, event);

    g_return_if_fail(event_str != NULL);

    action_str = gvir_config_genum_get_nick(GVIR_CONFIG_TYPE_DOMAIN_LIFECYCLE_ACTION, action);

    g_return_if_fail(action_str != NULL);

    gvir_config_object_set_node_content(GVIR_CONFIG_OBJECT(domain),

                                        event_str, action_str);

}

/**

 * 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));

}

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));

}

struct GetDeviceData {

    GVirConfigXmlDoc *doc;

    GList *devices;

};

static gboolean add_device(xmlNodePtr node, gpointer opaque)

{

    struct GetDeviceData* data = (struct GetDeviceData*)opaque;

    GVirConfigDomainDevice *device;

    device = gvir_config_domain_device_new_from_tree(data->doc, node);

    if (device != NULL)

        data->devices = g_list_append(data->devices, device);

    else

        g_debug("Failed to parse %s node", node->name);

    return TRUE;

}

/**

 * gvir_config_domain_get_devices:

 * @domain: a #GVirConfigDomain

 *

 * Gets the list of devices attached to @domain.  The returned list should

 * be freed with g_list_free(), after its elements have been unreffed with

 * g_object_unref().

 *

 * Returns: (element-type LibvirtGConfig.DomainDevice) (transfer full):

 * a newly allocated #GList of #GVirConfigDomainDevice.

 */

GList *gvir_config_domain_get_devices(GVirConfigDomain *domain)

{

    struct GetDeviceData data;

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    g_object_get(G_OBJECT(domain), "doc", &data.doc, NULL);

    data.devices = NULL;

    gvir_config_object_foreach_child(GVIR_CONFIG_OBJECT(domain), "devices",

                                     add_device, &data);

    if (data.doc != NULL) {

        g_object_unref(G_OBJECT(data.doc));

    }

    return data.devices;

}

static gboolean gvir_config_domain_set_custom_xml_helper(GVirConfigDomain *domain,

                                                         const gchar *xml,

                                                         const gchar *ns,

                                                         const gchar *ns_uri,

                                                         gboolean ns_children,

                                                         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, ns_children);

    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;

}

gboolean gvir_config_domain_set_custom_xml(GVirConfigDomain *domain,

                                           const gchar *xml,

                                           const gchar *ns,

                                           const gchar *ns_uri,

                                           GError **error)

{

    return gvir_config_domain_set_custom_xml_helper(domain,

                                                    xml,

                                                    ns,

                                                    ns_uri,

                                                    FALSE,

                                                    error);

}

gboolean gvir_config_domain_set_custom_xml_ns_children(GVirConfigDomain *domain,

                                                       const gchar *xml,

                                                       const gchar *ns,

                                                       const gchar *ns_uri,

                                                       GError **error)

{

    return gvir_config_domain_set_custom_xml_helper(domain,

                                                    xml,

                                                    ns,

                                                    ns_uri,

                                                    TRUE,

                                                    error);

}

struct LookupNamespacedNodeData {

    const char *ns_uri;

    xmlNodePtr node;

};

static gboolean lookup_namespaced_node(xmlNodePtr node, gpointer opaque)

{

    struct LookupNamespacedNodeData* data = opaque;

    if (node->ns == NULL)

        return TRUE;

    if (g_strcmp0((char *)node->ns->href, data->ns_uri) == 0) {

        data->node = node;

        return FALSE;

    }

    return TRUE;

}

gchar *gvir_config_domain_get_custom_xml(GVirConfigDomain *domain,

                                         const gchar *ns_uri)

{

    struct LookupNamespacedNodeData data = { NULL, NULL };

    g_return_val_if_fail(GVIR_CONFIG_IS_DOMAIN(domain), NULL);

    g_return_val_if_fail(ns_uri != NULL, NULL);

    data.ns_uri = ns_uri;

    gvir_config_object_foreach_child(GVIR_CONFIG_OBJECT(domain), "metadata",

                                     lookup_namespaced_node, &data);

    return gvir_config_xml_node_to_string(data.node);

}