ucancel cnonce simple test working

Author: dorinhogea

db/process_message.c

@@ -237,6 +237,11 @@ static const char *HELP_SQL[] = {
     "hist               - show recently run statements",
     "cancel N           - cancel running statement with id N",
     "cancelcnonce N     - cancel running statement with cnonce N",
+    "ucancel cnonce N   - cancel running statement with unified uuid N (per comdb2_connections)",
+    "ucancel fp N       - cancel running statement with fingerprint N (per comdb2_connections)",
+    "ucancel running    - cancel all running statement (leaves queued statements intact)",
+    "ucancel queued     - cancel all queued statement (leaves running statements intact)",
+    "ucancel all        - cancel all queued and running statements",
     "wrtimeout N        - set write timeout in ms",
     "help               - this information",
     NULL,
@@ -3118,6 +3123,34 @@ int process_command(struct dbenv *dbenv, char *line, int lline, int st)
                 cancel_sql_statement_with_cnonce(cnonce);
                 free(cnonce);
             }
+        } else if (tokcmp(tok, ltok, "ucancel") == 0) {
+            char *uuid = NULL;
+            enum ucancel_type t = UCANCEL_INV;
+            tok = segtok(line, lline, &st, &ltok);
+            if (ltok) {
+                if (tokcmp(tok, ltok, "all") == 0)
+                    t = UCANCEL_ALL;
+                else if (tokcmp(tok, ltok, "running") == 0)
+                    t = UCANCEL_RUN;
+                else if (tokcmp(tok, ltok, "queued") == 0)
+                    t = UCANCEL_QUE;
+                else if (tokcmp(tok, ltok, "cnonce") == 0)
+                    t = UCANCEL_CNO;
+                else if (tokcmp(tok, ltok, "fp") == 0)
+                    t = UCANCEL_FPT;
+
+                if (t == UCANCEL_CNO || t == UCANCEL_FPT) {
+                    tok =  segtok(line, lline, &st, &ltok);
+                    if (ltok)
+                        uuid = tokdup(tok, ltok);
+                    else
+                        t = UCANCEL_INV;
+                }
+                if (t != UCANCEL_INV)
+                    ucancel_sql_statements(t, uuid);
+            }
+            if (t == UCANCEL_INV)
+                logmsg(LOGMSG_ERROR, "Usage sql ucancel [all|queued|running|fp N|cnonce N]");
         } else if (tokcmp(tok, ltok, "help") == 0) {
             print_help_page(HELP_SQL);
         } else if (tokcmp(tok, ltok, "debug") == 0) {

db/sql.h

@@ -322,6 +322,17 @@ typedef struct sqlclntstate_fdb {
     int failed_heartbeats; /* used to signal failed communication with remotes */
 } sqlclntstate_fdb_t;
 
+enum ucancel_type {
+    UCANCEL_INV = 0,
+    UCANCEL_ALL = 1,    /* both queued and running */
+    UCANCEL_RUN = 2,    /* running only */
+    UCANCEL_QUE = 4,    /* queued only */
+    UCANCEL_CNO = 8,    /* filter by cnonce */
+    UCANCEL_FPT = 16    /* filter by fp */
+};
+
+int ucancel_sql_statements(enum ucancel_type type, char *uuid);
+
 CurRange *currange_new();
 #define CURRANGEARR_INIT_CAP 2
 void currangearr_init(CurRangeArr *arr);

db/sqlglue.c

@@ -9701,6 +9701,72 @@ void cancel_sql_statement_with_cnonce(const char *cnonce)
         logmsg(LOGMSG_USER, "Query with cnonce %s not found (finished?)\n", cnonce);
 }
 
