/* ---------------
* Misc utils
* ---------------
*/
int
virshDomainState(vshControl *ctl, virDomainPtr dom, int *reason)
{
virDomainInfo info;
virshControlPtr priv = ctl->privData;
if (reason)
*reason = -1;
if (!priv->useGetInfo) {
int state;
if (virDomainGetState(dom, &state, reason, 0) < 0) {
virErrorPtr err = virGetLastError();
if (err && err->code == VIR_ERR_NO_SUPPORT)
priv->useGetInfo = true;
else
return -1;
} else {
return state;
}
}
/* fall back to virDomainGetInfo if virDomainGetState is not supported */
if (virDomainGetInfo(dom, &info) < 0)
return -1;
else
return info.state;
}
void resume_all_vm() {
int state, reason, count, i;
// resume all the VM-es (except for the Domain-0)
for (i = 1; i < numDomains; i++)
virDomainResume(activeDomains[i]);
// capture the time after resume action
clock_gettime(CLOCK_MONOTONIC, &tp_start);
// this function will looped until all machines are resumed.
while (1) {
count = 0;
for (i = 1; i < numDomains; i++) {
// check if the state is RUNNING (or BLOCKED in Xen)
virDomainGetState(activeDomains[i], &state, &reason, 0);
if (state == VIR_DOMAIN_BLOCKED || state == VIR_DOMAIN_RUNNING)
count++;
}
if (count == numDomains - 1) break;
}
}
std::string VM_Controller::get_vm_detail(virDomainPtr dom){
Json::Value j;
j["status"] = "ok";
virDomainInfo info;
if(virDomainGetInfo(dom, &info) < 0){
LOG_ERROR("could not get domain info");
j["status"] = "no such domain";
return j.toStyledString();
}
// basic info
int state;
virDomainGetState(dom, &state, NULL, 0);
j["vm_status"] = state_code2string(state);
if(virDomainIsActive(dom)){
j["id"] = virDomainGetID(dom);
}
j["name"] = virDomainGetName(dom);
j["vcpu"] = virDomainGetMaxVcpus(dom);
j["mem_total"] = (unsigned long long)virDomainGetMaxMemory(dom);
// more detailed info
char *domain_xml = virDomainGetXMLDesc(dom, VIR_DOMAIN_XML_SECURE);
tinyxml2::XMLDocument doc;
doc.Parse(domain_xml);
j["img_path"] = doc.RootElement()
->FirstChildElement("devices")
->FirstChildElement("disk")
->FirstChildElement("source")
->Attribute("file");
tinyxml2::XMLElement *graphics = doc.RootElement()
->FirstChildElement("devices")
->FirstChildElement("graphics");
j["vnc_port"] = graphics->Attribute("port");
virDomainFree(dom);
return j.toStyledString();
}
void stop_all_vm() {
int state, reason, count, i;
// suspend all the VM-es (except for Domain-0)
for (i = 1; i < numDomains; i++)
virDomainSuspend(activeDomains[i]);
// capture the time after suspend action
clock_gettime(CLOCK_MONOTONIC, &tp_end);
// this function will looped until all machines are paused.
while (1) {
count = 0;
for (i = 1; i < numDomains; i++) {
// check if the state is PAUSED
virDomainGetState(activeDomains[i], &state, &reason, 0);
if (state == VIR_DOMAIN_PAUSED)
count++;
}
// break when all the machines are paused
if (count == numDomains - 1) break;
}
}
/**
* @brief provides the state of the Domain in form of integer
* @return integer representing state of domain
*
* The return value respresents the integer from the enum virDomainState
* (http://libvirt.org/html/libvirt-libvirt-domain.html#virDomainState)
*
* If the correct state cannot be ascertained, -1 is returned.
*/
int Domain::state()
{
int state;
int reason;
if (m_domain)
{
if (m_libVersion > 8000)
{
if (virDomainGetState(m_domain, &state, &reason, 0) != -1)
{
return state;
}
} else {
virDomainInfo info;
if (virDomainGetInfo(m_domain, &info) != -1)
{
return info.state;
}
}
}
return -1;
}
int ConnAliveThread::domEventCallback(virConnectPtr _conn, virDomainPtr dom, int event, int detail, void *opaque)
{
//qDebug()<<"domEventCallback"<<_conn;
ConnAliveThread *obj = static_cast<ConnAliveThread*>(opaque);
if ( NULL==obj || *(obj->ptr_ConnPtr)!=_conn ) return 0;
bool end = false;
QString msg, domainName;
domainName = QString(virDomainGetName(dom));
msg = QString("<b>'%1'</b> Domain %2 %3\n")
.arg(domainName)
.arg(obj->domEventToString(event))
.arg(obj->domEventDetailToString(event, detail, &end));
if ( end ) emit obj->domainEnd(domainName);
emit obj->connMsg(msg);
if ( obj->onView ) {
Result result;
QStringList domainList;
if ( _conn!=NULL && obj->keep_alive ) {
virDomainPtr *domains = NULL;
unsigned int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE |
VIR_CONNECT_LIST_DOMAINS_INACTIVE;
// the number of domains found or -1 and sets domains to NULL in case of error.
int ret = virConnectListAllDomains(_conn, &domains, flags);
if ( ret<0 ) {
obj->sendConnErrors();
return 0;
};
// therefore correctly to use for() command, because domains[0] can not exist.
for (int i = 0; i < ret; i++) {
QStringList currentAttr;
QString autostartStr;
int is_autostart = 0;
if (virDomainGetAutostart(domains[i], &is_autostart) < 0) {
autostartStr.append("no autostart");
} else autostartStr.append( is_autostart ? "yes" : "no" );
int state;
int reason;
// flags : extra flags; not used yet, so callers should always pass 0
flags = 0;
QString domainState;
if ( virDomainGetState(domains[i], &state, &reason, flags)+1 ) {
switch (state) {
case VIR_DOMAIN_NOSTATE:
domainState.append("NOSTATE");
break;
case VIR_DOMAIN_RUNNING:
domainState.append("RUNNING");
break;
case VIR_DOMAIN_BLOCKED:
domainState.append("BLOCKED");
break;
case VIR_DOMAIN_PAUSED:
domainState.append("PAUSED");
break;
case VIR_DOMAIN_SHUTDOWN:
domainState.append("SHUTDOWN");
break;
case VIR_DOMAIN_SHUTOFF:
domainState.append("SHUTOFF");
break;
case VIR_DOMAIN_CRASHED:
domainState.append("CRASHED");
break;
case VIR_DOMAIN_PMSUSPENDED:
domainState.append("PMSUSPENDED");
break;
default:
domainState.append("UNKNOWN");
break;
}
} else domainState.append("ERROR");
currentAttr<< QString().fromUtf8( virDomainGetName(domains[i]) )
<< QString("%1:%2")
.arg( virDomainIsActive(domains[i]) ? "active" : "inactive" )
.arg(domainState)
<< autostartStr
<< QString( virDomainIsPersistent(domains[i]) ? "yes" : "no" );
domainList.append(currentAttr.join(DFR));
virDomainFree(domains[i]);
};
free(domains);
};
//result.name = ;
result.type = "domain";
//result.number = number;
result.action = GET_ALL_ENTITY_STATE;
result.result = true;
result.msg = domainList;
emit obj->domStateChanged(result);
};
return 0;
}
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++;
}*/
}
