static int showDomains(virConnectPtr conn) { int ret = 0, i, numNames, numInactiveDomains, numActiveDomains; char **nameList = NULL; numActiveDomains = virConnectNumOfDomains(conn); if (numActiveDomains == -1) { ret = 1; printf("Failed to get number of active domains\n"); showError(conn); goto out; } numInactiveDomains = virConnectNumOfDefinedDomains(conn); if (numInactiveDomains == -1) { ret = 1; printf("Failed to get number of inactive domains\n"); showError(conn); goto out; } printf("There are %d active and %d inactive domains\n", numActiveDomains, numInactiveDomains); nameList = malloc(sizeof(*nameList) * numInactiveDomains); if (nameList == NULL) { ret = 1; printf("Could not allocate memory for list of inactive domains\n"); goto out; } numNames = virConnectListDefinedDomains(conn, nameList, numInactiveDomains); if (numNames == -1) { ret = 1; printf("Could not get list of defined domains from hypervisor\n"); showError(conn); goto out; } if (numNames > 0) { printf("Inactive domains:\n"); } for (i = 0 ; i < numNames ; i++) { printf(" %s\n", *(nameList + i)); /* The API documentation doesn't say so, but the names * returned by virConnectListDefinedDomains are strdup'd and * must be freed here. */ free(*(nameList + i)); } out: free(nameList); 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 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(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; } }
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; } }
int main(int argc, char** argv) { if(argc<2) { printf("usage: %s uri\n", argv[0]); return 1; } virConnectPtr conn=virConnectOpen(argv[1]); int l=virConnectNumOfDefinedDomains(conn); char* arr[l]; l=virConnectListDefinedDomains(conn, arr, l); for(int i=0;i<l;i++) { printf("%s\n", arr[i]); } virConnectClose(conn); }
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(); }
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); }
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 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); }
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; }