-
Notifications
You must be signed in to change notification settings - Fork 571
/
valkeymodule.h
2024 lines (1895 loc) · 120 KB
/
valkeymodule.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* valkeymodule.h
*
* This header file is forked from redismodule.h to reflect the new naming conventions adopted in Valkey.
*
* Key Changes:
* - Symbolic names have been changed from containing RedisModule, REDISMODULE, etc. to ValkeyModule, VALKEYMODULE, etc.
* to align with the new module naming convention. Developers must use these new symbolic names in their module
* implementations.
* - Terminology has been updated to be more inclusive: "slave" is now "replica", and "master"
* is now "primary". These changes are part of an effort to use more accurate and inclusive language.
*
* When developing modules for Valkey, ensure to include "valkeymodule.h". This header file contains
* the updated definitions and should be used to maintain compatibility with the changes made in Valkey.
*/
#ifndef VALKEYMODULE_H
#define VALKEYMODULE_H
#include <sys/types.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
typedef struct ValkeyModuleString ValkeyModuleString;
typedef struct ValkeyModuleKey ValkeyModuleKey;
/* -------------- Defines NOT common between core and modules ------------- */
#if defined VALKEYMODULE_CORE
/* Things only defined for the modules core (server), not exported to modules
* that include this file. */
#define ValkeyModuleString robj
#endif /* defined VALKEYMODULE_CORE */
#if !defined VALKEYMODULE_CORE && !defined VALKEYMODULE_CORE_MODULE
/* Things defined for modules, but not for core-modules. */
typedef long long mstime_t;
typedef long long ustime_t;
#endif /* !defined VALKEYMODULE_CORE && !defined VALKEYMODULE_CORE_MODULE */
/* ---------------- Defines common between core and modules --------------- */
/* Error status return values. */
#define VALKEYMODULE_OK 0
#define VALKEYMODULE_ERR 1
/* Module Based Authentication status return values. */
#define VALKEYMODULE_AUTH_HANDLED 0
#define VALKEYMODULE_AUTH_NOT_HANDLED 1
/* API versions. */
#define VALKEYMODULE_APIVER_1 1
/* Version of the ValkeyModuleTypeMethods structure. Once the ValkeyModuleTypeMethods
* structure is changed, this version number needs to be changed synchronistically. */
#define VALKEYMODULE_TYPE_METHOD_VERSION 5
/* API flags and constants */
#define VALKEYMODULE_READ (1 << 0)
#define VALKEYMODULE_WRITE (1 << 1)
/* ValkeyModule_OpenKey extra flags for the 'mode' argument.
* Avoid touching the LRU/LFU of the key when opened. */
#define VALKEYMODULE_OPEN_KEY_NOTOUCH (1 << 16)
/* Don't trigger keyspace event on key misses. */
#define VALKEYMODULE_OPEN_KEY_NONOTIFY (1 << 17)
/* Don't update keyspace hits/misses counters. */
#define VALKEYMODULE_OPEN_KEY_NOSTATS (1 << 18)
/* Avoid deleting lazy expired keys. */
#define VALKEYMODULE_OPEN_KEY_NOEXPIRE (1 << 19)
/* Avoid any effects from fetching the key */
#define VALKEYMODULE_OPEN_KEY_NOEFFECTS (1 << 20)
/* Mask of all VALKEYMODULE_OPEN_KEY_* values. Any new mode should be added to this list.
* Should not be used directly by the module, use RM_GetOpenKeyModesAll instead.
* Located here so when we will add new modes we will not forget to update it. */
#define _VALKEYMODULE_OPEN_KEY_ALL \
VALKEYMODULE_READ | VALKEYMODULE_WRITE | VALKEYMODULE_OPEN_KEY_NOTOUCH | VALKEYMODULE_OPEN_KEY_NONOTIFY | \
VALKEYMODULE_OPEN_KEY_NOSTATS | VALKEYMODULE_OPEN_KEY_NOEXPIRE | VALKEYMODULE_OPEN_KEY_NOEFFECTS
/* List push and pop */
#define VALKEYMODULE_LIST_HEAD 0
#define VALKEYMODULE_LIST_TAIL 1
/* Key types. */
#define VALKEYMODULE_KEYTYPE_EMPTY 0
#define VALKEYMODULE_KEYTYPE_STRING 1
#define VALKEYMODULE_KEYTYPE_LIST 2
#define VALKEYMODULE_KEYTYPE_HASH 3
#define VALKEYMODULE_KEYTYPE_SET 4
#define VALKEYMODULE_KEYTYPE_ZSET 5
#define VALKEYMODULE_KEYTYPE_MODULE 6
#define VALKEYMODULE_KEYTYPE_STREAM 7
/* Reply types. */
#define VALKEYMODULE_REPLY_UNKNOWN -1
#define VALKEYMODULE_REPLY_STRING 0
#define VALKEYMODULE_REPLY_ERROR 1
#define VALKEYMODULE_REPLY_INTEGER 2
#define VALKEYMODULE_REPLY_ARRAY 3
#define VALKEYMODULE_REPLY_NULL 4
#define VALKEYMODULE_REPLY_MAP 5
#define VALKEYMODULE_REPLY_SET 6
#define VALKEYMODULE_REPLY_BOOL 7
#define VALKEYMODULE_REPLY_DOUBLE 8
#define VALKEYMODULE_REPLY_BIG_NUMBER 9
#define VALKEYMODULE_REPLY_VERBATIM_STRING 10
#define VALKEYMODULE_REPLY_ATTRIBUTE 11
#define VALKEYMODULE_REPLY_PROMISE 12
/* Postponed array length. */
#define VALKEYMODULE_POSTPONED_ARRAY_LEN -1 /* Deprecated, please use VALKEYMODULE_POSTPONED_LEN */
#define VALKEYMODULE_POSTPONED_LEN -1
/* Expire */
#define VALKEYMODULE_NO_EXPIRE -1
/* Sorted set API flags. */
#define VALKEYMODULE_ZADD_XX (1 << 0)
#define VALKEYMODULE_ZADD_NX (1 << 1)
#define VALKEYMODULE_ZADD_ADDED (1 << 2)
#define VALKEYMODULE_ZADD_UPDATED (1 << 3)
#define VALKEYMODULE_ZADD_NOP (1 << 4)
#define VALKEYMODULE_ZADD_GT (1 << 5)
#define VALKEYMODULE_ZADD_LT (1 << 6)
/* Hash API flags. */
#define VALKEYMODULE_HASH_NONE 0
#define VALKEYMODULE_HASH_NX (1 << 0)
#define VALKEYMODULE_HASH_XX (1 << 1)
#define VALKEYMODULE_HASH_CFIELDS (1 << 2)
#define VALKEYMODULE_HASH_EXISTS (1 << 3)
#define VALKEYMODULE_HASH_COUNT_ALL (1 << 4)
#define VALKEYMODULE_CONFIG_DEFAULT 0 /* This is the default for a module config. */
#define VALKEYMODULE_CONFIG_IMMUTABLE (1ULL << 0) /* Can this value only be set at startup? */
#define VALKEYMODULE_CONFIG_SENSITIVE (1ULL << 1) /* Does this value contain sensitive information */
#define VALKEYMODULE_CONFIG_HIDDEN \
(1ULL << 4) /* This config is hidden in `config get <pattern>` (used for tests/debugging) */
#define VALKEYMODULE_CONFIG_PROTECTED (1ULL << 5) /* Becomes immutable if enable-protected-configs is enabled. */
#define VALKEYMODULE_CONFIG_DENY_LOADING (1ULL << 6) /* This config is forbidden during loading. */
#define VALKEYMODULE_CONFIG_MEMORY (1ULL << 7) /* Indicates if this value can be set as a memory value */
#define VALKEYMODULE_CONFIG_BITFLAGS (1ULL << 8) /* Indicates if this value can be set as a multiple enum values */
/* StreamID type. */
typedef struct ValkeyModuleStreamID {
uint64_t ms;
uint64_t seq;
} ValkeyModuleStreamID;
/* StreamAdd() flags. */
#define VALKEYMODULE_STREAM_ADD_AUTOID (1 << 0)
/* StreamIteratorStart() flags. */
#define VALKEYMODULE_STREAM_ITERATOR_EXCLUSIVE (1 << 0)
#define VALKEYMODULE_STREAM_ITERATOR_REVERSE (1 << 1)
/* StreamIteratorTrim*() flags. */
#define VALKEYMODULE_STREAM_TRIM_APPROX (1 << 0)
/* Context Flags: Info about the current context returned by
* RM_GetContextFlags(). */
/* The command is running in the context of a Lua script */
#define VALKEYMODULE_CTX_FLAGS_LUA (1 << 0)
/* The command is running inside a Valkey transaction */
#define VALKEYMODULE_CTX_FLAGS_MULTI (1 << 1)
/* The instance is a primary */
#define VALKEYMODULE_CTX_FLAGS_PRIMARY (1 << 2)
/* The instance is a replic */
#define VALKEYMODULE_CTX_FLAGS_REPLICA (1 << 3)
/* The instance is read-only (usually meaning it's a replica as well) */
#define VALKEYMODULE_CTX_FLAGS_READONLY (1 << 4)
/* The instance is running in cluster mode */
#define VALKEYMODULE_CTX_FLAGS_CLUSTER (1 << 5)
/* The instance has AOF enabled */
#define VALKEYMODULE_CTX_FLAGS_AOF (1 << 6)
/* The instance has RDB enabled */
#define VALKEYMODULE_CTX_FLAGS_RDB (1 << 7)
/* The instance has Maxmemory set */
#define VALKEYMODULE_CTX_FLAGS_MAXMEMORY (1 << 8)
/* Maxmemory is set and has an eviction policy that may delete keys */
#define VALKEYMODULE_CTX_FLAGS_EVICT (1 << 9)
/* Valkey is out of memory according to the maxmemory flag. */
#define VALKEYMODULE_CTX_FLAGS_OOM (1 << 10)
/* Less than 25% of memory available according to maxmemory. */
#define VALKEYMODULE_CTX_FLAGS_OOM_WARNING (1 << 11)
/* The command was sent over the replication link. */
#define VALKEYMODULE_CTX_FLAGS_REPLICATED (1 << 12)
/* Valkey is currently loading either from AOF or RDB. */
#define VALKEYMODULE_CTX_FLAGS_LOADING (1 << 13)
/* The replica has no link with its primary, note that
* there is the inverse flag as well:
*
* VALKEYMODULE_CTX_FLAGS_REPLICA_IS_ONLINE
*
* The two flags are exclusive, one or the other can be set. */
#define VALKEYMODULE_CTX_FLAGS_REPLICA_IS_STALE (1 << 14)
/* The replica is trying to connect with the primary.
* (REPL_STATE_CONNECT and REPL_STATE_CONNECTING states) */
#define VALKEYMODULE_CTX_FLAGS_REPLICA_IS_CONNECTING (1 << 15)
/* THe replica is receiving an RDB file from its primary. */
#define VALKEYMODULE_CTX_FLAGS_REPLICA_IS_TRANSFERRING (1 << 16)
/* The replica is online, receiving updates from its primary. */
#define VALKEYMODULE_CTX_FLAGS_REPLICA_IS_ONLINE (1 << 17)
/* There is currently some background process active. */
#define VALKEYMODULE_CTX_FLAGS_ACTIVE_CHILD (1 << 18)
/* The next EXEC will fail due to dirty CAS (touched keys). */
#define VALKEYMODULE_CTX_FLAGS_MULTI_DIRTY (1 << 19)
/* Valkey is currently running inside background child process. */
#define VALKEYMODULE_CTX_FLAGS_IS_CHILD (1 << 20)
/* The current client does not allow blocking, either called from
* within multi, lua, or from another module using RM_Call */
#define VALKEYMODULE_CTX_FLAGS_DENY_BLOCKING (1 << 21)
/* The current client uses RESP3 protocol */
#define VALKEYMODULE_CTX_FLAGS_RESP3 (1 << 22)
/* Valkey is currently async loading database for diskless replication. */
#define VALKEYMODULE_CTX_FLAGS_ASYNC_LOADING (1 << 23)
/* Valkey is starting. */
#define VALKEYMODULE_CTX_FLAGS_SERVER_STARTUP (1 << 24)
/* Next context flag, must be updated when adding new flags above!
This flag should not be used directly by the module.
* Use ValkeyModule_GetContextFlagsAll instead. */
#define _VALKEYMODULE_CTX_FLAGS_NEXT (1 << 25)
/* Keyspace changes notification classes. Every class is associated with a
* character for configuration purposes.
* NOTE: These have to be in sync with NOTIFY_* in server.h */
#define VALKEYMODULE_NOTIFY_KEYSPACE (1 << 0) /* K */
#define VALKEYMODULE_NOTIFY_KEYEVENT (1 << 1) /* E */
#define VALKEYMODULE_NOTIFY_GENERIC (1 << 2) /* g */
#define VALKEYMODULE_NOTIFY_STRING (1 << 3) /* $ */
#define VALKEYMODULE_NOTIFY_LIST (1 << 4) /* l */
#define VALKEYMODULE_NOTIFY_SET (1 << 5) /* s */
#define VALKEYMODULE_NOTIFY_HASH (1 << 6) /* h */
#define VALKEYMODULE_NOTIFY_ZSET (1 << 7) /* z */
#define VALKEYMODULE_NOTIFY_EXPIRED (1 << 8) /* x */
#define VALKEYMODULE_NOTIFY_EVICTED (1 << 9) /* e */
#define VALKEYMODULE_NOTIFY_STREAM (1 << 10) /* t */
#define VALKEYMODULE_NOTIFY_KEY_MISS \
(1 << 11) /* m (Note: This one is excluded from VALKEYMODULE_NOTIFY_ALL on purpose) */
#define VALKEYMODULE_NOTIFY_LOADED (1 << 12) /* module only key space notification, indicate a key loaded from rdb */
#define VALKEYMODULE_NOTIFY_MODULE (1 << 13) /* d, module key space notification */
#define VALKEYMODULE_NOTIFY_NEW (1 << 14) /* n, new key notification */
/* Next notification flag, must be updated when adding new flags above!
This flag should not be used directly by the module.
* Use ValkeyModule_GetKeyspaceNotificationFlagsAll instead. */
#define _VALKEYMODULE_NOTIFY_NEXT (1 << 15)
#define VALKEYMODULE_NOTIFY_ALL \
(VALKEYMODULE_NOTIFY_GENERIC | VALKEYMODULE_NOTIFY_STRING | VALKEYMODULE_NOTIFY_LIST | VALKEYMODULE_NOTIFY_SET | \
VALKEYMODULE_NOTIFY_HASH | VALKEYMODULE_NOTIFY_ZSET | VALKEYMODULE_NOTIFY_EXPIRED | VALKEYMODULE_NOTIFY_EVICTED | \
VALKEYMODULE_NOTIFY_STREAM | VALKEYMODULE_NOTIFY_MODULE) /* A */
/* A special pointer that we can use between the core and the module to signal
* field deletion, and that is impossible to be a valid pointer. */
#define VALKEYMODULE_HASH_DELETE ((ValkeyModuleString *)(long)1)
/* Error messages. */
#define VALKEYMODULE_ERRORMSG_WRONGTYPE "WRONGTYPE Operation against a key holding the wrong kind of value"
#define VALKEYMODULE_POSITIVE_INFINITE (1.0 / 0.0)
#define VALKEYMODULE_NEGATIVE_INFINITE (-1.0 / 0.0)
/* Cluster API defines. */
#define VALKEYMODULE_NODE_ID_LEN 40
#define VALKEYMODULE_NODE_MYSELF (1 << 0)
#define VALKEYMODULE_NODE_PRIMARY (1 << 1)
#define VALKEYMODULE_NODE_REPLICA (1 << 2)
#define VALKEYMODULE_NODE_PFAIL (1 << 3)
#define VALKEYMODULE_NODE_FAIL (1 << 4)
#define VALKEYMODULE_NODE_NOFAILOVER (1 << 5)
#define VALKEYMODULE_CLUSTER_FLAG_NONE 0
#define VALKEYMODULE_CLUSTER_FLAG_NO_FAILOVER (1 << 1)
#define VALKEYMODULE_CLUSTER_FLAG_NO_REDIRECTION (1 << 2)
#define VALKEYMODULE_NOT_USED(V) ((void)V)
/* Logging level strings */
#define VALKEYMODULE_LOGLEVEL_DEBUG "debug"
#define VALKEYMODULE_LOGLEVEL_VERBOSE "verbose"
#define VALKEYMODULE_LOGLEVEL_NOTICE "notice"
#define VALKEYMODULE_LOGLEVEL_WARNING "warning"
/* Bit flags for aux_save_triggers and the aux_load and aux_save callbacks */
#define VALKEYMODULE_AUX_BEFORE_RDB (1 << 0)
#define VALKEYMODULE_AUX_AFTER_RDB (1 << 1)
/* RM_Yield flags */
#define VALKEYMODULE_YIELD_FLAG_NONE (1 << 0)
#define VALKEYMODULE_YIELD_FLAG_CLIENTS (1 << 1)
/* RM_BlockClientOnKeysWithFlags flags */
#define VALKEYMODULE_BLOCK_UNBLOCK_DEFAULT (0)
#define VALKEYMODULE_BLOCK_UNBLOCK_DELETED (1 << 0)
/* This type represents a timer handle, and is returned when a timer is
* registered and used in order to invalidate a timer. It's just a 64 bit
* number, because this is how each timer is represented inside the radix tree
* of timers that are going to expire, sorted by expire time. */
typedef uint64_t ValkeyModuleTimerID;
/* CommandFilter Flags */
/* Do filter ValkeyModule_Call() commands initiated by module itself. */
#define VALKEYMODULE_CMDFILTER_NOSELF (1 << 0)
/* Declare that the module can handle errors with ValkeyModule_SetModuleOptions. */
#define VALKEYMODULE_OPTIONS_HANDLE_IO_ERRORS (1 << 0)
/* When set, Valkey will not call ValkeyModule_SignalModifiedKey(), implicitly in
* ValkeyModule_CloseKey, and the module needs to do that when manually when keys
* are modified from the user's perspective, to invalidate WATCH. */
#define VALKEYMODULE_OPTION_NO_IMPLICIT_SIGNAL_MODIFIED (1 << 1)
/* Declare that the module can handle diskless async replication with ValkeyModule_SetModuleOptions. */
#define VALKEYMODULE_OPTIONS_HANDLE_REPL_ASYNC_LOAD (1 << 2)
/* Declare that the module want to get nested key space notifications.
* If enabled, the module is responsible to break endless loop. */
#define VALKEYMODULE_OPTIONS_ALLOW_NESTED_KEYSPACE_NOTIFICATIONS (1 << 3)
/* Next option flag, must be updated when adding new module flags above!
* This flag should not be used directly by the module.
* Use ValkeyModule_GetModuleOptionsAll instead. */
#define _VALKEYMODULE_OPTIONS_FLAGS_NEXT (1 << 4)
/* Definitions for ValkeyModule_SetCommandInfo. */
typedef enum {
VALKEYMODULE_ARG_TYPE_STRING,
VALKEYMODULE_ARG_TYPE_INTEGER,
VALKEYMODULE_ARG_TYPE_DOUBLE,
VALKEYMODULE_ARG_TYPE_KEY, /* A string, but represents a keyname */
VALKEYMODULE_ARG_TYPE_PATTERN,
VALKEYMODULE_ARG_TYPE_UNIX_TIME,
VALKEYMODULE_ARG_TYPE_PURE_TOKEN,
VALKEYMODULE_ARG_TYPE_ONEOF, /* Must have sub-arguments */
VALKEYMODULE_ARG_TYPE_BLOCK /* Must have sub-arguments */
} ValkeyModuleCommandArgType;
#define VALKEYMODULE_CMD_ARG_NONE (0)
#define VALKEYMODULE_CMD_ARG_OPTIONAL (1 << 0) /* The argument is optional (like GET in SET command) */
#define VALKEYMODULE_CMD_ARG_MULTIPLE (1 << 1) /* The argument may repeat itself (like key in DEL) */
#define VALKEYMODULE_CMD_ARG_MULTIPLE_TOKEN \
(1 << 2) /* The argument may repeat itself, and so does its token (like `GET pattern` in SORT) */
#define _VALKEYMODULE_CMD_ARG_NEXT (1 << 3)
typedef enum {
VALKEYMODULE_KSPEC_BS_INVALID = 0, /* Must be zero. An implicitly value of
* zero is provided when the field is
* absent in a struct literal. */
VALKEYMODULE_KSPEC_BS_UNKNOWN,
VALKEYMODULE_KSPEC_BS_INDEX,
VALKEYMODULE_KSPEC_BS_KEYWORD
} ValkeyModuleKeySpecBeginSearchType;
typedef enum {
VALKEYMODULE_KSPEC_FK_OMITTED = 0, /* Used when the field is absent in a
* struct literal. Don't use this value
* explicitly. */
VALKEYMODULE_KSPEC_FK_UNKNOWN,
VALKEYMODULE_KSPEC_FK_RANGE,
VALKEYMODULE_KSPEC_FK_KEYNUM
} ValkeyModuleKeySpecFindKeysType;
/* Key-spec flags. For details, see the documentation of
* ValkeyModule_SetCommandInfo and the key-spec flags in server.h. */
#define VALKEYMODULE_CMD_KEY_RO (1ULL << 0)
#define VALKEYMODULE_CMD_KEY_RW (1ULL << 1)
#define VALKEYMODULE_CMD_KEY_OW (1ULL << 2)
#define VALKEYMODULE_CMD_KEY_RM (1ULL << 3)
#define VALKEYMODULE_CMD_KEY_ACCESS (1ULL << 4)
#define VALKEYMODULE_CMD_KEY_UPDATE (1ULL << 5)
#define VALKEYMODULE_CMD_KEY_INSERT (1ULL << 6)
#define VALKEYMODULE_CMD_KEY_DELETE (1ULL << 7)
#define VALKEYMODULE_CMD_KEY_NOT_KEY (1ULL << 8)
#define VALKEYMODULE_CMD_KEY_INCOMPLETE (1ULL << 9)
#define VALKEYMODULE_CMD_KEY_VARIABLE_FLAGS (1ULL << 10)
/* Channel flags, for details see the documentation of
* ValkeyModule_ChannelAtPosWithFlags. */
#define VALKEYMODULE_CMD_CHANNEL_PATTERN (1ULL << 0)
#define VALKEYMODULE_CMD_CHANNEL_PUBLISH (1ULL << 1)
#define VALKEYMODULE_CMD_CHANNEL_SUBSCRIBE (1ULL << 2)
#define VALKEYMODULE_CMD_CHANNEL_UNSUBSCRIBE (1ULL << 3)
typedef struct ValkeyModuleCommandArg {
const char *name;
ValkeyModuleCommandArgType type;
int key_spec_index; /* If type is KEY, this is a zero-based index of
* the key_spec in the command. For other types,
* you may specify -1. */
const char *token; /* If type is PURE_TOKEN, this is the token. */
const char *summary;
const char *since;
int flags; /* The VALKEYMODULE_CMD_ARG_* macros. */
const char *deprecated_since;
struct ValkeyModuleCommandArg *subargs;
const char *display_text;
} ValkeyModuleCommandArg;
typedef struct {
const char *since;
const char *changes;
} ValkeyModuleCommandHistoryEntry;
typedef struct {
const char *notes;
uint64_t flags; /* VALKEYMODULE_CMD_KEY_* macros. */
ValkeyModuleKeySpecBeginSearchType begin_search_type;
union {
struct {
/* The index from which we start the search for keys */
int pos;
} index;
struct {
/* The keyword that indicates the beginning of key args */
const char *keyword;
/* An index in argv from which to start searching.
* Can be negative, which means start search from the end, in reverse
* (Example: -2 means to start in reverse from the penultimate arg) */
int startfrom;
} keyword;
} bs;
ValkeyModuleKeySpecFindKeysType find_keys_type;
union {
struct {
/* Index of the last key relative to the result of the begin search
* step. Can be negative, in which case it's not relative. -1
* indicating till the last argument, -2 one before the last and so
* on. */
int lastkey;
/* How many args should we skip after finding a key, in order to
* find the next one. */
int keystep;
/* If lastkey is -1, we use limit to stop the search by a factor. 0
* and 1 mean no limit. 2 means 1/2 of the remaining args, 3 means
* 1/3, and so on. */
int limit;
} range;
struct {
/* Index of the argument containing the number of keys to come
* relative to the result of the begin search step */
int keynumidx;
/* Index of the fist key. (Usually it's just after keynumidx, in
* which case it should be set to keynumidx + 1.) */
int firstkey;
/* How many args should we skip after finding a key, in order to
* find the next one, relative to the result of the begin search
* step. */
int keystep;
} keynum;
} fk;
} ValkeyModuleCommandKeySpec;
typedef struct {
int version;
size_t sizeof_historyentry;
size_t sizeof_keyspec;
size_t sizeof_arg;
} ValkeyModuleCommandInfoVersion;
static const ValkeyModuleCommandInfoVersion ValkeyModule_CurrentCommandInfoVersion = {
.version = 1,
.sizeof_historyentry = sizeof(ValkeyModuleCommandHistoryEntry),
.sizeof_keyspec = sizeof(ValkeyModuleCommandKeySpec),
.sizeof_arg = sizeof(ValkeyModuleCommandArg)};
#define VALKEYMODULE_COMMAND_INFO_VERSION (&ValkeyModule_CurrentCommandInfoVersion)
typedef struct {
/* Always set version to VALKEYMODULE_COMMAND_INFO_VERSION */
const ValkeyModuleCommandInfoVersion *version;
const char *summary; /* Summary of the command */
const char *complexity; /* Complexity description */
const char *since; /* Debut module version of the command */
ValkeyModuleCommandHistoryEntry *history; /* History */
/* A string of space-separated tips meant for clients/proxies regarding this
* command */
const char *tips;
/* Number of arguments, it is possible to use -N to say >= N */
int arity;
ValkeyModuleCommandKeySpec *key_specs;
ValkeyModuleCommandArg *args;
} ValkeyModuleCommandInfo;
/* Eventloop definitions. */
#define VALKEYMODULE_EVENTLOOP_READABLE 1
#define VALKEYMODULE_EVENTLOOP_WRITABLE 2
typedef void (*ValkeyModuleEventLoopFunc)(int fd, void *user_data, int mask);
typedef void (*ValkeyModuleEventLoopOneShotFunc)(void *user_data);
/* Server events definitions.
* Those flags should not be used directly by the module, instead
* the module should use ValkeyModuleEvent_* variables.
* Note: This must be synced with moduleEventVersions */
#define VALKEYMODULE_EVENT_REPLICATION_ROLE_CHANGED 0
#define VALKEYMODULE_EVENT_PERSISTENCE 1
#define VALKEYMODULE_EVENT_FLUSHDB 2
#define VALKEYMODULE_EVENT_LOADING 3
#define VALKEYMODULE_EVENT_CLIENT_CHANGE 4
#define VALKEYMODULE_EVENT_SHUTDOWN 5
#define VALKEYMODULE_EVENT_REPLICA_CHANGE 6
#define VALKEYMODULE_EVENT_PRIMARY_LINK_CHANGE 7
#define VALKEYMODULE_EVENT_CRON_LOOP 8
#define VALKEYMODULE_EVENT_MODULE_CHANGE 9
#define VALKEYMODULE_EVENT_LOADING_PROGRESS 10
#define VALKEYMODULE_EVENT_SWAPDB 11
#define VALKEYMODULE_EVENT_REPL_BACKUP 12 /* Not used anymore. */
#define VALKEYMODULE_EVENT_FORK_CHILD 13
#define VALKEYMODULE_EVENT_REPL_ASYNC_LOAD 14
#define VALKEYMODULE_EVENT_EVENTLOOP 15
#define VALKEYMODULE_EVENT_CONFIG 16
#define VALKEYMODULE_EVENT_KEY 17
#define _VALKEYMODULE_EVENT_NEXT 18 /* Next event flag, should be updated if a new event added. */
typedef struct ValkeyModuleEvent {
uint64_t id; /* VALKEYMODULE_EVENT_... defines. */
uint64_t dataver; /* Version of the structure we pass as 'data'. */
} ValkeyModuleEvent;
struct ValkeyModuleCtx;
struct ValkeyModuleDefragCtx;
typedef void (*ValkeyModuleEventCallback)(struct ValkeyModuleCtx *ctx,
ValkeyModuleEvent eid,
uint64_t subevent,
void *data);
/* IMPORTANT: When adding a new version of one of below structures that contain
* event data (ValkeyModuleFlushInfoV1 for example) we have to avoid renaming the
* old ValkeyModuleEvent structure.
* For example, if we want to add ValkeyModuleFlushInfoV2, the ValkeyModuleEvent
* structures should be:
* ValkeyModuleEvent_FlushDB = {
* VALKEYMODULE_EVENT_FLUSHDB,
* 1
* },
* ValkeyModuleEvent_FlushDBV2 = {
* VALKEYMODULE_EVENT_FLUSHDB,
* 2
* }
* and NOT:
* ValkeyModuleEvent_FlushDBV1 = {
* VALKEYMODULE_EVENT_FLUSHDB,
* 1
* },
* ValkeyModuleEvent_FlushDB = {
* VALKEYMODULE_EVENT_FLUSHDB,
* 2
* }
* The reason for that is forward-compatibility: We want that module that
* compiled with a new valkeymodule.h to be able to work with a old server,
* unless the author explicitly decided to use the newer event type.
*/
static const ValkeyModuleEvent ValkeyModuleEvent_ReplicationRoleChanged = {VALKEYMODULE_EVENT_REPLICATION_ROLE_CHANGED,
1},
ValkeyModuleEvent_Persistence = {VALKEYMODULE_EVENT_PERSISTENCE, 1},
ValkeyModuleEvent_FlushDB = {VALKEYMODULE_EVENT_FLUSHDB, 1},
ValkeyModuleEvent_Loading = {VALKEYMODULE_EVENT_LOADING, 1},
ValkeyModuleEvent_ClientChange = {VALKEYMODULE_EVENT_CLIENT_CHANGE, 1},
ValkeyModuleEvent_Shutdown = {VALKEYMODULE_EVENT_SHUTDOWN, 1},
ValkeyModuleEvent_ReplicaChange = {VALKEYMODULE_EVENT_REPLICA_CHANGE, 1},
ValkeyModuleEvent_CronLoop = {VALKEYMODULE_EVENT_CRON_LOOP, 1},
ValkeyModuleEvent_PrimaryLinkChange = {VALKEYMODULE_EVENT_PRIMARY_LINK_CHANGE, 1},
ValkeyModuleEvent_ModuleChange = {VALKEYMODULE_EVENT_MODULE_CHANGE, 1},
ValkeyModuleEvent_LoadingProgress = {VALKEYMODULE_EVENT_LOADING_PROGRESS, 1},
ValkeyModuleEvent_SwapDB = {VALKEYMODULE_EVENT_SWAPDB, 1},
ValkeyModuleEvent_ReplAsyncLoad = {VALKEYMODULE_EVENT_REPL_ASYNC_LOAD, 1},
ValkeyModuleEvent_ForkChild = {VALKEYMODULE_EVENT_FORK_CHILD, 1},
ValkeyModuleEvent_EventLoop = {VALKEYMODULE_EVENT_EVENTLOOP, 1},
ValkeyModuleEvent_Config = {VALKEYMODULE_EVENT_CONFIG, 1},
ValkeyModuleEvent_Key = {VALKEYMODULE_EVENT_KEY, 1};
/* Those are values that are used for the 'subevent' callback argument. */
#define VALKEYMODULE_SUBEVENT_PERSISTENCE_RDB_START 0
#define VALKEYMODULE_SUBEVENT_PERSISTENCE_AOF_START 1
#define VALKEYMODULE_SUBEVENT_PERSISTENCE_SYNC_RDB_START 2
#define VALKEYMODULE_SUBEVENT_PERSISTENCE_ENDED 3
#define VALKEYMODULE_SUBEVENT_PERSISTENCE_FAILED 4
#define VALKEYMODULE_SUBEVENT_PERSISTENCE_SYNC_AOF_START 5
#define _VALKEYMODULE_SUBEVENT_PERSISTENCE_NEXT 6
#define VALKEYMODULE_SUBEVENT_LOADING_RDB_START 0
#define VALKEYMODULE_SUBEVENT_LOADING_AOF_START 1
#define VALKEYMODULE_SUBEVENT_LOADING_REPL_START 2
#define VALKEYMODULE_SUBEVENT_LOADING_ENDED 3
#define VALKEYMODULE_SUBEVENT_LOADING_FAILED 4
#define _VALKEYMODULE_SUBEVENT_LOADING_NEXT 5
#define VALKEYMODULE_SUBEVENT_CLIENT_CHANGE_CONNECTED 0
#define VALKEYMODULE_SUBEVENT_CLIENT_CHANGE_DISCONNECTED 1
#define _VALKEYMODULE_SUBEVENT_CLIENT_CHANGE_NEXT 2
#define VALKEYMODULE_SUBEVENT_PRIMARY_LINK_UP 0
#define VALKEYMODULE_SUBEVENT_PRIMARY_LINK_DOWN 1
#define _VALKEYMODULE_SUBEVENT_PRIMARY_NEXT 2
#define VALKEYMODULE_SUBEVENT_REPLICA_CHANGE_ONLINE 0
#define VALKEYMODULE_SUBEVENT_REPLICA_CHANGE_OFFLINE 1
#define _VALKEYMODULE_SUBEVENT_REPLICA_CHANGE_NEXT 2
#define VALKEYMODULE_EVENT_REPLROLECHANGED_NOW_PRIMARY 0
#define VALKEYMODULE_EVENT_REPLROLECHANGED_NOW_REPLICA 1
#define _VALKEYMODULE_EVENT_REPLROLECHANGED_NEXT 2
#define VALKEYMODULE_SUBEVENT_FLUSHDB_START 0
#define VALKEYMODULE_SUBEVENT_FLUSHDB_END 1
#define _VALKEYMODULE_SUBEVENT_FLUSHDB_NEXT 2
#define VALKEYMODULE_SUBEVENT_MODULE_LOADED 0
#define VALKEYMODULE_SUBEVENT_MODULE_UNLOADED 1
#define _VALKEYMODULE_SUBEVENT_MODULE_NEXT 2
#define VALKEYMODULE_SUBEVENT_CONFIG_CHANGE 0
#define _VALKEYMODULE_SUBEVENT_CONFIG_NEXT 1
#define VALKEYMODULE_SUBEVENT_LOADING_PROGRESS_RDB 0
#define VALKEYMODULE_SUBEVENT_LOADING_PROGRESS_AOF 1
#define _VALKEYMODULE_SUBEVENT_LOADING_PROGRESS_NEXT 2
#define VALKEYMODULE_SUBEVENT_REPL_ASYNC_LOAD_STARTED 0
#define VALKEYMODULE_SUBEVENT_REPL_ASYNC_LOAD_ABORTED 1
#define VALKEYMODULE_SUBEVENT_REPL_ASYNC_LOAD_COMPLETED 2
#define _VALKEYMODULE_SUBEVENT_REPL_ASYNC_LOAD_NEXT 3
#define VALKEYMODULE_SUBEVENT_FORK_CHILD_BORN 0
#define VALKEYMODULE_SUBEVENT_FORK_CHILD_DIED 1
#define _VALKEYMODULE_SUBEVENT_FORK_CHILD_NEXT 2
#define VALKEYMODULE_SUBEVENT_EVENTLOOP_BEFORE_SLEEP 0
#define VALKEYMODULE_SUBEVENT_EVENTLOOP_AFTER_SLEEP 1
#define _VALKEYMODULE_SUBEVENT_EVENTLOOP_NEXT 2
#define VALKEYMODULE_SUBEVENT_KEY_DELETED 0
#define VALKEYMODULE_SUBEVENT_KEY_EXPIRED 1
#define VALKEYMODULE_SUBEVENT_KEY_EVICTED 2
#define VALKEYMODULE_SUBEVENT_KEY_OVERWRITTEN 3
#define _VALKEYMODULE_SUBEVENT_KEY_NEXT 4
#define _VALKEYMODULE_SUBEVENT_SHUTDOWN_NEXT 0
#define _VALKEYMODULE_SUBEVENT_CRON_LOOP_NEXT 0
#define _VALKEYMODULE_SUBEVENT_SWAPDB_NEXT 0
/* ValkeyModuleClientInfo flags. */
#define VALKEYMODULE_CLIENTINFO_FLAG_SSL (1 << 0)
#define VALKEYMODULE_CLIENTINFO_FLAG_PUBSUB (1 << 1)
#define VALKEYMODULE_CLIENTINFO_FLAG_BLOCKED (1 << 2)
#define VALKEYMODULE_CLIENTINFO_FLAG_TRACKING (1 << 3)
#define VALKEYMODULE_CLIENTINFO_FLAG_UNIXSOCKET (1 << 4)
#define VALKEYMODULE_CLIENTINFO_FLAG_MULTI (1 << 5)
/* Here we take all the structures that the module pass to the core
* and the other way around. Notably the list here contains the structures
* used by the hooks API ValkeyModule_RegisterToServerEvent().
*
* The structures always start with a 'version' field. This is useful
* when we want to pass a reference to the structure to the core APIs,
* for the APIs to fill the structure. In that case, the structure 'version'
* field is initialized before passing it to the core, so that the core is
* able to cast the pointer to the appropriate structure version. In this
* way we obtain ABI compatibility.
*
* Here we'll list all the structure versions in case they evolve over time,
* however using a define, we'll make sure to use the last version as the
* public name for the module to use. */
#define VALKEYMODULE_CLIENTINFO_VERSION 1
typedef struct ValkeyModuleClientInfo {
uint64_t version; /* Version of this structure for ABI compat. */
uint64_t flags; /* VALKEYMODULE_CLIENTINFO_FLAG_* */
uint64_t id; /* Client ID. */
char addr[46]; /* IPv4 or IPv6 address. */
uint16_t port; /* TCP port. */
uint16_t db; /* Selected DB. */
} ValkeyModuleClientInfoV1;
#define ValkeyModuleClientInfo ValkeyModuleClientInfoV1
#define VALKEYMODULE_CLIENTINFO_INITIALIZER_V1 {.version = 1}
#define VALKEYMODULE_REPLICATIONINFO_VERSION 1
typedef struct ValkeyModuleReplicationInfo {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
int master; /* true if primary, false if replica */
char *masterhost; /* primary instance hostname for NOW_REPLICA */
int masterport; /* primary instance port for NOW_REPLICA */
char *replid1; /* Main replication ID */
char *replid2; /* Secondary replication ID */
uint64_t repl1_offset; /* Main replication offset */
uint64_t repl2_offset; /* Offset of replid2 validity */
} ValkeyModuleReplicationInfoV1;
#define ValkeyModuleReplicationInfo ValkeyModuleReplicationInfoV1
#define VALKEYMODULE_FLUSHINFO_VERSION 1
typedef struct ValkeyModuleFlushInfo {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
int32_t sync; /* Synchronous or threaded flush?. */
int32_t dbnum; /* Flushed database number, -1 for ALL. */
} ValkeyModuleFlushInfoV1;
#define ValkeyModuleFlushInfo ValkeyModuleFlushInfoV1
#define VALKEYMODULE_MODULE_CHANGE_VERSION 1
typedef struct ValkeyModuleModuleChange {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
const char *module_name; /* Name of module loaded or unloaded. */
int32_t module_version; /* Module version. */
} ValkeyModuleModuleChangeV1;
#define ValkeyModuleModuleChange ValkeyModuleModuleChangeV1
#define VALKEYMODULE_CONFIGCHANGE_VERSION 1
typedef struct ValkeyModuleConfigChange {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
uint32_t num_changes; /* how many Valkey config options were changed */
const char **config_names; /* the config names that were changed */
} ValkeyModuleConfigChangeV1;
#define ValkeyModuleConfigChange ValkeyModuleConfigChangeV1
#define VALKEYMODULE_CRON_LOOP_VERSION 1
typedef struct ValkeyModuleCronLoopInfo {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
int32_t hz; /* Approximate number of events per second. */
} ValkeyModuleCronLoopV1;
#define ValkeyModuleCronLoop ValkeyModuleCronLoopV1
#define VALKEYMODULE_LOADING_PROGRESS_VERSION 1
typedef struct ValkeyModuleLoadingProgressInfo {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
int32_t hz; /* Approximate number of events per second. */
int32_t progress; /* Approximate progress between 0 and 1024, or -1
* if unknown. */
} ValkeyModuleLoadingProgressV1;
#define ValkeyModuleLoadingProgress ValkeyModuleLoadingProgressV1
#define VALKEYMODULE_SWAPDBINFO_VERSION 1
typedef struct ValkeyModuleSwapDbInfo {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
int32_t dbnum_first; /* Swap Db first dbnum */
int32_t dbnum_second; /* Swap Db second dbnum */
} ValkeyModuleSwapDbInfoV1;
#define ValkeyModuleSwapDbInfo ValkeyModuleSwapDbInfoV1
#define VALKEYMODULE_KEYINFO_VERSION 1
typedef struct ValkeyModuleKeyInfo {
uint64_t version; /* Not used since this structure is never passed
from the module to the core right now. Here
for future compatibility. */
ValkeyModuleKey *key; /* Opened key. */
} ValkeyModuleKeyInfoV1;
#define ValkeyModuleKeyInfo ValkeyModuleKeyInfoV1
typedef enum {
VALKEYMODULE_ACL_LOG_AUTH = 0, /* Authentication failure */
VALKEYMODULE_ACL_LOG_CMD, /* Command authorization failure */
VALKEYMODULE_ACL_LOG_KEY, /* Key authorization failure */
VALKEYMODULE_ACL_LOG_CHANNEL /* Channel authorization failure */
} ValkeyModuleACLLogEntryReason;
/* Incomplete structures needed by both the core and modules. */
typedef struct ValkeyModuleIO ValkeyModuleIO;
typedef struct ValkeyModuleDigest ValkeyModuleDigest;
typedef struct ValkeyModuleInfoCtx ValkeyModuleInfoCtx;
typedef struct ValkeyModuleDefragCtx ValkeyModuleDefragCtx;
/* Function pointers needed by both the core and modules, these needs to be
* exposed since you can't cast a function pointer to (void *). */
typedef void (*ValkeyModuleInfoFunc)(ValkeyModuleInfoCtx *ctx, int for_crash_report);
typedef void (*ValkeyModuleDefragFunc)(ValkeyModuleDefragCtx *ctx);
typedef void (*ValkeyModuleUserChangedFunc)(uint64_t client_id, void *privdata);
/* ------------------------- End of common defines ------------------------ */
/* ----------- The rest of the defines are only for modules ----------------- */
#if !defined VALKEYMODULE_CORE || defined VALKEYMODULE_CORE_MODULE
/* Things defined for modules and core-modules. */
/* Macro definitions specific to individual compilers */
#ifndef VALKEYMODULE_ATTR_UNUSED
#ifdef __GNUC__
#define VALKEYMODULE_ATTR_UNUSED __attribute__((unused))
#else
#define VALKEYMODULE_ATTR_UNUSED
#endif
#endif
#ifndef VALKEYMODULE_ATTR_PRINTF
#ifdef __GNUC__
#define VALKEYMODULE_ATTR_PRINTF(idx, cnt) __attribute__((format(printf, idx, cnt)))
#else
#define VALKEYMODULE_ATTR_PRINTF(idx, cnt)
#endif
#endif
#ifndef VALKEYMODULE_ATTR_COMMON
#if defined(__GNUC__) && !(defined(__clang__) && defined(__cplusplus))
#define VALKEYMODULE_ATTR_COMMON __attribute__((__common__))
#else
#define VALKEYMODULE_ATTR_COMMON
#endif
#endif
/* Incomplete structures for compiler checks but opaque access. */
typedef struct ValkeyModuleCtx ValkeyModuleCtx;
typedef struct ValkeyModuleCommand ValkeyModuleCommand;
typedef struct ValkeyModuleCallReply ValkeyModuleCallReply;
typedef struct ValkeyModuleType ValkeyModuleType;
typedef struct ValkeyModuleBlockedClient ValkeyModuleBlockedClient;
typedef struct ValkeyModuleClusterInfo ValkeyModuleClusterInfo;
typedef struct ValkeyModuleDict ValkeyModuleDict;
typedef struct ValkeyModuleDictIter ValkeyModuleDictIter;
typedef struct ValkeyModuleCommandFilterCtx ValkeyModuleCommandFilterCtx;
typedef struct ValkeyModuleCommandFilter ValkeyModuleCommandFilter;
typedef struct ValkeyModuleServerInfoData ValkeyModuleServerInfoData;
typedef struct ValkeyModuleScanCursor ValkeyModuleScanCursor;
typedef struct ValkeyModuleUser ValkeyModuleUser;
typedef struct ValkeyModuleKeyOptCtx ValkeyModuleKeyOptCtx;
typedef struct ValkeyModuleRdbStream ValkeyModuleRdbStream;
typedef int (*ValkeyModuleCmdFunc)(ValkeyModuleCtx *ctx, ValkeyModuleString **argv, int argc);
typedef void (*ValkeyModuleDisconnectFunc)(ValkeyModuleCtx *ctx, ValkeyModuleBlockedClient *bc);
typedef int (*ValkeyModuleNotificationFunc)(ValkeyModuleCtx *ctx, int type, const char *event, ValkeyModuleString *key);
typedef void (*ValkeyModulePostNotificationJobFunc)(ValkeyModuleCtx *ctx, void *pd);
typedef void *(*ValkeyModuleTypeLoadFunc)(ValkeyModuleIO *rdb, int encver);
typedef void (*ValkeyModuleTypeSaveFunc)(ValkeyModuleIO *rdb, void *value);
typedef int (*ValkeyModuleTypeAuxLoadFunc)(ValkeyModuleIO *rdb, int encver, int when);
typedef void (*ValkeyModuleTypeAuxSaveFunc)(ValkeyModuleIO *rdb, int when);
typedef void (*ValkeyModuleTypeRewriteFunc)(ValkeyModuleIO *aof, ValkeyModuleString *key, void *value);
typedef size_t (*ValkeyModuleTypeMemUsageFunc)(const void *value);
typedef size_t (*ValkeyModuleTypeMemUsageFunc2)(ValkeyModuleKeyOptCtx *ctx, const void *value, size_t sample_size);
typedef void (*ValkeyModuleTypeDigestFunc)(ValkeyModuleDigest *digest, void *value);
typedef void (*ValkeyModuleTypeFreeFunc)(void *value);
typedef size_t (*ValkeyModuleTypeFreeEffortFunc)(ValkeyModuleString *key, const void *value);
typedef size_t (*ValkeyModuleTypeFreeEffortFunc2)(ValkeyModuleKeyOptCtx *ctx, const void *value);
typedef void (*ValkeyModuleTypeUnlinkFunc)(ValkeyModuleString *key, const void *value);
typedef void (*ValkeyModuleTypeUnlinkFunc2)(ValkeyModuleKeyOptCtx *ctx, const void *value);
typedef void *(*ValkeyModuleTypeCopyFunc)(ValkeyModuleString *fromkey, ValkeyModuleString *tokey, const void *value);
typedef void *(*ValkeyModuleTypeCopyFunc2)(ValkeyModuleKeyOptCtx *ctx, const void *value);
typedef int (*ValkeyModuleTypeDefragFunc)(ValkeyModuleDefragCtx *ctx, ValkeyModuleString *key, void **value);
typedef void (*ValkeyModuleClusterMessageReceiver)(ValkeyModuleCtx *ctx,
const char *sender_id,
uint8_t type,
const unsigned char *payload,
uint32_t len);
typedef void (*ValkeyModuleTimerProc)(ValkeyModuleCtx *ctx, void *data);
typedef void (*ValkeyModuleCommandFilterFunc)(ValkeyModuleCommandFilterCtx *filter);
typedef void (*ValkeyModuleForkDoneHandler)(int exitcode, int bysignal, void *user_data);
typedef void (*ValkeyModuleScanCB)(ValkeyModuleCtx *ctx,
ValkeyModuleString *keyname,
ValkeyModuleKey *key,
void *privdata);
typedef void (*ValkeyModuleScanKeyCB)(ValkeyModuleKey *key,
ValkeyModuleString *field,
ValkeyModuleString *value,
void *privdata);
typedef ValkeyModuleString *(*ValkeyModuleConfigGetStringFunc)(const char *name, void *privdata);
typedef long long (*ValkeyModuleConfigGetNumericFunc)(const char *name, void *privdata);
typedef int (*ValkeyModuleConfigGetBoolFunc)(const char *name, void *privdata);
typedef int (*ValkeyModuleConfigGetEnumFunc)(const char *name, void *privdata);
typedef int (*ValkeyModuleConfigSetStringFunc)(const char *name,
ValkeyModuleString *val,
void *privdata,
ValkeyModuleString **err);
typedef int (*ValkeyModuleConfigSetNumericFunc)(const char *name,
long long val,
void *privdata,
ValkeyModuleString **err);
typedef int (*ValkeyModuleConfigSetBoolFunc)(const char *name, int val, void *privdata, ValkeyModuleString **err);
typedef int (*ValkeyModuleConfigSetEnumFunc)(const char *name, int val, void *privdata, ValkeyModuleString **err);
typedef int (*ValkeyModuleConfigApplyFunc)(ValkeyModuleCtx *ctx, void *privdata, ValkeyModuleString **err);
typedef void (*ValkeyModuleOnUnblocked)(ValkeyModuleCtx *ctx, ValkeyModuleCallReply *reply, void *private_data);
typedef int (*ValkeyModuleAuthCallback)(ValkeyModuleCtx *ctx,
ValkeyModuleString *username,
ValkeyModuleString *password,
ValkeyModuleString **err);
typedef struct ValkeyModuleTypeMethods {
uint64_t version;
ValkeyModuleTypeLoadFunc rdb_load;
ValkeyModuleTypeSaveFunc rdb_save;
ValkeyModuleTypeRewriteFunc aof_rewrite;
ValkeyModuleTypeMemUsageFunc mem_usage;
ValkeyModuleTypeDigestFunc digest;
ValkeyModuleTypeFreeFunc free;
ValkeyModuleTypeAuxLoadFunc aux_load;
ValkeyModuleTypeAuxSaveFunc aux_save;
int aux_save_triggers;
ValkeyModuleTypeFreeEffortFunc free_effort;
ValkeyModuleTypeUnlinkFunc unlink;
ValkeyModuleTypeCopyFunc copy;
ValkeyModuleTypeDefragFunc defrag;
ValkeyModuleTypeMemUsageFunc2 mem_usage2;
ValkeyModuleTypeFreeEffortFunc2 free_effort2;
ValkeyModuleTypeUnlinkFunc2 unlink2;
ValkeyModuleTypeCopyFunc2 copy2;
ValkeyModuleTypeAuxSaveFunc aux_save2;
} ValkeyModuleTypeMethods;
#define VALKEYMODULE_GET_API(name) ValkeyModule_GetApi("ValkeyModule_" #name, ((void **)&ValkeyModule_##name))
/* Default API declaration prefix (not 'extern' for backwards compatibility) */
#ifndef VALKEYMODULE_API
#define VALKEYMODULE_API
#endif
/* Default API declaration suffix (compiler attributes) */
#ifndef VALKEYMODULE_ATTR
#define VALKEYMODULE_ATTR VALKEYMODULE_ATTR_COMMON
#endif
VALKEYMODULE_API void *(*ValkeyModule_Alloc)(size_t bytes)VALKEYMODULE_ATTR;
VALKEYMODULE_API void *(*ValkeyModule_TryAlloc)(size_t bytes)VALKEYMODULE_ATTR;
VALKEYMODULE_API void *(*ValkeyModule_Realloc)(void *ptr, size_t bytes)VALKEYMODULE_ATTR;
VALKEYMODULE_API void *(*ValkeyModule_TryRealloc)(void *ptr, size_t bytes)VALKEYMODULE_ATTR;
VALKEYMODULE_API void (*ValkeyModule_Free)(void *ptr) VALKEYMODULE_ATTR;
VALKEYMODULE_API void *(*ValkeyModule_Calloc)(size_t nmemb, size_t size)VALKEYMODULE_ATTR;
VALKEYMODULE_API void *(*ValkeyModule_TryCalloc)(size_t nmemb, size_t size)VALKEYMODULE_ATTR;
VALKEYMODULE_API char *(*ValkeyModule_Strdup)(const char *str)VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_GetApi)(const char *, void *) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_CreateCommand)(ValkeyModuleCtx *ctx,
const char *name,
ValkeyModuleCmdFunc cmdfunc,
const char *strflags,
int firstkey,
int lastkey,
int keystep) VALKEYMODULE_ATTR;
VALKEYMODULE_API ValkeyModuleCommand *(*ValkeyModule_GetCommand)(ValkeyModuleCtx *ctx,
const char *name)VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_CreateSubcommand)(ValkeyModuleCommand *parent,
const char *name,
ValkeyModuleCmdFunc cmdfunc,
const char *strflags,
int firstkey,
int lastkey,
int keystep) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_SetCommandInfo)(ValkeyModuleCommand *command,
const ValkeyModuleCommandInfo *info) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_SetCommandACLCategories)(ValkeyModuleCommand *command,
const char *ctgrsflags) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_AddACLCategory)(ValkeyModuleCtx *ctx, const char *name) VALKEYMODULE_ATTR;
VALKEYMODULE_API void (*ValkeyModule_SetModuleAttribs)(ValkeyModuleCtx *ctx, const char *name, int ver, int apiver)
VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_IsModuleNameBusy)(const char *name) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_WrongArity)(ValkeyModuleCtx *ctx) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_ReplyWithLongLong)(ValkeyModuleCtx *ctx, long long ll) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_GetSelectedDb)(ValkeyModuleCtx *ctx) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_SelectDb)(ValkeyModuleCtx *ctx, int newid) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_KeyExists)(ValkeyModuleCtx *ctx, ValkeyModuleString *keyname) VALKEYMODULE_ATTR;
VALKEYMODULE_API ValkeyModuleKey *(*ValkeyModule_OpenKey)(ValkeyModuleCtx *ctx,
ValkeyModuleString *keyname,
int mode)VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_GetOpenKeyModesAll)(void) VALKEYMODULE_ATTR;
VALKEYMODULE_API void (*ValkeyModule_CloseKey)(ValkeyModuleKey *kp) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_KeyType)(ValkeyModuleKey *kp) VALKEYMODULE_ATTR;
VALKEYMODULE_API size_t (*ValkeyModule_ValueLength)(ValkeyModuleKey *kp) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_ListPush)(ValkeyModuleKey *kp,
int where,
ValkeyModuleString *ele) VALKEYMODULE_ATTR;
VALKEYMODULE_API ValkeyModuleString *(*ValkeyModule_ListPop)(ValkeyModuleKey *key, int where)VALKEYMODULE_ATTR;
VALKEYMODULE_API ValkeyModuleString *(*ValkeyModule_ListGet)(ValkeyModuleKey *key, long index)VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_ListSet)(ValkeyModuleKey *key,
long index,
ValkeyModuleString *value) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_ListInsert)(ValkeyModuleKey *key,
long index,
ValkeyModuleString *value) VALKEYMODULE_ATTR;
VALKEYMODULE_API int (*ValkeyModule_ListDelete)(ValkeyModuleKey *key, long index) VALKEYMODULE_ATTR;
VALKEYMODULE_API ValkeyModuleCallReply *(*ValkeyModule_Call)(ValkeyModuleCtx *ctx,
const char *cmdname,
const char *fmt,
...)VALKEYMODULE_ATTR;
VALKEYMODULE_API const char *(*ValkeyModule_CallReplyProto)(ValkeyModuleCallReply *reply, size_t *len)VALKEYMODULE_ATTR;