struct domain_interface_info_list *libvirt_domain_interface_info_list() {
int i;
struct domain_interface_info_list *domain_interface_info_list = (struct domain_interface_info_list *) calloc(1,
sizeof(struct domain_interface_info_list));
domain_interface_info_list->num_domains = nr_domains;
domain_interface_info_list->domain_interface_info = (struct domain_interface_info *) calloc(nr_domains, sizeof(struct domain_interface_info));
for(i = 0; i < nr_interface_devices; ++i) {
struct _virDomainInterfaceStats stats;
if(virDomainInterfaceStats(interface_devices[i].dom, interface_devices[i].path, &stats, sizeof stats) != 0)
continue;
domain_interface_info_list->domain_interface_info[i].domain_name = strdup(virDomainGetName(domains[i]));
domain_interface_info_list->domain_interface_info[i].domain_id = virDomainGetID(domains[i]);
domain_interface_info_list->domain_interface_info[i].domain_if_rxbytes = (unsigned long long) stats.rx_bytes;
domain_interface_info_list->domain_interface_info[i].domain_if_txbytes = (unsigned long long) stats.tx_bytes;
domain_interface_info_list->domain_interface_info[i].domain_if_rxpackets = (unsigned long long) stats.rx_packets;
domain_interface_info_list->domain_interface_info[i].domain_if_txpackets = (unsigned long long) stats.tx_packets;
domain_interface_info_list->domain_interface_info[i].domain_if_rxerrors = (unsigned long long) stats.rx_errs;
domain_interface_info_list->domain_interface_info[i].domain_if_txerrors = (unsigned long long) stats.tx_errs;
domain_interface_info_list->domain_interface_info[i].domain_if_rxdrops = (unsigned long long) stats.rx_drop;
domain_interface_info_list->domain_interface_info[i].domain_if_txdrops = (unsigned long long) stats.tx_drop;
}
return domain_interface_info_list;
}
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);
}
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
fetch_domains(virConnectPtr conn)
{
int num_domains, ret = -1;
virDomainPtr *domains = NULL;
ssize_t i;
const int list_flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE;
DEBUG("Fetching list of running domains");
num_domains = virConnectListAllDomains(conn, &domains, list_flags);
DEBUG("num_domains=%d", num_domains);
if (num_domains < 0) {
ERROR("Unable to fetch list of running domains");
goto cleanup;
}
printf("Running domains:\n");
printf("----------------\n");
for (i = 0; i < num_domains; i++) {
virDomainPtr dom = domains[i];
const char *dom_name = virDomainGetName(dom);
printf("%s\n", dom_name);
virDomainFree(dom);
}
ret = 0;
cleanup:
free(domains);
return ret;
}
static void receiveData(int signal)
{
int n,guest_pid;
char msg[20] = "";
if (n = read(sm_channel,msg,10)!=0)
{
sscanf(msg,"%d",&guest_pid);
//printf("Targeted guest: %d\n",guest_pid);
}
else
printf("Error: obtained invalid guest pid %d , %s\n", n,msg);
if (guest_pid==-1)
{
printf("The Stabilization manager is attacked - resetting... \n");
printf("All virtual machines are being rebooted... \n");
rebootAll();
}
else
{
for (n=0; vms[n].pid>0;n++)
if (vms[n].pid==guest_pid)
break;
printf("Virtual Machine %s on process %d is attacked - rebooting... \n",
virDomainGetName(vms[n].dom), vms[n].pid);
if(vms[n].dom!=NULL && isActiveDomain(vms[n].dom)==1)
rebootVM(vms[n].dom);
}
}
static int
showDomains(virConnectPtr conn)
{
int ret = 0, numNames, numInactiveDomains, numActiveDomains;
ssize_t i;
int flags = VIR_CONNECT_LIST_DOMAINS_ACTIVE |
VIR_CONNECT_LIST_DOMAINS_INACTIVE;
virDomainPtr *nameList = NULL;
/* NB: The return from the virConnectNum*() APIs is only useful for
* the current call. A domain could be started or stopped and any
* assumptions made purely on these return values could result in
* unexpected results */
numActiveDomains = virConnectNumOfDomains(conn);
if (numActiveDomains == -1) {
ret = 1;
printf("Failed to get number of active domains: %s\n",
virGetLastErrorMessage());
goto out;
}
numInactiveDomains = virConnectNumOfDefinedDomains(conn);
if (numInactiveDomains == -1) {
ret = 1;
printf("Failed to get number of inactive domains: %s\n",
virGetLastErrorMessage());
goto out;
}
printf("There are %d active and %d inactive domains\n",
numActiveDomains, numInactiveDomains);
/* Return a list of all active and inactive domains. Using this API
* instead of virConnectListDomains() and virConnectListDefinedDomains()
* is preferred since it "solves" an inherit race between separated API
* calls if domains are started or stopped between calls */
numNames = virConnectListAllDomains(conn,
&nameList,
flags);
if (numNames == -1) {
ret = 1;
printf("Failed to get a list of all domains: %s\n",
virGetLastErrorMessage());
goto out;
}
for (i = 0; i < numNames; i++) {
int active = virDomainIsActive(nameList[i]);
printf(" %8s (%s)\n",
virDomainGetName(nameList[i]),
(active == 1 ? "active" : "non-active"));
/* must free the returned named per the API documentation */
virDomainFree(nameList[i]);
}
free(nameList);
out:
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 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 */
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 main(int argc, char *argv[]) {
if(argc <= 1)
printf("usage: deletedom domname\n"),exit(-1);
char **hosts = gethosts();
char **hostsptr = hosts;
virConnectPtr *dests = (virConnectPtr*)malloc(sizeof(virConnectPtr)*1024);
virConnectPtr *destsptr = dests;
while(*hostsptr != NULL) {
printf("Adding vmhost %s\n", *hostsptr);
char URL[512];
sprintf(URL, "qemu+ssh://%s/system", *hostsptr);
virConnectPtr dest = virConnectOpen(URL);
*(destsptr++) = dest;
*destsptr = NULL;
hostsptr++;
}
char *searched_name = argv[1];
virConnectPtr src = virConnectOpen("qemu:///system");
virDomainPtr *domains, *domainsptr;
virConnectListAllDomains(src, &domains, VIR_CONNECT_LIST_DOMAINS_ACTIVE|VIR_CONNECT_LIST_DOMAINS_INACTIVE|VIR_CONNECT_LIST_DOMAINS_RUNNING|VIR_CONNECT_LIST_DOMAINS_SHUTOFF|VIR_CONNECT_LIST_DOMAINS_PERSISTENT|VIR_CONNECT_LIST_DOMAINS_OTHER|VIR_CONNECT_LIST_DOMAINS_TRANSIENT|VIR_CONNECT_LIST_DOMAINS_PAUSED);
domainsptr = domains;
while(*domainsptr != NULL) {
virDomainPtr d = *domainsptr;
const char *name = virDomainGetName(d);
if (!strcmp(name, searched_name)) {
printf("Found it!\n");
destsptr = dests;
char uuid[VIR_UUID_BUFLEN];
virDomainGetUUID(*domainsptr, uuid);
while(*destsptr != NULL) {
virDomainPtr target=virDomainLookupByUUID(*destsptr, uuid);
virDomainSetMetadata(target, VIR_DOMAIN_METADATA_ELEMENT, "<value>1</value>", "do_delete", "/do_delete", VIR_DOMAIN_AFFECT_CURRENT);
destsptr++;
}
virDomainSetMetadata(d, VIR_DOMAIN_METADATA_ELEMENT, "<value>1</value>", "do_delete", "/do_delete", VIR_DOMAIN_AFFECT_CURRENT);
}
domainsptr++;
}
}
void getDomainInfo(int id, timeInfoNode infos)
{
virDomainPtr dom = NULL;
virDomainInfo info;
int ret;
struct timeval realTime;
int cpu_diff, real_diff;
float usage;
/* Find the domain of the given id */
dom = virDomainLookupByID(conn, id);
if (dom == NULL)
{
fprintf(stderr, "Failed to find Domain %d\n", id);
freeDom(dom);
closeConn();
}
/* Get the information of the domain */
ret = virDomainGetInfo(dom, &info);
if (ret < 0)
{
fprintf(stderr, "Failed to get information for Domain %d\n", id);
freeDom(dom);
closeConn();
}
/* get the end of realTime*/
if (gettimeofday(&realTime, NULL) == - 1)
{
fprintf(stderr, "Failed to get start time\n");
return;
}
/* calculate the usage of cpu */
cpu_diff = (info.cpuTime - infos.cpu_time) / 10000;
real_diff = 1000 *(realTime.tv_sec - infos.real_time.tv_sec) +
(realTime.tv_usec - infos.real_time.tv_usec);
usage = cpu_diff / (float)(real_diff);
/* print the results */
printf("%d\t%.3f%\t%lu\t%lu\t%hu\t%0X\t%s\n", id, usage, info.memory / 1024,
info.maxMem / 1024, info.nrVirtCpu, info.state, virDomainGetName(dom));
freeDom(dom);
}
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;
}
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
virDomainPtr dom;
char *xmlconfig = NULL;
if(argc != 2)
{
printf("usage: ./define_domain domain.xml\n");
return -1;
}
if ((xmlconfig = GetXml(argv[1])) == NULL)
{
fprintf(stderr, "Failed to get xml\n");
return -1;
}
conn = virConnectOpen("qemu:///system");
if (conn == NULL)
{
fprintf(stderr, "Failed to open connection to qemu:///system\n");
free(xmlconfig);
return -1;
}
dom = virDomainDefineXML(conn, xmlconfig);
if (!dom)
{
printf("Domain is not found\n");
free(xmlconfig);
virConnectClose(conn);
return -1;
}
fprintf(stderr, "Guest %s is defined\n", virDomainGetName(dom));
free(xmlconfig);
virDomainFree(dom);
virConnectClose(conn);
return 0;
}
struct domain_disk_info_list *libvirt_domain_disk_info_list() {
int i;
struct domain_disk_info_list *domain_disk_info_list = (struct domain_disk_info_list *) calloc(1, sizeof(struct domain_disk_info_list));
domain_disk_info_list->num_domains = nr_domains;
domain_disk_info_list->domain_disk_info = (struct domain_disk_info *) calloc(nr_domains, sizeof(struct domain_disk_info));
for(i = 0; i < nr_block_devices; ++i) {
struct _virDomainBlockStats stats;
if(virDomainBlockStats(block_devices[i].dom, block_devices[i].path, &stats, sizeof stats) != 0)
continue;
domain_disk_info_list->domain_disk_info[i].domain_name = strdup(virDomainGetName(domains[i]));
domain_disk_info_list->domain_disk_info[i].domain_id = virDomainGetID(domains[i]);
domain_disk_info_list->domain_disk_info[i].domain_vblock_rreq = (unsigned long long) stats.rd_req;
domain_disk_info_list->domain_disk_info[i].domain_vblock_wreq = (unsigned long long) stats.wr_req;
domain_disk_info_list->domain_disk_info[i].domain_vblock_rbytes = (unsigned long long) stats.rd_bytes;
domain_disk_info_list->domain_disk_info[i].domain_vblock_wbytes = (unsigned long long) stats.wr_bytes;
}
return domain_disk_info_list;
}
struct domain_info_list *libvirt_domain_info_list() {
int i;
struct domain_info_list *domain_info_list = (struct domain_info_list *) calloc(1, sizeof(struct domain_info_list));
domain_info_list->num_domains = nr_domains;
domain_info_list->domain_info = (struct domain_info *) calloc(nr_domains, sizeof(struct domain_info));
for(i = 0; i < nr_domains; ++i) {
if(virDomainGetInfo(domains[i], &vir_domain_info) != 0)
continue;
domain_info_list->domain_info[i].domain_name = strdup(virDomainGetName(domains[i]));
domain_info_list->domain_info[i].domain_id = virDomainGetID(domains[i]);
domain_info_list->domain_info[i].domain_state = vir_domain_info.state;
domain_info_list->domain_info[i].domain_mem_max = vir_domain_info.maxMem;
domain_info_list->domain_info[i].domain_mem_used = vir_domain_info.memory;
domain_info_list->domain_info[i].domain_num_vcpus = vir_domain_info.nrVirtCpu;
domain_info_list->domain_info[i].domain_cpu_total_time = vir_domain_info.cpuTime;
}
return domain_info_list;
}
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);
}
static int initVMIFile(int numDomains, char *sysmapName)
{
FILE *confFile;
int i;
confFile = fopen(CONFFILE, "wt");
if (!confFile)
{
printf("Cannot set up the VMI configuration file");
return 0;
}
for (i=0;i<numDomains;i++)
{
VMPID *vmEntry = vms + i;
int nb, pid = vmEntry->pid;
char *vmName = virDomainGetName(vmEntry->dom);
char command[30] = "", vmdata[200] = "";
fprintf(confFile, "%s {\n",vmName); //vmname
fprintf(confFile," sysmap = \"%s\";\n", sysmapName); //system map file
fprintf(confFile," ostype = \"%s\";\n", LINUX_OS); //OS Type
sprintf(command, "VMPid:%d", pid);
nb = write(sm_channel, command, strlen(command));
printf("Requesting parameters for VM %s - written %d bytes\n", command, nb);
if (read(sm_channel,vmdata,200)!=0)
{
printf("Got parameters for VM %s\n", vmdata);
fprintf(confFile, "%s", vmdata);
//fprintf(confFile, " pid = %d\n", pid);
}
fprintf(confFile, "}\n");
}
fclose(confFile);
return 1;
}
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();
}
static void ShowRunList(virConnectPtr vc)
{
int i;
virDomainPtr dom;
const char *name;
for (i = 0; i < CF_MAX_CONCURRENT_ENVIRONMENTS; i++)
{
if (CF_RUNNING[i] > 0)
{
if ((dom = virDomainLookupByID(vc, CF_RUNNING[i])))
{
Log(LOG_LEVEL_VERBOSE, "Found a running virtual domain with id %d", CF_RUNNING[i]);
}
if ((name = virDomainGetName(dom)))
{
Log(LOG_LEVEL_VERBOSE, "Found a running virtual domain called '%s'", name);
}
virDomainFree(dom);
}
}
}
static void ShowRunList(virConnectPtr vc)
{
int i;
virDomainPtr dom;
const char *name;
for (i = 0; i < CF_MAX_CONCURRENT_ENVIRONMENTS; i++)
{
if (CF_RUNNING[i] > 0)
{
if ((dom = virDomainLookupByID(vc, CF_RUNNING[i])))
{
CfOut(cf_verbose, "", " -> Found a running virtual domain with id %d\n", CF_RUNNING[i]);
}
if ((name = virDomainGetName(dom)))
{
CfOut(cf_verbose, "", " ---> Found a running virtual domain called \"%s\"\n", name);
}
virDomainFree(dom);
}
}
}
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;
}
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);
}
}
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;
}
static int
lv_read (void)
{
time_t t;
int i;
if (conn == NULL) {
/* `conn_string == NULL' is acceptable. */
conn = virConnectOpenReadOnly (conn_string);
if (conn == NULL) {
c_complain (LOG_ERR, &conn_complain,
PLUGIN_NAME " plugin: Unable to connect: "
"virConnectOpenReadOnly failed.");
return -1;
}
}
c_release (LOG_NOTICE, &conn_complain,
PLUGIN_NAME " plugin: Connection established.");
time (&t);
/* Need to refresh domain or device lists? */
if ((last_refresh == (time_t) 0) ||
((interval > 0) && ((last_refresh + interval) <= t))) {
if (refresh_lists () != 0) {
if (conn != NULL)
virConnectClose (conn);
conn = NULL;
return -1;
}
last_refresh = t;
}
#if 0
for (i = 0; i < nr_domains; ++i)
fprintf (stderr, "domain %s\n", virDomainGetName (domains[i]));
for (i = 0; i < nr_block_devices; ++i)
fprintf (stderr, "block device %d %s:%s\n",
i, virDomainGetName (block_devices[i].dom),
block_devices[i].path);
for (i = 0; i < nr_interface_devices; ++i)
fprintf (stderr, "interface device %d %s:%s\n",
i, virDomainGetName (interface_devices[i].dom),
interface_devices[i].path);
#endif
/* Get CPU usage, memory, VCPU usage for each domain. */
for (i = 0; i < nr_domains; ++i) {
virDomainInfo info;
virVcpuInfoPtr vinfo = NULL;
virDomainMemoryStatPtr minfo = NULL;
int status;
int j;
status = virDomainGetInfo (domains[i], &info);
if (status != 0)
{
ERROR (PLUGIN_NAME " plugin: virDomainGetInfo failed with status %i.",
status);
continue;
}
if (info.state != VIR_DOMAIN_RUNNING)
{
/* only gather stats for running domains */
continue;
}
cpu_submit (info.cpuTime, domains[i], "virt_cpu_total");
memory_submit ((gauge_t) info.memory * 1024, domains[i]);
vinfo = malloc (info.nrVirtCpu * sizeof (vinfo[0]));
if (vinfo == NULL) {
ERROR (PLUGIN_NAME " plugin: malloc failed.");
continue;
}
status = virDomainGetVcpus (domains[i], vinfo, info.nrVirtCpu,
/* cpu map = */ NULL, /* cpu map length = */ 0);
if (status < 0)
{
ERROR (PLUGIN_NAME " plugin: virDomainGetVcpus failed with status %i.",
status);
sfree (vinfo);
continue;
}
for (j = 0; j < info.nrVirtCpu; ++j)
vcpu_submit (vinfo[j].cpuTime,
domains[i], vinfo[j].number, "virt_vcpu");
sfree (vinfo);
minfo = malloc (VIR_DOMAIN_MEMORY_STAT_NR * sizeof (virDomainMemoryStatStruct));
if (minfo == NULL) {
ERROR ("virt plugin: malloc failed.");
continue;
}
status = virDomainMemoryStats (domains[i], minfo, VIR_DOMAIN_MEMORY_STAT_NR, 0);
if (status < 0) {
ERROR ("virt plugin: virDomainMemoryStats failed with status %i.",
status);
sfree (minfo);
continue;
}
for (j = 0; j < status; j++) {
memory_stats_submit ((gauge_t) minfo[j].val * 1024, domains[i], minfo[j].tag);
}
sfree (minfo);
}
/* Get block device stats for each domain. */
for (i = 0; i < nr_block_devices; ++i) {
struct _virDomainBlockStats stats;
if (virDomainBlockStats (block_devices[i].dom, block_devices[i].path,
&stats, sizeof stats) != 0)
continue;
if ((stats.rd_req != -1) && (stats.wr_req != -1))
submit_derive2 ("disk_ops",
(derive_t) stats.rd_req, (derive_t) stats.wr_req,
block_devices[i].dom, block_devices[i].path);
if ((stats.rd_bytes != -1) && (stats.wr_bytes != -1))
submit_derive2 ("disk_octets",
(derive_t) stats.rd_bytes, (derive_t) stats.wr_bytes,
block_devices[i].dom, block_devices[i].path);
} /* for (nr_block_devices) */
/* Get interface stats for each domain. */
for (i = 0; i < nr_interface_devices; ++i) {
struct _virDomainInterfaceStats stats;
char *display_name = NULL;
switch (interface_format) {
case if_address:
display_name = interface_devices[i].address;
break;
case if_number:
display_name = interface_devices[i].number;
break;
case if_name:
default:
display_name = interface_devices[i].path;
}
if (virDomainInterfaceStats (interface_devices[i].dom,
interface_devices[i].path,
&stats, sizeof stats) != 0)
continue;
if ((stats.rx_bytes != -1) && (stats.tx_bytes != -1))
submit_derive2 ("if_octets",
(derive_t) stats.rx_bytes, (derive_t) stats.tx_bytes,
interface_devices[i].dom, display_name);
if ((stats.rx_packets != -1) && (stats.tx_packets != -1))
submit_derive2 ("if_packets",
(derive_t) stats.rx_packets, (derive_t) stats.tx_packets,
interface_devices[i].dom, display_name);
if ((stats.rx_errs != -1) && (stats.tx_errs != -1))
submit_derive2 ("if_errors",
(derive_t) stats.rx_errs, (derive_t) stats.tx_errs,
interface_devices[i].dom, display_name);
if ((stats.rx_drop != -1) && (stats.tx_drop != -1))
submit_derive2 ("if_dropped",
(derive_t) stats.rx_drop, (derive_t) stats.tx_drop,
interface_devices[i].dom, display_name);
} /* for (nr_interface_devices) */
return 0;
}
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 PromiseResult CreateVirtDom(EvalContext *ctx, virConnectPtr vc, Attributes a, const Promise *pp)
{
int alloc_file = false;
char *xml_file;
const char *name;
char defaultxml[CF_MAXVARSIZE];
virDomainPtr dom;
int i;
snprintf(defaultxml, CF_MAXVARSIZE - 1,
"<domain type='test'>"
" <name>%s</name>"
" <memory>8388608</memory>"
" <currentMemory>2097152</currentMemory>"
" <vcpu>2</vcpu>" " <os>" " <type>hvm</type>" " </os>" "</domain>", pp->promiser);
for (i = 0; i < CF_MAX_CONCURRENT_ENVIRONMENTS; i++)
{
if (CF_RUNNING[i] > 0)
{
dom = virDomainLookupByID(vc, CF_RUNNING[i]);
name = virDomainGetName(dom);
if (name && strcmp(name, pp->promiser) == 0)
{
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "Found a running environment called '%s' - promise kept",
name);
return PROMISE_RESULT_NOOP;
}
virDomainFree(dom);
}
}
for (i = 0; CF_SUSPENDED[i] != NULL; i++)
{
if (strcmp(CF_SUSPENDED[i], pp->promiser) == 0)
{
Log(LOG_LEVEL_INFO, "Found an existing, but suspended, environment id = %s, called '%s'",
CF_SUSPENDED[i], CF_SUSPENDED[i]);
}
}
if(a.env.spec)
{
xml_file = xstrdup(a.env.spec);
alloc_file = true;
}
else
{
Log(LOG_LEVEL_VERBOSE, "No spec file is promised, so reverting to default settings");
xml_file = defaultxml;
}
PromiseResult result = PROMISE_RESULT_NOOP;
if ((dom = virDomainCreateXML(vc, xml_file, 0)))
{
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, pp, a, "Created a virtual domain '%s'", pp->promiser);
result = PromiseResultUpdate(result, PROMISE_RESULT_CHANGE);
if (a.env.cpus != CF_NOINT)
{
int maxcpus;
if ((maxcpus = virConnectGetMaxVcpus(vc, virConnectGetType(vc))) == -1)
{
Log(LOG_LEVEL_VERBOSE, "Can't determine the available CPU resources");
}
else
{
if (a.env.cpus > maxcpus)
{
Log(LOG_LEVEL_INFO,
"The promise to allocate %d CPUs in domain '%s' cannot be kept - only %d exist on the host",
a.env.cpus, pp->promiser, maxcpus);
}
else if (virDomainSetVcpus(dom, (unsigned int) a.env.cpus) == -1)
{
Log(LOG_LEVEL_INFO, "Unable to adjust CPU count to %d", a.env.cpus);
}
else
{
Log(LOG_LEVEL_INFO, "Verified that environment CPU count is now %d", a.env.cpus);
}
}
}
if (a.env.memory != CF_NOINT)
{
unsigned long maxmem;
if ((maxmem = virDomainGetMaxMemory(dom)) == -1)
{
Log(LOG_LEVEL_VERBOSE, "Can't determine the available CPU resources");
}
else
{
if (virDomainSetMaxMemory(dom, (unsigned long) a.env.memory) == -1)
{
Log(LOG_LEVEL_INFO, " Unable to set the memory limit to %d", a.env.memory);
}
else
{
Log(LOG_LEVEL_INFO, "Setting the memory limit to %d", a.env.memory);
}
if (virDomainSetMemory(dom, (unsigned long) a.env.memory) == -1)
{
Log(LOG_LEVEL_INFO, " Unable to set the current memory to %d", a.env.memory);
}
}
}
if (a.env.disk != CF_NOINT)
{
Log(LOG_LEVEL_VERBOSE, "Info: env_disk parameter is not currently supported on this platform");
}
virDomainFree(dom);
}
else
{
virErrorPtr vp;
vp = virGetLastError();
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a,
"Failed to create a virtual domain '%s' - check spec for errors: '%s'", pp->promiser, vp->message);
result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
Log(LOG_LEVEL_VERBOSE, "Quoted spec file: %s", xml_file);
}
if (alloc_file)
{
free(xml_file);
}
return result;
}
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;
}
Manageable::status_t
NodeWrap::ManagementMethod(uint32_t methodId, Args& args, std::string &errstr)
{
virDomainPtr domain_ptr;
cout << "Method Received: " << methodId << endl;
int ret;
switch (methodId) {
case _qmf::Node::METHOD_DOMAINDEFINEXML:
{
_qmf::ArgsNodeDomainDefineXML *io_args = (_qmf::ArgsNodeDomainDefineXML *) &args;
domain_ptr = virDomainDefineXML(conn, io_args->i_xmlDesc.c_str());
if (!domain_ptr) {
errstr = FORMAT_ERR(conn, "Error creating domain using xml description (virDomainDefineXML).", &ret);
return STATUS_USER + ret;
} else {
// Now we have to check to see if this domain is actually new or not, because it's possible that
// one already exists with this name/description and we just replaced it.. *ugh*
for (std::vector<DomainWrap*>::iterator iter = domains.begin(); iter != domains.end();) {
if (strcmp((*iter)->domain_name.c_str(), virDomainGetName(domain_ptr)) == 0) {
// We're just replacing an existing domain, however I'm pretty sure the
// old domain pointer becomes invalid at this point, so we should destroy
// the old domain reference. The other option would be to replace it and
// keep the object valid.. not sure which is better.
printf("Old domain already exists, removing it in favor of new object.");
delete(*iter);
iter = domains.erase(iter);
} else {
iter++;
}
}
DomainWrap *domain;
try {
domain = new DomainWrap(agent, this, domain_ptr, conn);
domains.push_back(domain);
io_args->o_domain = domain->GetManagementObject()->getObjectId();
} catch (int i) {
delete domain;
errstr = FORMAT_ERR(conn, "Error constructing domain object in virDomainDefineXML.", &ret);
return STATUS_USER + i;
}
return STATUS_OK;
}
}
case _qmf::Node::METHOD_STORAGEPOOLDEFINEXML:
{
_qmf::ArgsNodeStoragePoolDefineXML *io_args = (_qmf::ArgsNodeStoragePoolDefineXML *) &args;
virStoragePoolPtr pool_ptr;
pool_ptr = virStoragePoolDefineXML (conn, io_args->i_xmlDesc.c_str(), 0);
if (pool_ptr == NULL) {
errstr = FORMAT_ERR(conn, "Error defining storage pool using xml description (virStoragePoolDefineXML).", &ret);
return STATUS_USER + ret;
}
PoolWrap *pool;
try {
pool = new PoolWrap(agent, this, pool_ptr, conn);
pools.push_back(pool);
io_args->o_pool = pool->GetManagementObject()->getObjectId();
} catch (int i) {
delete pool;
errstr = FORMAT_ERR(conn, "Error constructing pool object in virStoragePoolDefineXML.", &ret);
return STATUS_USER + i;
}
return STATUS_OK;
}
case _qmf::Node::METHOD_STORAGEPOOLCREATEXML:
{
_qmf::ArgsNodeStoragePoolCreateXML *io_args = (_qmf::ArgsNodeStoragePoolCreateXML *) &args;
virStoragePoolPtr pool_ptr;
pool_ptr = virStoragePoolCreateXML (conn, io_args->i_xmlDesc.c_str(), 0);
if (pool_ptr == NULL) {
errstr = FORMAT_ERR(conn, "Error creating storage pool using xml description (virStoragePoolCreateXML).", &ret);
return STATUS_USER + ret;
}
PoolWrap *pool;
try {
pool = new PoolWrap(agent, this, pool_ptr, conn);
pools.push_back(pool);
io_args->o_pool = pool->GetManagementObject()->getObjectId();
} catch (int i) {
delete pool;
errstr = FORMAT_ERR(conn, "Error constructing pool object in virStoragePoolCreateXML.", &ret);
return STATUS_USER + i;
}
return STATUS_OK;
}
case _qmf::Node::METHOD_FINDSTORAGEPOOLSOURCES:
{
_qmf::ArgsNodeFindStoragePoolSources *io_args = (_qmf::ArgsNodeFindStoragePoolSources *) &args;
char *xml_result;
xml_result = virConnectFindStoragePoolSources(conn, io_args->i_type.c_str(), io_args->i_srcSpec.c_str(), 0);
if (xml_result == NULL) {
errstr = FORMAT_ERR(conn, "Error creating storage pool using xml description (virStoragePoolCreateXML).", &ret);
return STATUS_USER + ret;
}
io_args->o_xmlDesc = xml_result;
free(xml_result);
return STATUS_OK;
}
}
return STATUS_NOT_IMPLEMENTED;
}
}
case EVENT_DMAR_ACCESS:
break;
case EVENT_VDEV_HONEYPOT:
break;
}
return ret;
}
static int myDomainEventCallback2(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainPtr dom,
int event,
int detail,
void *opaque ATTRIBUTE_UNUSED)
{
printf("NOVA EVENT: Domain %s(%d): %s %s\n", virDomainGetName(dom),
virDomainGetID(dom), eventToString(event),
eventDetailToString(event, detail));
return 0;
}
static int myDomainEventRebootCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainPtr dom,
void *opaque ATTRIBUTE_UNUSED)
{
printf("NOVA EVENT: Domain %s(%d) rebooted\n", virDomainGetName(dom),
virDomainGetID(dom));
return 0;
}
case VIR_DOMAIN_EVENT_STOPPED_FROM_SNAPSHOT:
ret = "Snapshot";
break;
}
break;
}
return ret;
}
static int myDomainEventCallback1(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainPtr dom,
int event,
int detail,
void *opaque ATTRIBUTE_UNUSED)
{
printf("%s EVENT: Domain %s(%d) %s %s\n", __func__, virDomainGetName(dom),
virDomainGetID(dom), eventToString(event),
eventDetailToString(event, detail));
return 0;
}
static int myDomainEventCallback2(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainPtr dom,
int event,
int detail,
void *opaque ATTRIBUTE_UNUSED)
{
printf("%s EVENT: Domain %s(%d) %s %s\n", __func__, virDomainGetName(dom),
virDomainGetID(dom), eventToString(event),
eventDetailToString(event, detail));
return 0;
