static int
mymain(void)
{
struct metadataTest test;
int ret = EXIT_SUCCESS;
if (!(test.conn = virConnectOpen("test:///default")))
return EXIT_FAILURE;
if (!(test.dom = virDomainLookupByName(test.conn, "test"))) {
virConnectClose(test.conn);
return EXIT_FAILURE;
}
virtTestQuiesceLibvirtErrors(false);
if (virtTestRun("Assign metadata ", testAssignMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Rewrite Metadata ", testRewriteMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Erase metadata ", testEraseMetadata, &test) < 0)
ret = EXIT_FAILURE;
virDomainFree(test.dom);
virConnectClose(test.conn);
return ret;
}
void main(int argc, char *argv[]) {
char *myIP;
if (argc<2)
printf("arg1=myip\n"),exit(-128);
myIP = argv[1];
if (fork() == 0) {
// Child
virConnectPtr localhost = virConnectOpen("qemu:///system");
while(1) {
int alive = virConnectIsAlive(localhost);
if (alive == 0) {
printf("Connection lost, reopening.\n");
virConnectClose(localhost);
localhost = virConnectOpen("qemu:///system");
} else if (alive == -1) {
printf("Connection dead.\n");
virConnectClose(localhost);
localhost = virConnectOpen("qemu:///system");
sleep(3);
continue;
}
printf("*** connected\n");
run(myIP, localhost);
sleep(1);
}
virConnectClose(localhost);
}
exit(0);
}
static int
mymain(void)
{
int id = 0;
int ro = 0;
virConnectPtr conn;
virDomainPtr dom;
int status;
virCommandPtr cmd;
struct utsname ut;
/* Skip test if xend is not running. Calling xend on a non-xen
kernel causes some versions of xend to issue a crash report, so
we first probe uname results. */
uname(&ut);
if (strstr(ut.release, "xen") == NULL)
return EXIT_AM_SKIP;
cmd = virCommandNewArgList("/usr/sbin/xend", "status", NULL);
if (virCommandRun(cmd, &status) != 0 || status != 0) {
virCommandFree(cmd);
return EXIT_AM_SKIP;
}
virCommandFree(cmd);
virSetErrorFunc(NULL, errorHandler);
conn = virConnectOpen(NULL);
if (conn == NULL) {
ro = 1;
conn = virConnectOpenReadOnly(NULL);
}
if (conn == NULL) {
fprintf(stderr, "First virConnectOpen() failed\n");
return EXIT_FAILURE;
}
dom = virDomainLookupByID(conn, id);
if (dom == NULL) {
fprintf(stderr, "First lookup for domain %d failed\n", id);
return EXIT_FAILURE;
}
virDomainFree(dom);
virConnectClose(conn);
if (ro == 1)
conn = virConnectOpenReadOnly(NULL);
else
conn = virConnectOpen(NULL);
if (conn == NULL) {
fprintf(stderr, "Second virConnectOpen() failed\n");
return EXIT_FAILURE;
}
dom = virDomainLookupByID(conn, id);
if (dom == NULL) {
fprintf(stderr, "Second lookup for domain %d failed\n", id);
return EXIT_FAILURE;
}
virDomainFree(dom);
virConnectClose(conn);
return EXIT_SUCCESS;
}
static int network_op(char * name, int op)
{
virNetworkPtr net;
virConnectPtr conn;
int ret;
conn = virConnectOpen("qemu:///system");
if (conn == NULL)
{
fprintf(stderr, "Failed to open connection to qemu:///system\n");
return -1;
}
net = virNetworkLookupByName(conn, name);
if (net == NULL)
{
printf("network is not found\n");
virConnectClose(conn);
return -1;
}
if (op == NETWORK_DESTROY)
ret = virNetworkDestroy(net);
else if (op == NETWORK_SET_AUTOSTART)
ret = virNetworkSetAutostart(net, 1);
else if (op == NETWORK_UNSET_AUTOSTART)
ret = virNetworkSetAutostart(net, 0);
else
ret = -1;
virNetworkFree(net);
virConnectClose(conn);
return ret;
}
static void
cpg_virt_init_libvirt(struct cpg_info *info) {
config_object_t *config = info->config;
int i = 0;
if (info->vp) {
dbg_printf(2, "Lost libvirtd connection. Reinitializing.\n");
for (i = 0 ; i < info->vp_count ; i++)
virConnectClose(info->vp[i]);
free(info->vp);
info->vp = NULL;
}
info->vp_count = 0;
do {
virConnectPtr vp;
virConnectPtr *vpl = NULL;
char conf_attr[256];
char value[1024];
char *uri;
if (i != 0) {
snprintf(conf_attr, sizeof(conf_attr),
"backends/cpg/@uri%d", i);
} else
snprintf(conf_attr, sizeof(conf_attr), "backends/cpg/@uri");
++i;
if (sc_get(config, conf_attr, value, sizeof(value)) != 0)
break;
uri = value;
vp = virConnectOpen(uri);
if (!vp) {
dbg_printf(1, "[cpg-virt:INIT] Failed to connect to URI: %s\n", uri);
continue;
}
vpl = realloc(info->vp, sizeof(*info->vp) * (info->vp_count + 1));
if (!vpl) {
dbg_printf(1, "[cpg-virt:INIT] Out of memory allocating URI: %s\n",
uri);
virConnectClose(vp);
continue;
}
info->vp = vpl;
info->vp[info->vp_count++] = vp;
if (i > 1)
dbg_printf(1, "[cpg-virt:INIT] Added URI%d %s\n", i - 1, uri);
else
dbg_printf(1, "[cpg_virt:INIT] Added URI %s\n", uri);
} while (1);
}
timearg GetVirtInfo::GetCpuTime(QString VM_name)
{
virDomainPtr vm_ptr = virDomainLookupByName(conn, qPrintable(VM_name));
if(vm_ptr == NULL) {
printf("error finding domain\n");
virConnectClose(conn);
exit(1);
}
virDomainInfo info_s;
struct timeval real_time_s;
timearg return_arg;
if(virDomainGetInfo(vm_ptr, &info_s) != 0) {
printf("error get domain info\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
if(gettimeofday(&real_time_s, NULL) == -1) {
printf("error get time of day\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
return_arg.info = info_s;
return_arg.real_time = real_time_s;
virDomainFree(vm_ptr);
return return_arg;
/* sleep(1);
if(virDomainGetInfo(vm_ptr, &info_e) !=0) {
printf("error get domain info\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
if(gettimeofday(&real_time_e, NULL) == -1) {
printf("error get time of day\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
cpu_diff = (info_e.cpuTime - info_s.cpuTime) / 1000;
real_diff = 1000000 * (real_time_e.tv_sec - real_time_s.tv_sec) +(real_time_e.tv_usec - real_time_s.tv_usec);
virDomainFree(vm_ptr);
usage = cpu_diff / (float) (real_diff);
return usage*100;*/
}
int libvirt_domain_save(char * name, int idonweb)
{
virDomainPtr domain;
domain = virDomainLookupByName(g_conn, name);
if (domain == NULL) {
logerror(_("%s: connect domain by name(%s) error.\n"),
__func__, name);
return -1;
}
virDomainInfo info;
if (virDomainGetInfo(dom, &info) < 0) {
logprintfl(SCERROR, "Cannot check guest state\n");
return -3;
}
if (info.state == VIR_DOMAIN_SHUTOFF) {
logprintfl(SCERROR, "Not saving guest that isn't running\n");
return -4;
}
const char *filename = "";
if (virDomainSave(dom, filename) < 0) {
fprintf(stderr, "Unable to save guest to %s\n", filename);
}
fprintf(stdout, "Guest state saved to %s\n", filename);
virConnectClose(conn);
return 0;
}
int libvirt_check(int driver)
{
virSetErrorFunc(NULL, __customErrorFunc);
const char * URI;
if (driver == HYPERVISOR_IS_KVM)
URI = HYPERVISOR_URI_KVM;
else if (driver == HYPERVISOR_IS_XEN)
URI = HYPERVISOR_URI_XEN;
else {
logerror(_("unrecognized hypervisor driver(%d).\n"), driver);
return -1;
}
virConnectPtr conn = virConnectOpen(URI);
if (conn == NULL) {
logerror(_("Connect to %s error.\n"), URI);
return -1;
}
int numDomains = virConnectNumOfDomains(conn);
if (numDomains < 0) {
logerror(_("Connect to %s error.\n"), URI);
return -1;
}
virConnectClose(conn);
return 0;
}
static void getDomainInfo(int id) {
virConnectPtr conn = NULL; /* the hypervisor connection */
virDomainPtr dom = NULL; /* the domain being checked */
virDomainInfo info; /* the information being fetched */
int ret;
/* NULL means connect to local Xen hypervisor */
conn = virConnectOpenReadOnly(NULL);
if (conn == NULL) {
fprintf(stderr, "Failed to connect to hypervisor\n");
goto error;
}
/* Find the domain of the given id */
dom = virDomainLookupByID(conn, id);
if (dom == NULL) {
fprintf(stderr, "Failed to find Domain %d\n", id);
goto error;
}
/* Get the information */
ret = virDomainGetInfo(dom, &info);
if (ret < 0) {
fprintf(stderr, "Failed to get information for Domain %d\n", id);
goto error;
}
printf("Domains %d: %d CPUs\n", id, info.nrVirtCpu);
error:
if (dom != NULL)
virDomainFree(dom);
if (conn != NULL)
virConnectClose(conn);
}
int main(int argc, char **argv) {
int id = 0;
conn = virConnectOpenReadOnly(NULL);
if (conn == NULL) {
fprintf(stderr, "Failed to connect to hypervisor\n");
goto error;
}
if (argc > 1) {
id = atoi(argv[1]);
}
if (id == 0) {
int i, j, ids[10];
i = virConnectListDomains(conn, &ids[0], 10);
if (i<0) {
fprintf(stderr, "Failed to list the domains\n");
goto error;
}
for (j = 0;j < i;j++) {
if (ids[j] != 0) {
id = ids[j];
break;
}
}
}
if (id == 0) {
fprintf(stderr, "Failed find a running guest domain\n");
goto error;
}
error:
if (conn != NULL)
virConnectClose(conn);
return(0);
}
void spice_graphHlpThread::run()
{
if ( NULL==ptr_ConnPtr || NULL==*ptr_ConnPtr ) {
emit ptrIsNull();
return;
};
if ( virConnectRef(*ptr_ConnPtr)<0 ) {
sendConnErrors();
return;
};
QStringList nets;
virNetworkPtr *networks = NULL;
unsigned int flags = VIR_CONNECT_LIST_NETWORKS_ACTIVE |
VIR_CONNECT_LIST_NETWORKS_INACTIVE;
int ret = virConnectListAllNetworks(*ptr_ConnPtr, &networks, flags);
if ( ret<0 ) {
sendConnErrors();
} else {
// therefore correctly to use for() command, because networks[0] can not exist.
for (int i = 0; i < ret; i++) {
nets.append( virNetworkGetName(networks[i]) );
virNetworkFree(networks[i]);
};
if (networks) free(networks);
};
//int devs = virNodeNumOfDevices(ptr_ConnPtr, NULL, 0);
if ( virConnectClose(*ptr_ConnPtr)<0 ) {
sendConnErrors();
};
emit result(nets);
}
void libvirt_disconnect() {
free(activeDomains);
virConnectClose(conn);
// directly exit from here
exit(0);
}
void ConnAliveThread::closeConnection()
{
//qDebug()<<"closeConnection0"<<*ptr_ConnPtr<<URI;
if ( keep_alive ) {
keep_alive = false;
return;
};
//qDebug()<<"closeConnection1"<<*ptr_ConnPtr<<URI;
CONN_STATE state;
if ( *ptr_ConnPtr!=NULL ) {
//qDebug()<<"closeConnection2"<<*ptr_ConnPtr<<URI;
unregisterConnEvents();
//qDebug()<<"closeConnection3"<<*ptr_ConnPtr<<URI;
int ret = virConnectClose(*ptr_ConnPtr);
//qDebug()<<"virConnectRef -1"<<"ConnAliveThread"<<URI<<(ret+1>0);
if ( ret<0 ) {
state = FAILED;
sendConnErrors();
} else {
emit connMsg( QString("close exit code: %1").arg(ret) );
state = CLOSED;
emit connClosed(onView);
};
*ptr_ConnPtr = NULL;
} else {
emit connMsg( QString("connect is NULL") );
state = FAILED;
};
emit changeConnState(state);
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
int id;
char *vm_name;
if (argc < 2){
printf("Usage\n%s <virtual machine name\n", argv[0]);
exit(1);
} else {
vm_name = argv[1];
}
conn = connect_to_hypervisor();
id = find_a_domain(conn, vm_name);
virConnectClose(conn);
if (id > 0){
printf("Domain %s is running\n", vm_name);
} else if (id < 0){
printf("Domain %s is NOT running\n", vm_name);
} else {
// If ID is 0, it means that the virtual machine does not exist
// on the hypervisor
printf("Domain %s not found on this hypervisor\n", vm_name);
}
return 0;
}
static int dominfo_from_dom(const char *uri,
const char *domain,
struct domain **d)
{
virConnectPtr conn = NULL;
virDomainPtr dom = NULL;
int ret = 0;
conn = virConnectOpen(uri);
if (conn == NULL) {
printf("Unable to connect to libvirt\n");
goto out;
}
dom = virDomainLookupByName(conn, domain);
if (dom == NULL) {
printf("Unable to find domain `%s'\n", domain);
goto out;
}
ret = get_dominfo(dom, d);
out:
virDomainFree(dom);
virConnectClose(conn);
return ret;
}
//qDebug()<<URIs;
foreach (QString uri, URIs) {
virConnect *connPtr =
virConnectOpenReadOnly(uri.toUtf8().data());
if ( Q_NULLPTR!=connPtr ) {
// don't work for VBox
// int num = virConnectNumOfDefinedDomains(connPtr);
virDomainPtr *domains;
int ret = virConnectListAllDomains(
connPtr, &domains, 0);
if ( ret+1 ) {
for (int i = 0; i < ret; i++) {
if ( virDomainFree(domains[i]) <0 )
sendConnErrors();
};
if (domains) free(domains);
} else {
sendConnErrors();
};
virConnectClose(connPtr);
if ( ret ) {
emit localConnFound(uri);
};
} else {
sendConnErrors();
};
//msleep(333);
};
/**
* virNWFilterReload:
*
* Function to restart the nwfilter driver, it will recheck the configuration
* files and update its state
*/
static int
nwfilterDriverReload(void) {
virConnectPtr conn;
if (!driverState) {
return -1;
}
conn = virConnectOpen("qemu:///system");
if (conn) {
/* shut down all threads -- they will be restarted if necessary */
virNWFilterLearnThreadsTerminate(true);
nwfilterDriverLock(driverState);
virNWFilterCallbackDriversLock();
virNWFilterLoadAllConfigs(conn,
&driverState->nwfilters,
driverState->configDir);
virNWFilterCallbackDriversUnlock();
nwfilterDriverUnlock(driverState);
virConnectClose(conn);
}
return 0;
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
int i;
int numDomains;
int *activeDomains;
virDomainPtr dom;
conn = virConnectOpen("qemu:///system");
if (conn == NULL) {
fprintf(stderr, "Failed to open connection to qemu:///system\n");
}
numDomains = virConnectNumOfDomains(conn);
activeDomains = malloc(sizeof(int) * numDomains);
numDomains = virConnectListDomains(conn, activeDomains, numDomains);
printf("Active domain IDs:\n");
for (i = 0 ; i < numDomains ; i++) {
printf(" %d\n", activeDomains[i]);
}
printf("Terminating Domain\n");
free(activeDomains);
int domainName = "sudip";
dom = virDomainLookupByName(conn,domainName);
virDomainDestroy(dom);
virDomainFree(dom);
printf("Domain sudip terminated successfully\n");
if (conn != NULL)
virConnectClose(conn);
return 0;
}
int main (int argc, char **argv) {
/* Local Vars */
virConnectPtr conn;
const char *hvType;
unsigned long libVer, libMajor, libMinor, libRelease;
unsigned long hvVer, hvMajor, hvMinor, hvRelease;
/* Set signal handling and alarm */
if (signal(SIGALRM, timeout_alarm_handler) == SIG_ERR)
critical("Setup SIGALRM trap failed!");
/* Process check arguments */
if (process_arguments(argc, argv) != OK)
unknown("Parsing arguments failed!");
/* Start plugin timeout */
alarm(mp_timeout);
// PLUGIN CODE
conn = virt_connect();
hvType = virConnectGetType(conn);
if (hvType == NULL) {
if (mp_verbose > 0) {
virt_showError(conn);
}
critical("Failed to get hypervisor type.");
}
if (virConnectGetVersion(conn, &hvVer) != 0) {
if (mp_verbose > 0) {
virt_showError(conn);
}
critical("Failed to get hypervisor version.");
}
if (virConnectGetLibVersion(conn, &libVer) != 0) {
if (mp_verbose > 0) {
virt_showError(conn);
}
critical("Failed to get library version.");
}
virConnectClose(conn);
hvMajor = hvVer / 1000000;
hvVer %= 1000000;
hvMinor = hvVer / 1000;
hvRelease = hvVer % 1000;
libMajor = libVer / 1000000;
libVer %= 1000000;
libMinor = libVer / 1000;
libRelease = libVer % 1000;
/* Output and return */
ok("libvirtd: v.%lu.%lu.%lu Hypervisor: %s (v.%lu.%lu.%lu)",
libMajor, libMinor, libRelease,
hvType, hvMajor, hvMinor, hvRelease);
}
CMPIStatus enum_profiles(const CMPIBroker *broker,
const CMPIObjectPath *reference,
const char **properties,
struct inst_list *list)
{
CMPIStatus s = {CMPI_RC_OK, NULL};
virConnectPtr conn = NULL;
int i;
conn = connect_by_classname(broker, CLASSNAME(reference), &s);
if (conn == NULL)
goto out;
for (i = 0; profiles[i] != NULL; i++) {
CMPIInstance *inst = NULL;
s = get_profile(broker,
reference,
properties,
pfx_from_conn(conn),
profiles[i],
&inst);
if (s.rc != CMPI_RC_OK)
continue;
inst_list_add(list, inst);
}
out:
virConnectClose(conn);
return s;
}
void pci_hostHlpThread::run()
{
if ( NULL==ptr_ConnPtr || NULL==*ptr_ConnPtr ) {
emit ptrIsNull();
return;
};
if ( virConnectRef(*ptr_ConnPtr)<0 ) {
sendConnErrors();
return;
};
QStringList devices;
virNodeDevice **nodeDevices = NULL;
unsigned int flags =
VIR_CONNECT_LIST_NODE_DEVICES_CAP_PCI_DEV;
int ret = virConnectListAllNodeDevices(*ptr_ConnPtr, &nodeDevices, flags);
if ( ret<0 ) {
sendConnErrors();
} else {
// therefore correctly to use for() command, because networks[0] can not exist.
for (int i = 0; i < ret; i++) {
devices.append( QString("%1\n")
// flags: extra flags; not used yet,
// so callers should always pass 0
.arg(virNodeDeviceGetXMLDesc(nodeDevices[i], 0)));
virNodeDeviceFree(nodeDevices[i]);
};
if (nodeDevices) free(nodeDevices);
};
//int devs = virNodeNumOfDevices(ptr_ConnPtr, NULL, 0);
if ( virConnectClose(*ptr_ConnPtr)<0 )
sendConnErrors();
emit result(devices);
}
int libvirt_close(void) {
free_block_devices();
free_interface_devices();
free_domains();
if(conn != NULL)
virConnectClose(conn);
conn = NULL;
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
virDomainPtr dom;
char *xmlconfig = NULL;
if(argc != 2)
{
printf("usage: ./define_domain domain.xml\n");
return -1;
}
if ((xmlconfig = GetXml(argv[1])) == NULL)
{
fprintf(stderr, "Failed to get xml\n");
return -1;
}
conn = virConnectOpen("qemu:///system");
if (conn == NULL)
{
fprintf(stderr, "Failed to open connection to qemu:///system\n");
free(xmlconfig);
return -1;
}
dom = virDomainDefineXML(conn, xmlconfig);
if (!dom)
{
printf("Domain is not found\n");
free(xmlconfig);
virConnectClose(conn);
return -1;
}
fprintf(stderr, "Guest %s is defined\n", virDomainGetName(dom));
free(xmlconfig);
virDomainFree(dom);
virConnectClose(conn);
return 0;
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
int i;
int numDomains;
int *activeDomains;
char **inactiveDomains;
conn = virConnectOpen("qemu:///system");
if (conn == NULL)
{
fprintf(stderr, "Failed to open connection to qemu:///system\n");
return -1;
}
numDomains = virConnectNumOfDomains(conn);
if (numDomains == -1)
{
fprintf(stderr, "Failed to get domian num of qemu\n");
return -1;
}
activeDomains = malloc(sizeof(int) * numDomains);
numDomains = virConnectListDomains(conn, activeDomains, numDomains);
printf("%d Active domain list:\n", numDomains);
for (i = 0 ; i < numDomains ; i++)
{
printf("ID = %d, Name = %s\n", activeDomains[i], virDomainGetName(virDomainLookupByID(conn, activeDomains[i])));
}
free(activeDomains);
printf("----------------------------\n");
numDomains = virConnectNumOfDefinedDomains(conn);
if (numDomains == -1)
{
fprintf(stderr, "Failed to get defined domian num of qemu\n");
return -1;
}
inactiveDomains = malloc(sizeof(char *) * numDomains);
numDomains = virConnectListDefinedDomains(conn, inactiveDomains, numDomains);
printf("%d Inactive domain list:\n", numDomains);
for (i = 0 ; i < numDomains ; i++)
{
/*All inactive domains's id should be 0*/
printf("ID = %d, Name = %s\n", virDomainGetID(virDomainLookupByName(conn, inactiveDomains[i])), inactiveDomains[i]);
free(inactiveDomains[i]);
}
free(inactiveDomains);
virConnectClose(conn);
return 0;
}
int
main(int argc, char *argv[])
{
int ret = 0;
virConnectPtr conn;
char *uri;
printf("Attempting to connect to hypervisor\n");
uri = (argc > 0 ? argv[1] : NULL);
/* virConnectOpenAuth is called here with all default parameters,
* except, possibly, the URI of the hypervisor. */
conn = virConnectOpenAuth(uri, virConnectAuthPtrDefault, 0);
if (!conn) {
ret = 1;
printf("No connection to hypervisor\n");
showError(conn);
goto out;
}
uri = virConnectGetURI(conn);
if (!uri) {
ret = 1;
printf("Failed to get URI for hypervisor connection\n");
showError(conn);
goto disconnect;
}
printf("Connected to hypervisor at \"%s\"\n", uri);
free(uri);
if (0 != showHypervisorInfo(conn)) {
ret = 1;
goto disconnect;
}
if (0 != showDomains(conn)) {
ret = 1;
goto disconnect;
}
disconnect:
if (0 != virConnectClose(conn)) {
printf("Failed to disconnect from hypervisor\n");
showError(conn);
ret = 1;
} else {
printf("Disconnected from hypervisor\n");
}
out:
return ret;
}
static int
mymain(void)
{
struct metadataTest test;
int ret = EXIT_SUCCESS;
if (!(test.conn = virConnectOpen("test:///default")))
return EXIT_FAILURE;
if (!(test.dom = virDomainLookupByName(test.conn, "test"))) {
virConnectClose(test.conn);
return EXIT_FAILURE;
}
virtTestQuiesceLibvirtErrors(false);
if (virtTestRun("Assign metadata ", testAssignMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Rewrite Metadata ", testRewriteMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Erase metadata ", testEraseMetadata, &test) < 0)
ret = EXIT_FAILURE;
TEST_TITLE("1", "qwert");
TEST_TITLE("2", NULL);
TEST_TITLE("3", "blah");
TEST_TITLE_FAIL("4", "qwe\nrt");
TEST_TITLE("5", "");
TEST_TITLE_FAIL("6", "qwert\n");
TEST_TITLE_FAIL("7", "\n");
TEST_DESCR("1", "qwert\nqwert");
TEST_DESCR("2", NULL);
TEST_DESCR("3", "qwert");
TEST_DESCR("4", "\n");
TEST_DESCR("5", "");
virDomainFree(test.dom);
virConnectClose(test.conn);
return ret;
}
/*
* virshReconnect:
*
* Reconnect after a disconnect from libvirtd
*
*/
static int
virshReconnect(vshControl *ctl, const char *name, bool readonly, bool force)
{
bool connected = false;
virshControlPtr priv = ctl->privData;
/* If the flag was not specified, then it depends on whether we are
* reconnecting to the current URI (in which case we want to keep the
* readonly flag as it was) or to a specified URI in which case it
* should stay false */
if (!readonly && !name)
readonly = priv->readonly;
if (priv->conn) {
int ret;
connected = true;
virConnectUnregisterCloseCallback(priv->conn, virshCatchDisconnect);
ret = virConnectClose(priv->conn);
if (ret < 0)
vshError(ctl, "%s", _("Failed to disconnect from the hypervisor"));
else if (ret > 0)
vshError(ctl, "%s", _("One or more references were leaked after "
"disconnect from the hypervisor"));
}
priv->conn = virshConnect(ctl, name ? name : ctl->connname, readonly);
if (!priv->conn) {
if (disconnected)
vshError(ctl, "%s", _("Failed to reconnect to the hypervisor"));
else
vshError(ctl, "%s", _("failed to connect to the hypervisor"));
return -1;
} else {
if (name) {
VIR_FREE(ctl->connname);
ctl->connname = vshStrdup(ctl, name);
}
priv->readonly = readonly;
if (virConnectRegisterCloseCallback(priv->conn, virshCatchDisconnect,
ctl, NULL) < 0)
vshError(ctl, "%s", _("Unable to register disconnect callback"));
if (connected && !force)
vshError(ctl, "%s", _("Reconnected to the hypervisor"));
}
disconnected = 0;
priv->useGetInfo = false;
priv->useSnapshotOld = false;
priv->blockJobNoBytes = false;
return 0;
}
void libvirt_close(void)
{
if (g_conn == NULL)
return;
virConnectClose(g_conn);
__this_lock();
g_conn = NULL;
__this_unlock();
return;
}
int main(int argc, char **argv)
{
if(argc < 4)
{
exit(1); //error
}
user_id=atoi(argv[1]);
clust_id=atoi(argv[2]);
node_id=atoi(argv[3]);
clusterCfgRead();
//virSetErrorFunc(NULL, customGlobalErrorFunc);
virConnectPtr conn;
if (virInitialize() < 0) {
fprintf(stderr, "Failed to initialize libvirt");
return 12;
}
//virEventRegisterDefaultImpl();
conn = virConnectOpen("qemu:///system"); //xen+unix:///
if (!conn) {
printf("error opening\n");
return 13;
}
/* coming here we have to restore the snapshot of the vm */
// Build the path to restore the saved snapshot snap$.img [$=node_id]
char path[512];
memset(path,0,512);
sprintf(path,"%s/%d/%d/snap%d.img",clusterHomeDir,user_id,clust_id,node_id);
if( virDomainRestore(conn,path)!=0)
{
exit(21);
}
/*---------------------------------------------------------- */
if (conn && virConnectClose(conn) < 0){
printf("error closing\n");
return 16;
}
return 0;
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
virNetworkPtr net;
if(argc != 2)
{
printf("usage: ./start_network domain_network\n");
return -1;
}
conn = virConnectOpen("qemu:///system");
if (conn == NULL)
{
fprintf(stderr, "Failed to open connection to qemu:///system\n");
return -1;
}
net = virNetworkLookupByName(conn, argv[1]);
if (!net)
{
fprintf(stderr, "Network is not found\n");
virConnectClose(conn);
return -1;
}
if (virNetworkCreate(net) < 0)
{
virNetworkFree(net);
virConnectClose(conn);
fprintf(stderr, "Cannot start network\n");
return -1;
}
fprintf(stderr, "Network %s has started\n", argv[1]);
virNetworkFree(net);
virConnectClose(conn);
return 0;
}