VolumeWrap::VolumeWrap(PoolWrap *parent,
virStorageVolPtr volume_ptr,
virConnectPtr connect):
PackageOwner<PoolWrap::PackageDefinition>(parent),
ManagedObject(package().data_Volume),
_volume_ptr(volume_ptr), _conn(connect),
_lvm_name(""), _has_lvm_child(false),
_wrap_parent(parent)
{
const char *volume_key;
char *volume_path;
const char *volume_name;
volume_key = virStorageVolGetKey(_volume_ptr);
if (volume_key == NULL) {
REPORT_ERR(_conn, "Error getting storage volume key\n");
throw 1;
}
_volume_key = volume_key;
volume_path = virStorageVolGetPath(_volume_ptr);
if (volume_path == NULL) {
REPORT_ERR(_conn, "Error getting volume path\n");
throw 1;
}
_volume_path = volume_path;
volume_name = virStorageVolGetName(_volume_ptr);
if (volume_name == NULL) {
REPORT_ERR(_conn, "Error getting volume name\n");
throw 1;
}
_volume_name = volume_name;
_data.setProperty("key", _volume_key);
_data.setProperty("path", _volume_path);
_data.setProperty("name", _volume_name);
_data.setProperty("childLVMName", _lvm_name);
_data.setProperty("storagePool", parent->objectID());
// Set defaults
_data.setProperty("capacity", (uint64_t)0);
_data.setProperty("allocation", (uint64_t)0);
addData(_data);
printf("done\n");
}
const gchar *gvir_storage_vol_get_path(GVirStorageVol *vol, GError **error)
{
const char *path;
g_return_val_if_fail(GVIR_IS_STORAGE_VOL(vol), NULL);
g_return_val_if_fail(error == NULL || *error == NULL, NULL);
if (!(path = virStorageVolGetPath(vol->priv->handle))) {
gvir_set_error(error, GVIR_STORAGE_VOL_ERROR, 0,
"Failed to get storage_vol path on %p",
vol->priv->handle);
return NULL;
}
return path;
}
Result StorageVolControlThread::getAllStorageVolList()
{
Result result;
result.name = QString("%1_%2").arg(task.srcConName).arg(currPoolName);
QStringList storageVolList;
if (currStoragePool!=NULL) {
virStoragePoolFree(currStoragePool);
currStoragePool = NULL;
};
currStoragePool = virStoragePoolLookupByName(
*task.srcConnPtr, currPoolName.toUtf8().data());
if ( currStoragePool!=NULL && keep_alive ) {
virStorageVolPtr *storageVol = NULL;
// flags: extra flags; not used yet, so callers should always pass 0
unsigned int flags = 0;
int ret = virStoragePoolListAllVolumes(
currStoragePool, &storageVol, flags);
if ( ret<0 ) {
result.err = sendConnErrors();
result.result = false;
result.msg = storageVolList;
return result;
};
// therefore correctly to use for() command, because storageVol[0] can not exist.
for (int i = 0; i < ret; i++) {
QString type, capacity, allocation;
virStorageVolInfo info;
if ( virStorageVolGetInfo(storageVol[i], &info)+1 ) {
switch (info.type) {
case VIR_STORAGE_VOL_FILE:
type.append("file");
break;
case VIR_STORAGE_VOL_BLOCK:
type.append("block");
break;
case VIR_STORAGE_VOL_DIR:
type.append("dir");
break;
case VIR_STORAGE_VOL_NETWORK:
type.append("net");
break;
default:
type.append("-");
break;
};
allocation.append(QString("%1").arg(info.allocation));
capacity.append(QString("%1").arg(info.capacity));
} else {
sendConnErrors();
type.append("-");
allocation.append("-");
capacity.append("-");
};
QStringList currentAttr;
currentAttr<< QString::fromUtf8( virStorageVolGetName(storageVol[i]) )
<< QString::fromUtf8( virStorageVolGetPath(storageVol[i]) )
<< QString( type )
<< QString( allocation )
<< QString( capacity );;
storageVolList.append(currentAttr);
//qDebug()<<currentAttr<<"Volume";
virStorageVolFree(storageVol[i]);
};
free(storageVol);
} else
result.err = sendConnErrors();
result.result = true;
result.msg = storageVolList;
return result;
}
void
VolumeWrap::checkForLVMPool()
{
char *real_path = NULL;
const char *pool_sources_xml;
pool_sources_xml = _wrap_parent->getPoolSourcesXml();
if (pool_sources_xml) {
xmlDocPtr doc;
xmlNodePtr cur;
doc = xmlParseMemory(pool_sources_xml, strlen(pool_sources_xml));
if (doc == NULL ) {
return;
}
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
xmlFreeDoc(doc);
return;
}
xmlChar *path = NULL;
xmlChar *name = NULL;
cur = cur->xmlChildrenNode;
while (cur != NULL) {
xmlNodePtr source;
if ((!xmlStrcmp(cur->name, (const xmlChar *) "source"))) {
source = cur->xmlChildrenNode;
while (source != NULL) {
if ((!xmlStrcmp(source->name, (const xmlChar *) "device"))) {
path = xmlGetProp(source, (const xmlChar *) "path");
}
if ((!xmlStrcmp(source->name, (const xmlChar *) "name"))) {
name = xmlNodeListGetString(doc, source->xmlChildrenNode, 1);
}
source = source->next;
}
if (name && path) {
virStorageVolPtr vol;
printf ("xml returned device name %s, path %s; volume path is %s\n", name, path, _volume_path.c_str());
vol = virStorageVolLookupByPath(_conn, (char *) path);
if (vol != NULL) {
real_path = virStorageVolGetPath(vol);
if (real_path && strcmp(real_path, _volume_path.c_str()) == 0) {
printf ("found matching storage volume associated with pool!\n");
_lvm_name.assign((char *) name);
_has_lvm_child = true;
}
}
xmlFree(path);
xmlFree(name);
path = NULL;
name = NULL;
}
}
cur = cur->next;
}
xmlFreeDoc(doc);
}
}
static bool
cmdVolCreateAs(vshControl *ctl, const vshCmd *cmd)
{
virStoragePoolPtr pool;
virStorageVolPtr vol;
char *xml;
const char *name, *capacityStr = NULL, *allocationStr = NULL, *format = NULL;
const char *snapshotStrVol = NULL, *snapshotStrFormat = NULL;
unsigned long long capacity, allocation = 0;
virBuffer buf = VIR_BUFFER_INITIALIZER;
if (!vshConnectionUsability(ctl, ctl->conn))
return false;
if (!(pool = vshCommandOptPoolBy(ctl, cmd, "pool", NULL,
VSH_BYNAME)))
return false;
if (vshCommandOptString(cmd, "name", &name) <= 0)
goto cleanup;
if (vshCommandOptString(cmd, "capacity", &capacityStr) <= 0)
goto cleanup;
if (vshVolSize(capacityStr, &capacity) < 0) {
vshError(ctl, _("Malformed size %s"), capacityStr);
goto cleanup;
}
if (vshCommandOptString(cmd, "allocation", &allocationStr) > 0 &&
vshVolSize(allocationStr, &allocation) < 0) {
vshError(ctl, _("Malformed size %s"), allocationStr);
goto cleanup;
}
if (vshCommandOptString(cmd, "format", &format) < 0 ||
vshCommandOptString(cmd, "backing-vol", &snapshotStrVol) < 0 ||
vshCommandOptString(cmd, "backing-vol-format",
&snapshotStrFormat) < 0) {
vshError(ctl, "%s", _("missing argument"));
goto cleanup;
}
virBufferAddLit(&buf, "<volume>\n");
virBufferAsprintf(&buf, " <name>%s</name>\n", name);
virBufferAsprintf(&buf, " <capacity>%llu</capacity>\n", capacity);
if (allocationStr)
virBufferAsprintf(&buf, " <allocation>%llu</allocation>\n", allocation);
if (format) {
virBufferAddLit(&buf, " <target>\n");
virBufferAsprintf(&buf, " <format type='%s'/>\n",format);
virBufferAddLit(&buf, " </target>\n");
}
/* Convert the snapshot parameters into backingStore XML */
if (snapshotStrVol) {
/* Lookup snapshot backing volume. Try the backing-vol
* parameter as a name */
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Look up backing store volume '%s' as name\n",
cmd->def->name, snapshotStrVol);
virStorageVolPtr snapVol = virStorageVolLookupByName(pool, snapshotStrVol);
if (snapVol)
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Backing store volume found using '%s' as name\n",
cmd->def->name, snapshotStrVol);
if (snapVol == NULL) {
/* Snapshot backing volume not found by name. Try the
* backing-vol parameter as a key */
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Look up backing store volume '%s' as key\n",
cmd->def->name, snapshotStrVol);
snapVol = virStorageVolLookupByKey(ctl->conn, snapshotStrVol);
if (snapVol)
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Backing store volume found using '%s' as key\n",
cmd->def->name, snapshotStrVol);
}
if (snapVol == NULL) {
/* Snapshot backing volume not found by key. Try the
* backing-vol parameter as a path */
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Look up backing store volume '%s' as path\n",
cmd->def->name, snapshotStrVol);
snapVol = virStorageVolLookupByPath(ctl->conn, snapshotStrVol);
if (snapVol)
vshDebug(ctl, VSH_ERR_DEBUG,
"%s: Backing store volume found using '%s' as path\n",
cmd->def->name, snapshotStrVol);
}
if (snapVol == NULL) {
vshError(ctl, _("failed to get vol '%s'"), snapshotStrVol);
goto cleanup;
}
char *snapshotStrVolPath;
if ((snapshotStrVolPath = virStorageVolGetPath(snapVol)) == NULL) {
virStorageVolFree(snapVol);
goto cleanup;
}
/* Create XML for the backing store */
virBufferAddLit(&buf, " <backingStore>\n");
virBufferAsprintf(&buf, " <path>%s</path>\n",snapshotStrVolPath);
if (snapshotStrFormat)
virBufferAsprintf(&buf, " <format type='%s'/>\n",snapshotStrFormat);
virBufferAddLit(&buf, " </backingStore>\n");
/* Cleanup snapshot allocations */
VIR_FREE(snapshotStrVolPath);
virStorageVolFree(snapVol);
}
virBufferAddLit(&buf, "</volume>\n");
if (virBufferError(&buf)) {
vshPrint(ctl, "%s", _("Failed to allocate XML buffer"));
goto cleanup;
}
xml = virBufferContentAndReset(&buf);
vol = virStorageVolCreateXML(pool, xml, 0);
VIR_FREE(xml);
virStoragePoolFree(pool);
if (vol != NULL) {
vshPrint(ctl, _("Vol %s created\n"), name);
virStorageVolFree(vol);
return true;
} else {
vshError(ctl, _("Failed to create vol %s"), name);
return false;
}
cleanup:
virBufferFreeAndReset(&buf);
virStoragePoolFree(pool);
return false;
}
