External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-07-03 16:42:37 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove the Open Nebula driver

Browse Source 
The Open Nebula driver has been unmaintained since it was first
introduced. The only commits have been for tree-wide cleanups.
It also has a major design flaw, in that it only knows about guests
that it has created itself, which makes it of very limited use.

Discussions wrt evolution of the VMWare ESX driver, concluded that
it should limit itself to single-node ESX operation and not try to
manage the multi-node architecture of VirtualCenter. Open Nebula
is a cluster like Virtual Center, not a single node system, so
the same reasoning applies.

The DeltaCloud project includes an Open Nebula driver and is a much
better fit architecturally, since it is explicitly targetting the
distributed multihost cluster scenario.

Thus this patch deletes the libvirt Open Nebula driver with the
recommendation that people use DeltaCloud for managing it instead.

* configure.ac: Remove probe for xmlrpc & --with-one arg
* daemon/Makefile.am, daemon/libvirtd.c, src/Makefile.am: Remove
  ONE driver build
* src/opennebula/one_client.c, src/opennebula/one_client.h,
  src/opennebula/one_conf.c, src/opennebula/one_conf.h,
  src/opennebula/one_driver.c, src/opennebula/one_driver.c: Delete
  files
* autobuild.sh, libvirt.spec.in, mingw32-libvirt.spec.in: Remove
  build rules for Open Nebula
* docs/drivers.html.in, docs/sitemap.html.in: Remove reference
  to OpenNebula
* docs/drvone.html.in: Delete file
This commit is contained in:
Daniel P. Berrange 2011-03-22 16:12:34 +00:00
parent ab8984e482
commit 4591df766d
20 changed files with 5 additions and 1702 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
autobuild.sh
View File

@ -81,7 +81,6 @@ if [ -x /usr/bin/i686-pc-mingw32-gcc ]; then
--without-uml \
--without-vbox \
--without-openvz \
--without-one \
--without-phyp \
--without-netcf \
--without-audit \

41
configure.ac
View File

