static inline int
wait_domain(const char *vm_name, virConnectPtr vp, int timeout)
{
int tries = 0;
int response = 1;
int ret;
virDomainPtr vdp;
virDomainInfo vdi;
int uuid_check;
uuid_check = is_uuid(vm_name);
if (uuid_check) {
vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name);
} else {
vdp = virDomainLookupByName(vp, vm_name);
}
if (!vdp)
return 0;
/* Check domain liveliness. If the domain is still here,
we return failure, and the client must then retry */
/* XXX On the xen 3.0.4 API, we will be able to guarantee
synchronous virDomainDestroy, so this check will not
be necessary */
do {
if (++tries > timeout)
break;
sleep(1);
if (uuid_check) {
vdp = virDomainLookupByUUIDString(vp, (const char *)vm_name);
} else {
vdp = virDomainLookupByName(vp, vm_name);
}
if (!vdp) {
dbg_printf(2, "Domain no longer exists\n");
response = 0;
break;
}
memset(&vdi, 0, sizeof(vdi));
ret = virDomainGetInfo(vdp, &vdi);
virDomainFree(vdp);
if (ret < 0)
continue;
if (vdi.state == VIR_DOMAIN_SHUTOFF) {
dbg_printf(2, "Domain has been shut off\n");
response = 0;
break;
}
dbg_printf(4, "Domain still exists (state %d) after %d seconds\n",
vdi.state, tries);
} while (1);
return response;
}
bool
VirshType::ResumeFromSoftSuspend(void)
{
vmprintf(D_FULLDEBUG, "Inside VirshType::ResumeFromSoftSuspend\n");
if( (m_configfile.Length() == 0)) {
return false;
}
if( m_is_soft_suspended ) {
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(m_libvirt_connection, m_vm_name.Value());
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(m_libvirt_connection);
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", m_vm_name.Value(), (err ? err->message : "No reason found"));
return false;
}
priv = set_root_priv();
int result = virDomainResume(dom);
virDomainFree(dom);
set_priv(priv);
if( result != 0 ) {
// unpause failed.
vmprintf(D_ALWAYS, "Unpausing VM failed in "
"VirshType::ResumeFromSoftSuspend\n");
return false;
}
m_is_soft_suspended = false;
}
return true;
}
static int DeleteVirt(virConnectPtr vc, char *uri, Attributes a, Promise *pp)
{
virDomainPtr dom;
int ret = true;
dom = virDomainLookupByName(vc, pp->promiser);
if (dom)
{
if (virDomainDestroy(dom) == -1)
{
cfPS(cf_verbose, CF_FAIL, "", pp, a, " !! Failed to delete virtual domain \"%s\"\n", pp->promiser);
ret = false;
}
else
{
cfPS(cf_verbose, CF_CHG, "", pp, a, " -> Deleted virtual domain \"%s\"\n", pp->promiser);
}
virDomainFree(dom);
}
else
{
cfPS(cf_verbose, CF_NOP, "", pp, a, " -> No such virtual domain called \"%s\" - promise kept\n", pp->promiser);
}
return ret;
}
int main(int argc, char *argv[])
{
virConnectPtr conn;
int i;
int numDomains;
int *activeDomains;
virDomainPtr dom;
conn = virConnectOpen("qemu:///system");
if (conn == NULL) {
fprintf(stderr, "Failed to open connection to qemu:///system\n");
}
numDomains = virConnectNumOfDomains(conn);
activeDomains = malloc(sizeof(int) * numDomains);
numDomains = virConnectListDomains(conn, activeDomains, numDomains);
printf("Active domain IDs:\n");
for (i = 0 ; i < numDomains ; i++) {
printf(" %d\n", activeDomains[i]);
}
printf("Terminating Domain\n");
free(activeDomains);
int domainName = "sudip";
dom = virDomainLookupByName(conn,domainName);
virDomainDestroy(dom);
virDomainFree(dom);
printf("Domain sudip terminated successfully\n");
if (conn != NULL)
virConnectClose(conn);
return 0;
}
void SnapshotActionDialog::setDomainSnapshots()
{
if ( nullptr==ptr_ConnPtr || nullptr==*ptr_ConnPtr ) {
emit ptrIsNull();
return;
};
domain = virDomainLookupByName(
*ptr_ConnPtr, domName.toUtf8().data());
int namesLen = virDomainSnapshotNum(
domain, VIR_DOMAIN_SNAPSHOT_LIST_ROOTS);
if ( namesLen>0 ) {
char *names;
int ret = virDomainSnapshotListNames(
domain,
&names,
namesLen,
VIR_DOMAIN_SNAPSHOT_LIST_ROOTS);
if ( ret>0 ) {
for (int i = 0; i<ret; i++) {
addSnapshotChild(
i,
snapshotTree->rootIndex(),
(&names)[i]);
};
};
};
}
static PromiseResult DeleteVirt(EvalContext *ctx, virConnectPtr vc, Attributes a, const Promise *pp)
{
virDomainPtr dom;
dom = virDomainLookupByName(vc, pp->promiser);
PromiseResult result = PROMISE_RESULT_NOOP;
if (dom)
{
if (virDomainDestroy(dom) == -1)
{
cfPS(ctx, LOG_LEVEL_ERR, PROMISE_RESULT_FAIL, pp, a, "Failed to delete virtual domain '%s'", pp->promiser);
result = PromiseResultUpdate(result, PROMISE_RESULT_FAIL);
}
else
{
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, pp, a, "Deleted virtual domain '%s'", pp->promiser);
result = PromiseResultUpdate(result, PROMISE_RESULT_CHANGE);
}
virDomainFree(dom);
}
else
{
cfPS(ctx, LOG_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, pp, a, "No such virtual domain called '%s' - promise kept", pp->promiser);
}
return result;
}
void SetDisksDataThread::run()
{
if ( nullptr==ptr_ConnPtr || nullptr==*ptr_ConnPtr ) {
emit ptrIsNull();
return;
};
// NOTE: currConnName == domainName
virDomainPtr domain = virDomainLookupByName(
*ptr_ConnPtr, currConnName.toUtf8().data());
if ( nullptr!=domain ) {
char *xmlDesc = virDomainGetXMLDesc(domain, 0);
virDomainFree(domain);
if ( nullptr!=xmlDesc ) {
QDomDocument doc;
doc.setContent(QString(xmlDesc));
free(xmlDesc);
QDomElement _devices = doc
.firstChildElement("domain")
.firstChildElement("devices");
QDomElement _disk = _devices
.firstChildElement("disk");
while ( !_disk.isNull() ) {
emit diskData(_disk);
_disk = _disk.nextSiblingElement("disk");
};
};
} else
sendConnErrors();
}
static int
libvirt_status(const char *vm_name, void *priv)
{
struct libvirt_info *info = (struct libvirt_info *)priv;
virDomainPtr vdp;
virDomainInfo vdi;
int ret = 0;
dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
VALIDATE(info);
if (is_uuid(vm_name)) {
vdp = virDomainLookupByUUIDString(info->vp,
(const char *)vm_name);
} else {
vdp = virDomainLookupByName(info->vp, vm_name);
}
if (!vdp || ((virDomainGetInfo(vdp, &vdi) == 0) &&
(vdi.state == VIR_DOMAIN_SHUTOFF))) {
ret = RESP_OFF;
}
if (vdp)
virDomainFree(vdp);
return ret;
}
int libvirt_domain_save(char * name, int idonweb)
{
virDomainPtr domain;
domain = virDomainLookupByName(g_conn, name);
if (domain == NULL) {
logerror(_("%s: connect domain by name(%s) error.\n"),
__func__, name);
return -1;
}
virDomainInfo info;
if (virDomainGetInfo(dom, &info) < 0) {
logprintfl(SCERROR, "Cannot check guest state\n");
return -3;
}
if (info.state == VIR_DOMAIN_SHUTOFF) {
logprintfl(SCERROR, "Not saving guest that isn't running\n");
return -4;
}
const char *filename = "";
if (virDomainSave(dom, filename) < 0) {
fprintf(stderr, "Unable to save guest to %s\n", filename);
}
fprintf(stdout, "Guest state saved to %s\n", filename);
virConnectClose(conn);
return 0;
}
int VM_Controller::get_image_config_fd_by_name(std::string vm_name){
virDomainPtr dom = virDomainLookupByName(_conn, vm_name.c_str());
if(dom == NULL){
return -1;
}
char *domain_xml = virDomainGetXMLDesc(dom, VIR_DOMAIN_XML_SECURE);
virDomainFree(dom);
std::string config_file = _make_tmp_config_file_name(vm_name);
int fd = open(config_file.c_str(), O_WRONLY|O_CREAT);
int filesize = strlen(domain_xml);
int write_count = 0;
while(write_count < filesize){
int once_write_count = write(fd, domain_xml, filesize);
if(once_write_count < 0){
LOG_ERROR("write error");
close(fd);
return -1;
}
write_count += once_write_count;
}
close(fd);
fd = open(config_file.c_str(), O_RDONLY);
return fd;
}
static int dominfo_from_dom(const char *uri,
const char *domain,
struct domain **d)
{
virConnectPtr conn = NULL;
virDomainPtr dom = NULL;
int ret = 0;
conn = virConnectOpen(uri);
if (conn == NULL) {
printf("Unable to connect to libvirt\n");
goto out;
}
dom = virDomainLookupByName(conn, domain);
if (dom == NULL) {
printf("Unable to find domain `%s'\n", domain);
goto out;
}
ret = get_dominfo(dom, d);
out:
virDomainFree(dom);
virConnectClose(conn);
return ret;
}
// read /var/lib/libvirt/dnsmasq/default.leases to get ip
// domain must use DHCP
std::string VM_Controller::get_vm_ip_by_name(std::string domain_name){
LOG_INFO(domain_name);
Json::Value j;
virDomainPtr dom = virDomainLookupByName(_conn, domain_name.c_str());
if(dom == NULL){
Json::Value j;
j["status"] = "no such domain";
return j.toStyledString();
}
std::string mac = _get_vm_mac(dom);
LOG_INFO(mac);
virDomainFree(dom);
std::ifstream leases("/var/lib/libvirt/dnsmasq/default.leases");
while(!leases.eof()){
std::string line;
std::getline(leases, line);
DEBUG(line);
if(line == "")
break;
std::vector<std::string> v;
Tools::split(line, v, ' ');
if(v[1] == mac){
j["ip"] = v[2];
j["status"] = "ok";
return j.toStyledString();
}
}
leases.close();
j["status"] = "Could not find ip for the mac address";
return j.toStyledString();
}
bool
VirshType::killVMFast(const char* vmname, virConnectPtr libvirt_con)
{
vmprintf(D_FULLDEBUG, "Inside VirshType::killVMFast\n");
if( !vmname || (vmname[0] == '\0') ) {
return false;
}
priv_state priv = set_root_priv();
virDomainPtr dom = virDomainLookupByName(libvirt_con, vmname);
set_priv(priv);
if(dom == NULL)
{
virErrorPtr err = virConnGetLastError(libvirt_con);
if (err && err->code != VIR_ERR_NO_DOMAIN)
{
vmprintf(D_ALWAYS, "Error finding domain %s: %s\n", vmname, (err ? err->message : "No reason found"));
return false;
}
else
{
return true;
}
}
priv = set_root_priv();
bool ret = (virDomainDestroy(dom) == 0);
virDomainFree(dom);
set_priv(priv);
return ret;
}
static int DeleteVirt(EvalContext *ctx, virConnectPtr vc, Attributes a, Promise *pp)
{
virDomainPtr dom;
int ret = true;
dom = virDomainLookupByName(vc, pp->promiser);
if (dom)
{
if (virDomainDestroy(dom) == -1)
{
cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_FAIL, "", pp, a, " !! Failed to delete virtual domain \"%s\"\n", pp->promiser);
ret = false;
}
else
{
cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_CHANGE, "", pp, a, " -> Deleted virtual domain \"%s\"\n", pp->promiser);
}
virDomainFree(dom);
}
else
{
cfPS(ctx, OUTPUT_LEVEL_VERBOSE, PROMISE_RESULT_NOOP, "", pp, a, " -> No such virtual domain called \"%s\" - promise kept\n", pp->promiser);
}
return ret;
}
static int
mymain(void)
{
struct metadataTest test;
int ret = EXIT_SUCCESS;
if (!(test.conn = virConnectOpen("test:///default")))
return EXIT_FAILURE;
if (!(test.dom = virDomainLookupByName(test.conn, "test"))) {
virConnectClose(test.conn);
return EXIT_FAILURE;
}
virtTestQuiesceLibvirtErrors(false);
if (virtTestRun("Assign metadata ", testAssignMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Rewrite Metadata ", testRewriteMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Erase metadata ", testEraseMetadata, &test) < 0)
ret = EXIT_FAILURE;
virDomainFree(test.dom);
virConnectClose(test.conn);
return ret;
}
static int __domain_op_simple(char * name, int op)
{
if (g_conn == NULL)
return -1;
virDomainPtr domain;
domain = virDomainLookupByName(g_conn, name);
if (domain == NULL) {
logerror(_("%s: connect domain by name(%s) error. "
"domain may not exist\n"),
__func__, name);
return -1;
}
int ret;
if (op == __DOMAIN_OP_STOP)
ret = virDomainShutdown(domain);
else if (op == __DOMAIN_OP_STOP_FORCE)
ret = virDomainDestroy(domain);
else if (op == __DOMAIN_OP_REBOOT)
ret = virDomainReboot(domain, 0);
else
ret = -1;
virDomainFree(domain);
return ret;
}
long long VM_Controller::get_image_size_by_name_in_ll(std::string vm_name){
virDomainPtr dom = virDomainLookupByName(_conn, vm_name.c_str());
if(dom == NULL){
return -1ll;
}
else
return _get_vm_image_size(dom);
}
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 int
suspend_and_resume(virConnectPtr conn,
const char *dom_name,
unsigned int seconds)
{
int ret = -1;
virDomainPtr dom;
virDomainInfo dom_info;
if (!(dom = virDomainLookupByName(conn, dom_name))) {
ERROR("Unable to find domain '%s'", dom_name);
goto cleanup;
}
if (virDomainGetInfo(dom, &dom_info) < 0) {
ERROR("Unable to get domain info");
goto cleanup;
}
DEBUG("Domain state %d", dom_info.state);
switch (dom_info.state) {
case VIR_DOMAIN_NOSTATE:
case VIR_DOMAIN_RUNNING:
case VIR_DOMAIN_BLOCKED:
/* In these states the domain can be suspended */
DEBUG("Suspending domain");
if (virDomainSuspend(dom) < 0) {
ERROR("Unable to suspend domain");
goto cleanup;
}
DEBUG("Domain suspended. Entering sleep for %u seconds.", seconds);
sleep(seconds);
DEBUG("Sleeping done. Resuming the domain.");
if (virDomainResume(dom) < 0) {
ERROR("Unable to resume domain");
goto cleanup;
}
break;
default:
/* In all other states domain can't be suspended */
ERROR("Domain is not in a state where it can be suspended: %d",
dom_info.state);
goto cleanup;
}
ret = 0;
cleanup:
if (dom)
virDomainFree(dom);
return ret;
}
int VM_Controller::get_image_fd_by_name(std::string vm_name){
virDomainPtr dom = virDomainLookupByName(_conn, vm_name.c_str());
if(dom == NULL){
return -1;
}
std::string img_path = _get_vm_image_path(dom);
virDomainFree(dom);
int fd = open(img_path.c_str(), O_RDONLY);
return fd;
}
static int
doTerminateInstance( struct nc_state_t *nc,
ncMetadata *meta,
char *instanceId,
int *shutdownState,
int *previousState)
{
ncInstance *instance, *vninstance;
virConnectPtr *conn;
int err;
sem_p (inst_sem);
instance = find_instance(&global_instances, instanceId);
sem_v (inst_sem);
if (instance == NULL)
return NOT_FOUND;
/* try stopping the KVM domain */
conn = check_hypervisor_conn();
if (conn) {
sem_p(hyp_sem);
virDomainPtr dom = virDomainLookupByName(*conn, instanceId);
sem_v(hyp_sem);
if (dom) {
/* also protect 'destroy' commands, just in case */
sem_p (hyp_sem);
err = virDomainDestroy (dom);
sem_v (hyp_sem);
if (err==0) {
logprintfl (EUCAINFO, "destroyed domain for instance %s\n", instanceId);
}
sem_p(hyp_sem);
virDomainFree(dom); /* necessary? */
sem_v(hyp_sem);
} else {
if (instance->state != BOOTING)
logprintfl (EUCAWARN, "warning: domain %s to be terminated not running on hypervisor\n", instanceId);
}
}
/* change the state and let the monitoring_thread clean up state */
sem_p (inst_sem);
if (instance->state==BOOTING) {
change_state (instance, CANCELED);
} else {
change_state (instance, SHUTOFF);
}
sem_v (inst_sem);
*previousState = instance->stateCode;
*shutdownState = instance->stateCode;
return OK;
}
int libvirt_domain_active(char * name)
{
if (g_conn == NULL)
return 0;
virDomainPtr domain = virDomainLookupByName(g_conn, name);
int active = domain ? 1 : 0;
if (domain)
virDomainFree(domain);
return active;
}
std::string VM_Controller::get_vm_detail_by_name(std::string domain_name){
Json::Value j;
virDomainPtr dom = virDomainLookupByName(_conn, domain_name.c_str());
if(dom == NULL){
Json::Value j;
j["status"] = "no such domain";
return j.toStyledString();
}
std::string res = get_vm_detail(dom);
virDomainFree(dom);
return res;
}
int find_a_domain(virConnectPtr conn, char *domain){
virDomainPtr dom;
// Search for a virtual machine (aka domain) on the hypervisor
// connection
dom = virDomainLookupByName(conn, domain);
if (!dom) {
return 0;
} else {
return virDomainGetID(dom);
}
}
static void
add_domains_by_name (virConnectPtr conn, char **names, size_t n)
{
size_t i;
virDomainPtr dom;
for (i = 0; i < n; ++i) {
dom = virDomainLookupByName (conn, names[i]);
if (dom) /* transient errors are possible here, ignore them */
add_domain (dom);
}
}
timearg GetVirtInfo::GetCpuTime(QString VM_name)
{
virDomainPtr vm_ptr = virDomainLookupByName(conn, qPrintable(VM_name));
if(vm_ptr == NULL) {
printf("error finding domain\n");
virConnectClose(conn);
exit(1);
}
virDomainInfo info_s;
struct timeval real_time_s;
timearg return_arg;
if(virDomainGetInfo(vm_ptr, &info_s) != 0) {
printf("error get domain info\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
if(gettimeofday(&real_time_s, NULL) == -1) {
printf("error get time of day\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
return_arg.info = info_s;
return_arg.real_time = real_time_s;
virDomainFree(vm_ptr);
return return_arg;
/* sleep(1);
if(virDomainGetInfo(vm_ptr, &info_e) !=0) {
printf("error get domain info\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
if(gettimeofday(&real_time_e, NULL) == -1) {
printf("error get time of day\n");
virDomainFree(vm_ptr);
virConnectClose(conn);
exit(1);
}
cpu_diff = (info_e.cpuTime - info_s.cpuTime) / 1000;
real_diff = 1000000 * (real_time_e.tv_sec - real_time_s.tv_sec) +(real_time_e.tv_usec - real_time_s.tv_usec);
virDomainFree(vm_ptr);
usage = cpu_diff / (float) (real_diff);
return usage*100;*/
}
static int
libvirt_off(const char *vm_name, const char *src,
uint32_t seqno, void *priv)
{
struct libvirt_info *info = (struct libvirt_info *)priv;
virDomainPtr vdp;
virDomainInfo vdi;
int ret = -1;
dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
VALIDATE(info);
if (is_uuid(vm_name)) {
vdp = virDomainLookupByUUIDString(info->vp,
(const char *)vm_name);
} else {
vdp = virDomainLookupByName(info->vp, vm_name);
}
if (!vdp) {
dbg_printf(2, "Nothing to do - domain does not exist\n");
return 1;
}
if (((virDomainGetInfo(vdp, &vdi) == 0) &&
(vdi.state == VIR_DOMAIN_SHUTOFF))) {
dbg_printf(2, "Nothing to do - domain is off\n");
virDomainFree(vdp);
return 0;
}
syslog(LOG_NOTICE, "Destroying domain %s\n", vm_name);
dbg_printf(2, "[OFF] Calling virDomainDestroy\n");
ret = virDomainDestroy(vdp);
if (ret < 0) {
syslog(LOG_NOTICE, "Failed to destroy domain: %d\n", ret);
printf("virDomainDestroy() failed: %d\n", ret);
return 1;
}
if (ret) {
syslog(LOG_NOTICE,
"Domain %s still exists; fencing failed\n",
vm_name);
printf("Domain %s still exists; fencing failed\n", vm_name);
return 1;
}
return 0;
}
static int
libvirt_on(const char *vm_name, const char *src,
uint32_t seqno, void *priv)
{
struct libvirt_info *info = (struct libvirt_info *)priv;
virDomainPtr vdp;
virDomainInfo vdi;
int ret = -1;
dbg_printf(5, "%s %s\n", __FUNCTION__, vm_name);
VALIDATE(info);
if (is_uuid(vm_name)) {
vdp = virDomainLookupByUUIDString(info->vp,
(const char *)vm_name);
} else {
vdp = virDomainLookupByName(info->vp, vm_name);
}
if (vdp &&
((virDomainGetInfo(vdp, &vdi) == 0) &&
(vdi.state != VIR_DOMAIN_SHUTOFF))) {
dbg_printf(2, "Nothing to do - domain is running\n");
if (vdp)
virDomainFree(vdp);
return 0;
}
syslog(LOG_NOTICE, "Starting domain %s\n", vm_name);
dbg_printf(2, "[ON] Calling virDomainCreate\n");
ret = virDomainCreate(vdp);
if (ret < 0) {
syslog(LOG_NOTICE, "Failed to start domain: %d\n", ret);
printf("virDomainCreate() failed: %d\n", ret);
return 1;
}
if (ret) {
syslog(LOG_NOTICE,
"Domain %s did not start\n",
vm_name);
printf("Domain %s did not start\n", vm_name);
return 1;
}
syslog(LOG_NOTICE, "Domain %s started\n", vm_name);
return 0;
}
static int
doAttachSystemDisk ( struct nc_state_t *nc,
ncMetadata *meta,
char *instanceId,
char *isoPath)
{
ncInstance *instance;
virConnectPtr *conn;
virDomainPtr dom = NULL;
char xml[MAX_PATH]={'\0'};
int err;
snprintf (xml, sizeof(xml), "<disk type='block' device='cdrom'><source dev='%s'/><target dev='hdc' bus='ide'/><readonly/></disk>", isoPath);
//logprintfl(EUCAINFO, "doAttachSystemDisk(): founded %s [%s---%s---%d]\n", instanceId,__FILE__, __FUNCTION__, __LINE__);
sem_p(inst_sem);
instance = find_instance(&global_instances, instanceId);
sem_v(inst_sem);
if (instance == NULL || (instance->state != RUNNING&& instance->state != BLOCKED&& instance->state !=PAUSED)) {
logprintfl(EUCAINFO, "doAttachSystemDisk(): found %s failed or instance->state!=RUNNING||BLOCKED||PAUSED [file:%s---line:%d]\n", instanceId, __FILE__, __LINE__);
return NOT_FOUND;
}
conn = check_hypervisor_conn();
if (conn) {
/*
snprintf(cmd, sizeof(cmd), "virsh attach-disk %s %s hdc --type cdrom --mode readonly",instanceId, isoPath);
logprintfl(EUCAINFO, "xiongm: cmd=%s [%s---%s---%d]\n",cmd, __FILE__, __FUNCTION__, __LINE__);
system(cmd);
*/
dom = NULL;
sem_p(hyp_sem);
dom = virDomainLookupByName(*conn, instanceId);
sem_v(hyp_sem);
if (dom) {
sem_p (hyp_sem);
err = virDomainAttachDevice (dom, xml);
sem_v (hyp_sem);
if(err != 0) {
logprintfl(EUCAINFO,"virDomainAttachDevice failed. err=%d\n",err);
return 1;
}
}
logprintfl(EUCAINFO,"doAttachSystemDisk success.\n");
return 0;
}
else {
logprintfl(EUCAINFO, "doAttachSystemDisk(): no connect hypervisior [file:%s---line:%d]\n",__FILE__, __LINE__);
return 1;
}
}
static int
mymain(void)
{
struct metadataTest test;
int ret = EXIT_SUCCESS;
if (!(test.conn = virConnectOpen("test:///default")))
return EXIT_FAILURE;
if (!(test.dom = virDomainLookupByName(test.conn, "test"))) {
virConnectClose(test.conn);
return EXIT_FAILURE;
}
virtTestQuiesceLibvirtErrors(false);
if (virtTestRun("Assign metadata ", testAssignMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Rewrite Metadata ", testRewriteMetadata, &test) < 0)
ret = EXIT_FAILURE;
if (virtTestRun("Erase metadata ", testEraseMetadata, &test) < 0)
ret = EXIT_FAILURE;
TEST_TITLE("1", "qwert");
TEST_TITLE("2", NULL);
TEST_TITLE("3", "blah");
TEST_TITLE_FAIL("4", "qwe\nrt");
TEST_TITLE("5", "");
TEST_TITLE_FAIL("6", "qwert\n");
TEST_TITLE_FAIL("7", "\n");
TEST_DESCR("1", "qwert\nqwert");
TEST_DESCR("2", NULL);
TEST_DESCR("3", "qwert");
TEST_DESCR("4", "\n");
TEST_DESCR("5", "");
virDomainFree(test.dom);
virConnectClose(test.conn);
return ret;
}
