The two new APIs are rather trivial; based on bits and pieces of other existing APIs. But rather than blindly return 0 or 1 for HasMetadata, I chose to first validate that the snapshot in question in fact exists. In the process, I noticed other APIs that were blindly succeeding instead of checking for existence. * src/esx/esx_driver.c (esxDomainSnapshotIsCurrent) (esxDomainSnapshotHasMetadata): New functions. (esxDomainIsUpdated, esxDomainIsPersistent): Add existence checks. * src/vbox/vbox_tmpl.c (vboxDomainSnapshotIsCurrent) (vboxDomainSnapshotHasMetadata): New functions. (vboxDomainIsPersistent, vboxDomainIsUpdated): Add existence checks. --- v2: add existence checks to other functions I like this version better. However, while it compiles, I'm completely unable to runtime test it, so I'd appreciate a good review. src/esx/esx_driver.c | 116 ++++++++++++++++++++++++++++++++++++++-- src/vbox/vbox_tmpl.c | 145 ++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 253 insertions(+), 8 deletions(-) diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index b3f1948..db2144c 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -4243,10 +4243,28 @@ esxDomainIsActive(virDomainPtr domain) static int -esxDomainIsPersistent(virDomainPtr domain ATTRIBUTE_UNUSED) +esxDomainIsPersistent(virDomainPtr domain) { - /* ESX has no concept of transient domains, so all of them are persistent */ - return 1; + /* ESX has no concept of transient domains, so all of them are + * persistent. However, we do want to check for existence. */ + int result = -1; + esxPrivate *priv = domain->conn->privateData; + esxVI_ObjectContent *virtualMachine = NULL; + + if (esxVI_EnsureSession(priv->primary) < 0) + return -1; + + if (esxVI_LookupVirtualMachineByUuid(priv->primary, domain->uuid, + NULL, &virtualMachine, + esxVI_Occurrence_RequiredItem) < 0) + goto cleanup; + + result = 1; + +cleanup: + esxVI_ObjectContent_Free(&virtualMachine); + + return result; } @@ -4254,7 +4272,26 @@ esxDomainIsPersistent(virDomainPtr domain ATTRIBUTE_UNUSED) static int esxDomainIsUpdated(virDomainPtr domain ATTRIBUTE_UNUSED) { - return 0; + /* ESX domains never have a persistent state that differs from + * current state. However, we do want to check for existence. */ + int result = -1; + esxPrivate *priv = domain->conn->privateData; + esxVI_ObjectContent *virtualMachine = NULL; + + if (esxVI_EnsureSession(priv->primary) < 0) + return -1; + + if (esxVI_LookupVirtualMachineByUuid(priv->primary, domain->uuid, + NULL, &virtualMachine, + esxVI_Occurrence_RequiredItem) < 0) + goto cleanup; + + result = 0; + +cleanup: + esxVI_ObjectContent_Free(&virtualMachine); + + return result; } @@ -4707,6 +4744,75 @@ esxDomainSnapshotCurrent(virDomainPtr domain, unsigned int flags) } +static int +esxDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot, unsigned int flags) +{ + esxPrivate *priv = snapshot->domain->conn->privateData; + esxVI_VirtualMachineSnapshotTree *currentSnapshotTree = NULL; + esxVI_VirtualMachineSnapshotTree *rootSnapshotList = NULL; + esxVI_VirtualMachineSnapshotTree *snapshotTree = NULL; + int ret = -1; + + virCheckFlags(0, -1); + + if (esxVI_EnsureSession(priv->primary) < 0) { + return -1; + } + + /* Check that snapshot exists. */ + if (esxVI_LookupRootSnapshotTreeList(priv->primary, snapshot->domain->uuid, + &rootSnapshotList) < 0 || + esxVI_GetSnapshotTreeByName(rootSnapshotList, snapshot->name, + &snapshotTree, NULL, + esxVI_Occurrence_RequiredItem) < 0) { + goto cleanup; + } + + if (esxVI_LookupCurrentSnapshotTree(priv->primary, snapshot->domain->uuid, + &currentSnapshotTree, + esxVI_Occurrence_RequiredItem) < 0) { + goto cleanup; + } + + ret = STREQ(snapshot->name, currentSnapshotTree->name); + +cleanup: + esxVI_VirtualMachineSnapshotTree_Free(&currentSnapshotTree); + esxVI_VirtualMachineSnapshotTree_Free(&rootSnapshotList); + return ret; +} + + +static int +esxDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot, unsigned int flags) +{ + esxPrivate *priv = snapshot->domain->conn->privateData; + esxVI_VirtualMachineSnapshotTree *rootSnapshotList = NULL; + esxVI_VirtualMachineSnapshotTree *snapshotTree = NULL; + int ret = -1; + + virCheckFlags(0, -1); + + if (esxVI_EnsureSession(priv->primary) < 0) { + return -1; + } + + /* Check that snapshot exists. If so, there is no metadata. */ + if (esxVI_LookupRootSnapshotTreeList(priv->primary, snapshot->domain->uuid, + &rootSnapshotList) < 0 || + esxVI_GetSnapshotTreeByName(rootSnapshotList, snapshot->name, + &snapshotTree, NULL, + esxVI_Occurrence_RequiredItem) < 0) { + goto cleanup; + } + + ret = 0; + +cleanup: + esxVI_VirtualMachineSnapshotTree_Free(&rootSnapshotList); + return ret; +} + static int esxDomainRevertToSnapshot(virDomainSnapshotPtr snapshot, unsigned int flags) @@ -5021,6 +5127,8 @@ static virDriver esxDriver = { .domainSnapshotGetParent = esxDomainSnapshotGetParent, /* 0.9.7 */ .domainSnapshotCurrent = esxDomainSnapshotCurrent, /* 0.8.0 */ .domainRevertToSnapshot = esxDomainRevertToSnapshot, /* 0.8.0 */ + .domainSnapshotIsCurrent = esxDomainSnapshotIsCurrent, /* 0.9.13 */ + .domainSnapshotHasMetadata = esxDomainSnapshotHasMetadata, /* 0.9.13 */ .domainSnapshotDelete = esxDomainSnapshotDelete, /* 0.8.0 */ .isAlive = esxIsAlive, /* 0.9.8 */ }; diff --git a/src/vbox/vbox_tmpl.c b/src/vbox/vbox_tmpl.c index 4b0ee2e..8b7415a 100644 --- a/src/vbox/vbox_tmpl.c +++ b/src/vbox/vbox_tmpl.c @@ -1490,14 +1490,54 @@ static int vboxDomainIsActive(virDomainPtr dom) { } -static int vboxDomainIsPersistent(virDomainPtr dom ATTRIBUTE_UNUSED) { - /* All domains are persistent. */ - return 1; +static int vboxDomainIsPersistent(virDomainPtr dom ATTRIBUTE_UNUSED) +{ + /* All domains are persistent. However, we do want to check for + * existence. */ + VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxIID iid = VBOX_IID_INITIALIZER; + IMachine *machine = NULL; + nsresult rc; + + vboxIIDFromUUID(&iid, dom->uuid); + rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine); + if (NS_FAILED(rc)) { + vboxError(VIR_ERR_NO_DOMAIN, "%s", + _("no domain with matching UUID")); + goto cleanup; + } + + ret = 1; + +cleanup: + VBOX_RELEASE(machine); + vboxIIDUnalloc(&iid); + return ret; } static int vboxDomainIsUpdated(virDomainPtr dom ATTRIBUTE_UNUSED) { - return 0; + /* VBox domains never have a persistent state that differs from + * current state. However, we do want to check for existence. */ + VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxIID iid = VBOX_IID_INITIALIZER; + IMachine *machine = NULL; + nsresult rc; + + vboxIIDFromUUID(&iid, dom->uuid); + rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine); + if (NS_FAILED(rc)) { + vboxError(VIR_ERR_NO_DOMAIN, "%s", + _("no domain with matching UUID")); + goto cleanup; + } + + ret = 0; + +cleanup: + VBOX_RELEASE(machine); + vboxIIDUnalloc(&iid); + return ret; } static int vboxDomainSuspend(virDomainPtr dom) { @@ -6426,6 +6466,101 @@ cleanup: return ret; } +static int +vboxDomainSnapshotIsCurrent(virDomainSnapshotPtr snapshot, + unsigned int flags) +{ + virDomainPtr dom = snapshot->domain; + VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxIID iid = VBOX_IID_INITIALIZER; + IMachine *machine = NULL; + ISnapshot *snap = NULL; + ISnapshot *current = NULL; + PRUnichar *nameUtf16 = NULL; + char *name = NULL; + nsresult rc; + + virCheckFlags(0, -1); + + vboxIIDFromUUID(&iid, dom->uuid); + rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine); + if (NS_FAILED(rc)) { + vboxError(VIR_ERR_NO_DOMAIN, "%s", + _("no domain with matching UUID")); + goto cleanup; + } + + if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name))) + goto cleanup; + + rc = machine->vtbl->GetCurrentSnapshot(machine, &current); + if (NS_FAILED(rc)) { + vboxError(VIR_ERR_INTERNAL_ERROR, "%s", + _("could not get current snapshot")); + goto cleanup; + } + if (!current) { + ret = 0; + goto cleanup; + } + + rc = current->vtbl->GetName(current, &nameUtf16); + if (NS_FAILED(rc) || !nameUtf16) { + vboxError(VIR_ERR_INTERNAL_ERROR, "%s", + _("could not get current snapshot name")); + goto cleanup; + } + + VBOX_UTF16_TO_UTF8(nameUtf16, &name); + if (!name) { + virReportOOMError(); + goto cleanup; + } + + ret = STREQ(snapshot->name, name); + +cleanup: + VBOX_UTF8_FREE(name); + VBOX_UTF16_FREE(nameUtf16); + VBOX_RELEASE(current); + VBOX_RELEASE(machine); + vboxIIDUnalloc(&iid); + return ret; +} + +static int +vboxDomainSnapshotHasMetadata(virDomainSnapshotPtr snapshot, + unsigned int flags) +{ + virDomainPtr dom = snapshot->domain; + VBOX_OBJECT_CHECK(dom->conn, int, -1); + vboxIID iid = VBOX_IID_INITIALIZER; + IMachine *machine = NULL; + ISnapshot *snap = NULL; + nsresult rc; + + virCheckFlags(0, -1); + + vboxIIDFromUUID(&iid, dom->uuid); + rc = VBOX_OBJECT_GET_MACHINE(iid.value, &machine); + if (NS_FAILED(rc)) { + vboxError(VIR_ERR_NO_DOMAIN, "%s", + _("no domain with matching UUID")); + goto cleanup; + } + + /* Check that snapshot exists. If so, there is no metadata. */ + if (!(snap = vboxDomainSnapshotGet(data, dom, machine, snapshot->name))) + goto cleanup; + + ret = 0; + +cleanup: + VBOX_RELEASE(machine); + vboxIIDUnalloc(&iid); + return ret; +} + #if VBOX_API_VERSION < 3001 static int vboxDomainSnapshotRestore(virDomainPtr dom, @@ -9172,6 +9307,8 @@ virDriver NAME(Driver) = { .domainHasCurrentSnapshot = vboxDomainHasCurrentSnapshot, /* 0.8.0 */ .domainSnapshotGetParent = vboxDomainSnapshotGetParent, /* 0.9.7 */ .domainSnapshotCurrent = vboxDomainSnapshotCurrent, /* 0.8.0 */ + .domainSnapshotIsCurrent = vboxDomainSnapshotIsCurrent, /* 0.9.13 */ + .domainSnapshotHasMetadata = vboxDomainSnapshotHasMetadata, /* 0.9.13 */ .domainRevertToSnapshot = vboxDomainRevertToSnapshot, /* 0.8.0 */ .domainSnapshotDelete = vboxDomainSnapshotDelete, /* 0.8.0 */ .isAlive = vboxIsAlive, /* 0.9.8 */ -- 1.7.10.2