+static int _ucancel_sql_statements_cno(char *uuidstr)
+{
+    struct sql_thread *thd;
+    int rc = -1;
+
+    uuid_t uuid;
+
+    if (uuid_parse(uuidstr, uuid)) {
+        logmsg(LOGMSG_ERROR, "Failed to parse uuid \"%s\"\n", uuidstr);
+        return rc;
+    }
+
+    Pthread_mutex_lock(&gbl_sql_lock);
+    LISTC_FOR_EACH(&thedb->sql_threads, thd, lnk) {
+        if (thd->clnt && memcmp(thd->clnt->unifieduuid, uuid, sizeof(uuid_t)) == 0) {
+            logmsg(LOGMSG_ERROR, "Cancelling sql %s\n", thd->clnt->sql);
+            thd->stop_this_statement = 1;
+            rc = 0;
+            break;
+        }
+    }
+    Pthread_mutex_unlock(&gbl_sql_lock);
+    if (rc)
+        logmsg(LOGMSG_ERROR, "Sql cnonce \"%s\" not found\n", uuidstr);
+    return rc;
+}
+
+static int _ucancel_sql_statements_run(void)
+{
+    struct sql_thread *thd;
+
+    Pthread_mutex_lock(&gbl_sql_lock);
+    LISTC_FOR_EACH(&thedb->sql_threads, thd, lnk) {   
+        if (thd->clnt)
+            thd->stop_this_statement = 1;
+    }
+    Pthread_mutex_unlock(&gbl_sql_lock);
+
+    return 0;
+}
+
+/*
+ * "Unified" sql statements cancel routine
+ * MODES:
+ *  type == UCANCEL_ALL #cancel all running and queued statements
+ *  type == UCANCEL_RUN #cancel all running statements
+ *  type == UCANCEL_QUE #cancel all queued statements
+ *  type == UCANCEL_CNO #cancel one running statement with cnonce = "uuid"
+ *  type == UCANCEL_FPT #cancel all running statement with fingerprint = "uuid"
+ *
+ */
+int ucancel_sql_statements(enum ucancel_type type, char *uuid) {
+    switch(type) {
+    case UCANCEL_CNO:
+        return _ucancel_sql_statements_cno(uuid);
+    case UCANCEL_RUN:
+        return _ucancel_sql_statements_run();
+    case UCANCEL_ALL:
+    case UCANCEL_QUE:
+    case UCANCEL_FPT:
+       logmsg(LOGMSG_ERROR, "%d unimplemented\n", type);
+       return -1;
+    }
+    return 0;
+}
+
 void sql_dump_running_statements(void)
 {
     struct sql_thread *thd;

lua/syssp.c.in

@@ -491,15 +491,39 @@ static int db_send(Lua L)
 
 static int db_unified_cancel(Lua L)
 {
-    char *uuid;
+    char *type;
+    char *uuid = NULL;
     char cmd[256];
 
-    if (!lua_isstring(L, 1))
-        return luaL_error(L, "Expected string uuid argument");
-    uuid = (char*) lua_tostring(L, -1);
+    int nargs = lua_gettop(L);
+    /* type */
+    if (nargs == 2) {
+        if (!lua_isstring(L, -2))
+            return luaL_error(L, "Expected string type argument: all|queued|running|cnonce|fp");
+        type = (char*) lua_tostring(L, -2);
+        if (strncasecmp(type, "cnonce", sizeof("cnonce")) != 0 &&
+                strncasecmp(type, "fp", sizeof("fp")) != 0) {
+            return luaL_error(L, "Extra argument present\n");
+        }
+    } else {
+        if (!lua_isstring(L, -1))
+            return luaL_error(L, "Expected string type argument: all|queued|running|cnonce|fp");
+        type = (char*) lua_tostring(L, -1);
+        if (strncasecmp(type, "all", sizeof("all")) != 0 &&
+                strncasecmp(type, "running", sizeof("running")) != 0 && 
+                strncasecmp(type, "queued", sizeof("queued")) != 0) {
+            return luaL_error(L, "Expected string type argument: all|queued|running|cnonce|fp");
+        }
+    }
+
+    if (nargs == 2) {
+        if (!lua_isstring(L, -1))
+            return luaL_error(L, "Wrong type uuid for %s type", type);
+        uuid = (char*) lua_tostring(L, -1);
+    }
     lua_settop(L, 0);
 
-    snprintf(cmd, sizeof(cmd), "cancel %s\n", uuid);
+    snprintf(cmd, sizeof(cmd), "sql ucancel %s%s%s\n", type, uuid ? " ": "", uuid ? uuid : "");
 
     return _db_process_command(L, cmd, "result");
 }
@@ -795,7 +819,7 @@ static struct sp_source syssps[] = {
     }
     ,{
         "sys.cmd.cancel",
-        "local function main(cmd)\n"
+        "local function main(cmd, uuid)\n"
         "    local schema = {\n"
         "        { 'string', 'result' },\n"
         "    }\n"
@@ -804,7 +828,7 @@ static struct sp_source syssps[] = {
         "        db:column_name(v[2], i)\n"
         "        db:column_type(v[1], i)\n"
         "    end\n"
-        "    local msg = sys.cancel(cmd)\n"
+        "    local msg = sys.cancel(cmd, uuid)\n"
         "    for i, v in ipairs(msg) do\n"
         "        db:emit(v)\n"
         "    end\n"

tests/unifiedcancel.test/test_cancel.sh

@@ -31,16 +31,15 @@ function header
 
 header 1 "running a long query, retrieve it and cancel it"
 echo "Running tests on node ${mach}"
-echo "inserting 3 records"
-$S_SQL "insert into t values (1), (2), (3)"
+echo "inserting 60 records"
+$S_SQL "insert into t select * from generate_series(1,60)"
 if [[ $? != 0 ]] ; then
     echo "Failed to insert"
     exit 1
 fi
 
 echo "running async select sleep"
-#$S_SQL "select *, sleep(10, 1) from t order by id"
-$S_SQL "select *, sleep(60) from t order by id" &
+$S_SQL "select *, sleep(1) from t order by 1" &
 if [[ $? != 0 ]] ; then
     echo "Failed to async run sleep"
     exit 1
@@ -60,12 +59,14 @@ if [[ -z ${uuid} ]] ; then
 fi
 
 echo "running cancel ${uuid} trap"
-$S_SQL "exec procedure sys.cmd.cancel('${uuid}')"
+$S_SQL "exec procedure sys.cmd.cancel('cnonce', '${uuid}')"
 if [[ $? != 0 ]] ; then
     echo "Failed to run cancel message"
     exit 1
 fi
 
+sleep 2
+
 echo "check if the ${uuid} is gone"
 found_uuid=`$S_TSQL "select uuid from comdb2_connections where sql like '%sleep%' and sql not like '%connections%'"`
 if [[ $? != 0 ]] ; then