static gint
collect_error(VmonRequest *req, gint error, gboolean timeout)
{
char dom_uuid[VIR_UUID_STRING_BUFLEN] = { '\0' };
char req_uuid[VIR_UUID_STRING_BUFLEN] = { '\0' };
char buffer[4096]; /* TODO */
uuid_unparse(req->sr.uuid, req_uuid);
if (req->dom) {
virDomainGetUUIDString(req->dom, dom_uuid);
}
snprintf(buffer, sizeof(buffer),
"{"
" \"req-id\": \"%s\","
" \"timestamp\": %zu,"
" \"data\": {"
" \"vm-id\": \"%s\","
" \"error\": {"
" \"code\": %i,"
" \"message\": \"%s\""
" },"
" \"timeout\": \"%s\""
" } "
"}\n",
req_uuid,
time(NULL),
dom_uuid,
error,
"",
(timeout) ?"yes" :"no");
write_response(req->ctx->out, buffer, strlen(buffer));
return 0;
}
static void
add_domain (virDomainPtr dom)
{
struct domain *domain;
domains = realloc (domains, (nr_domains + 1) * sizeof (struct domain));
if (domains == NULL) {
perror ("realloc");
exit (EXIT_FAILURE);
}
domain = &domains[nr_domains];
nr_domains++;
domain->dom = dom;
domain->name = strdup (virDomainGetName (dom));
if (domain->name == NULL) {
perror ("strdup");
exit (EXIT_FAILURE);
}
char uuid[VIR_UUID_STRING_BUFLEN];
if (virDomainGetUUIDString (dom, uuid) == 0) {
domain->uuid = strdup (uuid);
if (domain->uuid == NULL) {
perror ("strdup");
exit (EXIT_FAILURE);
}
}
else
domain->uuid = NULL;
}
static int
domainStopped(virDomainPtr mojaDomain)
{
char dom_uuid[42];
if (!mojaDomain)
return -1;
virDomainGetUUIDString(mojaDomain, dom_uuid);
domain_sock_close(dom_uuid);
return 0;
}
static void
init_value_list (value_list_t *vl, time_t t, virDomainPtr dom)
{
int i, n;
const char *name;
char uuid[VIR_UUID_STRING_BUFLEN];
char *host_ptr;
size_t host_len;
vl->time = t;
vl->interval = interval_g;
sstrncpy (vl->plugin, "libvirt", sizeof (vl->plugin));
vl->host[0] = '\0';
host_ptr = vl->host;
host_len = sizeof (vl->host);
/* Construct the hostname field according to HostnameFormat. */
for (i = 0; i < HF_MAX_FIELDS; ++i) {
if (hostname_format[i] == hf_none)
continue;
n = DATA_MAX_NAME_LEN - strlen (vl->host) - 2;
if (i > 0 && n >= 1) {
strncat (vl->host, ":", 1);
n--;
}
switch (hostname_format[i]) {
case hf_none: break;
case hf_hostname:
strncat (vl->host, hostname_g, n);
break;
case hf_name:
name = virDomainGetName (dom);
if (name)
strncat (vl->host, name, n);
break;
case hf_uuid:
if (virDomainGetUUIDString (dom, uuid) == 0)
strncat (vl->host, uuid, n);
break;
}
}
vl->host[sizeof (vl->host) - 1] = '\0';
} /* void init_value_list */
static void
add_domain (virDomainPtr dom)
{
struct domain *domain;
domains = realloc (domains, (nr_domains + 1) * sizeof (struct domain));
if (domains == NULL) {
perror ("realloc");
exit (EXIT_FAILURE);
}
domain = &domains[nr_domains];
nr_domains++;
domain->name = strdup (virDomainGetName (dom));
if (domain->name == NULL) {
perror ("strdup");
exit (EXIT_FAILURE);
}
char uuid[VIR_UUID_STRING_BUFLEN];
if (virDomainGetUUIDString (dom, uuid) == 0) {
domain->uuid = strdup (uuid);
if (domain->uuid == NULL) {
perror ("strdup");
exit (EXIT_FAILURE);
}
}
else
domain->uuid = NULL;
domain->disks = NULL;
int n = guestfs___for_each_disk (g, dom, add_disk, domain);
if (n == -1)
exit (EXIT_FAILURE);
domain->nr_disks = n;
if (domain->nr_disks > MAX_DISKS) {
fprintf (stderr,
_("%s: ignoring %s, it has too many disks (%zu > %d)"),
program_name, domain->name, domain->nr_disks, MAX_DISKS);
free_domain (domain);
nr_domains--;
return;
}
}
static void
init_value_list (value_list_t *vl, virDomainPtr dom)
{
int i, n;
const char *name;
char uuid[VIR_UUID_STRING_BUFLEN];
sstrncpy (vl->plugin, PLUGIN_NAME, sizeof (vl->plugin));
vl->host[0] = '\0';
/* Construct the hostname field according to HostnameFormat. */
for (i = 0; i < HF_MAX_FIELDS; ++i) {
if (hostname_format[i] == hf_none)
continue;
n = DATA_MAX_NAME_LEN - strlen (vl->host) - 2;
if (i > 0 && n >= 1) {
strncat (vl->host, ":", 1);
n--;
}
switch (hostname_format[i]) {
case hf_none: break;
case hf_hostname:
strncat (vl->host, hostname_g, n);
break;
case hf_name:
name = virDomainGetName (dom);
if (name)
strncat (vl->host, name, n);
break;
case hf_uuid:
if (virDomainGetUUIDString (dom, uuid) == 0)
strncat (vl->host, uuid, n);
break;
}
}
vl->host[sizeof (vl->host) - 1] = '\0';
/* Construct the plugin instance field according to PluginInstanceFormat. */
for (i = 0; i < PLGINST_MAX_FIELDS; ++i) {
if (plugin_instance_format[i] == plginst_none)
continue;
n = sizeof(vl->plugin_instance) - strlen (vl->plugin_instance) - 2;
if (i > 0 && n >= 1) {
strncat (vl->plugin_instance, ":", 1);
n--;
}
switch (plugin_instance_format[i]) {
case plginst_none: break;
case plginst_name:
name = virDomainGetName (dom);
if (name)
strncat (vl->plugin_instance, name, n);
break;
case plginst_uuid:
if (virDomainGetUUIDString (dom, uuid) == 0)
strncat (vl->plugin_instance, uuid, n);
break;
}
}
vl->plugin_instance[sizeof (vl->plugin_instance) - 1] = '\0';
} /* void init_value_list */
static int
domainStarted(virDomainPtr mojaDomain, const char *path, int mode)
{
char dom_uuid[42];
char *xml;
xmlDocPtr doc;
xmlNodePtr cur, devices, child, serial;
xmlAttrPtr attr, attr_mode, attr_path;
if (!mojaDomain)
return -1;
virDomainGetUUIDString(mojaDomain, dom_uuid);
xml = virDomainGetXMLDesc(mojaDomain, 0);
// printf("%s\n", xml);
// @todo: free mojaDomain
// parseXML output
doc = xmlParseMemory(xml, strlen(xml));
xmlFree(xml);
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
fprintf(stderr, "Empty doc\n");
xmlFreeDoc(doc);
return -1;
}
if (xmlStrcmp(cur->name, (const xmlChar *) "domain")) {
fprintf(stderr, "no domain?\n");
xmlFreeDoc(doc);
return -1;
}
devices = cur->xmlChildrenNode;
for (devices = cur->xmlChildrenNode; devices != NULL;
devices = devices->next) {
if (xmlStrcmp(devices->name, (const xmlChar *) "devices")) {
continue;
}
for (child = devices->xmlChildrenNode; child != NULL;
child = child->next) {
if ((!mode && xmlStrcmp(child->name, (const xmlChar *) "serial")) ||
(mode && xmlStrcmp(child->name, (const xmlChar *) "channel"))) {
continue;
}
attr = xmlHasProp(child, (const xmlChar *)"type");
if (attr == NULL)
continue;
if (xmlStrcmp(attr->children->content,
(const xmlChar *) "unix")) {
continue;
}
for (serial = child->xmlChildrenNode; serial != NULL;
serial = serial->next) {
if (xmlStrcmp(serial->name,
(const xmlChar *) "source")) {
continue;
}
attr_mode = xmlHasProp(serial, (const xmlChar *)"mode");
attr_path = xmlHasProp(serial, (const xmlChar *)"path");
if (!attr_path || !attr_mode)
continue;
if (xmlStrcmp(attr_mode->children->content,
(const xmlChar *) "bind"))
continue;
if (path && !is_in_directory(path, (const char *)
attr_path->children->content))
continue;
domain_sock_setup(dom_uuid, (const char *)
attr_path->children->content);
}
}
}
xmlFreeDoc(doc);
return 0;
}
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++;
}
}
}
virt_list_t *vl_get(virConnectPtr vp, int my_id)
{
virt_list_t *vl = NULL;
int d_count, x, saved_errno;
virDomainPtr *dom_list;
errno = EINVAL;
if (!vp)
return NULL;
d_count = virConnectListAllDomains(vp, &dom_list, 0);
if (d_count <= 0)
goto out_fail;
vl = malloc(sizeof(uint32_t) + sizeof(virt_state_t) * d_count);
if (!vl)
goto out_fail;
vl->vm_count = d_count;
/* Ok, we have the domain IDs - let's get their names and states */
for (x = 0; x < d_count; x++) {
char *d_name;
virDomainInfo d_info;
char d_uuid[MAX_DOMAINNAME_LENGTH];
virDomainPtr dom = dom_list[x];
if (!(d_name = (char *)virDomainGetName(dom)))
goto out_fail;
if (virDomainGetUUIDString(dom, d_uuid) != 0)
goto out_fail;
if (virDomainGetInfo(dom, &d_info) < 0)
goto out_fail;
/* Store the name & state */
strncpy(vl->vm_states[x].v_name, d_name, MAX_DOMAINNAME_LENGTH);
strncpy(vl->vm_states[x].v_uuid, d_uuid, MAX_DOMAINNAME_LENGTH);
vl->vm_states[x].v_state.s_state = d_info.state;
vl->vm_states[x].v_state.s_owner = my_id;
}
for (x = 0 ; x < d_count; x++)
virDomainFree(dom_list[x]);
free(dom_list);
/* We have all the locally running domains & states now */
/* Sort */
qsort(&vl->vm_states[0], vl->vm_count, sizeof(vl->vm_states[0]),
_compare_virt);
return vl;
out_fail:
saved_errno = errno;
for (x = 0 ; x < d_count; x++)
virDomainFree(dom_list[x]);
free(dom_list);
if (vl)
free(vl);
errno = saved_errno;
return NULL;
}
void run(char *myIP, virConnectPtr localhost) {
printf("*** New run\n");
virDomainPtr *domains, *domainsptr;
virConnectListAllDomains(localhost, &domains, VIR_CONNECT_LIST_DOMAINS_ACTIVE|VIR_CONNECT_LIST_DOMAINS_INACTIVE|VIR_CONNECT_LIST_DOMAINS_RUNNING|VIR_CONNECT_LIST_DOMAINS_SHUTOFF);
domainsptr = domains;
char **domainuuids = malloc(sizeof(char*)*1024);
char **domainuuidsptr = domainuuids;
*domainuuids = NULL;
printf("Domains\n");
while(*domainsptr != NULL) {
char buf[VIR_UUID_STRING_BUFLEN];
virDomainGetUUIDString(*domainsptr, buf);
const char *name = virDomainGetName(*domainsptr);
if (!strncmp("ignore",name,strlen("ignore"))) {
domainsptr++;
continue;
}
printf("%s\n", buf);
*(domainuuidsptr++) = strdup(buf);
*domainuuidsptr = NULL;
domainsptr++;
}
domainuuidsptr = domainuuids;
size_t domainuuids_count=0;
while(*domainuuidsptr != NULL) domainuuidsptr++, domainuuids_count++;
domainuuidsptr = domainuuids;
domainsptr = domains;
char **hosts = gethosts();
char **hostsptr=hosts;
size_t hosts_count = 0;
while (*hostsptr != NULL) hosts_count++, hostsptr++;
hostsptr = hosts;
struct hostwithvmhash **cs = malloc(sizeof(struct hostwithvmhash)*1024);
*cs = NULL;
struct hostwithvmhash **csptr = cs;
int sign=0;
while(*hostsptr != NULL) {
if (!strcmp(*hostsptr, myIP)) printf("ME! ");
sign = !sign;
size_t k=1;
while(*domainuuidsptr != NULL) {
/* char *num = "$6$hest";
char *hash = crypt(*domainuuidsptr, num);
char *hash2 = crypt(*hostsptr, num);*/
struct hostwithvmhash *c=malloc(sizeof(struct hostwithvmhash));
c->host = *hostsptr;
// c->host_hash = strdup(hash+10);
c->vm = *domainuuidsptr;
// c->vm_hash = strdup(hash2+10);
c->combined = malloc(10000);
strcpy(c->combined, "");
strcat(c->combined, c->host);
strcat(c->combined, c->vm);
//c->combined = strdup(crypt(c->combined, num));
*(csptr++) = c;
*csptr = NULL;
domainuuidsptr++;
}
domainuuidsptr = domainuuids;
printf("%s\n", *hostsptr);
/* char URL[512];
sprintf(URL, "qemu+ssh://%s/system", *hosts);
virConnectPtr dest = virConnectOpen(URL);
*(destsptr++) = dest;
*destsptr = NULL;*/
hostsptr++;
}
csptr = cs;
printf("\n");
size_t count=0;
while(*csptr != NULL) count++, csptr++;
csptr = cs;
qsort(csptr, count, sizeof(struct hostwithvmhash*), (__compar_fn_t)cscompare);
struct hostwithvmhash **csptrptr = csptr;
size_t i=0,k=0,j=0,q=1,m=0;
char *last_host=NULL,*last_vm=NULL;
struct hostwithvmhash **seen=malloc(sizeof(struct hostwithvmhash*)*1024);
*seen = NULL;
struct hostwithvmhash **seenptr=seen;
struct hostwithvmhash **seenaddptr=seen;
while(*csptrptr != NULL) {
if (last_host == NULL || strcmp(last_host, (*csptrptr)->host))
last_host = (*csptrptr)->host,k++;
seenptr=seen;
int is_seen=0;
while(*seenptr != NULL) {
if (!strcmp((*seenptr)->vm, (*csptrptr)->vm))
is_seen=1;
seenptr++;
}
if (!is_seen) {
m++,*(seenaddptr++) = *csptrptr, *seenaddptr = NULL;
(*csptrptr)->prio = 100*m+(k+m)%hosts_count;
if (m == domainuuids_count)
m = 0, seenaddptr=seenptr=seen,*seen=NULL;
} else
(*csptrptr)->prio = k;
csptrptr++;
}
qsort(csptr, count, sizeof(struct hostwithvmhash*), (__compar_fn_t)cscompareprio);
struct hostwithvmhash **cleaned = cleanlist(csptr);
struct hostwithvmhash **cleanedstart = cleaned;
while(*cleaned != NULL) {
virDomainPtr d = virDomainLookupByUUIDString(localhost, (*cleaned)->vm);
const char *name = virDomainGetName(d);
int state, reason;
virDomainGetState(d, &state, &reason, 0);
if (!strcmp((*cleaned)->host, myIP)) {
printf("I should be running %s (%s)\n", name, (*cleaned)->vm);
if (state == VIR_DOMAIN_RUNNING)
printf("...and it's running.\n");
else
virDomainCreate(d);
} else {
printf("I should NOT be running %s (%s)\n", name, (*cleaned)->vm);
if (state == VIR_DOMAIN_RUNNING) {
printf("Destroying.\n");
virDomainDestroy(d);
} else
printf("...and it's not running.\n");
}
if (d) {
virDomainFree(d);
}
//printf("prio:%d host:%s, vm:%s combined:%s\n", (*cleaned)->prio, (*cleaned)->host, (*cleaned)->vm, (*cleaned)->combined);
cleaned++;
}
domainuuidsptr = domainuuids;
while(*domainuuidsptr != NULL) {
free(*domainuuidsptr);
domainuuidsptr++;
}
free(domainuuids);
free(cleanedstart);
csptr = cs;
while(*csptr != NULL) {
free((*csptr)->combined);
free(*csptr);
csptr++;
}
free(cs);
free(seen);
hostsptr = hosts;
while(*hostsptr != NULL) {
free(*hostsptr);
hostsptr++;
}
free(hosts);
domainsptr = domains;
while(*domainsptr != NULL) {
virDomainFree(*domainsptr);
domainsptr++;
}
free(domains);
/*
virDomainPtr *domains;
virConnectListAllDomains(src, &domains, VIR_CONNECT_LIST_DOMAINS_ACTIVE);
while(*domains != NULL) {
char *config = virDomainGetXMLDesc(*domains, 0);
char uuid[VIR_UUID_BUFLEN];
char uuidstr[VIR_UUID_STRING_BUFLEN];
virDomainGetUUIDString(*domains, uuidstr);
virDomainGetUUID(*domains, uuid);
destsptr = dests;
while (*destsptr != NULL) {
virConnectPtr dest = *destsptr;
virDomainPtr d = virDomainLookupByUUID(dest, uuid);
if (d)
printf("%s already in dest\n", uuidstr);
if (!d) {
printf("%s\n", config);
printf("Injecting domain on dest\n");
virDomainPtr new = virDomainDefineXML(dest, config);
}
fflush(stdout);
destsptr++;
}
domains++;
}*/
}
