66f31c2736dc3b85611e27641c6bf6822bc5411d
[ric-plt/dbaas.git] / redismodule / src / exstrings.c
1 /*
2  * Copyright (c) 2018-2019 Nokia.
3  *
4  *   Licensed under the Apache License, Version 2.0 (the "License");
5  *   you may not use this file except in compliance with the License.
6  *   You may obtain a copy of the License at
7  *
8  *       http://www.apache.org/licenses/LICENSE-2.0
9  *
10  *   Unless required by applicable law or agreed to in writing, software
11  *   distributed under the License is distributed on an "AS IS" BASIS,
12  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  *   See the License for the specific language governing permissions and
14  *   limitations under the License.
15  */
16
17 #include "redismodule.h"
18 #include <stdio.h>
19 #include <stdlib.h>
20 #include <ctype.h>
21 #include <string.h>
22 #include "../../redismodule/include/redismodule.h"
23
24 #ifdef __UT__
25 #include "exstringsStub.h"
26 #endif
27
28 /* make sure the response is not NULL or an error.
29 sends the error to the client and exit the current function if its */
30 #define  ASSERT_NOERROR(r) \
31     if (r == NULL) { \
32         return RedisModule_ReplyWithError(ctx,"ERR reply is NULL"); \
33     } else if (RedisModule_CallReplyType(r) == REDISMODULE_REPLY_ERROR) { \
34         RedisModule_ReplyWithCallReply(ctx,r); \
35         RedisModule_FreeCallReply(r); \
36         return REDISMODULE_ERR; \
37     }
38
39 #define OBJ_OP_NO 0
40 #define OBJ_OP_XX (1<<1)     /* OP if key exist */
41 #define OBJ_OP_NX (1<<2)     /* OP if key not exist */
42 #define OBJ_OP_IE (1<<4)     /* OP if equal old value */
43 #define OBJ_OP_NE (1<<5)     /* OP if not equal old value */
44
45
46 int setStringGenericCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
47                                        int argc, const int flag)
48 {
49     RedisModuleString *oldvalstr = NULL;
50     RedisModuleCallReply *reply = NULL;
51
52     if (argc < 4)
53         return RedisModule_WrongArity(ctx);
54     else
55         oldvalstr = argv[3];
56
57     /*Check if key type is string*/
58     RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
59         REDISMODULE_READ);
60     int type = RedisModule_KeyType(key);
61     RedisModule_CloseKey(key);
62
63     if (type == REDISMODULE_KEYTYPE_EMPTY) {
64         if (flag == OBJ_OP_IE){
65             RedisModule_ReplyWithNull(ctx);
66             return REDISMODULE_OK;
67         }
68     } else if (type != REDISMODULE_KEYTYPE_STRING) {
69         return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
70     }
71
72     /*Get the value*/
73     reply = RedisModule_Call(ctx, "GET", "s", argv[1]);
74     ASSERT_NOERROR(reply)
75     size_t curlen=0, oldvallen=0;
76     const char *oldval = RedisModule_StringPtrLen(oldvalstr, &oldvallen);
77     const char *curval = RedisModule_CallReplyStringPtr(reply, &curlen);
78     if (((flag == OBJ_OP_IE) &&
79         (!curval || (oldvallen != curlen) || strncmp(oldval, curval, curlen)))
80         ||
81         ((flag == OBJ_OP_NE) && curval && (oldvallen == curlen) &&
82           !strncmp(oldval, curval, curlen))) {
83         RedisModule_FreeCallReply(reply);
84         return RedisModule_ReplyWithNull(ctx);
85     }
86     RedisModule_FreeCallReply(reply);
87
88     /* Prepare the arguments for the command. */
89     int i, j=0, cmdargc=argc-2;
90     RedisModuleString *cmdargv[cmdargc];
91     for (i = 1; i < argc; i++) {
92         if (i == 3)
93             continue;
94         cmdargv[j++] = argv[i];
95     }
96
97     /* Call the command and pass back the reply. */
98     reply = RedisModule_Call(ctx, "SET", "v!", cmdargv, cmdargc);
99     ASSERT_NOERROR(reply)
100     RedisModule_ReplyWithCallReply(ctx, reply);
101
102     RedisModule_FreeCallReply(reply);
103     return REDISMODULE_OK;
104 }
105
106 int SetIE_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
107 {
108     return setStringGenericCommand(ctx, argv, argc, OBJ_OP_IE);
109 }
110
111 int SetNE_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
112 {
113     return setStringGenericCommand(ctx, argv, argc, OBJ_OP_NE);
114 }
115
116 int delStringGenericCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
117                                        int argc, const int flag)
118 {
119     RedisModuleString *oldvalstr = NULL;
120     RedisModuleCallReply *reply = NULL;
121
122     if (argc == 3)
123         oldvalstr = argv[2];
124     else
125         return RedisModule_WrongArity(ctx);
126
127     /*Check if key type is string*/
128     RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
129         REDISMODULE_READ);
130     int type = RedisModule_KeyType(key);
131     RedisModule_CloseKey(key);
132
133     if (type == REDISMODULE_KEYTYPE_EMPTY) {
134         return RedisModule_ReplyWithLongLong(ctx, 0);
135     } else if (type != REDISMODULE_KEYTYPE_STRING) {
136         return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
137     }
138
139     /*Get the value*/
140     reply = RedisModule_Call(ctx, "GET", "s", argv[1]);
141     ASSERT_NOERROR(reply)
142     size_t curlen = 0, oldvallen = 0;
143     const char *oldval = RedisModule_StringPtrLen(oldvalstr, &oldvallen);
144     const char *curval = RedisModule_CallReplyStringPtr(reply, &curlen);
145     if (((flag == OBJ_OP_IE) &&
146         (!curval || (oldvallen != curlen) || strncmp(oldval, curval, curlen)))
147         ||
148         ((flag == OBJ_OP_NE) && curval && (oldvallen == curlen) &&
149           !strncmp(oldval, curval, curlen))) {
150         RedisModule_FreeCallReply(reply);
151         return RedisModule_ReplyWithLongLong(ctx, 0);
152     }
153     RedisModule_FreeCallReply(reply);
154
155     /* Prepare the arguments for the command. */
156     int cmdargc=1;
157     RedisModuleString *cmdargv[1];
158     cmdargv[0] = argv[1];
159
160     /* Call the command and pass back the reply. */
161     reply = RedisModule_Call(ctx, "UNLINK", "v!", cmdargv, cmdargc);
162     ASSERT_NOERROR(reply)
163     RedisModule_ReplyWithCallReply(ctx, reply);
164
165     RedisModule_FreeCallReply(reply);
166     return REDISMODULE_OK;
167 }
168
169 int DelIE_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
170 {
171     return delStringGenericCommand(ctx, argv, argc, OBJ_OP_IE);
172 }
173
174 int DelNE_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
175 {
176     return delStringGenericCommand(ctx, argv, argc, OBJ_OP_NE);
177 }
178
179 int NGet_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
180 {
181     RedisModuleCallReply *reply = NULL;
182
183     if (argc != 2)
184         return RedisModule_WrongArity(ctx);
185
186     /* Call the command to get keys with pattern. */
187     reply = RedisModule_Call(ctx, "KEYS", "s", argv[1]);
188     ASSERT_NOERROR(reply)
189
190     /* Prepare the arguments for the command. */
191     size_t items = RedisModule_CallReplyLength(reply);
192     if (items == 0) {
193         //RedisModule_ReplyWithArray(ctx, items);
194         RedisModule_ReplyWithCallReply(ctx, reply);
195         RedisModule_FreeCallReply(reply);
196     }
197     else {
198         RedisModuleString *cmdargv[items];
199         size_t i=0, j;
200         for (j = 0; j < items; j++) {
201            RedisModuleString *rms = RedisModule_CreateStringFromCallReply(RedisModule_CallReplyArrayElement(reply, j));
202            cmdargv[i++] = rms;
203
204            /*Assume all keys via SDL is string type for sake of saving time*/
205 #if 0
206            /*Check if key type is string*/
207            RedisModuleKey *key = RedisModule_OpenKey(ctx, rms ,REDISMODULE_READ);
208
209            if (key) {
210                int type = RedisModule_KeyType(key);
211                RedisModule_CloseKey(key);
212                if (type == REDISMODULE_KEYTYPE_STRING) {
213                    cmdargv[i++] = rms;
214                }
215            } else {
216                RedisModule_CloseKey(key);
217            }
218 #endif
219         }
220         RedisModule_FreeCallReply(reply);
221
222         reply = RedisModule_Call(ctx, "MGET", "v", cmdargv, i);
223         ASSERT_NOERROR(reply)
224         items = RedisModule_CallReplyLength(reply);
225         RedisModule_ReplyWithArray(ctx, i*2);
226         for (j = 0; (j<items && j<i); j++) {
227            RedisModule_ReplyWithString(ctx, cmdargv[j]);
228            RedisModule_ReplyWithString(ctx, RedisModule_CreateStringFromCallReply(RedisModule_CallReplyArrayElement(reply, j)));
229         }
230
231         RedisModule_FreeCallReply(reply);
232     }
233
234     return REDISMODULE_OK;
235 }
236
237 int NDel_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
238 {
239     RedisModuleCallReply *reply = NULL;
240
241     if (argc != 2)
242         return RedisModule_WrongArity(ctx);
243
244     /* Call the command to get keys with pattern. */
245     reply = RedisModule_Call(ctx, "KEYS", "s", argv[1]);
246     ASSERT_NOERROR(reply)
247
248     /* Prepare the arguments for the command. */
249     size_t items = RedisModule_CallReplyLength(reply);
250     if (items == 0) {
251         RedisModule_ReplyWithLongLong(ctx, 0);
252         RedisModule_FreeCallReply(reply);
253     }
254     else {
255         RedisModuleString *cmdargv[items];
256         size_t i=0, j;
257         for (j = 0; j < items; j++) {
258            RedisModuleString *rms = RedisModule_CreateStringFromCallReply(RedisModule_CallReplyArrayElement(reply, j));
259            cmdargv[i++] = rms;
260
261            /*Assume all keys via SDL is string type for sake of saving time*/
262 #if 0
263            //Check if key type is string
264            RedisModuleKey *key = RedisModule_OpenKey(ctx, rms ,REDISMODULE_READ);
265
266            if (key) {
267                int type = RedisModule_KeyType(key);
268                RedisModule_CloseKey(key);
269                if (type == REDISMODULE_KEYTYPE_STRING) {
270                    cmdargv[i++] = rms;
271                }
272            } else {
273                RedisModule_CloseKey(key);
274            }
275 #endif
276         }
277         RedisModule_FreeCallReply(reply);
278
279         reply = RedisModule_Call(ctx, "UNLINK", "v!", cmdargv, i);
280         ASSERT_NOERROR(reply)
281         RedisModule_ReplyWithCallReply(ctx, reply);
282         RedisModule_FreeCallReply(reply);
283
284     }
285
286     return REDISMODULE_OK;
287 }
288
289 int setPubStringGenericCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
290                                        int argc, const int flag)
291 {
292     RedisModuleString *oldvalstr = NULL, *channel = NULL, *message = NULL;
293     RedisModuleCallReply *reply = NULL;
294
295     if (flag == OBJ_OP_NO) {
296         if (argc < 5 || (argc % 2) == 0)
297             return RedisModule_WrongArity(ctx);
298         else {
299             channel = argv[argc-2];
300             message = argv[argc-1];
301         }
302     } else if (flag == OBJ_OP_XX || flag == OBJ_OP_NX) {
303         if (argc != 5)
304             return RedisModule_WrongArity(ctx);
305         else {
306             channel = argv[3];
307             message = argv[4];
308         }
309     } else {
310         if (argc != 6)
311             return RedisModule_WrongArity(ctx);
312         else {
313             oldvalstr = argv[3];
314             channel = argv[4];
315             message = argv[5];
316         }
317     }
318
319     /*Check if key type is string*/
320     RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
321         REDISMODULE_READ);
322     int type = RedisModule_KeyType(key);
323     RedisModule_CloseKey(key);
324
325     if (flag != OBJ_OP_NO) {
326         if (type == REDISMODULE_KEYTYPE_EMPTY) {
327             if (flag == OBJ_OP_IE || flag == OBJ_OP_XX){
328                 return RedisModule_ReplyWithNull(ctx);
329             }
330         } else if (flag == OBJ_OP_NX) {
331             return RedisModule_ReplyWithNull(ctx);
332         } else if (type != REDISMODULE_KEYTYPE_STRING) {
333             return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
334         }
335     }
336
337     if (flag == OBJ_OP_IE || flag == OBJ_OP_NE) {
338         /*Get the value*/
339         reply = RedisModule_Call(ctx, "GET", "s", argv[1]);
340         ASSERT_NOERROR(reply)
341         size_t curlen = 0, oldvallen = 0;
342         const char *oldval = RedisModule_StringPtrLen(oldvalstr, &oldvallen);
343         const char *curval = RedisModule_CallReplyStringPtr(reply, &curlen);
344         if (((flag == OBJ_OP_IE) &&
345             (!curval || (oldvallen != curlen) || strncmp(oldval, curval, curlen)))
346             ||
347             ((flag == OBJ_OP_NE) && curval && (oldvallen == curlen) &&
348               !strncmp(oldval, curval, curlen))) {
349             RedisModule_FreeCallReply(reply);
350             return RedisModule_ReplyWithNull(ctx);
351         }
352         RedisModule_FreeCallReply(reply);
353     }
354
355
356     /* Prepare the arguments for the command. */
357     int i, j=0, cmdargc=argc-3;
358     RedisModuleString *cmdargv[cmdargc];
359     for (i = 1; i < argc-2; i++) {
360         if ((flag == OBJ_OP_IE || flag == OBJ_OP_NE) && (i == 3))
361             continue;
362         cmdargv[j++] = argv[i];
363     }
364
365     /* Call the command and pass back the reply. */
366     reply = RedisModule_Call(ctx, "MSET", "v!", cmdargv, j);
367     ASSERT_NOERROR(reply)
368     int replytype = RedisModule_CallReplyType(reply);
369     if (replytype == REDISMODULE_REPLY_NULL) {
370         RedisModule_ReplyWithNull(ctx);
371     }
372     else {
373         cmdargc = 2;
374         cmdargv[0] = channel;
375         cmdargv[1] = message;
376         RedisModuleCallReply *pubreply = RedisModule_Call(ctx, "PUBLISH", "v", cmdargv, cmdargc);
377         RedisModule_FreeCallReply(pubreply);
378         RedisModule_ReplyWithCallReply(ctx, reply);
379     }
380
381     RedisModule_FreeCallReply(reply);
382     return REDISMODULE_OK;
383 }
384
385 int SetPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
386 {
387     return setPubStringGenericCommand(ctx, argv, argc, OBJ_OP_NO);
388 }
389
390 int SetIEPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
391 {
392     return setPubStringGenericCommand(ctx, argv, argc, OBJ_OP_IE);
393 }
394
395 int SetNEPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
396 {
397     return setPubStringGenericCommand(ctx, argv, argc, OBJ_OP_NE);
398 }
399
400 int SetNXPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
401 {
402     return setPubStringGenericCommand(ctx, argv, argc, OBJ_OP_NX);
403 }
404
405 int SetXXPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
406 {
407     return setPubStringGenericCommand(ctx, argv, argc, OBJ_OP_XX);
408 }
409
410 int delPubStringGenericCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
411                                        int argc, const int flag)
412 {
413     RedisModuleString *oldvalstr = NULL, *channel = NULL, *message = NULL;
414     RedisModuleCallReply *reply = NULL;
415
416     if (flag == OBJ_OP_NO) {
417         if (argc < 4)
418             return RedisModule_WrongArity(ctx);
419         else {
420             channel = argv[argc-2];
421             message = argv[argc-1];
422         }
423     } else {
424         if (argc != 5)
425             return RedisModule_WrongArity(ctx);
426         else {
427             oldvalstr = argv[2];
428             channel = argv[3];
429             message = argv[4];
430         }
431     }
432
433     if (flag != OBJ_OP_NO) {
434         /*Check if key type is string*/
435         RedisModuleKey *key = RedisModule_OpenKey(ctx,argv[1],
436             REDISMODULE_READ);
437         int type = RedisModule_KeyType(key);
438         RedisModule_CloseKey(key);
439
440         if (type == REDISMODULE_KEYTYPE_EMPTY) {
441             return RedisModule_ReplyWithLongLong(ctx, 0);
442         } else if (type != REDISMODULE_KEYTYPE_STRING) {
443             return RedisModule_ReplyWithError(ctx,REDISMODULE_ERRORMSG_WRONGTYPE);
444         }
445     }
446
447     if (flag == OBJ_OP_IE || flag == OBJ_OP_NE) {
448         /*Get the value*/
449         reply = RedisModule_Call(ctx, "GET", "s", argv[1]);
450         ASSERT_NOERROR(reply)
451         size_t curlen = 0, oldvallen = 0;
452         const char *oldval = RedisModule_StringPtrLen(oldvalstr, &oldvallen);
453         const char *curval = RedisModule_CallReplyStringPtr(reply, &curlen);
454         if (((flag == OBJ_OP_IE) &&
455             (!curval || (oldvallen != curlen) || strncmp(oldval, curval, curlen)))
456             ||
457             ((flag == OBJ_OP_NE) && curval && (oldvallen == curlen) &&
458               !strncmp(oldval, curval, curlen))) {
459             RedisModule_FreeCallReply(reply);
460             return RedisModule_ReplyWithLongLong(ctx, 0);
461         }
462         RedisModule_FreeCallReply(reply);
463     }
464
465
466     /* Prepare the arguments for the command. */
467     int i, j=0, cmdargc=argc-3;
468     RedisModuleString *cmdargv[cmdargc];
469     for (i = 1; i < argc-2; i++) {
470         if ((flag == OBJ_OP_IE || flag == OBJ_OP_NE) && (i == 2))
471             continue;
472         cmdargv[j++] = argv[i];
473     }
474
475     /* Call the command and pass back the reply. */
476     reply = RedisModule_Call(ctx, "UNLINK", "v!", cmdargv, j);
477     ASSERT_NOERROR(reply)
478     int replytype = RedisModule_CallReplyType(reply);
479     if (replytype == REDISMODULE_REPLY_NULL) {
480         RedisModule_ReplyWithNull(ctx);
481     }
482     else if (RedisModule_CallReplyInteger(reply) == 0) {
483         RedisModule_ReplyWithCallReply(ctx, reply);
484     } else {
485         cmdargc = 2;
486         cmdargv[0] = channel;
487         cmdargv[1] = message;
488         RedisModuleCallReply *pubreply = RedisModule_Call(ctx, "PUBLISH", "v", cmdargv, cmdargc);
489         RedisModule_FreeCallReply(pubreply);
490         RedisModule_ReplyWithCallReply(ctx, reply);
491     }
492
493     RedisModule_FreeCallReply(reply);
494     return REDISMODULE_OK;
495 }
496
497 int DelPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
498 {
499    return delPubStringGenericCommand(ctx, argv, argc, OBJ_OP_NO);
500 }
501
502 int DelIEPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
503 {
504    return delPubStringGenericCommand(ctx, argv, argc, OBJ_OP_IE);
505 }
506
507 int DelNEPub_RedisCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
508 {
509    return delPubStringGenericCommand(ctx, argv, argc, OBJ_OP_NE);
510 }
511
512 /* This function must be present on each Redis module. It is used in order to
513  * register the commands into the Redis server. */
514 int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
515     REDISMODULE_NOT_USED(argv);
516     REDISMODULE_NOT_USED(argc);
517
518     if (RedisModule_Init(ctx,"exstrings",1,REDISMODULE_APIVER_1)
519         == REDISMODULE_ERR) return REDISMODULE_ERR;
520
521     if (RedisModule_CreateCommand(ctx,"setie",
522         SetIE_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
523         return REDISMODULE_ERR;
524
525     if (RedisModule_CreateCommand(ctx,"setne",
526         SetNE_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
527         return REDISMODULE_ERR;
528
529     if (RedisModule_CreateCommand(ctx,"delie",
530         DelIE_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
531         return REDISMODULE_ERR;
532
533     if (RedisModule_CreateCommand(ctx,"delne",
534         DelNE_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
535         return REDISMODULE_ERR;
536
537     if (RedisModule_CreateCommand(ctx,"nget",
538         NGet_RedisCommand,"readonly",1,1,1) == REDISMODULE_ERR)
539         return REDISMODULE_ERR;
540
541     if (RedisModule_CreateCommand(ctx,"ndel",
542         NDel_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
543         return REDISMODULE_ERR;
544
545     if (RedisModule_CreateCommand(ctx,"msetpub",
546         SetPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
547         return REDISMODULE_ERR;
548
549     if (RedisModule_CreateCommand(ctx,"setiepub",
550         SetIEPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
551         return REDISMODULE_ERR;
552
553     if (RedisModule_CreateCommand(ctx,"setnepub",
554         SetNEPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
555         return REDISMODULE_ERR;
556
557     if (RedisModule_CreateCommand(ctx,"setxxpub",
558         SetXXPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
559         return REDISMODULE_ERR;
560
561     if (RedisModule_CreateCommand(ctx,"setnxpub",
562         SetNXPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
563         return REDISMODULE_ERR;
564
565     if (RedisModule_CreateCommand(ctx,"delpub",
566         DelPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
567         return REDISMODULE_ERR;
568
569     if (RedisModule_CreateCommand(ctx,"deliepub",
570         DelIEPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
571         return REDISMODULE_ERR;
572
573     if (RedisModule_CreateCommand(ctx,"delnepub",
574         DelNEPub_RedisCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
575         return REDISMODULE_ERR;
576
577     return REDISMODULE_OK;
578 }