void
virStoragePoolObjDefUseNewDef(virStoragePoolObjPtr obj)
{
virStoragePoolDefFree(obj->def);
obj->def = obj->newDef;
obj->newDef = NULL;
}
void
virStoragePoolObjDispose(void *opaque)
{
virStoragePoolObjPtr obj = opaque;
if (!obj)
return;
virStoragePoolObjClearVols(obj);
virStoragePoolDefFree(obj->def);
virStoragePoolDefFree(obj->newDef);
VIR_FREE(obj->configFile);
VIR_FREE(obj->autostartLink);
}
static int
testCompareXMLToXMLFiles(const char *inxml, const char *outxml)
{
char *inXmlData = NULL;
char *outXmlData = NULL;
char *actual = NULL;
int ret = -1;
virStoragePoolDefPtr dev = NULL;
if (virtTestLoadFile(inxml, &inXmlData) < 0)
goto fail;
if (virtTestLoadFile(outxml, &outXmlData) < 0)
goto fail;
if (!(dev = virStoragePoolDefParseString(inXmlData)))
goto fail;
if (!(actual = virStoragePoolDefFormat(dev)))
goto fail;
if (STRNEQ(outXmlData, actual)) {
virtTestDifference(stderr, outXmlData, actual);
goto fail;
}
ret = 0;
fail:
VIR_FREE(inXmlData);
VIR_FREE(outXmlData);
VIR_FREE(actual);
virStoragePoolDefFree(dev);
return ret;
}
void
virStoragePoolObjSetDef(virStoragePoolObjPtr obj,
virStoragePoolDefPtr def)
{
virStoragePoolDefFree(obj->def);
obj->def = def;
}
static int
testCompareXMLToXMLFiles(const char *poolxml, const char *inxml,
const char *outxml, unsigned int flags)
{
char *actual = NULL;
int ret = -1;
virStoragePoolDefPtr pool = NULL;
virStorageVolDefPtr dev = NULL;
if (!(pool = virStoragePoolDefParseFile(poolxml)))
goto fail;
if (!(dev = virStorageVolDefParseFile(pool, inxml, flags)))
goto fail;
if (!(actual = virStorageVolDefFormat(pool, dev)))
goto fail;
if (virTestCompareToFile(actual, outxml) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(actual);
virStoragePoolDefFree(pool);
virStorageVolDefFree(dev);
return ret;
}
static virStoragePoolPtr
parallelsStoragePoolDefineXML(virConnectPtr conn,
const char *xml, unsigned int flags)
{
parallelsConnPtr privconn = conn->privateData;
virStoragePoolDefPtr def;
virStoragePoolObjPtr pool = NULL;
virStoragePoolPtr ret = NULL;
virCheckFlags(0, NULL);
parallelsDriverLock(privconn);
if (!(def = virStoragePoolDefParseString(xml)))
goto cleanup;
if (def->type != VIR_STORAGE_POOL_DIR) {
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("Only local directories are supported"));
goto cleanup;
}
if (virStoragePoolObjIsDuplicate(&privconn->pools, def, 0) < 0)
goto cleanup;
if (virStoragePoolSourceFindDuplicate(&privconn->pools, def) < 0)
goto cleanup;
if (parallelsStoragePoolGetAlloc(def))
goto cleanup;
if (!(pool = virStoragePoolObjAssignDef(&privconn->pools, def)))
goto cleanup;
if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) {
virStoragePoolObjRemove(&privconn->pools, pool);
def = NULL;
goto cleanup;
}
def = NULL;
if (VIR_STRDUP(pool->configFile, "\0") < 0)
goto cleanup;
ret = virGetStoragePool(conn, pool->def->name, pool->def->uuid,
NULL, NULL);
cleanup:
virStoragePoolDefFree(def);
if (pool)
virStoragePoolObjUnlock(pool);
parallelsDriverUnlock(privconn);
return ret;
}
static virStoragePoolObjPtr
parallelsPoolCreateByPath(virConnectPtr conn, const char *path)
{
parallelsConnPtr privconn = conn->privateData;
virStoragePoolObjListPtr pools = &privconn->pools;
virStoragePoolDefPtr def;
virStoragePoolObjPtr pool = NULL;
if (VIR_ALLOC(def) < 0)
goto no_memory;
if (!(def->name = parallelsMakePoolName(conn, path)))
goto error;
if (VIR_ALLOC_N(def->uuid, VIR_UUID_BUFLEN))
goto no_memory;
if (virUUIDGenerate(def->uuid)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Can't generate UUID"));
goto error;
}
def->type = VIR_STORAGE_POOL_DIR;
if (VIR_STRDUP(def->target.path, path) < 0)
goto error;
if (!(pool = virStoragePoolObjAssignDef(pools, def)))
goto error;
if (virStoragePoolObjSaveDef(conn->storagePrivateData, pool, def) < 0) {
virStoragePoolObjRemove(pools, pool);
goto error;
}
virStoragePoolObjUnlock(pool);
return pool;
no_memory:
virReportOOMError();
error:
virStoragePoolDefFree(def);
if (pool)
virStoragePoolObjUnlock(pool);
return NULL;
}
static int
test_vdi_list_parser(collie_test test, char *poolxml, char *volxml)
{
int ret = -1;
char *poolXmlData = NULL;
char *volXmlData = NULL;
char *output = NULL;
virStoragePoolDefPtr pool = NULL;
virStorageVolDefPtr vol = NULL;
if (virtTestLoadFile(poolxml, &poolXmlData) < 0)
goto cleanup;
if (virtTestLoadFile(volxml, &volXmlData) < 0)
goto cleanup;
if (!(pool = virStoragePoolDefParseString(poolXmlData)))
goto cleanup;
if (!(vol = virStorageVolDefParseString(pool, volXmlData)))
goto cleanup;
output = strdup(test.output);
if (!output)
goto cleanup;
if (virStorageBackendSheepdogParseVdiList(vol, output) !=
test.expected_return)
goto cleanup;
if (test.expected_return) {
ret = 0;
goto cleanup;
}
if (vol->capacity == test.expected_capacity &&
vol->allocation == test.expected_allocation)
ret = 0;
cleanup:
VIR_FREE(output);
VIR_FREE(poolXmlData);
VIR_FREE(volXmlData);
virStoragePoolDefFree(pool);
virStorageVolDefFree(vol);
return ret;
}
static int testCompareXMLToXMLFiles(const char *poolxml,
const char *inxml,
const char *outxml) {
char poolXmlData[MAX_FILE];
char *poolXmlPtr = &(poolXmlData[0]);
char inXmlData[MAX_FILE];
char *inXmlPtr = &(inXmlData[0]);
char outXmlData[MAX_FILE];
char *outXmlPtr = &(outXmlData[0]);
char *actual = NULL;
int ret = -1;
virStoragePoolDefPtr pool = NULL;
virStorageVolDefPtr dev = NULL;
if (virtTestLoadFile(poolxml, &poolXmlPtr, MAX_FILE) < 0)
goto fail;
if (virtTestLoadFile(inxml, &inXmlPtr, MAX_FILE) < 0)
goto fail;
if (virtTestLoadFile(outxml, &outXmlPtr, MAX_FILE) < 0)
goto fail;
if (!(pool = virStoragePoolDefParseString(poolXmlData)))
goto fail;
if (!(dev = virStorageVolDefParseString(pool, inXmlData)))
goto fail;
if (!(actual = virStorageVolDefFormat(pool, dev)))
goto fail;
if (STRNEQ(outXmlData, actual)) {
virtTestDifference(stderr, outXmlData, actual);
goto fail;
}
ret = 0;
fail:
free(actual);
virStoragePoolDefFree(pool);
virStorageVolDefFree(dev);
return ret;
}
static int
testCompareXMLToXMLFiles(const char *inxml, const char *outxml)
{
char *actual = NULL;
int ret = -1;
virStoragePoolDefPtr dev = NULL;
if (!(dev = virStoragePoolDefParseFile(inxml)))
goto fail;
if (!(actual = virStoragePoolDefFormat(dev)))
goto fail;
if (virtTestCompareToFile(actual, outxml) < 0)
goto fail;
ret = 0;
fail:
VIR_FREE(actual);
virStoragePoolDefFree(dev);
return ret;
}
static int
testCompareXMLToArgvFiles(bool shouldFail,
const char *poolxml,
const char *volxml,
const char *inputpoolxml,
const char *inputvolxml,
const char *cmdline,
unsigned int flags,
unsigned long parse_flags)
{
char *actualCmdline = NULL;
virStorageVolEncryptConvertStep convertStep = VIR_STORAGE_VOL_ENCRYPT_NONE;
int ret = -1;
virCommandPtr cmd = NULL;
virStorageVolDefPtr vol = NULL, inputvol = NULL;
virStoragePoolDefPtr def = NULL;
virStoragePoolDefPtr inputpool = NULL;
virStoragePoolObjPtr obj = NULL;
if (!(def = virStoragePoolDefParseFile(poolxml)))
goto cleanup;
if (!(obj = virStoragePoolObjNew())) {
virStoragePoolDefFree(def);
goto cleanup;
}
virStoragePoolObjSetDef(obj, def);
if (inputpoolxml) {
if (!(inputpool = virStoragePoolDefParseFile(inputpoolxml)))
goto cleanup;
}
if (inputvolxml)
parse_flags |= VIR_VOL_XML_PARSE_NO_CAPACITY;
if (!(vol = virStorageVolDefParseFile(def, volxml, parse_flags)))
goto cleanup;
if (inputvolxml &&
!(inputvol = virStorageVolDefParseFile(inputpool, inputvolxml, 0)))
goto cleanup;
testSetVolumeType(vol, def);
testSetVolumeType(inputvol, inputpool);
/* Using an input file for encryption requires a multi-step process
* to create an image of the same size as the inputvol and then to
* convert the inputvol afterwards. Since we only care about the
* command line we have to copy code from storageBackendCreateQemuImg
* and adjust it for the test needs. */
if (inputvol && (vol->target.encryption || inputvol->target.encryption))
convertStep = VIR_STORAGE_VOL_ENCRYPT_CREATE;
do {
cmd = virStorageBackendCreateQemuImgCmdFromVol(obj, vol,
inputvol, flags,
create_tool,
"/path/to/secretFile",
"/path/to/inputSecretFile",
convertStep);
if (!cmd) {
if (shouldFail) {
virResetLastError();
ret = 0;
}
goto cleanup;
}
if (convertStep != VIR_STORAGE_VOL_ENCRYPT_CONVERT) {
if (!(actualCmdline = virCommandToString(cmd)))
goto cleanup;
} else {
char *createCmdline = actualCmdline;
char *cvtCmdline;
int rc;
if (!(cvtCmdline = virCommandToString(cmd)))
goto cleanup;
rc = virAsprintf(&actualCmdline, "%s\n%s",
createCmdline, cvtCmdline);
VIR_FREE(createCmdline);
VIR_FREE(cvtCmdline);
if (rc < 0)
goto cleanup;
}
if (convertStep == VIR_STORAGE_VOL_ENCRYPT_NONE)
convertStep = VIR_STORAGE_VOL_ENCRYPT_DONE;
else if (convertStep == VIR_STORAGE_VOL_ENCRYPT_CREATE)
convertStep = VIR_STORAGE_VOL_ENCRYPT_CONVERT;
else if (convertStep == VIR_STORAGE_VOL_ENCRYPT_CONVERT)
convertStep = VIR_STORAGE_VOL_ENCRYPT_DONE;
} while (convertStep != VIR_STORAGE_VOL_ENCRYPT_DONE);
if (virTestCompareToFile(actualCmdline, cmdline) < 0)
goto cleanup;
ret = 0;
cleanup:
virStoragePoolDefFree(inputpool);
virStorageVolDefFree(vol);
virStorageVolDefFree(inputvol);
virCommandFree(cmd);
VIR_FREE(actualCmdline);
virStoragePoolObjEndAPI(&obj);
return ret;
}
static int
testCompareXMLToArgvFiles(bool shouldFail,
const char *poolxml,
const char *volxml,
const char *inputpoolxml,
const char *inputvolxml,
const char *cmdline,
unsigned int flags,
int imgformat)
{
char *volXmlData = NULL;
char *poolXmlData = NULL;
char *inputpoolXmlData = NULL;
char *inputvolXmlData = NULL;
char *expectedCmdline = NULL;
char *actualCmdline = NULL;
int ret = -1;
int len;
virCommandPtr cmd = NULL;
virConnectPtr conn;
virStorageVolDefPtr vol = NULL, inputvol = NULL;
virStoragePoolDefPtr pool = NULL;
virStoragePoolDefPtr inputpool = NULL;
virStoragePoolObj poolobj = {.def = NULL };
if (!(conn = virGetConnect()))
goto cleanup;
if (virtTestLoadFile(poolxml, &poolXmlData) < 0)
goto cleanup;
if (virtTestLoadFile(volxml, &volXmlData) < 0)
goto cleanup;
if (inputvolxml &&
virtTestLoadFile(inputvolxml, &inputvolXmlData) < 0)
goto cleanup;
if (!(pool = virStoragePoolDefParseString(poolXmlData)))
goto cleanup;
poolobj.def = pool;
if (inputpoolxml) {
if (virtTestLoadFile(inputpoolxml, &inputpoolXmlData) < 0)
goto cleanup;
if (!(inputpool = virStoragePoolDefParseString(inputpoolXmlData)))
goto cleanup;
}
if (!(vol = virStorageVolDefParseString(pool, volXmlData)))
goto cleanup;
if (inputvolxml &&
!(inputvol = virStorageVolDefParseString(inputpool, inputvolXmlData)))
goto cleanup;
testSetVolumeType(vol, pool);
testSetVolumeType(inputvol, inputpool);
cmd = virStorageBackendCreateQemuImgCmd(conn, &poolobj, vol, inputvol,
flags, create_tool, imgformat);
if (!cmd) {
if (shouldFail) {
virResetLastError();
ret = 0;
}
goto cleanup;
}
if (!(actualCmdline = virCommandToString(cmd)))
goto cleanup;
len = virtTestLoadFile(cmdline, &expectedCmdline);
if (len < 0)
goto cleanup;
if (len && expectedCmdline[len-1] == '\n')
expectedCmdline[len-1] = '\0';
if (STRNEQ_NULLABLE(expectedCmdline, actualCmdline)) {
virtTestDifference(stderr, expectedCmdline, actualCmdline);
goto cleanup;
}
ret = 0;
cleanup:
virStoragePoolDefFree(pool);
virStoragePoolDefFree(inputpool);
virStorageVolDefFree(vol);
virStorageVolDefFree(inputvol);
virCommandFree(cmd);
VIR_FREE(actualCmdline);
VIR_FREE(expectedCmdline);
VIR_FREE(inputpoolXmlData);
VIR_FREE(poolXmlData);
VIR_FREE(volXmlData);
VIR_FREE(inputvolXmlData);
virObjectUnref(conn);
return ret;
}
static int
testCompareXMLToArgvFiles(bool shouldFail,
const char *poolxml,
const char *volxml,
const char *inputpoolxml,
const char *inputvolxml,
const char *cmdline,
unsigned int flags,
int imgformat,
unsigned long parse_flags)
{
char *actualCmdline = NULL;
int ret = -1;
virCommandPtr cmd = NULL;
virConnectPtr conn;
virStorageVolDefPtr vol = NULL, inputvol = NULL;
virStoragePoolDefPtr pool = NULL;
virStoragePoolDefPtr inputpool = NULL;
virStoragePoolObj poolobj = {.def = NULL };
if (!(conn = virGetConnect()))
goto cleanup;
if (!(pool = virStoragePoolDefParseFile(poolxml)))
goto cleanup;
poolobj.def = pool;
if (inputpoolxml) {
if (!(inputpool = virStoragePoolDefParseFile(inputpoolxml)))
goto cleanup;
}
if (inputvolxml)
parse_flags |= VIR_VOL_XML_PARSE_NO_CAPACITY;
if (!(vol = virStorageVolDefParseFile(pool, volxml, parse_flags)))
goto cleanup;
if (inputvolxml &&
!(inputvol = virStorageVolDefParseFile(inputpool, inputvolxml, 0)))
goto cleanup;
testSetVolumeType(vol, pool);
testSetVolumeType(inputvol, inputpool);
cmd = virStorageBackendCreateQemuImgCmdFromVol(conn, &poolobj, vol,
inputvol, flags,
create_tool, imgformat);
if (!cmd) {
if (shouldFail) {
virResetLastError();
ret = 0;
}
goto cleanup;
}
if (!(actualCmdline = virCommandToString(cmd)))
goto cleanup;
if (virTestCompareToFile(actualCmdline, cmdline) < 0)
goto cleanup;
ret = 0;
cleanup:
virStoragePoolDefFree(pool);
virStoragePoolDefFree(inputpool);
virStorageVolDefFree(vol);
virStorageVolDefFree(inputvol);
virCommandFree(cmd);
VIR_FREE(actualCmdline);
virObjectUnref(conn);
return ret;
}
