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;
}
