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);
}
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;
}
void libvirt_connect() {
int i;
int *activeDomainIDs;
// connect to xend
conn = virConnectOpen("xen:///");
if (conn == NULL) {
printf("Failed to open connection to xen");
exit(0);
}
// get the Domain ID list
numDomains = virConnectNumOfDomains(conn);
activeDomainIDs = (int*) malloc(sizeof(int) * numDomains);
activeDomains = (virDomainPtr*) malloc(sizeof(virDomainPtr) * numDomains);
numDomains = virConnectListDomains(conn, activeDomainIDs, numDomains);
// associate the Domain ID list to Domain name list
printf("Active domain IDs:\n");
for (i = 0; i < numDomains; i++) {
activeDomains[i] = virDomainLookupByID(conn, activeDomainIDs[i]);
printf(" [%s - %d]\n", virDomainGetName(activeDomains[i]), activeDomainIDs[i]);
}
// Domain ID list is useless
free(activeDomainIDs);
}
int libvirt_node_info_update(NodeInfo * ni)
{
if (g_conn == NULL || ni == NULL)
return -1;
int ret = -1;
int cpu_commit = 0;
unsigned int mem_commit = 0;
int *activeDomains = NULL;
__this_lock();
int numDomains = virConnectNumOfDomains(g_conn);
if (numDomains <= 0) {
ret = numDomains;
goto out;
}
activeDomains = malloc(sizeof(int) * numDomains);
if (activeDomains == NULL) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
goto out;
}
numDomains = virConnectListDomains(g_conn, activeDomains, numDomains);
if (numDomains <= 0) {
ret = numDomains;
goto out;
}
for (int i = 0; i< numDomains; i++) {
/* skip id dom 0 */
if (activeDomains[i] == 0)
continue;
virDomainPtr d = virDomainLookupByID(g_conn, activeDomains[i]);
if (d == NULL) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
goto out;
}
virDomainInfo di;
if (virDomainGetInfo(d, &di)) {
logerror(_("error in %s(%d)\n"), __func__, __LINE__);
goto out;
}
cpu_commit += di.nrVirtCpu;
mem_commit += di.maxMem;
virDomainFree(d);
}
ni->cpu_commit = cpu_commit;
ni->mem_commit = mem_commit;
ret = numDomains;
out:
__this_unlock();
if (activeDomains)
free(activeDomains);
return ret;
}
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;
}
static int
registerExisting(virConnectPtr vp, const char *path, int mode)
{
int *d_ids = NULL;
int d_count, x;
virDomainPtr dom;
virDomainInfo d_info;
errno = EINVAL;
if (!vp)
return -1;
d_count = virConnectNumOfDomains(vp);
if (d_count <= 0) {
if (d_count == 0) {
/* Successful, but no domains running */
errno = 0;
return 0;
}
goto out_fail;
}
d_ids = malloc(sizeof (int) * d_count);
if (!d_ids)
goto out_fail;
if (virConnectListDomains(vp, d_ids, d_count) < 0)
goto out_fail;
/* Ok, we have the domain IDs - let's get their names and states */
for (x = 0; x < d_count; x++) {
dom = virDomainLookupByID(vp, d_ids[x]);
if (!dom) {
/* XXX doom */
goto out_fail;
}
if (virDomainGetInfo(dom, &d_info) < 0) {
/* XXX no info for the domain?!! */
virDomainFree(dom);
goto out_fail;
}
if (d_info.state != VIR_DOMAIN_SHUTOFF &&
d_info.state != VIR_DOMAIN_CRASHED)
domainStarted(dom, path, mode);
virDomainFree(dom);
}
out_fail:
free(d_ids);
return 0;
}
static PromiseResult VerifyVirtDomain(EvalContext *ctx, char *uri, enum cfhypervisors envtype, Attributes a, const Promise *pp)
{
int num, i;
/* set up the library error handler */
virSetErrorFunc(NULL, (void *) EnvironmentErrorHandler);
if (CFVC[envtype] == NULL)
{
if ((CFVC[envtype] = virConnectOpenAuth(uri, virConnectAuthPtrDefault, 0)) == NULL)
{
Log(LOG_LEVEL_ERR, "Failed to connect to virtualization monitor '%s'", uri);
return PROMISE_RESULT_NOOP;
}
}
for (i = 0; i < CF_MAX_CONCURRENT_ENVIRONMENTS; i++)
{
CF_RUNNING[i] = -1;
CF_SUSPENDED[i] = NULL;
}
num = virConnectListDomains(CFVC[envtype], CF_RUNNING, CF_MAX_CONCURRENT_ENVIRONMENTS);
Log(LOG_LEVEL_VERBOSE, "Found %d running guest environments on this host (including enclosure)", num);
ShowRunList(CFVC[envtype]);
num = virConnectListDefinedDomains(CFVC[envtype], CF_SUSPENDED, CF_MAX_CONCURRENT_ENVIRONMENTS);
Log(LOG_LEVEL_VERBOSE, "Found %d dormant guest environments on this host", num);
ShowDormant();
PromiseResult result = PROMISE_RESULT_NOOP;
switch (a.env.state)
{
case ENVIRONMENT_STATE_CREATE:
result = PromiseResultUpdate(result, CreateVirtDom(ctx, CFVC[envtype], a, pp));
break;
case ENVIRONMENT_STATE_DELETE:
result = PromiseResultUpdate(result, DeleteVirt(ctx, CFVC[envtype], a, pp));
break;
case ENVIRONMENT_STATE_RUNNING:
result = PromiseResultUpdate(result, RunningVirt(ctx, CFVC[envtype], a, pp));
break;
case ENVIRONMENT_STATE_SUSPENDED:
result = PromiseResultUpdate(result, SuspendedVirt(ctx, CFVC[envtype], a, pp));
break;
case ENVIRONMENT_STATE_DOWN:
result = PromiseResultUpdate(result, DownVirt(ctx, CFVC[envtype], a, pp));
break;
default:
Log(LOG_LEVEL_INFO, "No state specified for this environment");
break;
}
return result;
}
static void VerifyVirtDomain(EvalContext *ctx, char *uri, enum cfhypervisors envtype, Attributes a, Promise *pp)
{
int num, i;
/* set up the library error handler */
virSetErrorFunc(NULL, (void *) EnvironmentErrorHandler);
if (CFVC[envtype] == NULL)
{
if ((CFVC[envtype] = virConnectOpenAuth(uri, virConnectAuthPtrDefault, 0)) == NULL)
{
CfOut(OUTPUT_LEVEL_ERROR, "", " !! Failed to connect to virtualization monitor \"%s\"", uri);
return;
}
}
for (i = 0; i < CF_MAX_CONCURRENT_ENVIRONMENTS; i++)
{
CF_RUNNING[i] = -1;
CF_SUSPENDED[i] = NULL;
}
num = virConnectListDomains(CFVC[envtype], CF_RUNNING, CF_MAX_CONCURRENT_ENVIRONMENTS);
CfOut(OUTPUT_LEVEL_VERBOSE, "", " -> Found %d running guest environments on this host (including enclosure)", num);
ShowRunList(CFVC[envtype]);
num = virConnectListDefinedDomains(CFVC[envtype], CF_SUSPENDED, CF_MAX_CONCURRENT_ENVIRONMENTS);
CfOut(OUTPUT_LEVEL_VERBOSE, "", " -> Found %d dormant guest environments on this host", num);
ShowDormant();
switch (a.env.state)
{
case ENVIRONMENT_STATE_CREATE:
CreateVirtDom(ctx, CFVC[envtype], a, pp);
break;
case ENVIRONMENT_STATE_DELETE:
DeleteVirt(ctx, CFVC[envtype], a, pp);
break;
case ENVIRONMENT_STATE_RUNNING:
RunningVirt(ctx, CFVC[envtype], a, pp);
break;
case ENVIRONMENT_STATE_SUSPENDED:
SuspendedVirt(ctx, CFVC[envtype], a, pp);
break;
case ENVIRONMENT_STATE_DOWN:
DownVirt(ctx, CFVC[envtype], a, pp);
break;
default:
CfOut(OUTPUT_LEVEL_INFORM, "", " !! No state specified for this environment");
break;
}
}
static void VerifyVirtDomain(char *uri, enum cfhypervisors envtype, Attributes a, Promise *pp)
{
int num, i;
/* set up the library error handler */
virSetErrorFunc(NULL, (void *) EnvironmentErrorHandler);
if (CFVC[envtype] == NULL)
{
if ((CFVC[envtype] = virConnectOpenAuth(uri, virConnectAuthPtrDefault, 0)) == NULL)
{
CfOut(cf_error, "", " !! Failed to connect to virtualization monitor \"%s\"", uri);
return;
}
}
for (i = 0; i < CF_MAX_CONCURRENT_ENVIRONMENTS; i++)
{
CF_RUNNING[i] = -1;
CF_SUSPENDED[i] = NULL;
}
num = virConnectListDomains(CFVC[envtype], CF_RUNNING, CF_MAX_CONCURRENT_ENVIRONMENTS);
CfOut(cf_verbose, "", " -> Found %d running guest environments on this host (including enclosure)", num);
ShowRunList(CFVC[envtype]);
num = virConnectListDefinedDomains(CFVC[envtype], CF_SUSPENDED, CF_MAX_CONCURRENT_ENVIRONMENTS);
CfOut(cf_verbose, "", " -> Found %d dormant guest environments on this host", num);
ShowDormant(CFVC[envtype]);
switch (a.env.state)
{
case cfvs_create:
CreateVirtDom(CFVC[envtype], uri, a, pp);
break;
case cfvs_delete:
DeleteVirt(CFVC[envtype], uri, a, pp);
break;
case cfvs_running:
RunningVirt(CFVC[envtype], uri, a, pp);
break;
case cfvs_suspended:
SuspendedVirt(CFVC[envtype], uri, a, pp);
break;
case cfvs_down:
DownVirt(CFVC[envtype], uri, a, pp);
break;
default:
CfOut(cf_inform, "", " !! No state specified for this environment");
break;
}
}
std::string VM_Controller::get_vm_info(){
Json::Value j(Json::arrayValue);
int numActiveDomains = virConnectNumOfDomains(_conn);
int *activeDomainsIDs = (int *)malloc(sizeof(int) * numActiveDomains);
numActiveDomains = virConnectListDomains(_conn,
activeDomainsIDs,
numActiveDomains);
for (int i = 0 ; i < numActiveDomains ; i++) {
virDomainPtr dom = virDomainLookupByID(_conn, activeDomainsIDs[i]);
virDomainInfo info;
if(virDomainGetInfo(dom, &info) < 0){
LOG_ERROR("could not get domain info");
continue;
}
Json::Value j_dom(Json::objectValue);
j_dom["id"] = activeDomainsIDs[i];
j_dom["mem_total"] = (unsigned long long)info.maxMem;
j_dom["vcpu"] = info.nrVirtCpu;
j_dom["name"] = virDomainGetName(dom);
j_dom["status"] = "running";
j.append(j_dom);
}
free(activeDomainsIDs);
int numInactiveDomains = virConnectNumOfDefinedDomains(_conn);
char **inactiveDomainsNames = (char **)malloc(sizeof(char *)
* numInactiveDomains);
numInactiveDomains = virConnectListDefinedDomains(_conn,
inactiveDomainsNames,
numInactiveDomains);
if(numInactiveDomains < 0){
LOG_ERROR("could not get defined domains");
exit(-1);
}
for(int i=0; i< numInactiveDomains; i++){
Json::Value j_dom(Json::objectValue);
j_dom["status"] = "shutoff";
j_dom["name"] = inactiveDomainsNames[i];
free(inactiveDomainsNames[i]);
j.append(j_dom);
}
free(inactiveDomainsNames);
return j.toStyledString();
}
static void refreshDomains(void)
{
int i,*activeDomains;
char *domName;
char shc[50];
for (i=0; i<MAX_DOMAINS;i++)
{
vms[i].dom = NULL;
vms[i].pid = -1;
memset(vms[i].ip,0,20*sizeof(char));
}
numDomains = virConnectNumOfDomains(conn);
activeDomains = malloc(sizeof(int) * numDomains);
numDomains = virConnectListDomains(conn, activeDomains, numDomains);
if (numDomains==0)
{
printf("No active VMs\n");
return -1;
}
for (i = 0 ; i < numDomains ; i++)
{
memset(shc,0,50*sizeof(char));
vms[i].dom = virDomainLookupByID(conn, activeDomains[i]);
domName = virDomainGetName(vms[i].dom);
sprintf(shc,"./vm-ip.sh %s", domName);
pid=0;
examineVM(domName);
vms[i].pid=pid;
runShell(shc, vms[i].ip, 20);
printf("Process %d runs the virtual machine %s on IP %s\n ", vms[i].pid, domName, vms[i].ip);
}
printf("\n");
//initVMIFile(numDomains, sysmap);
free(activeDomains);
}
int main()
{
int idCount;
int i;
int id;
//int ids[MAXID];
int *ids;
//timeInfoNode timeInfos[MAXID];
printf("--------------------------------------------------------\n");
printf(" XEN Domain Monitor \n");
printf("--------------------------------------------------------\n");
/* NULL means connect to local Xen hypervisor */
conn = virConnectOpenReadOnly(NULL);
if (conn == NULL)
{
fprintf(stderr, "Failed to connect to hypervisor\n");
closeConn();
return 0;
}
/*char* caps;
caps = virConnectGetCapabilities(conn);
printf("Capabilities:\n%s\n",caps);
free(caps);*/
char *host;
host = virConnectGetHostname(conn);
fprintf(stdout, "Hostname:%s\n",host);
free(host);
int vcpus;
vcpus = virConnectGetMaxVcpus(conn,NULL);
fprintf(stdout, "Maxmum support vcpus:%d\n",vcpus);
unsigned long long node_free_memory;
node_free_memory = virNodeGetFreeMemory(conn);
fprintf(stdout, "free memory:%lld\n",node_free_memory);
virNodeInfo nodeinfo;
virNodeGetInfo(conn,&nodeinfo);
fprintf(stdout, "Model: %s\n", nodeinfo.model);
fprintf(stdout, "Memory size: %lukb\n", nodeinfo.memory);
fprintf(stdout, "Number of CPUs: %u\n", nodeinfo.cpus);
fprintf(stdout, "MHz of CPUs: %u\n", nodeinfo.mhz);
fprintf(stdout, "Number of NUMA nodes: %u\n", nodeinfo.nodes);
fprintf(stdout, "Number of CPU sockets: %u\n", nodeinfo.sockets);
fprintf(stdout, "Number of CPU cores per socket: %u\n", nodeinfo.cores);
fprintf(stdout, "Number of CPU threads per core: %u\n", nodeinfo.threads);
fprintf(stdout, "Virtualization type: %s\n", virConnectGetType(conn));
unsigned long ver;
virConnectGetVersion(conn, &ver);
fprintf(stdout, "Version: %lu\n", ver);
/*unsigned long Libver;
virConnectGetLibVersion(conn, &Libver);
fprintf(stdout, "Libvirt Version: %lu\n", Libver);*/
char *uri;
uri = virConnectGetURI(conn);
fprintf(stdout, "Canonical URI: %s\n", uri);
free(uri);
/* get the count of IDs and save these ID into ids[] */
idCount = virConnectNumOfDomains(conn);
ids = malloc(sizeof(int) *idCount);
idCount = virConnectListDomains(conn,ids,idCount);
//idCount = virConnectListDomains(conn, &ids[0], MAXID);
if (idCount < 0)
{
fprintf(stderr, "Failed to list the domains\n");
closeConn();
return 0;
}
timeInfoNode timeInfos[idCount];
printf("Domain Totals: %d\n", idCount);
printf("ID\tCPU\tMEM\tMaxMEM\tVCPUs\tState\tNAME\n");
/* loop get the CPUtime info by IDs */
for (i = 0; i < idCount; i++)
{
id = ids[i];
getTimeInfo(id, &(timeInfos[i]));
}
sleep(1);
/* loop print the domain info and calculate the usage of cpus*/
for (i = 0; i < idCount; i++)
{
id = ids[i];
getDomainInfo(id, timeInfos[i]);
}
free(ids);
printf("--------------------------------------------------------\n");
closeConn();
return 0;
}
int get_domain_list(virConnectPtr conn, virDomainPtr **_list)
{
char **names = NULL;
int n_names;
int *ids = NULL;
int n_ids;
virDomainPtr *list = NULL;
int i;
int idx = 0;
n_names = virConnectNumOfDefinedDomains(conn);
n_ids = virConnectNumOfDomains(conn);
if ((n_names < 0) || (n_ids < 0))
goto out;
list = calloc(n_names + n_ids, sizeof(virDomainPtr));
if (!list)
return 0;
if (n_names > 0) {
names = calloc(n_names, sizeof(char *));
if (!names)
goto out;
#if LIBVIR_VERSION_NUMBER<=2000
n_names = virConnectListDefinedDomains(conn,
(const char **)names,
n_names);
#else
n_names = virConnectListDefinedDomains(conn,
(char ** const)names,
n_names);
#endif
if (n_names < 0)
goto out;
}
for (i = 0; i < n_names; i++) {
virDomainPtr dom;
dom = virDomainLookupByName(conn, names[i]);
if (dom)
list[idx++] = dom;
free(names[i]);
}
if (n_ids > 0) {
ids = calloc(n_ids, sizeof(int));
if (!ids)
goto out;
n_ids = virConnectListDomains(conn, ids, n_ids);
if (n_ids < 0)
goto out;
}
for (i = 0; i < n_ids; i++) {
virDomainPtr dom;
dom = virDomainLookupByID(conn, ids[i]);
if (dom)
list[idx++] = dom;
}
out:
free(names);
free(ids);
if (idx == 0) {
free(list);
list = NULL;
}
*_list = list;
return idx;
}
void
get_all_libvirt_domains (const char *libvirt_uri)
{
virErrorPtr err;
int n;
size_t i;
/* Get the list of all domains. */
conn = virConnectOpenAuth (libvirt_uri, virConnectAuthPtrDefault,
VIR_CONNECT_RO);
if (!conn) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not connect to libvirt (code %d, domain %d): %s\n"),
guestfs_int_program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
n = virConnectNumOfDomains (conn);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not get number of running domains (code %d, domain %d): %s\n"),
guestfs_int_program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
int ids[n];
n = virConnectListDomains (conn, ids, n);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not list running domains (code %d, domain %d): %s\n"),
guestfs_int_program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
add_domains_by_id (conn, ids, n);
n = virConnectNumOfDefinedDomains (conn);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not get number of inactive domains (code %d, domain %d): %s\n"),
guestfs_int_program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
char *names[n];
n = virConnectListDefinedDomains (conn, names, n);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not list inactive domains (code %d, domain %d): %s\n"),
guestfs_int_program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
add_domains_by_name (conn, names, n);
/* You must free these even though the libvirt documentation doesn't
* mention it.
*/
for (i = 0; i < (size_t) n; ++i)
free (names[i]);
/* No domains? */
if (nr_domains == 0)
return;
/* Sort the domains alphabetically by name for display. */
qsort (domains, nr_domains, sizeof (struct domain), compare_domain_names);
}
//!
//!
//!
//! @param[in] ptr
//!
//! @return Always returns NULL
//!
static void *tortura_thread(void *ptr)
{
int i = 0;
int iter = 0;
int error = 0;
int num_doms = 0;
int dom_ids[MAXDOMS] = { 0 };
long long tid = (*(long long *)ptr);
virDomainPtr dom[MAXDOMS] = { NULL };
virDomainInfo info[MAXDOMS] = { 0 };
check_hypervisor_conn();
for (iter = 0; iter < ITERS; iter++) {
printf("thread %lld starting iteration %d\n", tid, iter);
pthread_mutex_lock(&check_mutex);
{
num_doms = virConnectListDomains(conn, dom_ids, MAXDOMS);
}
pthread_mutex_unlock(&check_mutex);
for (i = 0; i < num_doms; i++) {
pthread_mutex_lock(&check_mutex);
{
dom[i] = virDomainLookupByID(conn, dom_ids[i]);
}
pthread_mutex_unlock(&check_mutex);
if (!dom[i]) {
printf("failed to look up domain %d\n", dom_ids[i]);
continue;
}
}
for (i = 0; i < num_doms; i++) {
pthread_mutex_lock(&check_mutex);
{
error = virDomainGetInfo(dom[i], &info[i]);
}
pthread_mutex_unlock(&check_mutex);
if (error < 0) {
printf("failed to get info on domain %d\n", dom_ids[i]);
continue;
}
}
for (i = 0; i < num_doms; i++) {
pthread_mutex_lock(&check_mutex);
{
error = virDomainFree(dom[i]);
}
pthread_mutex_unlock(&check_mutex);
if (error < 0) {
printf("failed to close domain %d\n", dom_ids[i]);
continue;
}
}
}
return (NULL);
}
void NodeWrap::syncDomains()
{
/* Sync up with domains that are defined but not active. */
int maxname = virConnectNumOfDefinedDomains(conn);
if (maxname < 0) {
REPORT_ERR(conn, "virConnectNumOfDefinedDomains");
return;
} else {
char **dnames;
dnames = (char **) malloc(sizeof(char *) * maxname);
if ((maxname = virConnectListDefinedDomains(conn, dnames, maxname)) < 0) {
REPORT_ERR(conn, "virConnectListDefinedDomains");
free(dnames);
return;
}
for (int i = 0; i < maxname; i++) {
virDomainPtr domain_ptr;
bool found = false;
for (std::vector<DomainWrap*>::iterator iter = domains.begin();
iter != domains.end(); iter++) {
if ((*iter)->domain_name == dnames[i]) {
found = true;
break;
}
}
if (found) {
continue;
}
domain_ptr = virDomainLookupByName(conn, dnames[i]);
if (!domain_ptr) {
REPORT_ERR(conn, "virDomainLookupByName");
} else {
DomainWrap *domain;
try {
domain = new DomainWrap(agent, this, domain_ptr, conn);
printf("Created new domain: %s, ptr is %p\n", dnames[i], domain_ptr);
domains.push_back(domain);
} catch (int i) {
printf ("Error constructing domain\n");
REPORT_ERR(conn, "constructing domain.");
delete domain;
}
}
}
for (int i = 0; i < maxname; i++) {
free(dnames[i]);
}
free(dnames);
}
/* Go through all the active domains */
int maxids = virConnectNumOfDomains(conn);
if (maxids < 0) {
REPORT_ERR(conn, "virConnectNumOfDomains");
return;
} else {
int *ids;
ids = (int *) malloc(sizeof(int *) * maxids);
if ((maxids = virConnectListDomains(conn, ids, maxids)) < 0) {
printf("Error getting list of defined domains\n");
return;
}
for (int i = 0; i < maxids; i++) {
virDomainPtr domain_ptr;
char dom_uuid[VIR_UUID_STRING_BUFLEN];
domain_ptr = virDomainLookupByID(conn, ids[i]);
if (!domain_ptr) {
REPORT_ERR(conn, "virDomainLookupByID");
continue;
}
if (virDomainGetUUIDString(domain_ptr, dom_uuid) < 0) {
REPORT_ERR(conn, "virDomainGetUUIDString");
continue;
}
bool found = false;
for (std::vector<DomainWrap*>::iterator iter = domains.begin();
iter != domains.end(); iter++) {
if (strcmp((*iter)->domain_uuid.c_str(), dom_uuid) == 0) {
found = true;
break;
}
}
if (found) {
virDomainFree(domain_ptr);
continue;
}
DomainWrap *domain;
try {
domain = new DomainWrap(agent, this, domain_ptr, conn);
printf("Created new domain: %d, ptr is %p\n", ids[i], domain_ptr);
domains.push_back(domain);
} catch (int i) {
printf ("Error constructing domain\n");
REPORT_ERR(conn, "constructing domain.");
delete domain;
}
}
free(ids);
}
/* Go through our list of domains and ensure that they still exist. */
for (std::vector<DomainWrap*>::iterator iter = domains.begin(); iter != domains.end();) {
printf("verifying domain %s\n", (*iter)->domain_name.c_str());
virDomainPtr ptr = virDomainLookupByUUIDString(conn, (*iter)->domain_uuid.c_str());
if (ptr == NULL) {
REPORT_ERR(conn, "virDomainLookupByUUIDString");
delete (*iter);
iter = domains.erase(iter);
} else {
virDomainFree(ptr);
iter++;
}
}
}
void adopt_instances()
{
int dom_ids[MAXDOMS];
int num_doms = 0;
int i;
virDomainPtr dom = NULL;
if (! check_hypervisor_conn())
return;
logprintfl (EUCAINFO, "looking for existing domains\n");
virSetErrorFunc (NULL, libvirt_error_handler);
num_doms = virConnectListDomains(nc_state.conn, dom_ids, MAXDOMS);
if (num_doms == 0) {
logprintfl (EUCAINFO, "no currently running domains to adopt\n");
return;
} if (num_doms < 0) {
logprintfl (EUCAWARN, "WARNING: failed to find out about running domains\n");
return;
}
for ( i=0; i<num_doms; i++) {
int error;
virDomainInfo info;
const char * dom_name;
ncInstance * instance;
sem_p(hyp_sem);
dom = virDomainLookupByID(nc_state.conn, dom_ids[i]);
sem_v(hyp_sem);
if (!dom) {
logprintfl (EUCAWARN, "WARNING: failed to lookup running domain #%d, ignoring it\n", dom_ids[i]);
continue;
}
sem_p(hyp_sem);
error = virDomainGetInfo(dom, &info);
sem_v(hyp_sem);
if (error < 0 || info.state == VIR_DOMAIN_NOSTATE) {
logprintfl (EUCAWARN, "WARNING: failed to get info on running domain #%d, ignoring it\n", dom_ids[i]);
continue;
}
if (info.state == VIR_DOMAIN_SHUTDOWN ||
info.state == VIR_DOMAIN_SHUTOFF ||
info.state == VIR_DOMAIN_CRASHED ) {
logprintfl (EUCADEBUG, "ignoring non-running domain #%d\n", dom_ids[i]);
continue;
}
sem_p(hyp_sem);
if ((dom_name = virDomainGetName(dom))==NULL) {
sem_v(hyp_sem);
logprintfl (EUCAWARN, "WARNING: failed to get name of running domain #%d, ignoring it\n", dom_ids[i]);
continue;
}
sem_v(hyp_sem);
if (!strcmp(dom_name, "Domain-0"))
continue;
if ((instance = scRecoverInstanceInfo (dom_name))==NULL) {
logprintfl (EUCAWARN, "WARNING: failed to recover Eucalyptus metadata of running domain %s, ignoring it\n", dom_name);
continue;
}
change_state (instance, info.state);
sem_p (inst_sem);
int err = add_instance (&global_instances, instance);
sem_v (inst_sem);
if (err) {
free_instance (&instance);
continue;
}
logprintfl (EUCAINFO, "- adopted running domain %s from user %s\n", instance->instanceId, instance->userId);
/* TODO: try to look up IPs? */
sem_p(hyp_sem);
virDomainFree (dom);
sem_v(hyp_sem);
}
}
int default_selector(virConnectPtr conn, virDomainPtr domsPtr_sche_lst[], int *domPtr_sche_lst_nxt)
{
int doms_actvie_nxt = 0;
virDomainPtr domsPtr_active_lst[MAX_DOMS_NR];
virDomainInfo domain_info;
int i = 0;
int *dom_active_id_lst;
double dom_cpu_uti = 0.0;
/*
* get the active domain, store the domian_ptr in doms_active_Ptr_lst[i];
*/
doms_actvie_nxt = virConnectNumOfDomains(conn);
if(doms_actvie_nxt < 0){
perror("failed to execute virConnectNumOfDomains");
return ERROR;
}
dom_active_id_lst = malloc(sizeof(int) * doms_actvie_nxt);
doms_actvie_nxt = virConnectListDomains(conn, dom_active_id_lst, doms_actvie_nxt);
if(doms_actvie_nxt < 0){
perror("failed to execute virConnectListDomains");
return ERROR;
}
for(i = 0; i < doms_actvie_nxt; i++){
domsPtr_active_lst[i] = virDomainLookupByID(conn, dom_active_id_lst[i]);
if(domsPtr_active_lst[i] == NULL){
perror("failed to execute virDomainLookupByID");
return ERROR;
}
}
free(dom_active_id_lst);
dom_active_id_lst = NULL;
/*
* query every domains's used memory
* set domsPtr_active_lst[i] = NULL,
* if the domain's mem is less than the MEM_THREASHOLD.
*/
for(i = 0; i < doms_actvie_nxt; i++){
if(virDomainGetInfo(domsPtr_active_lst[i], &domain_info) < 0){
perror("failed to virDomainGetInfo");
return ERROR;
}
//DEBUG print every domain memory.
printf("dom_mem_max : %d\n", domain_info.maxMem);
printf("dom_mem_used : %d\n", domain_info.memory);
if(domain_info.memory < MEM_THRESHOLD){
free(domsPtr_active_lst[i]);
domsPtr_active_lst[i] = NULL;
}
}
/*
* query every domain CPU total utilization.
* populate domsPtr_sche_lst
*/
*domPtr_sche_lst_nxt = 0;
for(i = 0; i < doms_actvie_nxt; i++){
if(domsPtr_active_lst[i] != NULL){
dom_cpu_uti = domain_get_cpu_util(conn, domsPtr_active_lst[i]);
//DEBUG print every domain cpu_utili.
printf("dom_cpu_utilization : %f\n",dom_cpu_uti);
if(dom_cpu_uti > CPU_THRESHOLD)
domsPtr_sche_lst[(*domPtr_sche_lst_nxt)++] = domsPtr_active_lst[i];
else
continue;
}
}
return SUCCESS;
}
void
get_domains_from_libvirt (void)
{
virErrorPtr err;
virConnectPtr conn;
int n;
size_t i, j, nr_disks_added;
nr_domains = 0;
domains = NULL;
/* Get the list of all domains. */
conn = virConnectOpenReadOnly (libvirt_uri);
if (!conn) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not connect to libvirt (code %d, domain %d): %s"),
program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
n = virConnectNumOfDomains (conn);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not get number of running domains (code %d, domain %d): %s"),
program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
int ids[n];
n = virConnectListDomains (conn, ids, n);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not list running domains (code %d, domain %d): %s"),
program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
add_domains_by_id (conn, ids, n);
n = virConnectNumOfDefinedDomains (conn);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not get number of inactive domains (code %d, domain %d): %s"),
program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
char *names[n];
n = virConnectListDefinedDomains (conn, names, n);
if (n == -1) {
err = virGetLastError ();
fprintf (stderr,
_("%s: could not list inactive domains (code %d, domain %d): %s"),
program_name, err->code, err->domain, err->message);
exit (EXIT_FAILURE);
}
add_domains_by_name (conn, names, n);
/* You must free these even though the libvirt documentation doesn't
* mention it.
*/
for (i = 0; i < (size_t) n; ++i)
free (names[i]);
virConnectClose (conn);
/* No domains? */
if (nr_domains == 0)
return;
/* Sort the domains alphabetically by name for display. */
qsort (domains, nr_domains, sizeof (struct domain), compare_domain_names);
print_title ();
/* To minimize the number of times we have to launch the appliance,
* shuffle as many domains together as we can, but not exceeding
* MAX_DISKS per request. If --one-per-guest was requested then only
* request disks from a single guest each time.
* Interesting application for NP-complete knapsack problem here.
*/
if (one_per_guest) {
for (i = 0; i < nr_domains; ++i)
multi_df (&domains[i], 1);
} else {
for (i = 0; i < nr_domains; /**/) {
nr_disks_added = 0;
/* Make a request with domains [i..j-1]. */
for (j = i; j < nr_domains; ++j) {
if (nr_disks_added + domains[j].nr_disks > MAX_DISKS)
break;
nr_disks_added += domains[j].nr_disks;
}
multi_df (&domains[i], j-i);
i = j;
}
}
/* Free up domains structure. */
for (i = 0; i < nr_domains; ++i)
free_domain (&domains[i]);
free (domains);
}
void main()
{
int i,val=-1,choice,choice_id,num_domains;
int *active_domains;
virConnectPtr conn;
virDomainPtr vdp;
conn = virConnectOpen("xen:///");
if (conn == NULL) {
fprintf(stderr, "Error opening connection to XEN:/// \n");
return 1;
}
else
{
//For finding Active Devices
num_domains=virConnectNumOfDomains(conn);
active_domanins=malloc(sizeof(int) * num_domains);
num_domains = virConnectListDomains(conn, active_domains, num_domains);
printf("Active domain IDs : \n");
for (i = 0 ; i < num_domains ; i++) {
printf(" %d\n", active_domains[i]);
}
free(active_domains);
while(1)
{
printf("1.Start\n2.Suspend\n3.Resume\n4.stop\n5.exit ");
scanf("%d",&choice);
printf("\n Please Insert the Active Domian ID ");
scanf("%d",&choice_id);
vdp=virDomainLookupById(conn,choice_id);
switch(choice)
{
case 1:/* Start */
val=virDomainCreate(vdp);
if(val==0)
printf("Success");
else
printf("Failed");
break;
case 2:/* Suspend */
val=virDomainSuspend(vdp);
if(val==0)
printf("Success");
else
printf("Failed");
break;
case 3:/* Resume */
val=virDomainResume(vdp);
if(val==0)
printf("Success");
else
printf("Failed");
break;
case 4: /* stop */
val=virDomainStop(vdp);
if(val==0)
printf("Success");
else
printf("Failed");
break;
default:exit(1);
}
}
virConnectClose(conn);
}
}
int main (int argc, char * argv[])
{
virConnectPtr conn = NULL;
int dom_ids [MAXDOMS];
int num_doms = 0;
char *hypervisor, hypervisorURL[32], cmd[1024];
char *eucahome=NULL;
// logfile (NULL, EUCAFATAL); // suppress all messages
if (argc != 2) {
fprintf (stderr, "error: test_nc expects one parameter (name of hypervisor)\n");
exit (1);
}
hypervisor = argv[1];
if (!strcmp(hypervisor, "kvm")) {
snprintf(hypervisorURL, 32, "qemu:///system");
} else if (!strcmp(hypervisor, "xen")) {
snprintf(hypervisorURL, 32, "xen:///");
} else if (!strcmp(hypervisor, "not_configured")) {
fprintf (stderr, "error: HYPERVISOR variable is not set in eucalyptus.conf\n");
exit (1);
} else {
fprintf (stderr, "error: hypervisor type (%s) is not recognized\n", hypervisor);
exit (1);
}
// check that commands that NC needs are there
if (system("perl --version")) {
fprintf (stderr, "error: could not run perl\n");
exit (1);
}
eucahome = getenv (EUCALYPTUS_ENV_VAR_NAME);
if (!eucahome) {
eucahome = strdup (""); // root by default
} else {
eucahome = strdup(eucahome);
}
add_euca_to_path (eucahome);
fprintf (stderr, "looking for system utilities...\n");
if (diskutil_init(FALSE)) // NC does not require GRUB for now
exit (1);
// check if euca2ools commands for bundle-instance are available
fprintf (stderr, "ok\n\nlooking for euca2ools...\n");
static char * helpers_name [3] = {
"euca-bundle-upload",
"euca-check-bucket",
"euca-delete-bundle"
};
char * helpers_path [3]; // load paths from eucalyptus.conf or set to NULL
helpers_path [0] = find_conf_value (eucahome, "NC_BUNDLE_UPLOAD_PATH");
helpers_path [1] = find_conf_value (eucahome, "NC_CHECK_BUCKET_PATH");
helpers_path [2] = find_conf_value (eucahome, "NC_DELETE_BUNDLE_PATH");
if (verify_helpers (helpers_name, helpers_path, 3) > 0) {
if (verify_helpers (helpers_name, NULL, 3) > 0) {
fprintf (stderr, "error: failed to find required euca2ools\n");
exit (1);
}
}
// ensure hypervisor information is available
fprintf (stderr, "ok\n\nchecking the hypervisor...\n");
if (!strcmp(hypervisor, "kvm")) {
snprintf(cmd, 1024, "%s/usr/lib/eucalyptus/euca_rootwrap %s/usr/share/eucalyptus/get_sys_info", eucahome, eucahome);
} else {
snprintf(cmd, 1024, "%s/usr/lib/eucalyptus/euca_rootwrap %s/usr/share/eucalyptus/get_xen_info", eucahome, eucahome);
}
if (system(cmd)) {
fprintf (stderr, "error: could not run '%s'\n", cmd);
exit (1);
}
// check that libvirt can query the hypervisor
conn = virConnectOpen (hypervisorURL); // NULL means local hypervisor
if (conn == NULL) {
print_libvirt_error ();
fprintf (stderr, "error: failed to connect to hypervisor\n");
exit (1);
}
num_doms = virConnectListDomains (conn, dom_ids, MAXDOMS);
if (num_doms < 0) {
print_libvirt_error ();
fprintf (stderr, "error: failed to query running domains\n");
exit (1);
}
fprintf (stdout, "NC test was successful\n");
return 0;
}
void main()
{
virConnectPtr connection;
virDomainPtr vdp_id, vdp_name;
int i,ret_val=-1;
int ch,ch_id,domainnum;
int *domains;
char name[25];
const char *active_name;
connection = virConnectOpen("xen:///");
if (connection == NULL)
{ fprintf(stderr, "Error opening connection to XEN:/// \n");
exit(1);
}
else
{
domainnum=virConnectNumOfDomains(connection);
domains=malloc(sizeof(int) * domainnum);
domainnum = virConnectListDomains(connection, domains, domainnum);
printf("\t\t ----Active Domains---- \n");
for (i = 0 ; i < domainnum ; i++)
{
vdp_id=virDomainLookupByID(connection,i);
active_name=virDomainGetName(vdp_id);
printf(" \t\t%s \n", active_name);
}
free(domains);
while(1)
{
printf("1.Start\n2.Suspend\n3.Resume\n4.stop\n5.exit\n ");
printf("Enter Your Choice : ");
scanf("%d",&ch);
if(ch != 5)
{
printf("\n Please Insert the Active Domian Name: ");
scanf("%s",name);
vdp_name = virDomainLookupByName(connection,name);
}
switch(ch)
{
case 1:
ret_val=virDomainCreate(vdp_name);
if(ret_val==0)
printf("Domain %s started\n", name);
else
printf("Start Operation Failed\n");
break;
case 2:
ret_val=virDomainSuspend(vdp_name);
if(ret_val==0)
printf("Domain %s Suspended\n", name);
else
printf("Suspend Operation Failed\n");
break;
case 3:
ret_val=virDomainResume(vdp_name);
if(ret_val==0)
printf("Domain %s Resumed\n", name);
else
printf("Resume Operation Failed\n");
break;
case 4:
ret_val=virDomainShutdown(vdp_name);
if(ret_val==0)
printf("Domain %s Stopped\n", name);
else
printf("Stop Operation Failed\n");
break;
case 5:
exit(1);
default:
exit(1);
}
}
virConnectClose(connection);
}
}
void main()
{
int i,val=-1,ch,no_domains;
char name[50];
int *act_domains;
virConnectPtr con_ptr;
virDomainPtr dom_ptr;
con_ptr = virConnectOpen("xen:///");
if (con_ptr == NULL) {
fprintf(stderr, "Error opening connection to XEN:/// \n");
return 1;
}
else
{
no_domains=virConnectNumOfDomains(con_ptr);
act_domains=malloc(sizeof(int) * no_domains);
no_domains = virConnectListDomains(con_ptr, act_domains, no_domains);
free(act_domains);
while(1)
{
printf("1.Start\n2.Suspend\n3.Resume\n4.Shutdown\n5.exit ");
scanf("%d",&ch);
printf("\n Enter Active Domian name ");
scanf("%s",&name);
dom_ptr=virDomainLookupByName(con_ptr,name);
switch(ch)
{
case 1:
val=virDomainCreate(dom_ptr);
if(val==0)
printf("Success");
else
printf("Failed");
break;
case 2:
val=virDomainSuspend(dom_ptr);
if(val==0)
printf("Success");
else
printf("Failed");
break;
case 3:
val=virDomainResume(dom_ptr);
if(val==0)
printf("Success");
else
printf("Failed");
break;
case 4:
val=virDomainShutdown(dom_ptr);
if(val==0)
printf("Success");
else
printf("Failed");
break;
default:exit(1);
}
}
virConnectClose(con_ptr);
}
}
static int
refresh_lists (void)
{
int n;
n = virConnectNumOfDomains (conn);
if (n < 0) {
VIRT_ERROR (conn, "reading number of domains");
return -1;
}
if (n > 0) {
int i;
int *domids;
/* Get list of domains. */
domids = malloc (sizeof (*domids) * n);
if (domids == NULL) {
ERROR (PLUGIN_NAME " plugin: malloc failed.");
return -1;
}
n = virConnectListDomains (conn, domids, n);
if (n < 0) {
VIRT_ERROR (conn, "reading list of domains");
sfree (domids);
return -1;
}
free_block_devices ();
free_interface_devices ();
free_domains ();
/* Fetch each domain and add it to the list, unless ignore. */
for (i = 0; i < n; ++i) {
virDomainPtr dom = NULL;
const char *name;
char *xml = NULL;
xmlDocPtr xml_doc = NULL;
xmlXPathContextPtr xpath_ctx = NULL;
xmlXPathObjectPtr xpath_obj = NULL;
int j;
dom = virDomainLookupByID (conn, domids[i]);
if (dom == NULL) {
VIRT_ERROR (conn, "virDomainLookupByID");
/* Could be that the domain went away -- ignore it anyway. */
continue;
}
name = virDomainGetName (dom);
if (name == NULL) {
VIRT_ERROR (conn, "virDomainGetName");
goto cont;
}
if (il_domains && ignorelist_match (il_domains, name) != 0)
goto cont;
if (add_domain (dom) < 0) {
ERROR (PLUGIN_NAME " plugin: malloc failed.");
goto cont;
}
/* Get a list of devices for this domain. */
xml = virDomainGetXMLDesc (dom, 0);
if (!xml) {
VIRT_ERROR (conn, "virDomainGetXMLDesc");
goto cont;
}
/* Yuck, XML. Parse out the devices. */
xml_doc = xmlReadDoc ((xmlChar *) xml, NULL, NULL, XML_PARSE_NONET);
if (xml_doc == NULL) {
VIRT_ERROR (conn, "xmlReadDoc");
goto cont;
}
xpath_ctx = xmlXPathNewContext (xml_doc);
/* Block devices. */
xpath_obj = xmlXPathEval
((xmlChar *) "/domain/devices/disk/target[@dev]",
xpath_ctx);
if (xpath_obj == NULL || xpath_obj->type != XPATH_NODESET ||
xpath_obj->nodesetval == NULL)
goto cont;
for (j = 0; j < xpath_obj->nodesetval->nodeNr; ++j) {
xmlNodePtr node;
char *path = NULL;
node = xpath_obj->nodesetval->nodeTab[j];
if (!node) continue;
path = (char *) xmlGetProp (node, (xmlChar *) "dev");
if (!path) continue;
if (il_block_devices &&
ignore_device_match (il_block_devices, name, path) != 0)
goto cont2;
add_block_device (dom, path);
cont2:
if (path) xmlFree (path);
}
xmlXPathFreeObject (xpath_obj);
/* Network interfaces. */
xpath_obj = xmlXPathEval
((xmlChar *) "/domain/devices/interface[target[@dev]]",
xpath_ctx);
if (xpath_obj == NULL || xpath_obj->type != XPATH_NODESET ||
xpath_obj->nodesetval == NULL)
goto cont;
xmlNodeSetPtr xml_interfaces = xpath_obj->nodesetval;
for (j = 0; j < xml_interfaces->nodeNr; ++j) {
char *path = NULL;
char *address = NULL;
xmlNodePtr xml_interface;
xml_interface = xml_interfaces->nodeTab[j];
if (!xml_interface) continue;
xmlNodePtr child = NULL;
for (child = xml_interface->children; child; child = child->next) {
if (child->type != XML_ELEMENT_NODE) continue;
if (xmlStrEqual(child->name, (const xmlChar *) "target")) {
path = (char *) xmlGetProp (child, (const xmlChar *) "dev");
if (!path) continue;
} else if (xmlStrEqual(child->name, (const xmlChar *) "mac")) {
address = (char *) xmlGetProp (child, (const xmlChar *) "address");
if (!address) continue;
}
}
if (il_interface_devices &&
(ignore_device_match (il_interface_devices, name, path) != 0 ||
ignore_device_match (il_interface_devices, name, address) != 0))
goto cont3;
add_interface_device (dom, path, address, j+1);
cont3:
if (path) xmlFree (path);
if (address) xmlFree (address);
}
cont:
if (xpath_obj) xmlXPathFreeObject (xpath_obj);
if (xpath_ctx) xmlXPathFreeContext (xpath_ctx);
if (xml_doc) xmlFreeDoc (xml_doc);
sfree (xml);
}
sfree (domids);
}
return 0;
}
int libvirt_open() {
conn = virConnectOpenReadOnly("xen:///");
if(conn == NULL) {
printf("libvirt connection open error on uri \n");
return 0;
}
int n;
n = virConnectNumOfDomains(conn);
if(n < 0) {
printf("Error reading number of domains \n");
return -1;
}
int i;
int *domids;
domids = malloc(sizeof(int) * n);
if(domids == 0) {
printf("libvirt domain ids malloc failed");
return -1;
}
n = virConnectListDomains(conn, domids, n);
if(n < 0) {
printf("Error reading list of domains \n");
free(domids);
return -1;
}
free_block_devices();
free_interface_devices();
free_domains();
for (i = 0; i < n ; ++i) {
virDomainPtr dom = NULL;
const char *name;
char *xml = NULL;
xmlDocPtr xml_doc = NULL;
xmlXPathContextPtr xpath_ctx = NULL;
xmlXPathObjectPtr xpath_obj = NULL;
int j;
//printf("Publishing Domain Id : %d \n ", domids[i]);
dom = virDomainLookupByID(conn, domids[i]);
if(dom == NULL) {
printf("Domain no longer active or moved away .. \n");
}
name = virDomainGetName(dom);
//printf("Publishing Domain Name : %s \n ", name);
if(name == NULL) {
printf("Domain name not valid .. \n");
goto cont;
}
if(add_domain(dom) < 0) {
printf("libvirt plugin malloc failed .. \n");
goto cont;
}
xml = virDomainGetXMLDesc(dom, 0);
if(!xml) {
printf("Virt domain xml description error ..\n");
goto cont;
}
//printf("Publishing XML : \n %s \n ", xml);
xml_doc = xmlReadDoc((xmlChar *) xml, NULL, NULL, XML_PARSE_NONET);
if(xml_doc == NULL) {
printf("XML read doc error ..\n");
goto cont;
}
xpath_ctx = xmlXPathNewContext(xml_doc);
xpath_obj = xmlXPathEval((xmlChar *) "/domain/devices/disk/target[@dev]", xpath_ctx);
if(xpath_obj == NULL || xpath_obj->type != XPATH_NODESET || xpath_obj->nodesetval == NULL) {
goto cont;
}
for(j = 0; j < xpath_obj->nodesetval->nodeNr; ++j) {
xmlNodePtr node;
char *path = NULL;
node = xpath_obj->nodesetval->nodeTab[j];
if(!node) continue;
path = (char *) xmlGetProp (node, (xmlChar *) "dev");
if(!path) continue;
add_block_device(dom, path);
}
xmlXPathFreeObject(xpath_obj);
xpath_obj = xmlXPathEval((xmlChar *) "/domain/devices/interface/target[@dev]", xpath_ctx);
if(xpath_obj == NULL || xpath_obj->type != XPATH_NODESET || xpath_obj->nodesetval == NULL) {
goto cont;
}
for(j = 0; j < xpath_obj->nodesetval->nodeNr; ++j) {
xmlNodePtr node;
char *path = NULL;
node = xpath_obj->nodesetval->nodeTab[j];
if(!node) continue;
path = (char *) xmlGetProp(node, (xmlChar *) "dev");
if(!path) continue;
add_interface_device(dom, path);
}
cont:
if(xpath_obj) xmlXPathFreeObject(xpath_obj);
if(xpath_ctx) xmlXPathFreeContext(xpath_ctx);
if(xml_doc) xmlFreeDoc(xml_doc);
if(xml) free(xml);
}
free(domids);
return 0;
}
//!
//! Main entry point of the application
//!
//! @param[in] argc the number of parameter passed on the command line
//! @param[in] argv the list of arguments
//!
//! @return Always return 0
//!
int main(int argc, char *argv[])
{
int dom_ids[MAXDOMS] = { 0 };
int num_doms = 0;
char *eucahome = NULL;
char *hypervisor = NULL;
char rootWrap[EUCA_MAX_PATH] = "";
char cmd[EUCA_MAX_PATH] = "";
char hypervisorURL[32] = "";
virConnectPtr conn = NULL;
// logfile (NULL, EUCAFATAL); // suppress all messages
if (argc != 2) {
fprintf(stderr, "error: test_nc expects one parameter (name of hypervisor)\n");
exit(1);
}
hypervisor = argv[1];
if (!strcmp(hypervisor, "kvm") || !strcmp(hypervisor, "qemu")) {
snprintf(hypervisorURL, 32, "qemu:///system");
} else if (!strcmp(hypervisor, "xen")) {
snprintf(hypervisorURL, 32, "xen:///");
} else if (!strcmp(hypervisor, "not_configured")) {
fprintf(stderr, "error: HYPERVISOR variable is not set in eucalyptus.conf\n");
exit(1);
} else {
fprintf(stderr, "error: hypervisor type (%s) is not recognized\n", hypervisor);
exit(1);
}
// check that commands that NC needs are there
if (euca_execlp(NULL, "perl", "--version", NULL) != EUCA_OK) {
fprintf(stderr, "error: could not run perl\n");
exit(1);
}
if ((eucahome = getenv(EUCALYPTUS_ENV_VAR_NAME)) == NULL) {
eucahome = strdup(""); // root by default
} else {
eucahome = strdup(eucahome);
// Sanitize this string
if (euca_sanitize_path(eucahome) != EUCA_OK) {
EUCA_FREE(eucahome);
eucahome = strdup("");
}
}
add_euca_to_path(eucahome);
fprintf(stderr, "looking for system utilities...\n");
if (diskutil_init(0)) {
EUCA_FREE(eucahome);
exit(1);
}
// ensure hypervisor information is available
fprintf(stderr, "ok\n\nchecking the hypervisor...\n");
snprintf(rootWrap, sizeof(rootWrap), EUCALYPTUS_ROOTWRAP, eucahome);
if (!strcmp(hypervisor, "kvm") || !strcmp(hypervisor, "qemu")) {
snprintf(cmd, sizeof(cmd), EUCALYPTUS_HELPER_DIR "/get_sys_info", eucahome);
} else {
snprintf(cmd, sizeof(cmd), EUCALYPTUS_HELPER_DIR "/get_xen_info", eucahome);
}
if (euca_execlp(NULL, rootWrap, cmd, NULL) != EUCA_OK) {
fprintf(stderr, "error: could not run '%s %s'\n", rootWrap, cmd);
EUCA_FREE(eucahome);
exit(1);
}
// check that libvirt can query the hypervisor
// NULL means local hypervisor
if ((conn = virConnectOpen(hypervisorURL)) == NULL) {
print_libvirt_error();
fprintf(stderr, "error: failed to connect to hypervisor\n");
EUCA_FREE(eucahome);
exit(1);
}
if ((num_doms = virConnectListDomains(conn, dom_ids, MAXDOMS)) < 0) {
print_libvirt_error();
fprintf(stderr, "error: failed to query running domains\n");
EUCA_FREE(eucahome);
exit(1);
}
fprintf(stdout, "NC test was successful\n");
EUCA_FREE(eucahome);
return (0);
}
