/*
* ovirt-vm.c: oVirt virtual machine
*
* Copyright (C) 2012, 2013 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: Christophe Fergeau <cfergeau@redhat.com>
*/
#include <config.h>
#include <stdlib.h>
#include <glib/gi18n-lib.h>
#include <rest/rest-xml-node.h>
#include <rest/rest-xml-parser.h>
#include "govirt.h"
#include "govirt-private.h"
static gboolean parse_ticket_status(RestXmlNode *root, OvirtResource *resource,
GError **error);
struct _OvirtVmPrivate {
OvirtCollection *cdroms;
OvirtVmState state;
OvirtVmDisplay *display;
gchar *host_href;
gchar *host_id;
gchar *cluster_href;
gchar *cluster_id;
} ;
G_DEFINE_TYPE_WITH_PRIVATE(OvirtVm, ovirt_vm, OVIRT_TYPE_RESOURCE);
enum OvirtResponseStatus {
OVIRT_RESPONSE_UNKNOWN,
OVIRT_RESPONSE_FAILED,
OVIRT_RESPONSE_PENDING,
OVIRT_RESPONSE_IN_PROGRESS,
OVIRT_RESPONSE_COMPLETE
};
enum {
PROP_0,
PROP_STATE,
PROP_DISPLAY,
PROP_HOST_HREF,
PROP_HOST_ID,
PROP_CLUSTER_HREF,
PROP_CLUSTER_ID,
};
static char *ensure_href_from_id(const char *id,
const char *path)
{
if (id == NULL)
return NULL;
return g_strdup_printf("%s/%s", path, id);
}
static const char *get_host_href(OvirtVm *vm)
{
if (vm->priv->host_href == NULL)
vm->priv->host_href = ensure_href_from_id(vm->priv->host_id, "/ovirt-engine/api/hosts");
return vm->priv->host_href;
}
static const char *get_cluster_href(OvirtVm *vm)
{
if (vm->priv->cluster_href == NULL)
vm->priv->cluster_href = ensure_href_from_id(vm->priv->cluster_id, "/ovirt-engine/api/clusters");
return vm->priv->cluster_href;
}
static void ovirt_vm_get_property(GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
OvirtVm *vm = OVIRT_VM(object);
switch (prop_id) {
case PROP_STATE:
g_value_set_enum(value, vm->priv->state);
break;
case PROP_DISPLAY:
g_value_set_object(value, vm->priv->display);
break;
case PROP_HOST_HREF:
g_value_set_string(value, get_host_href(vm));
break;
case PROP_HOST_ID:
g_value_set_string(value, vm->priv->host_id);
break;
case PROP_CLUSTER_HREF:
g_value_set_string(value, get_cluster_href(vm));
break;
case PROP_CLUSTER_ID:
g_value_set_string(value, vm->priv->cluster_id);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
static void ovirt_vm_set_property(GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
OvirtVm *vm = OVIRT_VM(object);
switch (prop_id) {
case PROP_STATE:
vm->priv->state = g_value_get_enum(value);
break;
case PROP_DISPLAY:
g_clear_object(&vm->priv->display);
vm->priv->display = g_value_dup_object(value);
break;
case PROP_HOST_HREF:
g_free(vm->priv->host_href);
vm->priv->host_href = g_value_dup_string(value);
break;
case PROP_HOST_ID:
g_free(vm->priv->host_id);
vm->priv->host_id = g_value_dup_string(value);
break;
case PROP_CLUSTER_HREF:
g_free(vm->priv->cluster_href);
vm->priv->cluster_href = g_value_dup_string(value);
break;
case PROP_CLUSTER_ID:
g_free(vm->priv->cluster_id);
vm->priv->cluster_id = g_value_dup_string(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
}
static void ovirt_vm_dispose(GObject *object)
{
OvirtVm *vm = OVIRT_VM(object);
g_clear_object(&vm->priv->cdroms);
g_clear_object(&vm->priv->display);
g_clear_pointer(&vm->priv->host_href, g_free);
g_clear_pointer(&vm->priv->host_id, g_free);
g_clear_pointer(&vm->priv->cluster_href, g_free);
g_clear_pointer(&vm->priv->cluster_id, g_free);
G_OBJECT_CLASS(ovirt_vm_parent_class)->dispose(object);
}
static gboolean ovirt_vm_init_from_xml(OvirtResource *resource,
RestXmlNode *node,
GError **error)
{
OvirtVmDisplay *display;
RestXmlNode *display_node;
OvirtResourceClass *parent_class;
OvirtXmlElement vm_elements[] = {
{ .prop_name = "host-href",
.xml_path = "host",
.xml_attr = "href",
},
{ .prop_name = "host-id",
.xml_path = "host",
.xml_attr = "id",
},
{ .prop_name = "cluster-href",
.xml_path = "cluster",
.xml_attr = "href",
},
{ .prop_name = "cluster-id",
.xml_path = "cluster",
.xml_attr = "id",
},
{ .prop_name = "state",
.xml_path = "status",
},
{ NULL, },
};
display_node = rest_xml_node_find(node, "display");
if (display_node == NULL) {
g_debug("Could not find 'display' node");
return FALSE;
}
display = ovirt_vm_display_new_from_xml(display_node);
if (display == NULL)
return FALSE;
g_object_set(G_OBJECT(resource), "display", display, NULL);
g_object_unref(G_OBJECT(display));
if (!ovirt_rest_xml_node_parse(node, G_OBJECT(resource), vm_elements))
return FALSE;
parent_class = OVIRT_RESOURCE_CLASS(ovirt_vm_parent_class);
return parent_class->init_from_xml(resource, node, error);
}
static void ovirt_vm_class_init(OvirtVmClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
OvirtResourceClass *resource_class = OVIRT_RESOURCE_CLASS(klass);
resource_class->init_from_xml = ovirt_vm_init_from_xml;
object_class->dispose = ovirt_vm_dispose;
object_class->get_property = ovirt_vm_get_property;
object_class->set_property = ovirt_vm_set_property;
g_object_class_install_property(object_class,
PROP_STATE,
g_param_spec_enum("state",
"State",
"Virtual Machine State",
OVIRT_TYPE_VM_STATE,
OVIRT_VM_STATE_UNKNOWN,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_DISPLAY,
g_param_spec_object("display",
"Display",
"Virtual Machine Display Information",
OVIRT_TYPE_VM_DISPLAY,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_HOST_HREF,
g_param_spec_string("host-href",
"Host href",
"Host href for the Virtual Machine",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_HOST_ID,
g_param_spec_string("host-id",
"Host Id",
"Host Id for the Virtual Machine",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_CLUSTER_HREF,
g_param_spec_string("cluster-href",
"Cluster href",
"Cluster href for the Virtual Machine",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
g_object_class_install_property(object_class,
PROP_CLUSTER_ID,
g_param_spec_string("cluster-id",
"Cluster Id",
"Cluster Id for the Virtual Machine",
NULL,
G_PARAM_READWRITE |
G_PARAM_STATIC_STRINGS));
}
static void ovirt_vm_init(G_GNUC_UNUSED OvirtVm *vm)
{
vm->priv = ovirt_vm_get_instance_private(vm);
}
G_GNUC_INTERNAL
OvirtVm *ovirt_vm_new_from_xml(RestXmlNode *node, GError **error)
{
OvirtResource *vm = ovirt_resource_new_from_xml(OVIRT_TYPE_VM, node, error);
return OVIRT_VM(vm);
}
OvirtVm *ovirt_vm_new(void)
{
OvirtResource *vm = ovirt_resource_new(OVIRT_TYPE_VM);
return OVIRT_VM(vm);
}
void
ovirt_vm_get_ticket_async(OvirtVm *vm, OvirtProxy *proxy,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
ovirt_resource_invoke_action_async(OVIRT_RESOURCE(vm), "ticket",
proxy, parse_ticket_status,
cancellable, callback,
user_data);
}
gboolean
ovirt_vm_get_ticket_finish(OvirtVm *vm, GAsyncResult *result, GError **err)
{
return ovirt_resource_action_finish(OVIRT_RESOURCE(vm), result, err);
}
void
ovirt_vm_start_async(OvirtVm *vm, OvirtProxy *proxy,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
ovirt_resource_invoke_action_async(OVIRT_RESOURCE(vm), "start", proxy, NULL,
cancellable, callback, user_data);
}
gboolean
ovirt_vm_start_finish(OvirtVm *vm, GAsyncResult *result, GError **err)
{
return ovirt_resource_action_finish(OVIRT_RESOURCE(vm), result, err);
}
void
ovirt_vm_stop_async(OvirtVm *vm, OvirtProxy *proxy,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
ovirt_resource_invoke_action_async(OVIRT_RESOURCE(vm), "stop", proxy, NULL,
cancellable, callback, user_data);
}
gboolean
ovirt_vm_stop_finish(OvirtVm *vm, GAsyncResult *result, GError **err)
{
return ovirt_resource_action_finish(OVIRT_RESOURCE(vm), result, err);
}
gboolean ovirt_vm_get_ticket(OvirtVm *vm, OvirtProxy *proxy, GError **error)
{
return ovirt_resource_action(OVIRT_RESOURCE(vm), proxy, "ticket",
parse_ticket_status,
error);
}
gboolean ovirt_vm_start(OvirtVm *vm, OvirtProxy *proxy, GError **error)
{
return ovirt_resource_action(OVIRT_RESOURCE(vm), proxy, "start",
NULL, error);
}
gboolean ovirt_vm_stop(OvirtVm *vm, OvirtProxy *proxy, GError **error)
{
return ovirt_resource_action(OVIRT_RESOURCE(vm), proxy, "stop",
NULL, error);
}
static gboolean parse_ticket_status(RestXmlNode *root, OvirtResource *resource, GError **error)
{
OvirtVmDisplay *display;
gchar *ticket = NULL;
guint expiry = 0;
gboolean ret = FALSE;
OvirtXmlElement ticket_elements[] = {
{ .prop_name = "ticket",
.xml_path = "value",
},
{ .prop_name = "expiry",
.xml_path = "expiry",
},
{ NULL, },
};
g_return_val_if_fail(root != NULL, FALSE);
g_return_val_if_fail(OVIRT_IS_VM(resource), FALSE);
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
g_object_get(G_OBJECT(resource), "display", &display, NULL);
g_return_val_if_fail(display != NULL, FALSE);
root = rest_xml_node_find(root, "ticket");
if (root == NULL) {
g_set_error(error, OVIRT_ERROR, OVIRT_ERROR_PARSING_FAILED,
_("Could not find 'ticket' node"));
goto end;
}
ovirt_rest_xml_node_parse(root, G_OBJECT(display), ticket_elements);
g_object_get(G_OBJECT(display), "ticket", &ticket, "expiry", &expiry, NULL);
if (ticket == NULL) {
g_set_error(error, OVIRT_ERROR, OVIRT_ERROR_PARSING_FAILED,
_("Could not find 'value' node"));
goto end;
}
g_free(ticket);
if (expiry == 0) {
g_set_error(error, OVIRT_ERROR, OVIRT_ERROR_PARSING_FAILED,
_("Could not find 'expiry' node"));
goto end;
}
ret = TRUE;
end:
g_object_unref(G_OBJECT(display));
return ret;
}
void ovirt_vm_refresh_async(OvirtVm *vm, OvirtProxy *proxy,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_return_if_fail(OVIRT_IS_VM(vm));
ovirt_resource_refresh_async(OVIRT_RESOURCE(vm), proxy,
cancellable, callback,
user_data);
}
gboolean ovirt_vm_refresh_finish(OvirtVm *vm,
GAsyncResult *result,
GError **err)
{
g_return_val_if_fail(OVIRT_IS_VM(vm), FALSE);
return ovirt_resource_refresh_finish(OVIRT_RESOURCE(vm),
result, err);
}
/**
* ovirt_vm_get_cdroms:
* @vm: a #OvirtVm
*
* Gets a #OvirtCollection representing the list of remote cdroms from a
* virtual machine object. This method does not initiate any network
* activity, the remote cdrom list must be then be fetched using
* ovirt_collection_fetch() or ovirt_collection_fetch_async().
*
* Return value: (transfer none): a #OvirtCollection representing the list
* of cdroms associated with @vm.
*/
OvirtCollection *ovirt_vm_get_cdroms(OvirtVm *vm)
{
g_return_val_if_fail(OVIRT_IS_VM(vm), NULL);
if (vm->priv->cdroms == NULL)
vm->priv->cdroms = ovirt_sub_collection_new_from_resource(OVIRT_RESOURCE(vm),
"cdroms",
"cdroms",
OVIRT_TYPE_CDROM,
"cdrom");
return vm->priv->cdroms;
}
/**
* ovirt_vm_get_host:
* @vm: a #OvirtVm
*
* Gets a #OvirtHost representing the host the virtual machine belongs to.
* This method does not initiate any network activity, the remote host must be
* then be fetched using ovirt_resource_refresh() or
* ovirt_resource_refresh_async().
*
* Return value: (transfer full): a #OvirtHost representing host the @vm
* belongs to.
*/
OvirtHost *ovirt_vm_get_host(OvirtVm *vm)
{
g_return_val_if_fail(OVIRT_IS_VM(vm), NULL);
g_return_val_if_fail(vm->priv->host_id != NULL, NULL);
return ovirt_host_new_from_id(vm->priv->host_id, get_host_href(vm));
}
/**
* ovirt_vm_get_cluster:
* @vm: a #OvirtVm
*
* Gets a #OvirtCluster representing the cluster the virtual machine belongs
* to. This method does not initiate any network activity, the remote host must
* be then be fetched using ovirt_resource_refresh() or
* ovirt_resource_refresh_async().
*
* Return value: (transfer full): a #OvirtCluster representing cluster the @vm
* belongs to.
*/
OvirtCluster *ovirt_vm_get_cluster(OvirtVm *vm)
{
g_return_val_if_fail(OVIRT_IS_VM(vm), NULL);
g_return_val_if_fail(vm->priv->cluster_id != NULL, NULL);
return ovirt_cluster_new_from_id(vm->priv->cluster_id, get_cluster_href(vm));
}