@ -271,8 +271,6 @@ AC_ARG_WITH([vbox],
[with_vbox=yes])
AC_ARG_WITH([lxc],
AC_HELP_STRING([--with-lxc], [add Linux Container support @<:@default=check@:>@]),[],[with_lxc=check])
AC_ARG_WITH([one],
AC_HELP_STRING([--with-one], [add ONE support @<:@default=check@:>@]),[],[with_one=check])
AC_ARG_WITH([esx],
AC_HELP_STRING([--with-esx], [add ESX support @<:@default=check@:>@]),[],[with_esx=check])
AC_ARG_WITH([test],
@ -440,11 +438,6 @@ if test "$with_qemu" = "yes" ; then
fi
AM_CONDITIONAL([WITH_QEMU], [test "$with_qemu" = "yes"])
if test "$with_one" = "yes" ; then
AC_DEFINE_UNQUOTED([WITH_ONE],1,[whether ONE driver is enabled])
fi
AM_CONDITIONAL([WITH_ONE],[test "$with_one" = "yes"])
if test "$with_test" = "yes" ; then
AC_DEFINE_UNQUOTED([WITH_TEST], 1, [whether Test driver is enabled])
fi
@ -725,34 +718,6 @@ fi
dnl Need to test if pkg-config exists
PKG_PROG_PKG_CONFIG
dnl OpenNebula driver Compilation setting
dnl
if test "$with_libvirtd" = "no" ; then
with_one=no
fi
XMLRPC_CFLAGS=
XMLRPC_LIBS=
if test "x$with_one" = "xyes" || test "x$with_one" = "xcheck"; then
PKG_CHECK_MODULES(XMLRPC, xmlrpc_client >= $XMLRPC_REQUIRED,
[with_one=yes], [
if test "x$with_one" = "xcheck" ; then
with_one=no
else
AC_MSG_ERROR(
[You must install XMLRPC-C >= $XMLRPC_REQUIRED to compile libvirt ONE driver])
fi
])
if test "x$with_one" = "xyes" ; then
AC_DEFINE_UNQUOTED([HAVE_XMLRPC], 1,
[whether One is used to broadcast server presence])
fi
fi
AM_CONDITIONAL([HAVE_XMLRPC], [test "x$with_one" = "xyes"])
AM_CONDITIONAL([WITH_ONE], [test "x$with_one" = "xyes"])
AC_SUBST([XMLRPC_CFLAGS])
AC_SUBST([XMLRPC_LIBS])
dnl ==========================================================================
dnl find libxml2 library, borrowed from xmlsec
@ -2415,7 +2380,6 @@ AC_MSG_NOTICE([ XenAPI: $with_xenapi])
AC_MSG_NOTICE([xenlight: $with_libxl])
AC_MSG_NOTICE([ LXC: $with_lxc])
AC_MSG_NOTICE([ PHYP: $with_phyp])
AC_MSG_NOTICE([ ONE: $with_one])
AC_MSG_NOTICE([ ESX: $with_esx])
AC_MSG_NOTICE([ Test: $with_test])
AC_MSG_NOTICE([ Remote: $with_remote])
@ -2542,11 +2506,6 @@ AC_MSG_NOTICE([ netcf: $NETCF_CFLAGS $NETCF_LIBS])
else
AC_MSG_NOTICE([ netcf: no])
fi
if test "$with_one" = "yes" ; then
AC_MSG_NOTICE([ xmlrpc: $XMLRPC_CFLAGS $XMLRPC_LIBS])
else
AC_MSG_NOTICE([ xmlrpc: no])
fi
if test "$with_qemu" = "yes" && test "$LIBPCAP_FOUND" != "no"; then
AC_MSG_NOTICE([ pcap: $LIBPCAP_CFLAGS $LIBPCAP_LIBS])
else

4
daemon/Makefile.am
View File

@ -114,10 +114,6 @@ if WITH_UML
libvirtd_LDADD += ../src/libvirt_driver_uml.la
endif
if WITH_ONE
libvirtd_LDADD += ../src/libvirt_driver_one.la
endif
if WITH_STORAGE_DIR
libvirtd_LDADD += ../src/libvirt_driver_storage.la
endif

7
daemon/libvirtd.c
View File

@ -87,9 +87,6 @@
# ifdef WITH_UML
# include "uml/uml_driver.h"
# endif
# ifdef WITH_ONE
# include "opennebula/one_driver.h"
# endif
# ifdef WITH_NETWORK
# include "network/bridge_driver.h"
# endif
@ -925,7 +922,6 @@ static struct qemud_server *qemudInitialize(void) {
virDriverLoadModule("qemu");
virDriverLoadModule("lxc");
virDriverLoadModule("uml");
virDriverLoadModule("one");
virDriverLoadModule("nwfilter");
#else
# ifdef WITH_NETWORK
@ -958,9 +954,6 @@ static struct qemud_server *qemudInitialize(void) {
# ifdef WITH_UML
umlRegister();
# endif
# ifdef WITH_ONE
oneRegister();
# endif
#endif
return server;

1
docs/drivers.html.in
View File

@ -20,7 +20,6 @@
<ul>
<li><strong><a href="drvlxc.html">LXC</a></strong> - Linux Containers</li>
<li><strong><a href="drvone.html">OpenNebula</a></strong></li>
<li><strong><a href="drvopenvz.html">OpenVZ</a></strong></li>
<li><strong><a href="drvqemu.html">QEMU</a></strong></li>
<li><strong><a href="drvtest.html">Test</a></strong> - Used for testing</li>

108
docs/drvone.html.in
View File

@ -1,108 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<meta http-equiv="CONTENT-TYPE" content="text/html; charset=utf-8">
<title></title>
<meta name="GENERATOR" content="OpenOffice.org 3.0 (Linux)">
<meta name="CREATED" content="0;0">
<meta name="CHANGED" content="20090701;13170700">
</head>
<body lang="en-US" dir="LTR">
<h1>OpenNebula Virtual Infrastructure Manager driver</h1>
<p><a name="toc"></a><a href="http://opennebula.org/">OpenNebula</a>
is a Virtual Infrastructure Manager that controls Virtual Machines (VM) in a pool of distributed resources
by orchestrating network, storage and virtualization technologies. The OpenNebula driver lets you manage your private or hybrid (<a href="http://aws.amazon.com/ec2/">Amazon EC2</a> or <a href="http://www.elastichosts.com/">Elastic Hosts</a> based) cloud using a standard libvirt interface, including the API as well as the related
tools and VM description files.</p>
<h2>
<a name="prereq"></a>Deployment pre-requisites</h2>
<ul>
<li>
<p style="margin-bottom: 0in">A working OpenNebula installation,
version 1.2 or higher.
</p>
</li>
</ul>
<h2>
<a name="uris"></a>Connections to OpenNebula driver</h2>
<p>The Uri of the driver protocol is "one". Some example
connection Uris for the driver are:
</p>
<pre>
one:/// (local access)
one+unix:/// (local access)
one://example.com/ (remote access)
one+tcp://example.com/ (remote access, SASl/Kerberos)
one+ssh://user@example.com/ (remote access, SSH tunnelled)
</pre>
<h2>
<a name="xmlconfig"></a>Example domain XML config</h2>
<p>There are some limitations on the XML attributes that may be
specified when interfacing OpenNebula. The following xml example
details the attributes and options supported by the OpenNebula
driver:</p>
<h3>Paravirtualized guest direct kernel boot
</h3>
<pre>
&lt;domain type='one'&gt;
&lt;name&gt;vm01&lt;/name&gt;
&lt;memory&gt;32768&lt;/memory&gt;
&lt;vcpu&gt;1&lt;/vcpu&gt;
&lt;os&gt;
&lt;type&gt;linux&lt;/type&gt;
&lt;kernel&gt;/boot/vmlinuz-2.6.24-17-xen&lt;/kernel&gt;
&lt;initrd&gt;/boot/initrd.img-2.6.24-17-xen&lt;/initrd&gt;
&lt;cmdline&gt;&lt;/cmdline&gt;
&lt;root&gt;sda1&lt;/root&gt;
&lt;/os&gt;
&lt;devices&gt;
&lt;disk type='file' device='disk'&gt;
&lt;source file='/images/sgehosts/01/disk.img'/&gt;
&lt;target dev='sda1'/&gt;
&lt;/disk&gt;
&lt;disk type='file' device='disk'&gt;
&lt;source file='/images/sgehosts/01/swap.img'/&gt;
&lt;target dev='sda2'/&gt;
&lt;/disk&gt;
&lt;disk type='file' device='cdrom'&gt;
&lt;source file='/images/iso/cdrom.iso'/&gt;
&lt;target dev='hdc'/&gt;
&lt;readonly/&gt;
&lt;/disk&gt;
&lt;!--BRIDGE--&gt;
&lt;interface type='bridge'&gt;
&lt;source bridge='eth0'/&gt;
&lt;mac address='00:16:3e:5d:c7:9e'/&gt;
&lt;/interface&gt;
&lt;!--ONE Network--&gt;
&lt;interface type='network'&gt;
&lt;source network='onenetwork'/&gt;
&lt;/interface&gt;
&lt;/devices&gt;
&lt;/domain&gt;
</pre>
<p>
<b>Note:</b> The "&lt;interface type='network'&gt;" will
attach the interface to a previously configured network (named
<tt>onenetwork</tt>) within the <a href="http://opennebula.org/">OpenNebula</a> system, typically with the
<tt>onevnet</tt> CLI command.</p>
<p><b>Note</b>: OpenNebula supports the simultaneous use of different hypervisors, so you can specify any os type (linux or hvm) supported by your cluster.
</p>
<h2>Links</h2>
<ul>
<li><a href="http://www.opennebula.org/doku.php?id=documentation">OpenNebula Documentation</a>
</li>
<li><a href="http://www.opennebula.org/doku.php?id=documentation:rel1.2:ug">OpenNebula User Guide</a>
</li>
</ul>
</body>
</html>

4
docs/sitemap.html.in
View File

@ -190,10 +190,6 @@
<a href="drvvbox.html">VirtualBox</a>
<span>Driver for VirtualBox</span>
</li>
<li>
<a href="drvone.html">OpenNebula</a>
<span>Driver for OpenNebula</span>
</li>
<li>
<a href="drvesx.html">VMware ESX</a>
<span>Driver for VMware ESX</span>

2
include/libvirt/virterror.h
View File

@ -66,7 +66,7 @@ typedef enum {
VIR_FROM_SECURITY = 24, /* Error from security framework */
VIR_FROM_VBOX = 25, /* Error from VirtualBox driver */
VIR_FROM_INTERFACE = 26, /* Error when operating on an interface */
VIR_FROM_ONE = 27, /* Error from OpenNebula driver */
VIR_FROM_ONE = 27, /* The OpenNebula driver no longer exists. Retained for ABI/API compat only */
VIR_FROM_ESX = 28, /* Error from ESX driver */
VIR_FROM_PHYP = 29, /* Error from IBM power hypervisor */
VIR_FROM_SECRET = 30, /* Error from secret storage */

12
libvirt.spec.in
View File

@ -46,8 +46,6 @@
%define with_uml 0%{!?_without_uml:%{server_drivers}}
%define with_xenapi 0%{!?_without_xenapi:%{server_drivers}}
%define with_libxl 0%{!?_without_libxl:%{server_drivers}}
# XXX this shouldn't be here, but it mistakenly links into libvirtd
%define with_one 0%{!?_without_one:%{server_drivers}}
# Then the hypervisor drivers that talk a native remote protocol
%define with_phyp 0%{!?_without_phyp:1}
@ -96,13 +94,12 @@
%define with_numactl 0
%endif
# RHEL doesn't ship OpenVZ, VBox, UML, OpenNebula, PowerHypervisor,
# RHEL doesn't ship OpenVZ, VBox, UML, PowerHypervisor,
# VMWare, libxenserver (xenapi), or libxenlight (Xen 4.1 and newer)
%if 0%{?rhel}
%define with_openvz 0
%define with_vbox 0
%define with_uml 0
%define with_one 0
%define with_phyp 0
%define with_vmware 0
%define with_xenapi 0
@ -314,9 +311,6 @@ BuildRequires: python-devel
%if %{with_xen}
BuildRequires: xen-devel
%endif
%if %{with_one}
BuildRequires: xmlrpc-c-devel >= 1.14.0
%endif
BuildRequires: libxml2-devel
BuildRequires: xhtml1-dtds
BuildRequires: libxslt
@ -570,10 +564,6 @@ of recent versions of Linux (and other OSes).
%define _without_uml --without-uml
%endif
%if ! %{with_one}
%define _without_one --without-one
%endif
%if %{with_rhel5}
%define _with_rhel5_api --with-rhel5-api
%endif

1
mingw32-libvirt.spec.in
View File

@ -54,7 +54,6 @@ MinGW Windows libvirt virtualization library.
--without-uml \
--without-vbox \
--without-openvz \
--without-one \
--without-phyp \
--without-netcf \
--without-audit \

2
po/POTFILES.in
View File

@ -46,8 +46,6 @@ src/nwfilter/nwfilter_driver.c
src/nwfilter/nwfilter_ebiptables_driver.c
src/nwfilter/nwfilter_gentech_driver.c
src/nwfilter/nwfilter_learnipaddr.c
src/opennebula/one_conf.c
src/opennebula/one_driver.c
src/openvz/openvz_conf.c
src/openvz/openvz_driver.c
src/phyp/phyp_driver.c

29
src/Makefile.am
View File

@ -306,14 +306,6 @@ UML_DRIVER_SOURCES = \
uml/uml_conf.c uml/uml_conf.h \
uml/uml_driver.c uml/uml_driver.h
ONE_DRIVER_SOURCES = \
./opennebula/one_conf.c \
./opennebula/one_conf.h \
./opennebula/one_driver.c \
./opennebula/one_driver.h \
./opennebula/one_client.c \
./opennebula/one_client.h
ESX_DRIVER_SOURCES = \
esx/esx_private.h \
esx/esx_driver.c esx/esx_driver.h \
@ -794,26 +786,6 @@ endif
libvirt_driver_uml_la_SOURCES = $(UML_DRIVER_SOURCES)
endif
if WITH_ONE
if WITH_DRIVER_MODULES
mod_LTLIBRARIES += libvirt_driver_one.la
else
noinst_LTLIBRARIES += libvirt_driver_one.la
# Stateful, so linked to daemon instead
#libvirt_la_BUILT_LIBADD += libvirt_driver_one.la
endif
libvirt_driver_one_la_CFLAGS = $(XMLRPC_CFLAGS) \
-I@top_srcdir@/src/conf $(AM_CFLAGS)
libvirt_driver_one_la_LDFLAGS = $(AM_LDFLAGS)
libvirt_driver_one_la_LIBADD = $(XMLRPC_LIBS)
#libvirt_driver_one_la_CFLAGS = "-DWITH_ONE"
if WITH_DRIVER_MODULES
libvirt_driver_one_la_LIBADD += ../gnulib/lib/libgnu.la
libvirt_driver_one_la_LDFLAGS += -module -avoid-version
endif
libvirt_driver_one_la_SOURCES = $(ONE_DRIVER_SOURCES)
endif
BUILT_SOURCES += $(ESX_DRIVER_GENERATED)
@ -1023,7 +995,6 @@ EXTRA_DIST += \
$(QEMU_DRIVER_SOURCES) \
$(LXC_DRIVER_SOURCES) \
$(UML_DRIVER_SOURCES) \
$(ONE_DRIVER_SOURCES) \
$(OPENVZ_DRIVER_SOURCES) \
$(PHYP_DRIVER_SOURCES) \
$(VBOX_DRIVER_SOURCES) \

5
src/README
View File

@ -27,7 +27,6 @@ Then there are the hypervisor implementations:
* esx/ - VMware ESX and GSX support using vSphere API over SOAP
* lxc/ - Linux Native Containers
* opennebula/ - Open Nebula using XMLRPC
* openvz/ - OpenVZ containers using cli tools
* phyp/ - IBM Power Hypervisor using CLI tools over SSH
* qemu/ - QEMU / KVM using qemu CLI/monitor
@ -42,8 +41,8 @@ Then there are the hypervisor implementations:
Finally some secondary drivers that are shared for several HVs.
Currently these are used by LXC, OpenVZ, QEMU, UML and Xen drivers.
The ESX, OpenNebula, Power Hypervisor, Remote, Test & VirtualBox
drivers all implement the secondary drivers directly
The ESX, Power Hypervisor, Remote, Test & VirtualBox drivers all
implement the secondary drivers directly
* cpu/ - CPU feature management
* interface/ - Host network interface management

207
src/opennebula/one_client.c
View File

@ -1,207 +0,0 @@
/* Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
* Complutense de Madrid (dsa-research.org)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <config.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include "one_client.h"
#include "datatypes.h"
#include "util.h"
#include "memory.h"
oneClient one_client;
void c_oneStart()
{
xmlrpc_env_init(&one_client.env);
xmlrpc_client_init2(&one_client.env, XMLRPC_CLIENT_NO_FLAGS,
"OpenNebula API Client", "1.2", NULL, 0);
one_client.error = 0;
one_client.url = "http://localhost:2633/RPC2";
one_client.session = "one-session";
};
int c_oneReturnCode(xmlrpc_value *resultP);
int c_oneReturnCode(xmlrpc_value *resultP)
{
int return_code;
char *return_string;
xmlrpc_decompose_value(&one_client.env, resultP, "(bs)",
&return_code, &return_string);
if( return_code )
{
xmlrpc_DECREF(resultP);
VIR_FREE(return_string);
return 0;
}
else
{
VIR_FREE(one_client.error);
one_client.error=return_string;
return -1;
}
}
int c_oneDeploy(int vmid, int hid)
{
xmlrpc_value *resultP;
resultP = xmlrpc_client_call(&one_client.env, one_client.url,
"one.vmdeploy", "(sii)", one_client.session, (xmlrpc_int32)vmid,
(xmlrpc_int32)hid);
return c_oneReturnCode(resultP);
}
int c_oneMigrate(int vmid, int hid, int flag)
{
xmlrpc_value *resultP;
resultP = xmlrpc_client_call(&one_client.env, one_client.url,
"one.vmmigrate", "(siib)", one_client.session, (xmlrpc_int32)vmid,
(xmlrpc_int32)hid,
(xmlrpc_bool)flag);
return c_oneReturnCode(resultP);
}
int c_oneAllocateTemplate(char* vm_template)
{
xmlrpc_value *resultP;
xmlrpc_value *valueP;
int return_code;
char *return_string;
int vmid;
resultP = xmlrpc_client_call(&one_client.env, one_client.url,
"one.vmallocate", "(ss)", one_client.session, vm_template);
xmlrpc_array_read_item(&one_client.env, resultP, 0, &valueP);
xmlrpc_read_bool(&one_client.env, valueP, &return_code);
if( return_code )
{
xmlrpc_DECREF(valueP);
xmlrpc_array_read_item(&one_client.env, resultP, 1, &valueP);
xmlrpc_read_int(&one_client.env, valueP, &vmid);
xmlrpc_DECREF(valueP);
xmlrpc_DECREF(resultP);
return vmid;
}
else
{
xmlrpc_DECREF(valueP);
xmlrpc_array_read_item(&one_client.env, resultP, 1, &valueP);
xmlrpc_read_string(&one_client.env, valueP,
(const char **)&return_string);
xmlrpc_DECREF(valueP);
xmlrpc_DECREF(resultP);
VIR_FREE(one_client.error);
one_client.error=return_string;
return -1;
}
}
int c_oneAction(int vmid, char* action)
{
xmlrpc_value *resultP;
resultP = xmlrpc_client_call(&one_client.env, one_client.url,
"one.vmaction", "(ssi)", one_client.session, action,
(xmlrpc_int32)vmid);
return c_oneReturnCode(resultP);
}
int c_oneShutdown(int vmid)
{
return c_oneAction(vmid, (char *)"shutdown");
}
int c_oneSuspend(int vmid)
{
return c_oneAction(vmid, (char *)"suspend");
}
int c_oneStop(int vmid)
{
return c_oneAction(vmid, (char *)"stop");
}
int c_oneResume(int vmid)
{
return c_oneAction(vmid, (char *)"resume");
}
int c_oneCancel(int vmid)
{
return c_oneAction(vmid, (char *)"cancel");
}
int c_oneFinalize(int vmid)
{
return c_oneAction(vmid, (char *)"finalize");
}
int c_oneVmInfo(int vmid, char* ret_info, int length)
{
xmlrpc_value *resultP;
int return_code;
char *return_string;
int retval = -1;
resultP = xmlrpc_client_call(&one_client.env, one_client.url,
"one.vmget_info", "(si)", one_client.session, vmid);
xmlrpc_decompose_value(&one_client.env, resultP, "(bs)",
&return_code, &return_string);
if( return_code )
{
if (virStrncpy(ret_info, return_string, length-1, length) != NULL)
/* Only set the return value to 0 if we succeeded */
retval = 0;
}
xmlrpc_DECREF(resultP);
VIR_FREE(return_string);
return retval;
}
void c_oneFree()
{
xmlrpc_env_clean(&one_client.env);
xmlrpc_client_cleanup();
}

62
src/opennebula/one_client.h
View File

@ -1,62 +0,0 @@
/* Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
* Complutense de Madrid (dsa-research.org)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef ONE_CLIENT_H_
# define ONE_CLIENT_H_
# include <xmlrpc-c/base.h>
# include <xmlrpc-c/client.h>
struct _oneClient {
xmlrpc_env env;
const char *url;
const char *session;
char *error;
};
typedef struct _oneClient oneClient;
typedef oneClient *oneClientPtr;
void c_oneStart(void);
int c_oneDeploy(int vmid, int hid);
int c_oneMigrate(int vmid, int hid, int flag);
int c_oneAllocateTemplate(char* vm_template);
int c_oneAction(int vmid,char* action);
int c_oneShutdown(int vmid);
int c_oneSuspend(int vmid);
int c_oneStop(int vmid);
int c_oneResume(int vmid);
int c_oneCancel(int vmid);
int c_oneFinalize(int vmid);
int c_oneVmInfo(int vmid, char* ret_info,int leng);
void c_oneFree(void);
#endif /* ONE_CLIENT_H_ */

285
src/opennebula/one_conf.c
View File

@ -1,285 +0,0 @@
/*----------------------------------------------------------------------------------*/
/*
* Copyright (C) 2010 Red Hat, Inc.
* Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
* Complutense de Madrid (dsa-research.org)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*-----------------------------------------------------------------------------------*/
#include <config.h>
#include <sys/utsname.h>
#include "virterror_internal.h"
#include "one_conf.h"
#include "buf.h"
#include "memory.h"
#include "util.h"
#define VIR_FROM_THIS VIR_FROM_ONE
/* --------------------------------------------------------------------------------- */
/**
* oneCapsInit initialize the driver capabilities
* @return a pointer to the driver capabilities NULL in case of error
*/
virCapsPtr oneCapsInit(void)
{
struct utsname utsname;
virCapsPtr caps;
virCapsGuestPtr guest;
uname(&utsname);
if ((caps = virCapabilitiesNew(utsname.machine,0,0)) == NULL)
{
goto no_memory;
}
virCapabilitiesSetMacPrefix(caps,(unsigned char[]){ 0x52, 0x54, 0x00 });
if ((guest = virCapabilitiesAddGuest(caps,
"hvm",
"i686",
32,
NULL,
NULL,
0,
NULL)) == NULL)
{
goto no_memory;
}
if (virCapabilitiesAddGuestDomain(guest,
"one",
NULL,
NULL,
0,
NULL) == NULL)
{
goto no_memory;
}
if ((guest = virCapabilitiesAddGuest(caps,
"hvm",
"x86_64",
64,
NULL,
NULL,
0,
NULL)) == NULL)
{
goto no_memory;
}
if (virCapabilitiesAddGuestDomain(guest,
"one",
NULL,
NULL,
0,
NULL) == NULL)
{
goto no_memory;
}
if ((guest = virCapabilitiesAddGuest(caps,
"xen",
"i686",
32,
NULL,
NULL,
0,
NULL)) == NULL)
{
goto no_memory;
}
if (virCapabilitiesAddGuestDomain(guest,
"one",
NULL,
NULL,
0,
NULL) == NULL)
{
goto no_memory;
}
return caps;
no_memory:
virCapabilitiesFree(caps);
return NULL;
}
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/**
* oneSubmitVM generates an OpenNebula description file and submits the new VM
* @param driver the OpenNebula driver
* @param vm the virtual machine pointer
* @return the OpenNebula ID for the new VM or -1 in case of error
*/
int oneSubmitVM(one_driver_t* driver ATTRIBUTE_UNUSED,
virDomainObjPtr vm)
{
char* templ;
int oneid;
if ((templ = xmlOneTemplate(vm->def)) == NULL)
return -1;
if ((oneid = c_oneAllocateTemplate(templ)) < 0) {
oneError(VIR_ERR_OPERATION_FAILED, "%s",
_("Error submitting virtual machine to OpenNebula"));
VIR_FREE(templ);
return -1;
}
VIR_FREE(templ);
return oneid;
}
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/* --------------------------------------------------------------------------------- */
/**
* xmlOneTemplate Generate an OpenNebula template to deploy a VM from libvirt
* internal Domain definition.
* @param def Internal libvirt Domain definition
* @return OpenNebula VM template.
*/
char* xmlOneTemplate(virDomainDefPtr def)
{
int i;
virBuffer buf= VIR_BUFFER_INITIALIZER;
virBufferVSprintf(&buf,"#OpenNebula Template automatically generated "
"by libvirt\nNAME = %s\nCPU = %d\nMEMORY = %ld\n",
def->name,
def->maxvcpus,
VIR_DIV_UP(def->mem.max_balloon, 1024));
/*Optional Booting OpenNebula Information:*/
if (def->os.kernel) {
virBufferVSprintf(&buf,"OS=[ kernel = \"%s\"",def->os.kernel);
if (def->os.initrd)
virBufferVSprintf(&buf,",\n initrd = \"%s\"",def->os.initrd);
if (def->os.cmdline)
virBufferVSprintf(&buf,",\n kernel_cmd = \"%s\"",def->os.cmdline);
if (def->os.root)
virBufferVSprintf(&buf,",\n root = \"%s\"",def->os.root);
virBufferAddLit(&buf," ]\n");
}
/* set Disks & NICS */
for (i=0 ; i < def->ndisks ; i++) {
/* missing source is only allowed at cdrom and floppy */
if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virBufferVSprintf(&buf, "DISK=[ type = disk,\n"
"\tsource = \"%s\",\n",
def->disks[i]->src);
}
else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
virBufferAddLit(&buf, "DISK=[ type = cdrom,\n");
if (def->disks[i]->src) virBufferVSprintf(&buf, "\tsource = \"%s\",\n",def->disks[i]->src);
}
else if (def->disks[i]->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY) {
virBufferAddLit(&buf, "DISK=[ type = floppy,\n");
if (def->disks[i]->src) virBufferVSprintf(&buf, "\tsource = \"%s\",\n",def->disks[i]->src);
}
virBufferVSprintf(&buf, "\ttarget = \"%s\",\n"
"\treadonly =",
def->disks[i]->dst);
if (def->disks[i]->readonly)
virBufferAddLit(&buf,"\"yes\"]\n");
else
virBufferAddLit(&buf,"\"no\"]\n");
}
for (i=0 ; i< def->nnets ; i++)
{
if (!def->nets[i]) {
continue;
}
switch(def->nets[i]->type)
{
case VIR_DOMAIN_NET_TYPE_BRIDGE:
virBufferVSprintf(&buf,"NIC=[ bridge =\"%s\",\n",def->nets[i]->data.bridge.brname);
if (def->nets[i]->ifname)
virBufferVSprintf(&buf," target =\"%s\",\n",def->nets[i]->ifname);
virBufferVSprintf(&buf," mac =\"%02x:%02x:%02x:%02x:%02x:%02x\" ]\n",
def->nets[i]->mac[0],def->nets[i]->mac[1],
def->nets[i]->mac[2],def->nets[i]->mac[3],
def->nets[i]->mac[4],def->nets[i]->mac[5]);
break;
case VIR_DOMAIN_NET_TYPE_NETWORK:
virBufferVSprintf(&buf,"NIC=[ network=\"%s\"",def->nets[i]->data.network.name);
if (def->nets[i]->ifname)
virBufferVSprintf(&buf,",\n target =\"%s\"",def->nets[i]->ifname);
virBufferAddLit(&buf," ]\n");
break;
default: break;
}
}
for(i=0;i<def->ngraphics;i++) {
if (def->graphics[i] == NULL)
continue;
if (def->graphics[i]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
virBufferAddLit(&buf,"GRAPHICS = [\n type = \"vnc\"");
if (def->graphics[i]->data.vnc.listenAddr != NULL)
virBufferVSprintf(&buf,",\n listen = \"%s\"",
def->graphics[i]->data.vnc.listenAddr);
if (def->graphics[i]->data.vnc.autoport == 0)
virBufferVSprintf(&buf,",\n port = \"%d\"",
def->graphics[i]->data.vnc.port);
if (def->graphics[i]->data.vnc.auth.passwd != NULL)
virBufferVSprintf(&buf,",\n passwd = \"%s\"",
def->graphics[i]->data.vnc.auth.passwd);
virBufferAddLit(&buf," ]\n");
}
else /* graphics.type==VIR_DOMAIN_GRAPHICS_TYPE_SDL */
virBufferAddLit(&buf,"GRAPHICS = [\n type = \"sdl\" ]\n");
}
if (virBufferError(&buf))
goto no_memory;
return virBufferContentAndReset(&buf);
no_memory:
virReportOOMError();
virBufferFreeAndReset(&buf);
return NULL;
};

