Merge with master and fix CI failure.

Author: Yuhong Guo

src/common/redis_module/ray_redis_module.cc

@@ -91,7 +91,8 @@ RedisModuleString *FormatPubsubChannel(
   // Format the pubsub channel enum to a string. TablePubsub_MAX should be more
   // than enough digits, but add 1 just in case for the null terminator.
   char pubsub_channel[static_cast<int>(TablePubsub::MAX) + 1];
-  sprintf(pubsub_channel, "%d", ParseTablePubsub(pubsub_channel_str));
+  sprintf(pubsub_channel, "%d",
+          static_cast<int>(ParseTablePubsub(pubsub_channel_str)));
   return RedisString_Format(ctx, "%s:%S", pubsub_channel, id);
 }
 

src/local_scheduler/local_scheduler_client.cc

@@ -214,14 +214,16 @@ std::pair<std::vector<ObjectID>, std::vector<ObjectID>> local_scheduler_wait(
       fbb, to_flatbuf(fbb, object_ids), num_returns, timeout_milliseconds,
       wait_local);
   fbb.Finish(message);
-  write_message(conn->conn, ray::protocol::MessageType_WaitRequest,
+  write_message(conn->conn,
+                static_cast<int64_t>(ray::protocol::MessageType::WaitRequest),
                 fbb.GetSize(), fbb.GetBufferPointer());
   // Read result.
   int64_t type;
   int64_t reply_size;
   uint8_t *reply;
   read_message(conn->conn, &type, &reply_size, &reply);
-  RAY_CHECK(type == ray::protocol::MessageType_WaitReply);
+  RAY_CHECK(static_cast<ray::protocol::MessageType>(type) ==
+            ray::protocol::MessageType::WaitReply);
   auto reply_message = flatbuffers::GetRoot<ray::protocol::WaitReply>(reply);
   // Convert result.
   std::pair<std::vector<ObjectID>, std::vector<ObjectID>> result;

src/ray/object_manager/object_directory.cc

@@ -148,8 +148,8 @@ ray::Status ObjectDirectory::LookupLocations(const ObjectID &object_id,
   JobID job_id = JobID::nil();
   ray::Status status = gcs_client_->object_table().Lookup(
       job_id, object_id,
-      [this, callback](gcs::AsyncGcsClient *client, const ObjectID &object_id,
-                       const std::vector<ObjectTableDataT> &location_history) {
+      [callback](gcs::AsyncGcsClient *client, const ObjectID &object_id,
+                 const std::vector<ObjectTableDataT> &location_history) {
         // Build the set of current locations based on the entries in the log.
         std::unordered_set<ClientID> client_ids;
         std::vector<ClientID> locations_vector =

src/ray/object_manager/test/object_manager_test.cc

@@ -289,7 +289,6 @@ class TestObjectManager : public TestObjectManagerBase {
   }
 
   void TestWaitWhileSubscribed(UniqueID sub_id, ObjectID object_1, ObjectID object_2) {
-    int num_objects = 2;
     int required_objects = 1;
     int timeout_ms = 1000;
 
@@ -300,7 +299,7 @@ class TestObjectManager : public TestObjectManagerBase {
 
     RAY_CHECK_OK(server1->object_manager_.AddWaitRequest(
         wait_id, object_ids, timeout_ms, required_objects, false,
-        [this, sub_id, object_1, object_ids, num_objects, start_time](
+        [this, sub_id, object_1, object_ids, start_time](
             const std::vector<ray::ObjectID> &found,
             const std::vector<ray::ObjectID> &remaining) {
           int64_t elapsed = (boost::posix_time::second_clock::local_time() - start_time)

src/ray/raylet/node_manager.cc

@@ -460,7 +460,7 @@ void NodeManager::ProcessClientMessage(
       worker->MarkUnblocked();
     }
   } break;
-  case protocol::MessageType_WaitRequest: {
+  case protocol::MessageType::WaitRequest: {
     // Read the data.
     auto message = flatbuffers::GetRoot<protocol::WaitRequest>(message_data);
     std::vector<ObjectID> object_ids = from_flatbuf(*message->object_ids());
@@ -470,14 +470,15 @@ void NodeManager::ProcessClientMessage(
 
     ray::Status status = object_manager_.Wait(
         object_ids, wait_ms, num_required_objects, wait_local,
-        [this, client](std::vector<ObjectID> found, std::vector<ObjectID> remaining) {
+        [client](std::vector<ObjectID> found, std::vector<ObjectID> remaining) {
           // Write the data.
           flatbuffers::FlatBufferBuilder fbb;
           flatbuffers::Offset<protocol::WaitReply> wait_reply = protocol::CreateWaitReply(
               fbb, to_flatbuf(fbb, found), to_flatbuf(fbb, remaining));
           fbb.Finish(wait_reply);
-          RAY_CHECK_OK(client->WriteMessage(protocol::MessageType_WaitReply,
-                                            fbb.GetSize(), fbb.GetBufferPointer()));
+          RAY_CHECK_OK(
+              client->WriteMessage(static_cast<int64_t>(protocol::MessageType::WaitReply),
+                                   fbb.GetSize(), fbb.GetBufferPointer()));
         });
     RAY_CHECK_OK(status);
   } break;