Пример #1
0
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_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_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);
    }
}
Пример #2
0
static void test_domain(void)
{
    GVirConfigDomain *domain;
    const char *features[] = { "foo", "bar", "baz", NULL };
    GStrv feat;
    unsigned int i;

    domain = gvir_config_domain_new();
    g_assert(domain != NULL);

    gvir_config_domain_set_virt_type(domain, GVIR_CONFIG_DOMAIN_VIRT_KVM);
    g_assert_cmpint(gvir_config_domain_get_virt_type(domain), ==, GVIR_CONFIG_DOMAIN_VIRT_KVM);

    gvir_config_domain_set_name(domain, "foo");
    g_assert_cmpstr(gvir_config_domain_get_name(domain), ==, "foo");

    gvir_config_domain_set_memory(domain, 1234);
    g_assert_cmpint(gvir_config_domain_get_memory(domain), ==, 1234);
    gvir_config_domain_set_vcpus(domain, 3);
    g_assert_cmpint(gvir_config_domain_get_vcpus(domain), ==, 3);

    gvir_config_domain_set_features(domain, (const GStrv)features);
    feat = gvir_config_domain_get_features(domain);
    for (i = 0; features[i] != NULL; i++) {
        g_assert(feat[i] != NULL);
        g_assert_cmpstr(feat[i], ==, features[i]);
    }
    g_strfreev(feat);

    gvir_config_domain_set_lifecycle(domain,
                                     GVIR_CONFIG_DOMAIN_LIFECYCLE_ON_POWEROFF,
                                     GVIR_CONFIG_DOMAIN_LIFECYCLE_RESTART);

    gvir_config_domain_set_custom_xml(domain, "<foo/>", "ns", "http://foo", NULL);
    gvir_config_domain_set_custom_xml(domain, "<foo/>", "nsbar", "http://bar", NULL);
    gvir_config_domain_set_custom_xml(domain, "<foo/>", "ns", "http://bar", NULL);
    gvir_config_domain_set_custom_xml(domain, "<bar/>", "ns", "http://foo", NULL);

    g_assert_cmpstr_free1(gvir_config_domain_get_custom_xml(domain, "http://foo"), ==, "<ns:bar xmlns:ns=\"http://foo\"/>");
    g_assert_cmpstr_free1(gvir_config_domain_get_custom_xml(domain, "http://bar"), ==, "<ns:foo xmlns:ns=\"http://bar\"/>");

    check_xml(domain, "gconfig-domain.xml");

    g_object_unref(G_OBJECT(domain));
}
Пример #3
0
static void test_domain_cpu(void)
{
    GVirConfigDomain *domain;
    /* cpu node */
    GVirConfigDomainCpu *cpu;

    domain = gvir_config_domain_new();
    cpu = gvir_config_domain_cpu_new();
    gvir_config_domain_set_vcpus(domain, 3);

    /* cpu/feature nodes */
    GVirConfigDomainCpuFeature *feature;
    GList *cpu_features = NULL;

    gvir_config_domain_cpu_set_match_policy(cpu, GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_STRICT);
    gvir_config_domain_cpu_set_mode(cpu, GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_PASSTHROUGH);
    feature = gvir_config_domain_cpu_feature_new();
    gvir_config_capabilities_cpu_feature_set_name(GVIR_CONFIG_CAPABILITIES_CPU_FEATURE(feature),
                                                  "foo");
    gvir_config_domain_cpu_feature_set_policy(feature, GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_REQUIRE);
    gvir_config_capabilities_cpu_add_feature(GVIR_CONFIG_CAPABILITIES_CPU(cpu),
                                             GVIR_CONFIG_CAPABILITIES_CPU_FEATURE(feature));
    g_object_unref(feature);

    /* cpu/topology nodes */
    GVirConfigCapabilitiesCpuTopology *topology;

    topology = gvir_config_capabilities_cpu_topology_new();
    gvir_config_capabilities_cpu_topology_set_cores(topology, 1);
    gvir_config_capabilities_cpu_topology_set_sockets(topology, 2);
    gvir_config_capabilities_cpu_topology_set_threads(topology, 3);
    gvir_config_capabilities_cpu_set_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu),
                                              topology);
    g_object_unref(topology);
    gvir_config_domain_set_cpu(domain, cpu);
    g_object_unref(cpu);


    cpu = gvir_config_domain_get_cpu(domain);
    g_assert(cpu != NULL);
    g_assert(GVIR_CONFIG_IS_CAPABILITIES_CPU(cpu));
    g_assert_cmpint(gvir_config_domain_cpu_get_match_policy(cpu), ==, GVIR_CONFIG_DOMAIN_CPU_MATCH_POLICY_STRICT);
    g_assert_cmpint(gvir_config_domain_cpu_get_mode(cpu), ==, GVIR_CONFIG_DOMAIN_CPU_MODE_HOST_PASSTHROUGH);

    cpu_features = gvir_config_capabilities_cpu_get_features(GVIR_CONFIG_CAPABILITIES_CPU(cpu));
    g_assert_cmpint(g_list_length(cpu_features), ==, 1);
    g_assert(GVIR_CONFIG_IS_DOMAIN_CPU_FEATURE(cpu_features->data));
    feature = GVIR_CONFIG_DOMAIN_CPU_FEATURE(cpu_features->data);
    g_assert_cmpstr(gvir_config_capabilities_cpu_feature_get_name(GVIR_CONFIG_CAPABILITIES_CPU_FEATURE(feature)), ==, "foo");
    g_assert_cmpint(gvir_config_domain_cpu_feature_get_policy(feature), ==, GVIR_CONFIG_DOMAIN_CPU_FEATURE_POLICY_REQUIRE);
    g_list_free_full(cpu_features, g_object_unref);

    topology = gvir_config_capabilities_cpu_get_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu));
    g_assert(topology != NULL);
    g_assert_cmpint(gvir_config_capabilities_cpu_topology_get_cores(topology), ==, 1);
    g_assert_cmpint(gvir_config_capabilities_cpu_topology_get_sockets(topology), ==, 2);
    g_assert_cmpint(gvir_config_capabilities_cpu_topology_get_threads(topology), ==, 3);
    g_object_unref(topology);
    g_object_unref(cpu);

    check_xml(domain, "gconfig-domain-cpu.xml");

    cpu = gvir_config_domain_get_cpu(domain);
    gvir_config_capabilities_cpu_set_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu),
                                              NULL);
    topology = gvir_config_capabilities_cpu_get_topology(GVIR_CONFIG_CAPABILITIES_CPU(cpu));
    g_assert(topology == NULL);
    g_object_unref(G_OBJECT(cpu));

    gvir_config_domain_set_cpu(domain, NULL);
    cpu = gvir_config_domain_get_cpu(domain);
    g_assert(cpu == NULL);

    g_object_unref(G_OBJECT(domain));
}