54
src/opennebula/one_conf.h
View File

@ -1,54 +0,0 @@
/*----------------------------------------------------------------------------------*/
/*
* Copyright (C) 2010 Red Hat, Inc.
* Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
* Complutense de Madrid (dsa-research.org)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*-----------------------------------------------------------------------------------*/
#ifndef ONE_CONF_H
# define ONE_CONF_H
# include <config.h>
# include "internal.h"
# include "domain_conf.h"
# include "capabilities.h"
# include "threads.h"
# include "one_client.h"
struct one_driver{
virMutex lock;
virCapsPtr caps;
virDomainObjList domains;
int nextid;
};
typedef struct one_driver one_driver_t;
virCapsPtr oneCapsInit(void);
int oneSubmitVM(one_driver_t* driver, virDomainObjPtr vm);
char* xmlOneTemplate(virDomainDefPtr def);
# define oneError(code, ...) \
virReportErrorHelper(NULL, VIR_FROM_ONE, code, __FILE__, \
__FUNCTION__, __LINE__, __VA_ARGS__)
#endif /* ONE_CONF_H */

850
src/opennebula/one_driver.c
View File

@ -1,850 +0,0 @@
/*---------------------------------------------------------------------------*/
/*
* Copyright (C) 2010-2011 Red Hat, Inc.
* Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
* Complutense de Madrid (dsa-research.org)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*---------------------------------------------------------------------------*/
#include <config.h>
#include <fcntl.h>
#include <sched.h>
#include <sys/utsname.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <sys/poll.h>
#include <unistd.h>
#include <wait.h>
#include <sys/time.h>
#include "virterror_internal.h"
#include "logging.h"
#include "datatypes.h"
#include "one_conf.h"
#include "one_driver.h"
#include "memory.h"
#include "util.h"
#include "bridge.h"
#define VIR_FROM_THIS VIR_FROM_ONE
static int oneStartup(int privileged);
static int oneShutdown(void);
static int oneActive(void);
static void oneDriverLock(one_driver_t* driver)
{
virMutexLock(&driver->lock);
}
static void oneDriverUnlock(one_driver_t* driver)
{
virMutexUnlock(&driver->lock);
}
static one_driver_t *one_driver =NULL;
static virDrvOpenStatus oneOpen(virConnectPtr conn,
virConnectAuthPtr auth ATTRIBUTE_UNUSED,
int flags ATTRIBUTE_UNUSED)
{
/* Verify uri was specified */
if (conn->uri == NULL) {
conn->uri = xmlParseURI("one:///");
if (!conn->uri) {
virReportOOMError();
return VIR_DRV_OPEN_ERROR;
}
} else if (conn->uri->scheme == NULL ||
STRNEQ(conn->uri->scheme, "one")) {
goto declineConnection;
}
conn->privateData = one_driver;
return VIR_DRV_OPEN_SUCCESS;
declineConnection:
return VIR_DRV_OPEN_DECLINED;
}
static int oneClose(virConnectPtr conn)
{
conn->privateData = NULL;
return 0;
}
static int oneIsEncrypted(virConnectPtr conn ATTRIBUTE_UNUSED)
{
/* Not encrypted because it uses HTTP, not HTTPs */
return 0;
}
static int oneIsSecure(virConnectPtr conn ATTRIBUTE_UNUSED)
{
/* Not secure because it uses HTTP, not HTTPs */
return 0;
}
static int oneIsUpdated(virDomainPtr conn ATTRIBUTE_UNUSED)
{
return 0;
}
static virDomainPtr oneDomainLookupByID(virConnectPtr conn,
int id)
{
one_driver_t *driver = conn->privateData;
virDomainPtr dom = NULL;
virDomainObjPtr vm = NULL;
oneDriverLock(driver);
vm = virDomainFindByID(&driver->domains, id);
oneDriverUnlock(driver);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN, NULL);
goto return_point;
}
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) {
dom->id = vm->def->id;
}
return_point:
if(vm) {
virDomainObjUnlock(vm);
}
return dom;
}
static virDomainPtr oneDomainLookupByUUID(virConnectPtr conn,
const unsigned char *uuid)
{
one_driver_t *driver = conn->privateData;
virDomainPtr dom = NULL;
virDomainObjPtr vm = NULL;
oneDriverLock(driver);
vm = virDomainFindByUUID(&driver->domains, uuid);
oneDriverUnlock(driver);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN, NULL);
goto return_point;
}
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) {
dom->id = vm->def->id;
}
return_point:
if(vm) {
virDomainObjUnlock(vm);
}
return dom;
}
static virDomainPtr oneDomainLookupByName(virConnectPtr conn,
const char *name)
{
one_driver_t *driver = conn->privateData;
virDomainObjPtr vm = NULL;
virDomainPtr dom=NULL;
oneDriverLock(driver);
vm = virDomainFindByName(&driver->domains, name);
oneDriverUnlock(driver);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN, NULL);
goto return_point;
}
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) {
dom->id = vm->def->id;
}
return_point:
if(vm) {
virDomainObjUnlock(vm);
}
return dom;
}
static int oneListDomains(virConnectPtr conn, int *ids, int nids)
{
one_driver_t *driver = conn->privateData;
int n;
oneDriverLock(driver);
n = virDomainObjListGetActiveIDs(&driver->domains, ids, nids);
oneDriverUnlock(driver);
return n;
}
static int oneNumDomains(virConnectPtr conn)
{
one_driver_t *driver = conn->privateData;
int n;
oneDriverLock(driver);
n = virDomainObjListNumOfDomains(&driver->domains, 1);
oneDriverUnlock(driver);
return n;
}
static int oneListDefinedDomains(virConnectPtr conn,
char **const names, int nnames) {
one_driver_t *driver = conn->privateData;
int n;
oneDriverLock(driver);
n = virDomainObjListGetInactiveNames(&driver->domains, names, nnames);
oneDriverUnlock(driver);
return n;
}
static int oneNumDefinedDomains(virConnectPtr conn)
{
one_driver_t *driver = conn->privateData;
int n;
oneDriverLock(driver);
n = virDomainObjListNumOfDomains(&driver->domains, 0);
oneDriverUnlock(driver);
return n;
}
static virDomainPtr oneDomainDefine(virConnectPtr conn, const char *xml)
{
one_driver_t *driver = conn->privateData;
virDomainDefPtr def;
virDomainObjPtr vm;
virDomainPtr dom=NULL;
oneDriverLock(driver);
if (!(def = virDomainDefParseString(driver->caps, xml,
VIR_DOMAIN_XML_INACTIVE)))
goto return_point;
if (!(vm = virDomainAssignDef(driver->caps,
&driver->domains, def, false))) {
virDomainDefFree(def);
goto return_point;
}
vm->def->id = -1;
vm->persistent = 1;
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) {
dom->id = vm->def->id;
}
virDomainObjUnlock(vm);
return_point:
oneDriverUnlock(driver);
return dom;
}
static int oneDomainUndefine(virDomainPtr dom)
{
one_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
int ret=-1;
oneDriverLock(driver);
vm =virDomainFindByUUID(&driver->domains, dom->uuid);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN, "%s",
_("no domain with matching uuid"));
goto return_point;
}
if (!vm->persistent) {
oneError(VIR_ERR_OPERATION_INVALID, "%s",
_("cannot undefine transient domain"));
goto return_point;
}
virDomainRemoveInactive(&driver->domains, vm);
ret=0;
return_point:
if (vm)
virDomainObjUnlock(vm);
oneDriverUnlock(driver);
return ret;
}
static int oneDomainGetInfo(virDomainPtr dom,
virDomainInfoPtr info)
{
one_driver_t *driver = dom->conn->privateData;
struct timeval tv;
virDomainObjPtr vm;
oneDriverLock(driver);
vm= virDomainFindByUUID(&driver->domains, dom->uuid);
oneDriverUnlock(driver);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN, "%s",
_("no domain with matching uuid"));
return -1;
}
if(gettimeofday(&tv,NULL)<0) {
oneError(VIR_ERR_INTERNAL_ERROR, "%s",
_("getting time of day"));
virDomainObjUnlock(vm);
return -1;
}
if (!virDomainObjIsActive(vm)) {
info->cpuTime = 0;
} else {
char vm_info[257];
c_oneVmInfo(vm->pid,vm_info,256);
/* State: */
char* cptr = strstr(vm_info,"STATE");
cptr = index(cptr, ':');
cptr++;
int one_state=atoi(cptr);
switch(one_state) {
case 3: /** running */
if (vm->state!=VIR_DOMAIN_SHUTDOWN)
vm->state=VIR_DOMAIN_RUNNING;
break;
case 5: /** pause */
vm->state=VIR_DOMAIN_PAUSED;
break;
case 6: /** done */
vm->state=VIR_DOMAIN_SHUTOFF;
vm->def->id=-1;
break;
case 7: /** error */
vm->state=VIR_DOMAIN_CRASHED;
break;
default:
break;
};
/* Memory: */
cptr=strstr(vm_info,"MEMORY");
cptr=index(cptr,':');
cptr++;
vm->def->mem.cur_balloon = atoi(cptr);
/* run time: */
cptr=strstr(vm_info,"START TIME");
cptr=index(cptr,':');
cptr++;
long starttime = atol(cptr);
info->cpuTime = (tv.tv_sec - starttime) *1000ll *1000ll *1000ll;
}
info->state = vm->state;
info->maxMem = vm->def->mem.max_balloon;
info->memory = vm->def->mem.cur_balloon;
info->nrVirtCpu = vm->def->vcpus;
virDomainObjUnlock(vm);
return 0;
}
static char *oneGetOSType(virDomainPtr dom)
{
one_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm = NULL;
char *ret = NULL;
oneDriverLock(driver);
vm =virDomainFindByUUID(&driver->domains, dom->uuid);
oneDriverUnlock(driver);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN, "%s",
_("no domain with matching uuid"));
goto cleanup;
}
ret = strdup(vm->def->os.type);
if (!ret)
virReportOOMError();
cleanup:
if (vm)
virDomainObjUnlock(vm);
return ret;
}
static int oneDomainStartWithFlags(virDomainPtr dom, unsigned int flags)
{
virConnectPtr conn = dom->conn;
one_driver_t *driver = conn->privateData;
virDomainObjPtr vm;
int ret = -1;
int oneid;
virCheckFlags(0, -1);
oneDriverLock(driver);
vm = virDomainFindByName(&driver->domains, dom->name);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN,
_("no domain named %s"), dom->name);
goto return_point;
}
if((oneid = oneSubmitVM(driver, vm)) < 0) {
goto return_point;
}
vm->pid=oneid;
vm->def->id=driver->nextid++;
vm->state=VIR_DOMAIN_BLOCKED;
ret=0;
return_point:
if(vm)
virDomainObjUnlock(vm);
oneDriverUnlock(driver);
return ret;
}
static int oneDomainStart(virDomainPtr dom)
{
return oneDomainStartWithFlags(dom, 0);
}
static virDomainPtr
oneDomainCreateAndStart(virConnectPtr conn,
const char *xml,
unsigned int flags) {
one_driver_t *driver = conn->privateData;
virDomainObjPtr vm = NULL;
virDomainDefPtr def;
virDomainPtr dom = NULL;
int oneid;
virCheckFlags(0, NULL);
oneDriverLock(driver);
if (!(def = virDomainDefParseString(driver->caps, xml,
VIR_DOMAIN_XML_INACTIVE)))
goto return_point;
vm = virDomainFindByName(&driver->domains, def->name);
if (vm) {
oneError(VIR_ERR_OPERATION_FAILED,
_("Already an OpenNebula VM active with the name: '%s' id: %d "),
def->name,def->id);
goto return_point;
}
if (!(vm = virDomainAssignDef(driver->caps,
&driver->domains, def, false))) {
virDomainDefFree(def);
goto return_point;
}
if ((oneid = oneSubmitVM(driver, vm)) < 0) {
virDomainRemoveInactive(&driver->domains, vm);
vm=NULL;
goto return_point;
}
vm->def->id=driver->nextid++;
vm->persistent=0;
vm->pid=oneid;
vm->state=VIR_DOMAIN_BLOCKED;
dom = virGetDomain(conn, vm->def->name, vm->def->uuid);
if (dom) {
dom->id = vm->def->id;
}
return_point:
if(vm)
virDomainObjUnlock(vm);
oneDriverUnlock(driver);
return dom;
}
static int oneDomainShutdown(virDomainPtr dom)
{
one_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret=-1;
oneDriverLock(driver);
if (!(vm=virDomainFindByID(&driver->domains, dom->id))) {
oneError(VIR_ERR_NO_DOMAIN,
_("no domain with id %d"), dom->id);
goto return_point;
}
if (c_oneShutdown(vm->pid)) {
oneError(VIR_ERR_OPERATION_INVALID, "%s",
_("Wrong state to perform action"));
goto return_point;
}
vm->state=VIR_DOMAIN_SHUTDOWN;
ret= 0;
if (!vm->persistent) {
virDomainRemoveInactive(&driver->domains, vm);
vm = NULL;
}
return_point:
if(vm)
virDomainObjUnlock(vm);
oneDriverUnlock(driver);
return ret;
}
static int oneDomainDestroy(virDomainPtr dom)
{
one_driver_t *driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret=-1;
oneDriverLock(driver);
vm= virDomainFindByID(&driver->domains, dom->id);
if (!vm) {
oneError(VIR_ERR_NO_DOMAIN,
_("no domain with id %d"), dom->id);
goto return_point;
}
if(c_oneCancel(vm->pid)) {
/* VM not running, delete the instance at ONE DB */
if(c_oneFinalize(vm->pid)){
oneError(VIR_ERR_OPERATION_INVALID, "%s",
_("Wrong state to perform action"));
goto return_point;
}
}
if(!vm->persistent) {
virDomainRemoveInactive(&driver->domains,vm);
vm=NULL;
}
ret=0;
return_point:
if(vm)
virDomainObjUnlock(vm);
oneDriverUnlock(driver);
return ret;
}
static int oneDomainSuspend(virDomainPtr dom)
{
one_driver_t* driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret=-1;
oneDriverLock(driver);
if ((vm=virDomainFindByID(&driver->domains,dom->id))){
if (vm->state == VIR_DOMAIN_RUNNING) {
if( !(c_oneSuspend(vm->pid)) ) {
vm->state=VIR_DOMAIN_PAUSED;
ret=0;
goto return_point;
}
oneError(VIR_ERR_OPERATION_INVALID, "%s",
_("Wrong state to perform action"));
goto return_point;
}
oneError(VIR_ERR_OPERATION_INVALID, "%s",
_("domain is not running"));
} else {
oneError(VIR_ERR_NO_DOMAIN,
_("no domain with matching id %d"), dom->id);
}
return_point:
if(vm)
virDomainObjUnlock(vm);
oneDriverUnlock(driver);
return ret;
};
static int oneDomainResume(virDomainPtr dom)
{
one_driver_t* driver = dom->conn->privateData;
virDomainObjPtr vm;
int ret=-1;
oneDriverLock(driver);
if ((vm=virDomainFindByID(&driver->domains,dom->id))) {
if (vm->state == VIR_DOMAIN_PAUSED) {
if( !(c_oneResume(vm->pid)) ) {
vm->state=VIR_DOMAIN_RUNNING;
ret=0;
goto return_point;
}
oneError(VIR_ERR_OPERATION_INVALID, "%s",
_("Wrong state to perform action"));
goto return_point;
}
oneError(VIR_ERR_OPERATION_INVALID, "%s",
_("domain is not paused"));
} else {
oneError(VIR_ERR_NO_DOMAIN,
_("no domain with matching id %d"), dom->id);
}
return_point:
if(vm)
virDomainObjUnlock(vm);
oneDriverUnlock(driver);
return ret;
};
static int oneStartup(int privileged ATTRIBUTE_UNUSED){
if (VIR_ALLOC(one_driver) < 0) {
return -1;
}
if(virMutexInit(&one_driver->lock)<0){
VIR_FREE(one_driver);
return -1;
}
c_oneStart();
oneDriverLock(one_driver);
if (virDomainObjListInit(&one_driver->domains) < 0) {
goto error;
}
one_driver->nextid=1;
if ((one_driver->caps = oneCapsInit()) == NULL) {
virReportOOMError();
goto error;
}
oneDriverUnlock(one_driver);
return 0;
error:
oneDriverUnlock(one_driver);
oneShutdown();
return -1;
}
static int oneShutdown(void){
if (one_driver == NULL)
return(-1);
oneDriverLock(one_driver);
virDomainObjListDeinit(&one_driver->domains);
virCapabilitiesFree(one_driver->caps);
oneDriverUnlock(one_driver);
virMutexDestroy(&one_driver->lock);
VIR_FREE(one_driver);
one_driver = NULL;
c_oneFree();
return 0;
}
static int oneActive(void){
int active = 0;
if (one_driver == NULL)
return(0);
oneDriverLock(one_driver);
active = virDomainObjListNumOfDomains(&one_driver->domains, 1);
oneDriverUnlock(one_driver);
return active;
}
static int oneVersion(virConnectPtr conn ATTRIBUTE_UNUSED, unsigned long *hvVer)
{
*hvVer = 1;
return 0;
}
static int oneGetAutostart(virDomainPtr domain ATTRIBUTE_UNUSED, int *autostart)
{
autostart=0;
return 0;
}
static char* oneGetCapabilities(virConnectPtr conn){
one_driver_t* privconn = conn->privateData;
char *xml;
oneDriverLock(privconn);
if ((xml = virCapabilitiesFormatXML(privconn->caps)) == NULL)
virReportOOMError();
oneDriverUnlock(privconn);
return xml;
}
/* Function Tables */
static virDriver oneDriver = {
VIR_DRV_ONE, /* the number virDrvNo */
"one", /* the name of the driver */
oneOpen, /* open */
oneClose, /* close */
NULL, /* supports_feature */
NULL, /* type */
oneVersion, /* version */
NULL, /* libvirtVersion (impl. in libvirt.c) */
NULL, /* getHostname */
NULL, /* getSysinfo */
NULL, /* getMaxVcpus */
NULL, /* nodeGetInfo */
oneGetCapabilities, /* getCapabilities */
oneListDomains, /* listDomains */
oneNumDomains, /* numOfDomains */
oneDomainCreateAndStart, /* domainCreateXML */
oneDomainLookupByID, /* domainLookupByID */
oneDomainLookupByUUID, /* domainLookupByUUID */
oneDomainLookupByName, /* domainLookupByName */
oneDomainSuspend, /* domainSuspend */
oneDomainResume, /* domainResume */
oneDomainShutdown, /* domainShutdown */
NULL, /* domainReboot */
oneDomainDestroy, /* domainDestroy */
oneGetOSType, /* domainGetOSType */
NULL, /* domainGetMaxMemory */
NULL, /* domainSetMaxMemory */
NULL, /* domainSetMemory */
NULL, /* domainSetMemoryFlags */
NULL, /* domainSetMemoryParameters */
NULL, /* domainGetMemoryParameters */
NULL, /* domainSetBlkioParameters */
NULL, /* domainGetBlkioParameters */
oneDomainGetInfo, /* domainGetInfo */
NULL, /* domainSave */
NULL, /* domainRestore */
NULL, /* domainCoreDump */
NULL, /* domainSetVcpus */
NULL, /* domainSetVcpusFlags */
NULL, /* domainGetVcpusFlags */
NULL, /* domainPinVcpu */
NULL, /* domainGetVcpus */
NULL, /* domainGetMaxVcpus */
NULL, /* domainGetSecurityLabel */
NULL, /* nodeGetSecurityModel */
NULL, /* domainDumpXML */
NULL, /* domainXMLFromNative */
NULL, /* domainXMLToNative */
oneListDefinedDomains, /* listDefinedDomains */
oneNumDefinedDomains, /* numOfDefinedDomains */
oneDomainStart, /* domainCreate */
oneDomainStartWithFlags, /* domainCreateWithFlags */
oneDomainDefine, /* domainDefineXML */
oneDomainUndefine, /* domainUndefine */
NULL, /* domainAttachDevice */
NULL, /* domainAttachDeviceFlags */
NULL, /* domainDetachDevice */
NULL, /* domainDetachDeviceFlags */
NULL, /* domainUpdateDeviceFlags */
oneGetAutostart, /* domainGetAutostart */
NULL, /* domainSetAutostart */
NULL, /* domainGetSchedulerType */
NULL, /* domainGetSchedulerParameters */
NULL, /* domainSetSchedulerParameters */
NULL, /* domainMigratePrepare */
NULL, /* domainMigratePerform */
NULL, /* domainMigrateFinish */
NULL, /* domainBlockStats */
NULL, /* domainInterfaceStats */
NULL, /* domainMemoryStats */
NULL, /* domainBlockPeek */
NULL, /* domainMemoryPeek */
NULL, /* domainGetBlockInfo */
NULL, /* nodeGetCellsFreeMemory */
NULL, /* getFreeMemory */
NULL, /* domainEventRegister */
NULL, /* domainEventDeregister */
NULL, /* domainMigratePrepare2 */
NULL, /* domainMigrateFinish2 */
NULL, /* nodeDeviceDettach; */
NULL, /* nodeDeviceReAttach; */
NULL, /* nodeDeviceReset; */
NULL, /* domainMigratePrepareTunnel */
oneIsEncrypted, /* isEncrypted */
oneIsSecure, /* isSecure */
NULL, /* domainIsActive */
NULL, /* domainIsPersistent */
oneIsUpdated, /* domainIsUpdated */
NULL, /* cpuCompare */
NULL, /* cpuBaseline */
NULL, /* domainGetJobInfo */
NULL, /* domainAbortJob */
NULL, /* domainMigrateSetMaxDowntime */
NULL, /* domainMigrateSetMaxSpeed */
NULL, /* domainEventRegisterAny */
NULL, /* domainEventDeregisterAny */
NULL, /* domainManagedSave */
NULL, /* domainHasManagedSaveImage */
NULL, /* domainManagedSaveRemove */
NULL, /* domainSnapshotCreateXML */
NULL, /* domainSnapshotDumpXML */
NULL, /* domainSnapshotNum */
NULL, /* domainSnapshotListNames */
NULL, /* domainSnapshotLookupByName */
NULL, /* domainHasCurrentSnapshot */
NULL, /* domainSnapshotCurrent */
NULL, /* domainRevertToSnapshot */
NULL, /* domainSnapshotDelete */
NULL, /* qemuDomainMonitorCommand */
NULL, /* domainOpenConsole */
};
static virStateDriver oneStateDriver = {
.name = "OpenNebula",
.initialize = oneStartup,
.cleanup = oneShutdown,
.active = oneActive,
};
int oneRegister(void)
{
virRegisterDriver(&oneDriver);
virRegisterStateDriver(&oneStateDriver);
return 0;
}

30
src/opennebula/one_driver.h
View File

@ -1,30 +0,0 @@
/*---------------------------------------------------------------------------*/
/* Copyright 2002-2009, Distributed Systems Architecture Group, Universidad
* Complutense de Madrid (dsa-research.org)
*
* 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, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
/*---------------------------------------------------------------------------*/
#ifndef ONE_DRIVER_H
# define ONE_DRIVER_H
# include <config.h>
# include "one_client.h"
int oneRegister(void);
#endif /* ONE_DRIVER_H */

2
tools/virsh.pod
View File

@ -20,7 +20,7 @@ Linux Operating System means the ability to run multiple instances of
Operating Systems concurrently on a single hardware system where the
basic resources are driven by a Linux instance. The library aims at
providing a long term stable C API. It currently supports Xen, QEmu,
KVM, LXC, OpenVZ, VirtualBox, OpenNebula, and VMware ESX.
KVM, LXC, OpenVZ, VirtualBox and VMware ESX.
The basic structure of most virsh usage is: