mgmt_parser.rl

   1 /*
   2  * Copyright (C) 2012-2020 all contributors <cmogstored-public@yhbt.net>
   3  * License: GPL-3.0+ <https://www.gnu.org/licenses/gpl-3.0.txt>
   4  */
   5 #include "cmogstored.h"
   6 #include "mgmt.h"
   7
   8 /*
   9  * only set fsck prio if we're still accepting connections, graceful
  10  * shutdown in single-threaded mode uses normal (fair) prio
  11  */
  12 static void set_prio_fsck(struct mog_mgmt *mgmt)
  13 {
  14         if (mgmt->svc->mgmt_mfd)
  15                 mgmt->prio = MOG_PRIO_FSCK;
  16 }
  17
  18 %%{
  19         machine mgmt_parser;
  20         include path_parser "path_parser.rl";
  21
  22         eor = '\r'?'\n';
  23         reason = ' '("fsck" @ { set_prio_fsck(mgmt); } | [a-zA-Z0-9_]+);
  24         invalid_line := (
  25                 [ \t]*
  26                 ([^ \t\r]+) > { mgmt->mark[0] = fpc - buf; }
  27                 (any-'\n')* > { mgmt->mark[1] = fpc - buf; }
  28                 '\n'
  29         ) @ {
  30                 mog_mgmt_fn_unknown(mgmt, buf);
  31                 really_done = 1;
  32                 fbreak;
  33         };
  34         size = (
  35                 "size "(mog_path) > { mgmt->mark[0] = fpc - buf; }
  36                 eor > { mgmt->mark[1] = fpc - buf; }
  37                 @ { mgmt->mgmt_method = MOG_MGMT_METHOD_SIZE; fbreak; }
  38         );
  39         digest = (
  40                 (
  41                         "MD5" @ { mgmt->alg = GC_MD5; }
  42                         |
  43                         "SHA-1" @ { mgmt->alg = GC_SHA1; }
  44                 )
  45                 " "
  46                 (mog_path) > { mgmt->mark[0] = fpc - buf; }
  47                 ( reason? eor) > { mgmt->mark[1] = fpc - buf; }
  48                 @ { mgmt->mgmt_method = MOG_MGMT_METHOD_DIG; fbreak; }
  49         );
  50         watch = "watch" eor @ {
  51                 static int have_iostat = 1;
  52
  53                 if (have_iostat)
  54                         mgmt->forward = MOG_IOSTAT;
  55                 else
  56                         mog_mgmt_fn_watch_err(mgmt);
  57                 fbreak;
  58         };
  59         aio_threads = (
  60                 "server aio_threads"i ' '?'='(' ')?
  61                 (digit+) > { mgmt->mark[0] = fpc - buf; }
  62                 eor > { mgmt->mark[1] = fpc - buf; }
  63                 @ { mog_mgmt_fn_aio_threads(mgmt, buf); fbreak; }
  64         );
  65
  66         true_val = ('1'|'true'|'yes'|'on');
  67         false_val = ('0'|'false'|'no'|'off');
  68
  69         persist_client = (
  70                 "set mogstored.persist_client"i ' '?'='(' ')?
  71                 (
  72                         (true_val) @ { mgmt->svc->persist_client = true; }
  73                         |
  74                         (false_val) @ { mgmt->svc->persist_client = false; }
  75                 )
  76                 eor
  77                 @ {
  78                         mog_mgmt_fn_blank(mgmt);
  79                         fbreak;
  80                 }
  81         );
  82         blank = [ \t]* eor @ { mog_mgmt_fn_blank(mgmt); fbreak; };
  83         shutdown = "shutdown" (" "+"graceful")? eor @ {
  84                 cmogstored_quit();
  85                 fbreak;
  86         };
  87
  88         command = (digest|size|watch|aio_threads|persist_client|shutdown|blank);
  89         main := command $! {
  90                 p = buf;
  91                 fhold;
  92                 fgoto invalid_line;
  93         };
  94 }%%
  95
  96 %% write data;
  97
  98 void mog_mgmt_reset_parser(struct mog_mgmt *mgmt)
  99 {
 100         int cs;
 101         %% write init;
 102         mgmt->cs = cs;
 103         mgmt->mark[0] = mgmt->mark[1] = 0;
 104 }
 105
 106 void mog_mgmt_init(struct mog_mgmt *mgmt, struct mog_svc *svc)
 107 {
 108         memset(mgmt, 0, sizeof(struct mog_mgmt));
 109         mog_mgmt_reset_parser(mgmt);
 110         mgmt->svc = svc;
 111 }
 112
 113 enum mog_parser_state
 114 mog_mgmt_parse(struct mog_mgmt *mgmt, char *buf, size_t len)
 115 {
 116         char *p, *pe, *eof = NULL;
 117         int cs = mgmt->cs;
 118         int really_done = 0;
 119         size_t off = mgmt->buf_off;
 120         uint32_t *mog_devid = &mgmt->mog_devid;
 121
 122         assert(mgmt->wbuf == NULL && "unwritten data in buffer");
 123         assert(off <= len && "mgmt offset past end of buffer");
 124
 125         p = buf + off;
 126         pe = buf + len;
 127
 128         assert((void *)(pe - p) == (void *)(len - off) &&
 129                "pointers aren't same distance");
 130
 131         %% write exec;
 132
 133         if (really_done)
 134                 cs = mgmt_parser_first_final;
 135
 136         mgmt->cs = cs;
 137         mgmt->buf_off = p - buf;
 138
 139         if (cs == mgmt_parser_error)
 140                 return MOG_PARSER_ERROR;
 141
 142         assert(p <= pe && "buffer overflow after mgmt parse");
 143         assert(mgmt->buf_off <= len && "offset longer than len");
 144
 145         if (mgmt->cs == mgmt_parser_first_final) return MOG_PARSER_DONE;
 146         return MOG_PARSER_CONTINUE;
 147 }