(string_family): Add support for MC GAT

The memcache protocol commands GAT and GATS should use the same code
path as MC GET, but also touch expiry of keys which are searched.

The expiry is stored in memcache flag of connection context. The mget
code path is changed to expire keys if a combination of mc protocol and
the set_expiry flag are found.

Signed-off-by: Abhijat Malviya <[email protected]>

Author: abhijat

src/facade/memcache_parser_test.cc

@@ -149,6 +149,20 @@ TEST_F(MCParserTest, Meta) {
   EXPECT_TRUE(cmd_.return_hit);
 }
 
+TEST_F(MCParserTest, Gat) {
+  auto res = parser_.Parse("gat 1000 foo bar baz\r\n", &consumed_, &cmd_);
+  EXPECT_EQ(MemcacheParser::OK, res);
+  EXPECT_EQ(consumed_, 22);
+  EXPECT_EQ(cmd_.type, MemcacheParser::GAT);
+  EXPECT_EQ(cmd_.key, "foo");
+  EXPECT_THAT(cmd_.keys_ext, UnorderedElementsAre("bar", "baz"));
+  EXPECT_EQ(cmd_.expire_ts, 1000);
+
+  cmd_ = {};
+  res = parser_.Parse("gat foo bar\r\n", &consumed_, &cmd_);
+  EXPECT_EQ(MemcacheParser::BAD_INT, res);
+}
+
 class MCParserNoreplyTest : public MCParserTest {
  protected:
   void RunTest(string_view str, bool noreply) {

src/server/acl/acl_family_test.cc

@@ -329,7 +329,7 @@ TEST_F(AclFamilyTest, TestCat) {
               UnorderedElementsAre("GETSET", "GETRANGE", "INCRBYFLOAT", "GETDEL", "DECRBY",
                                    "PREPEND", "SETEX", "MSET", "SET", "PSETEX", "SUBSTR", "DECR",
                                    "STRLEN", "INCR", "INCRBY", "MGET", "GET", "SETNX", "GETEX",
-                                   "APPEND", "MSETNX", "SETRANGE"));
+                                   "APPEND", "MSETNX", "SETRANGE", "GAT"));
 }
 
 TEST_F(AclFamilyTest, TestGetUser) {

src/server/conn_context.h

@@ -149,6 +149,7 @@ struct ConnectionState {
 
   enum MCGetMask {
     FETCH_CAS_VER = 1,
+    SET_EXPIRY = 2,
   };
 
   size_t UsedMemory() const;
@@ -257,8 +258,10 @@ struct ConnectionState {
 
   // used for memcache set/get commands.
   // For set op - it's the flag value we are storing along with the value.
-  // For get op - we use it as a mask of MCGetMask values.
-  uint32_t memcache_flag = 0;
+  // For get op - we use it as a mask of MCGetMask values stored in the highest two bits
+  // For GAT and GATS - the expiry in seconds supplied is stored in the top 62 bits along with the
+  // MCGetMask values in the lower two bits
+  uint64_t memcache_flag = 0;
 
   ExecInfo exec_info;
   ReplicationInfo replication_info;

src/server/dragonfly_test.cc

@@ -374,6 +374,25 @@ TEST_F(DflyEngineTest, Memcache) {
   EXPECT_THAT(resp, ElementsAre("VALUE key 1 3 0", "bar", "VALUE key2 2 8 0", "bar2val2", "END"));
 }
 
+TEST_F(DflyEngineTest, MemcacheGat) {
+  using m = MemcacheParser;
+
+  EXPECT_THAT(GetMC(m::GAT, {"1000", "foo", "bar"}), ElementsAre("END"));
+  EXPECT_THAT(RunMC(m::SET, "exp-key", "exp-val"), ElementsAre("STORED"));
+  EXPECT_THAT(GetMC(m::GAT, {"1", "exp-key"}), ElementsAre("VALUE exp-key 0 7", "exp-val", "END"));
+
+  AdvanceTime(2 * 1000);
+  EXPECT_THAT(RunMC(m::GET, "exp-key"), ElementsAre("END"));
+
+  EXPECT_THAT(RunMC(m::SET, "a", "a-val"), ElementsAre("STORED"));
+  EXPECT_THAT(RunMC(m::SET, "x", "x-val"), ElementsAre("STORED"));
+  EXPECT_THAT(GetMC(m::GAT, {"3", "a", "x", "z", "foo"}),
+              ElementsAre("VALUE a 0 5", "a-val", "VALUE x 0 5", "x-val", "END"));
+
+  AdvanceTime(2 * 1000);
+  EXPECT_THAT(GetMC(m::GAT, {"3", "a", "x", "z", "foo"}), ElementsAre("END"));
+}
+
 TEST_F(DflyEngineTest, MemcacheFlags) {
   using MP = MemcacheParser;
 

src/server/main_service.cc

@@ -1596,6 +1596,9 @@ void Service::DispatchMC(const MemcacheParser::Command& cmd, std::string_view va
     case MemcacheParser::QUIT:
       strcpy(cmd_name, "QUIT");
       break;
+    case MemcacheParser::GAT:
+      strcpy(cmd_name, "GAT");
+      break;
     case MemcacheParser::STATS:
       server_family_.StatsMC(cmd.key, mc_builder);
       return;
@@ -1616,6 +1619,13 @@ void Service::DispatchMC(const MemcacheParser::Command& cmd, std::string_view va
 
   ConnectionContext* dfly_cntx = static_cast<ConnectionContext*>(cntx);
 
+  // if expire_ts is greater than month it's a unix timestamp
+  // https://github.com/memcached/memcached/blob/master/doc/protocol.txt#L139
+  constexpr uint32_t kExpireLimit = 60 * 60 * 24 * 30;
+  const uint64_t expire_ts = cmd.expire_ts && cmd.expire_ts <= kExpireLimit
+                                 ? cmd.expire_ts + time(nullptr)
+                                 : cmd.expire_ts;
+
   if (MemcacheParser::IsStoreCmd(cmd.type)) {
     char* v = const_cast<char*>(value.data());
     args.emplace_back(v, value.size());
@@ -1624,12 +1634,6 @@ void Service::DispatchMC(const MemcacheParser::Command& cmd, std::string_view va
       args.emplace_back(store_opt, strlen(store_opt));
     }
 
-    // if expire_ts is greater than month it's a unix timestamp
-    // https://github.com/memcached/memcached/blob/master/doc/protocol.txt#L139
-    constexpr uint32_t kExpireLimit = 60 * 60 * 24 * 30;
-    const uint64_t expire_ts = cmd.expire_ts && cmd.expire_ts <= kExpireLimit
-                                   ? cmd.expire_ts + time(nullptr)
-                                   : cmd.expire_ts;
     if (expire_ts && memcmp(cmd_name, "SET", 3) == 0) {
       char* next = absl::numbers_internal::FastIntToBuffer(expire_ts, ttl);
       args.emplace_back(ttl_op, 4);
@@ -1641,6 +1645,11 @@ void Service::DispatchMC(const MemcacheParser::Command& cmd, std::string_view va
       char* key = const_cast<char*>(s.data());
       args.emplace_back(key, s.size());
     }
+
+    if (cmd.type == MemcacheParser::GAT) {
+      dfly_cntx->conn_state.memcache_flag |= ConnectionState::SET_EXPIRY;
+      dfly_cntx->conn_state.memcache_flag |= expire_ts << 2;
+    }
     if (cmd.type == MemcacheParser::GETS) {
       dfly_cntx->conn_state.memcache_flag |= ConnectionState::FETCH_CAS_VER;
     }