Make struct valkeyClusterNodeIterator opaque

Signed-off-by: Björn Svensson <[email protected]>

include/valkey/cluster.h

@@ -34,7 +34,6 @@
 #define VALKEY_CLUSTER_H
 
 #include "async.h"
-#include "dict.h"
 #include "valkey.h"
 
 #define UNUSED(x) (void)(x)
@@ -66,6 +65,7 @@
 extern "C" {
 #endif
 
+struct dict;
 struct hilist;
 struct valkeyClusterAsyncContext;
 struct valkeyTLSContext;
@@ -148,11 +148,15 @@ typedef struct valkeyClusterAsyncContext {
 
 } valkeyClusterAsyncContext;
 
+#if UINTPTR_MAX == UINT64_MAX
+#define VALKEY_NODE_ITERATOR_SIZE 56
+#elif defined(__arm__)
+#define VALKEY_NODE_ITERATOR_SIZE 40
+#else
+#define VALKEY_NODE_ITERATOR_SIZE 32
+#endif
 typedef struct valkeyClusterNodeIterator {
-    valkeyClusterContext *cc;
-    uint64_t route_version;
-    int retries_left;
-    dictIterator di;
+    char opaque_data[VALKEY_NODE_ITERATOR_SIZE];
 } valkeyClusterNodeIterator;
 
 /*

src/cluster.c

@@ -3611,33 +3611,44 @@ void valkeyClusterAsyncFree(valkeyClusterAsyncContext *acc) {
     vk_free(acc);
 }
 
+struct nodeIterator {
+    valkeyClusterContext *cc;
+    uint64_t route_version;
+    int retries_left;
+    dictIterator di;
+};
+/* Make sure VALKEY_NODE_ITERATOR_SIZE is correct. */
+vk_static_assert(sizeof(struct nodeIterator) == VALKEY_NODE_ITERATOR_SIZE);
+
 /* Initiate an iterator for iterating over current cluster nodes */
 void valkeyClusterInitNodeIterator(valkeyClusterNodeIterator *iter,
                                    valkeyClusterContext *cc) {
-    iter->cc = cc;
-    iter->route_version = cc->route_version;
-    dictInitIterator(&iter->di, cc->nodes);
-    iter->retries_left = 1;
+    struct nodeIterator *ni = (struct nodeIterator *)iter;
+    ni->cc = cc;
+    ni->route_version = cc->route_version;
+    dictInitIterator(&ni->di, cc->nodes);
+    ni->retries_left = 1;
 }
 
 /* Get next node from the iterator
  * The iterator will restart if the routing table is updated
  * before all nodes have been iterated. */
 valkeyClusterNode *valkeyClusterNodeNext(valkeyClusterNodeIterator *iter) {
-    if (iter->retries_left <= 0)
+    struct nodeIterator *ni = (struct nodeIterator *)iter;
+    if (ni->retries_left <= 0)
         return NULL;
 
-    if (iter->route_version != iter->cc->route_version) {
+    if (ni->route_version != ni->cc->route_version) {
         // The routing table has changed and current iterator
         // is invalid. The nodes dict has been recreated in
         // the cluster context. We need to re-init the dictIter.
-        dictInitIterator(&iter->di, iter->cc->nodes);
-        iter->route_version = iter->cc->route_version;
-        iter->retries_left--;
+        dictInitIterator(&ni->di, ni->cc->nodes);
+        ni->route_version = ni->cc->route_version;
+        ni->retries_left--;
     }
 
     dictEntry *de;
-    if ((de = dictNext(&iter->di)) != NULL)
+    if ((de = dictNext(&ni->di)) != NULL)
         return dictGetEntryVal(de);
     else
         return NULL;

src/vkutil.h

@@ -36,6 +36,9 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+/* Static assert macro for C99. */
+#define vk_static_assert(cond) extern char vk_static_assert[sizeof(char[1 - 2 * !(cond)])]
+
 /*
  * Wrapper to workaround well known, safe, implicit type conversion when
  * invoking system calls.

tests/clusterclient.c

@@ -122,6 +122,7 @@ int main(int argc, char **argv) {
         if (send_to_all) {
             valkeyClusterNodeIterator ni;
             valkeyClusterInitNodeIterator(&ni, cc);
+            uint64_t route_version = cc->route_version;
 
             valkeyClusterNode *node;
             while ((node = valkeyClusterNodeNext(&ni)) != NULL) {
@@ -133,7 +134,7 @@ int main(int argc, char **argv) {
                     printReply(reply);
                 }
                 freeReplyObject(reply);
-                if (ni.route_version != cc->route_version) {
+                if (route_version != cc->route_version) {
                     /* Updated slotmap resets the iterator. Abort iteration. */
                     break;
                 }