11:38 a.m.
The VIR_STORAGE_POOL_EVENT_REFRESHED constant does not
reflect any change in the lifecycle of the storage pool.
It should thus not be part of the storage pool lifecycle
event set, but rather be a top level event in its own
right. Thus we introduce VIR_STORAGE_POOL_EVENT_ID_REFRESH
to replace it.
Signed-off-by: Daniel P. Berrange <berrange(a)redhat.com>
---
NB this breaks API and wire protocol, so we *must*
include this before 2.0.0. Ideally we should get it
into before we cut any rc release too.
daemon/remote.c | 29 +++++++++++++++++
examples/object-events/event-test.c | 14 ++++++--
include/libvirt/libvirt-storage.h | 2 +-
src/conf/storage_event.c | 57 +++++++++++++++++++++++++++++++++
src/conf/storage_event.h | 4 +++
src/libvirt_private.syms | 1 +
src/remote/remote_driver.c | 30 +++++++++++++++++
src/remote/remote_protocol.x | 13 +++++++-
src/remote_protocol-structs | 5 +++
src/storage/storage_driver.c | 12 +++----
src/test/test_driver.c | 4 +--
tests/objecteventtest.c | 29 ++++++++++++-----
tools/virsh-pool.c | 64 +++++++++++++++++++++++++++++++------
13 files changed, 232 insertions(+), 32 deletions(-)
diff --git a/daemon/remote.c b/daemon/remote.c
index 5ee82bb..4aa43c2 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -1294,8 +1294,37 @@ remoteRelayStoragePoolEventLifecycle(virConnectPtr conn,
return 0;
}
+static int
+remoteRelayStoragePoolEventRefresh(virConnectPtr conn,
+ virStoragePoolPtr pool,
+ void *opaque)
+{
+ daemonClientEventCallbackPtr callback = opaque;
+ remote_storage_pool_event_refresh_msg data;
+
+ if (callback->callbackID < 0 ||
+ !remoteRelayStoragePoolEventCheckACL(callback->client, conn, pool))
+ return -1;
+
+ VIR_DEBUG("Relaying storage pool refresh event callback %d",
+ callback->callbackID);
+
+ /* build return data */
+ memset(&data, 0, sizeof(data));
+ make_nonnull_storage_pool(&data.pool, pool);
+ data.callbackID = callback->callbackID;
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH,
+ (xdrproc_t)xdr_remote_storage_pool_event_refresh_msg,
+ &data);
+
+ return 0;
+}
+
static virConnectStoragePoolEventGenericCallback storageEventCallbacks[] = {
VIR_STORAGE_POOL_EVENT_CALLBACK(remoteRelayStoragePoolEventLifecycle),
+ VIR_STORAGE_POOL_EVENT_CALLBACK(remoteRelayStoragePoolEventRefresh),
};
verify(ARRAY_CARDINALITY(storageEventCallbacks) == VIR_STORAGE_POOL_EVENT_ID_LAST);
diff --git a/examples/object-events/event-test.c b/examples/object-events/event-test.c
index 215e026..f2f71cc 100644
--- a/examples/object-events/event-test.c
+++ b/examples/object-events/event-test.c
@@ -349,8 +349,6 @@ storagePoolEventToString(int event)
return "Started";
case VIR_STORAGE_POOL_EVENT_STOPPED:
return "Stopped";
- case VIR_STORAGE_POOL_EVENT_REFRESHED:
- return "Refreshed";
case VIR_STORAGE_POOL_EVENT_LAST:
break;
}
@@ -679,6 +677,17 @@ myStoragePoolEventCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
}
+static int
+myStoragePoolEventRefreshCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virStoragePoolPtr pool,
+ void *opaque ATTRIBUTE_UNUSED)
+{
+ printf("%s EVENT: Storage pool %s refresh\n", __func__,
+ virStoragePoolGetName(pool));
+ return 0;
+}
+
+
static void
eventTypedParamsPrint(virTypedParameterPtr params,
int nparams)
@@ -936,6 +945,7 @@ struct storagePoolEventData {
struct storagePoolEventData storagePoolEvents[] = {
STORAGE_POOL_EVENT(VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE, myStoragePoolEventCallback),
+ STORAGE_POOL_EVENT(VIR_STORAGE_POOL_EVENT_ID_REFRESH,
myStoragePoolEventRefreshCallback),
};
/* make sure that the events are kept in sync */
diff --git a/include/libvirt/libvirt-storage.h b/include/libvirt/libvirt-storage.h
index a67a97f..0974f6e 100644
--- a/include/libvirt/libvirt-storage.h
+++ b/include/libvirt/libvirt-storage.h
@@ -394,6 +394,7 @@ int virStoragePoolIsPersistent(virStoragePoolPtr pool);
*/
typedef enum {
VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE = 0, /*
virConnectStoragePoolEventLifecycleCallback */
+ VIR_STORAGE_POOL_EVENT_ID_REFRESH = 1, /* virConnectStoragePoolEventGenericCallback
*/
# ifdef VIR_ENUM_SENTINELS
VIR_STORAGE_POOL_EVENT_ID_LAST
@@ -443,7 +444,6 @@ typedef enum {
VIR_STORAGE_POOL_EVENT_UNDEFINED = 1,
VIR_STORAGE_POOL_EVENT_STARTED = 2,
VIR_STORAGE_POOL_EVENT_STOPPED = 3,
- VIR_STORAGE_POOL_EVENT_REFRESHED = 4,
# ifdef VIR_ENUM_SENTINELS
VIR_STORAGE_POOL_EVENT_LAST
diff --git a/src/conf/storage_event.c b/src/conf/storage_event.c
index c5688be..5768bab 100644
--- a/src/conf/storage_event.c
+++ b/src/conf/storage_event.c
@@ -48,10 +48,20 @@ struct _virStoragePoolEventLifecycle {
typedef struct _virStoragePoolEventLifecycle virStoragePoolEventLifecycle;
typedef virStoragePoolEventLifecycle *virStoragePoolEventLifecyclePtr;
+struct _virStoragePoolEventRefresh {
+ virStoragePoolEvent parent;
+
+ bool dummy;
+};
+typedef struct _virStoragePoolEventRefresh virStoragePoolEventRefresh;
+typedef virStoragePoolEventRefresh *virStoragePoolEventRefreshPtr;
+
static virClassPtr virStoragePoolEventClass;
static virClassPtr virStoragePoolEventLifecycleClass;
+static virClassPtr virStoragePoolEventRefreshClass;
static void virStoragePoolEventDispose(void *obj);
static void virStoragePoolEventLifecycleDispose(void *obj);
+static void virStoragePoolEventRefreshDispose(void *obj);
static int
virStoragePoolEventsOnceInit(void)
@@ -68,6 +78,12 @@ virStoragePoolEventsOnceInit(void)
sizeof(virStoragePoolEventLifecycle),
virStoragePoolEventLifecycleDispose)))
return -1;
+ if (!(virStoragePoolEventRefreshClass =
+ virClassNew(virStoragePoolEventClass,
+ "virStoragePoolEventRefresh",
+ sizeof(virStoragePoolEventRefresh),
+ virStoragePoolEventRefreshDispose)))
+ return -1;
return 0;
}
@@ -90,6 +106,14 @@ virStoragePoolEventLifecycleDispose(void *obj)
static void
+virStoragePoolEventRefreshDispose(void *obj)
+{
+ virStoragePoolEventRefreshPtr event = obj;
+ VIR_DEBUG("obj=%p", event);
+}
+
+
+static void
virStoragePoolEventDispatchDefaultFunc(virConnectPtr conn,
virObjectEventPtr event,
virConnectObjectEventGenericCallback cb,
@@ -115,6 +139,13 @@ virStoragePoolEventDispatchDefaultFunc(virConnectPtr conn,
goto cleanup;
}
+ case VIR_STORAGE_POOL_EVENT_ID_REFRESH:
+ {
+ ((virConnectStoragePoolEventGenericCallback)cb)(conn, pool,
+ cbopaque);
+ goto cleanup;
+ }
+
case VIR_STORAGE_POOL_EVENT_ID_LAST:
break;
}
@@ -235,3 +266,29 @@ virStoragePoolEventLifecycleNew(const char *name,
return (virObjectEventPtr)event;
}
+
+
+/**
+ * virStoragePoolEventRefreshNew:
+ * @name: name of the storage pool object the event describes
+ * @uuid: uuid of the storage pool object the event describes
+ *
+ * Create a new storage pool refresh event.
+ */
+virObjectEventPtr
+virStoragePoolEventRefreshNew(const char *name,
+ const unsigned char *uuid)
+{
+ virStoragePoolEventRefreshPtr event;
+
+ if (virStoragePoolEventsInitialize() < 0)
+ return NULL;
+
+ if (!(event = virObjectEventNew(virStoragePoolEventRefreshClass,
+ virStoragePoolEventDispatchDefaultFunc,
+ VIR_STORAGE_POOL_EVENT_ID_REFRESH,
+ 0, name, uuid)))
+ return NULL;
+
+ return (virObjectEventPtr)event;
+}
diff --git a/src/conf/storage_event.h b/src/conf/storage_event.h
index 7c8ccb7..ea72691 100644
--- a/src/conf/storage_event.h
+++ b/src/conf/storage_event.h
@@ -57,4 +57,8 @@ virStoragePoolEventLifecycleNew(const char *name,
int type,
int detail);
+virObjectEventPtr
+virStoragePoolEventRefreshNew(const char *name,
+ const unsigned char *uuid);
+
#endif
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index ef30f7f..0009f89 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -881,6 +881,7 @@ virStorageVolTypeToString;
# conf/storage_event.h
virStoragePoolEventLifecycleNew;
+virStoragePoolEventRefreshNew;
virStoragePoolEventStateRegisterID;
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 1f81f03..e9904f8 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -362,6 +362,11 @@ remoteStoragePoolBuildEventLifecycle(virNetClientProgramPtr prog
ATTRIBUTE_UNUSE
void *evdata, void *opaque);
static void
+remoteStoragePoolBuildEventRefresh(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque);
+
+static void
remoteConnectNotifyEventConnectionClosed(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque);
@@ -544,6 +549,10 @@ static virNetClientProgramEvent remoteEvents[] = {
remoteStoragePoolBuildEventLifecycle,
sizeof(remote_storage_pool_event_lifecycle_msg),
(xdrproc_t)xdr_remote_storage_pool_event_lifecycle_msg },
+ { REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH,
+ remoteStoragePoolBuildEventRefresh,
+ sizeof(remote_storage_pool_event_refresh_msg),
+ (xdrproc_t)xdr_remote_storage_pool_event_refresh_msg },
};
static void
@@ -5134,6 +5143,27 @@ remoteStoragePoolBuildEventLifecycle(virNetClientProgramPtr prog
ATTRIBUTE_UNUSE
}
static void
+remoteStoragePoolBuildEventRefresh(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ struct private_data *priv = conn->privateData;
+ remote_storage_pool_event_refresh_msg *msg = evdata;
+ virStoragePoolPtr pool;
+ virObjectEventPtr event = NULL;
+
+ pool = get_nonnull_storage_pool(conn, msg->pool);
+ if (!pool)
+ return;
+
+ event = virStoragePoolEventRefreshNew(pool->name, pool->uuid);
+ virObjectUnref(pool);
+
+ remoteEventQueue(priv, event, msg->callbackID);
+}
+
+static void
remoteDomainBuildQemuMonitorEvent(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque)
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index d11bfdf..4403714 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -3126,6 +3126,11 @@ struct remote_storage_pool_event_lifecycle_msg {
int detail;
};
+struct remote_storage_pool_event_refresh_msg {
+ int callbackID;
+ remote_nonnull_storage_pool pool;
+};
+
struct remote_domain_fsfreeze_args {
remote_nonnull_domain dom;
remote_nonnull_string mountpoints<REMOTE_DOMAIN_FSFREEZE_MOUNTPOINTS_MAX>; /*
(const char **) */
@@ -5871,5 +5876,11 @@ enum remote_procedure {
* @generate: both
* @acl: domain:write
*/
- REMOTE_PROC_DOMAIN_SET_GUEST_VCPUS = 372
+ REMOTE_PROC_DOMAIN_SET_GUEST_VCPUS = 372,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH = 373
};
diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index 0d89b15..46e798b 100644
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -2567,6 +2567,10 @@ struct remote_storage_pool_event_lifecycle_msg {
int event;
int detail;
};
+struct remote_storage_pool_event_refresh_msg {
+ int callbackID;
+ remote_nonnull_storage_pool pool;
+};
struct remote_domain_fsfreeze_args {
remote_nonnull_domain dom;
struct {
@@ -3140,4 +3144,5 @@ enum remote_procedure {
REMOTE_PROC_STORAGE_POOL_EVENT_LIFECYCLE = 370,
REMOTE_PROC_DOMAIN_GET_GUEST_VCPUS = 371,
REMOTE_PROC_DOMAIN_SET_GUEST_VCPUS = 372,
+ REMOTE_PROC_STORAGE_POOL_EVENT_REFRESH = 373,
};
diff --git a/src/storage/storage_driver.c b/src/storage/storage_driver.c
index d75c5aa..cef2124 100644
--- a/src/storage/storage_driver.c
+++ b/src/storage/storage_driver.c
@@ -1206,10 +1206,8 @@ storagePoolRefresh(virStoragePoolPtr obj,
goto cleanup;
}
- event = virStoragePoolEventLifecycleNew(pool->def->name,
- pool->def->uuid,
- VIR_STORAGE_POOL_EVENT_REFRESHED,
- 0);
+ event = virStoragePoolEventRefreshNew(pool->def->name,
+ pool->def->uuid);
ret = 0;
cleanup:
@@ -2342,10 +2340,8 @@ virStorageVolPoolRefreshThread(void *opaque)
if (backend->refreshPool(NULL, pool) < 0)
VIR_DEBUG("Failed to refresh storage pool");
- event = virStoragePoolEventLifecycleNew(pool->def->name,
- pool->def->uuid,
- VIR_STORAGE_POOL_EVENT_REFRESHED,
- 0);
+ event = virStoragePoolEventRefreshNew(pool->def->name,
+ pool->def->uuid);
cleanup:
if (event)
diff --git a/src/test/test_driver.c b/src/test/test_driver.c
index 2622335..baff085 100644
--- a/src/test/test_driver.c
+++ b/src/test/test_driver.c
@@ -4480,9 +4480,7 @@ testStoragePoolRefresh(virStoragePoolPtr pool,
goto cleanup;
}
- event = virStoragePoolEventLifecycleNew(pool->name, pool->uuid,
- VIR_STORAGE_POOL_EVENT_REFRESHED,
- 0);
+ event = virStoragePoolEventRefreshNew(pool->name, pool->uuid);
ret = 0;
cleanup:
diff --git a/tests/objecteventtest.c b/tests/objecteventtest.c
index ac8cce3..5e8087b 100644
--- a/tests/objecteventtest.c
+++ b/tests/objecteventtest.c
@@ -67,7 +67,6 @@ typedef struct {
int defineEvents;
int undefineEvents;
int unexpectedEvents;
- int refreshEvents;
} lifecycleEventCounter;
static void
@@ -78,7 +77,6 @@ lifecycleEventCounter_reset(lifecycleEventCounter *counter)
counter->defineEvents = 0;
counter->undefineEvents = 0;
counter->unexpectedEvents = 0;
- counter->refreshEvents = 0;
}
typedef struct {
@@ -153,8 +151,16 @@ storagePoolLifecycleCb(virConnectPtr conn ATTRIBUTE_UNUSED,
counter->defineEvents++;
else if (event == VIR_STORAGE_POOL_EVENT_UNDEFINED)
counter->undefineEvents++;
- else if (event == VIR_STORAGE_POOL_EVENT_REFRESHED)
- counter->refreshEvents++;
+}
+
+static void
+storagePoolRefreshCb(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virStoragePoolPtr pool ATTRIBUTE_UNUSED,
+ void* opaque)
+{
+ int *counter = opaque;
+
+ (*counter)++;
}
static int
@@ -646,18 +652,24 @@ testStoragePoolStartStopEvent(const void *data)
{
const objecteventTest *test = data;
lifecycleEventCounter counter;
- int id;
+ int refreshCounter;
+ int id1, id2;
int ret = 0;
if (!test->pool)
return -1;
lifecycleEventCounter_reset(&counter);
+ refreshCounter = 0;
- id = virConnectStoragePoolEventRegisterAny(test->conn, test->pool,
+ id1 = virConnectStoragePoolEventRegisterAny(test->conn, test->pool,
VIR_STORAGE_POOL_EVENT_ID_LIFECYCLE,
VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolLifecycleCb),
&counter, NULL);
+ id2 = virConnectStoragePoolEventRegisterAny(test->conn, test->pool,
+ VIR_STORAGE_POOL_EVENT_ID_REFRESH,
+ VIR_STORAGE_POOL_EVENT_CALLBACK(&storagePoolRefreshCb),
+ &refreshCounter, NULL);
virStoragePoolCreate(test->pool, 0);
virStoragePoolRefresh(test->pool, 0);
virStoragePoolDestroy(test->pool);
@@ -668,13 +680,14 @@ testStoragePoolStartStopEvent(const void *data)
}
if (counter.startEvents != 1 || counter.stopEvents != 1 ||
- counter.refreshEvents != 1 || counter.unexpectedEvents > 0) {
+ refreshCounter != 1 || counter.unexpectedEvents > 0) {
ret = -1;
goto cleanup;
}
cleanup:
- virConnectStoragePoolEventDeregisterAny(test->conn, id);
+ virConnectStoragePoolEventDeregisterAny(test->conn, id1);
+ virConnectStoragePoolEventDeregisterAny(test->conn, id2);
return ret;
}
diff --git a/tools/virsh-pool.c b/tools/virsh-pool.c
index 18e218c..6045331 100644
--- a/tools/virsh-pool.c
+++ b/tools/virsh-pool.c
@@ -1899,8 +1899,7 @@ VIR_ENUM_IMPL(virshPoolEvent,
N_("Defined"),
N_("Undefined"),
N_("Started"),
- N_("Stopped"),
- N_("Refreshed"))
+ N_("Stopped"))
static const char *
virshPoolEventToString(int event)
@@ -1909,18 +1908,21 @@ virshPoolEventToString(int event)
return str ? _(str) : _("unknown");
}
+struct vshEventCallback {
+ const char *name;
+ virConnectStoragePoolEventGenericCallback cb;
+};
+typedef struct vshEventCallback vshEventCallback;
+
struct virshPoolEventData {
vshControl *ctl;
bool loop;
bool timestamp;
int count;
+ vshEventCallback *cb;
};
typedef struct virshPoolEventData virshPoolEventData;
-VIR_ENUM_DECL(virshPoolEventId)
-VIR_ENUM_IMPL(virshPoolEventId,
- VIR_STORAGE_POOL_EVENT_ID_LAST,
- "lifecycle")
static void
vshEventLifecyclePrint(virConnectPtr conn ATTRIBUTE_UNUSED,
@@ -1955,6 +1957,45 @@ vshEventLifecyclePrint(virConnectPtr conn ATTRIBUTE_UNUSED,
vshEventDone(data->ctl);
}
+static void
+vshEventGenericPrint(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virStoragePoolPtr pool,
+ void *opaque)
+{
+ virshPoolEventData *data = opaque;
+
+ if (!data->loop && data->count)
+ return;
+
+ if (data->timestamp) {
+ char timestamp[VIR_TIME_STRING_BUFLEN];
+
+ if (virTimeStringNowRaw(timestamp) < 0)
+ timestamp[0] = '\0';
+
+ vshPrint(data->ctl, _("%s: event '%s'' for storage pool
%s\n"),
+ timestamp,
+ data->cb->name,
+ virStoragePoolGetName(pool));
+ } else {
+ vshPrint(data->ctl, _("event '%s' for storage pool %s\n"),
+ data->cb->name,
+ virStoragePoolGetName(pool));
+ }
+
+ data->count++;
+ if (!data->loop)
+ vshEventDone(data->ctl);
+}
+
+static vshEventCallback vshEventCallbacks[] = {
+ { "lifecycle",
+ VIR_STORAGE_POOL_EVENT_CALLBACK(vshEventLifecyclePrint), },
+ { "refresh", vshEventGenericPrint, }
+};
+verify(VIR_STORAGE_POOL_EVENT_ID_LAST == ARRAY_CARDINALITY(vshEventCallbacks));
+
+
static const vshCmdInfo info_pool_event[] = {
{.name = "help",
.data = N_("Storage Pool Events")
@@ -2009,7 +2050,7 @@ cmdPoolEvent(vshControl *ctl, const vshCmd *cmd)
size_t i;
for (i = 0; i < VIR_STORAGE_POOL_EVENT_ID_LAST; i++)
- vshPrint(ctl, "%s\n", virshPoolEventIdTypeToString(i));
+ vshPrint(ctl, "%s\n", vshEventCallbacks[i].name);
return true;
}
@@ -2019,7 +2060,11 @@ cmdPoolEvent(vshControl *ctl, const vshCmd *cmd)
vshError(ctl, "%s", _("either --list or event type is
required"));
return false;
}
- if ((event = virshPoolEventIdTypeFromString(eventName)) < 0) {
+
+ for (event = 0; event < VIR_STORAGE_POOL_EVENT_ID_LAST; event++)
+ if (STREQ(eventName, vshEventCallbacks[event].name))
+ break;
+ if (event == VIR_STORAGE_POOL_EVENT_ID_LAST) {
vshError(ctl, _("unknown event type %s"), eventName);
return false;
}
@@ -2028,6 +2073,7 @@ cmdPoolEvent(vshControl *ctl, const vshCmd *cmd)
data.loop = vshCommandOptBool(cmd, "loop");
data.timestamp = vshCommandOptBool(cmd, "timestamp");
data.count = 0;
+ data.cb = &vshEventCallbacks[event];
if (vshCommandOptTimeoutToMs(ctl, cmd, &timeout) < 0)
return false;
@@ -2037,7 +2083,7 @@ cmdPoolEvent(vshControl *ctl, const vshCmd *cmd)
goto cleanup;
if ((eventId = virConnectStoragePoolEventRegisterAny(priv->conn, pool, event,
-
VIR_STORAGE_POOL_EVENT_CALLBACK(vshEventLifecyclePrint),
+ data.cb->cb,
&data, NULL)) < 0)
goto cleanup;
switch (vshEventWait(ctl)) {
--
2.7.4