using noncopyable

include/pika_binlog.h

@@ -45,7 +45,7 @@ class Version final : public pstd::noncopyable {
   std::shared_ptr<pstd::RWFile> save_;
 };
 
-class Binlog {
+class Binlog : public pstd::noncopyable {
  public:
   Binlog(std::string  Binlog_path, int file_size = 100 * 1024 * 1024);
   ~Binlog();
@@ -83,10 +83,6 @@ class Binlog {
 
   void Close();
 
-  // No copying allowed
-  Binlog(const Binlog&) = delete;
-  void operator=(const Binlog&) = delete;
-
  private:
   pstd::Status Put(const char* item, int len);
   static pstd::Status AppendPadding(pstd::WritableFile* file, uint64_t* len);

include/pika_consensus.h

@@ -7,16 +7,14 @@
 
 #include <utility>
 
-#include <utility>
-
 #include "include/pika_binlog_transverter.h"
 #include "include/pika_client_conn.h"
 #include "include/pika_define.h"
 #include "include/pika_slave_node.h"
 #include "include/pika_stable_log.h"
 #include "pstd/include/env.h"
 
-class Context {
+class Context : public pstd::noncopyable {
  public:
   Context(std::string path);
 
@@ -38,9 +36,6 @@ class Context {
     tmp_stream << "  Applied window " << applied_win_.ToStringStatus();
     return tmp_stream.str();
   }
-  // No copying allowed;
-  Context(const Context&) = delete;
-  void operator=(const Context&) = delete;
 
  private:
   std::string path_;

src/net/include/http_conn.h

@@ -12,6 +12,7 @@
 
 #include "pstd/include/pstd_status.h"
 #include "pstd/include/xdebug.h"
+#include "pstd/include/pika_noncopyable.h"
 
 #include "net/include/net_conn.h"
 #include "net/include/net_define.h"
@@ -128,7 +129,7 @@ class HTTPResponse {
   bool SerializeHeader();
 };
 
-class HTTPHandles {
+class HTTPHandles : public pstd::noncopyable {
  public:
   // You need implement these handles.
   /*
@@ -164,12 +165,6 @@ class HTTPHandles {
   HTTPHandles() = default;
   virtual ~HTTPHandles() = default;
 
-  /*
-   * No allowed copy and copy assign
-   */
-  HTTPHandles(const HTTPHandles&) = delete;
-  void operator=(const HTTPHandles&) = delete;
-
  protected:
   /*
    * Assigned in ServerHandle's CreateWorkerSpecificData

src/net/include/net_conn.h

@@ -19,12 +19,13 @@
 #include "net/include/server_thread.h"
 #include "net/src/net_multiplexer.h"
 #include "pstd/include/testutil.h"
+#include "pstd/include/pika_noncopyable.h"
 
 namespace net {
 
 class Thread;
 
-class NetConn : public std::enable_shared_from_this<NetConn> {
+class NetConn : public std::enable_shared_from_this<NetConn>, public pstd::noncopyable {
  public:
   NetConn(int fd, std::string  ip_port, Thread* thread, NetMultiplexer* mpx = nullptr);
 #ifdef __ENABLE_SSL
@@ -93,11 +94,6 @@ class NetConn : public std::enable_shared_from_this<NetConn> {
 
   bool security() { return ssl_ != nullptr; }
 #endif
-  /*
-   * No allowed copy and copy assign operator
-   */
-  NetConn(const NetConn&) = delete;
-  void operator=(const NetConn&) = delete;
 
  private:
   int fd_ = -1;

src/net/include/net_pubsub.h

@@ -29,7 +29,7 @@ namespace net {
 class NetFiredEvent;
 class NetConn;
 
-class PubSubThread : public Thread {
+class PubSubThread : public Thread, public pstd::noncopyable {
  public:
   PubSubThread();
 
@@ -72,9 +72,6 @@ class PubSubThread : public Thread {
   void UpdateConnReadyState(int fd, const ReadyState& state);
 
   bool IsReady(int fd);
-  // No copying allowed
-  PubSubThread(const PubSubThread&) = delete;
-  void operator=(const PubSubThread&) = delete;
 
  private:
   void RemoveConn(const std::shared_ptr<NetConn>& conn);

src/net/include/net_thread.h

@@ -11,10 +11,11 @@
 #include <string>
 
 #include "pstd/include/pstd_mutex.h"
+#include "pstd/include/pika_noncopyable.h"
 
 namespace net {
 
-class Thread {
+class Thread : public pstd::noncopyable {
  public:
   Thread();
   virtual ~Thread();
@@ -35,12 +36,6 @@ class Thread {
 
   void set_thread_name(const std::string& name) { thread_name_ = name; }
 
-  /*
-   * No allowed copy and copy assign
-   */
-  Thread(const Thread&) = delete;
-  void operator=(const Thread&) = delete;
-
  protected:
   std::atomic<bool> should_stop_;
 

src/net/include/thread_pool.h

@@ -32,7 +32,7 @@ struct TimeTask {
   bool operator<(const TimeTask& task) const { return exec_time > task.exec_time; }
 };
 
-class ThreadPool {
+class ThreadPool : public pstd::noncopyable {
  public:
   class Worker {
    public:
@@ -41,11 +41,6 @@ class ThreadPool {
 
     int start();
     int stop();
-    /*
-     * No allowed copy and copy assign
-     */
-    Worker(const Worker&) = delete;
-    void operator=(const Worker&) = delete;
 
    private:
     pthread_t thread_id_;

src/net/src/dispatch_thread.h

@@ -22,7 +22,7 @@ class NetItem;
 class NetFiredEvent;
 class WorkerThread;
 
-class DispatchThread : public ServerThread {
+class DispatchThread : public ServerThread, public pstd::noncopyable {
  public:
   DispatchThread(int port, int work_num, ConnFactory* conn_factory, int cron_interval, int queue_limit,
                  const ServerHandle* handle);
@@ -54,9 +54,6 @@ class DispatchThread : public ServerThread {
   void HandleNewConn(int connfd, const std::string& ip_port) override;
 
   void SetQueueLimit(int queue_limit) override;
-  // No copying allowed
-  DispatchThread(const DispatchThread&) = delete;
-  void operator=(const DispatchThread&) = delete;
 
  private:
   /*

src/net/src/pb_cli.cc

@@ -12,12 +12,15 @@
 #include "net/include/net_define.h"
 #include "pstd/include/pstd_status.h"
 #include "pstd/include/xdebug.h"
+#include "pstd/include/pika_noncopyable.h"
+
 
 using pstd::Status;
+
 namespace net {
 
 // Default PBCli is block IO;
-class PbCli : public NetCli {
+class PbCli : public NetCli, public pstd::noncopyable {
  public:
   PbCli(const std::string& ip, int port);
   ~PbCli() override;
@@ -28,8 +31,6 @@ class PbCli : public NetCli {
   // Read, parse and store the reply
   Status Recv(void* msg_res) override;
 
-  PbCli(const PbCli&) = delete;
-  void operator=(const PbCli&) = delete;
  private:
   // BuildWbuf need to access rbuf_, wbuf_;
   char* rbuf_;

src/net/src/redis_cli.cc

@@ -15,14 +15,15 @@
 #include <utility>
 #include <vector>
 
+#include "pstd/include/pika_noncopyable.h"
 #include "net/include/net_cli.h"
 #include "net/include/net_define.h"
 
 using pstd::Status;
 
 namespace net {
 
-class RedisCli : public NetCli {
+class RedisCli : public NetCli, public pstd::noncopyable {
  public:
   RedisCli();
   ~RedisCli() override;
@@ -33,10 +34,6 @@ class RedisCli : public NetCli {
   // Read, parse and store the reply
   Status Recv(void* trival = nullptr) override;
 
-  // No copyable
-  RedisCli(const RedisCli&) = delete;
-  void operator=(const RedisCli&) = delete;
-
  private:
   RedisCmdArgsType argv_;  // The parsed result
 

src/net/src/server_socket.h

@@ -12,9 +12,11 @@
 #include <iostream>
 #include <string>
 
+#include "pstd/include/pika_noncopyable.h"
+
 namespace net {
 
-class ServerSocket {
+class ServerSocket : public pstd::noncopyable {
  public:
   explicit ServerSocket(int port, bool is_block = false);
 
@@ -49,13 +51,6 @@ class ServerSocket {
 
   void set_sockfd(int sockfd) { sockfd_ = sockfd; }
 
-  /*
-   * No allowed copy and copy assign operator
-   */
-
-  ServerSocket(const ServerSocket&) = delete;
-  void operator=(const ServerSocket&) = delete;
-
  private:
   int SetNonBlock();
   /*

src/pika_client_conn.cc

@@ -26,9 +26,8 @@ PikaClientConn::PikaClientConn(int fd, const std::string& ip_port, net::Thread*
                                const net::HandleType& handle_type, int max_conn_rbuf_size)
     : RedisConn(fd, ip_port, thread, mpx, handle_type, max_conn_rbuf_size),
       server_thread_(reinterpret_cast<net::ServerThread*>(thread)),
-      current_table_(g_pika_conf->default_table())
-      {
-  autoh_stat_.Init();
+      current_table_(g_pika_conf->default_table()) {
+  auth_stat_.Init();
 }
 
 std::shared_ptr<Cmd> PikaClientConn::DoCmd(const PikaCmdArgsType& argv, const std::string& opt,
@@ -43,9 +42,9 @@ std::shared_ptr<Cmd> PikaClientConn::DoCmd(const PikaCmdArgsType& argv, const st
   c_ptr->SetConn(std::dynamic_pointer_cast<PikaClientConn>(shared_from_this()));
   c_ptr->SetResp(resp_ptr);
 
-  // Check autohed
+  // Check authed
   // AuthCmd will set stat_
-  if (!autoh_stat_.IsAuthed(c_ptr)) {
+  if (!auth_stat_.IsAuthed(c_ptr)) {
     c_ptr->res().SetRes(CmdRes::kErrOther, "NOAUTH Authentication required.");
     return c_ptr;
   }
@@ -283,7 +282,7 @@ void PikaClientConn::ExecRedisCmd(const PikaCmdArgsType& argv, const std::shared
 
 // Initial permission status
 void PikaClientConn::AuthStat::Init() {
-  // Check autoh required
+  // Check auth required
   stat_ = g_pika_conf->userpass().empty() ? kLimitAuthed : kNoAuthed;
   if (stat_ == kLimitAuthed && g_pika_conf->requirepass().empty()) {
     stat_ = kAdminAuthed;
@@ -308,15 +307,15 @@ bool PikaClientConn::AuthStat::IsAuthed(const std::shared_ptr<Cmd>& cmd_ptr) {
       }
       break;
     default:
-      LOG(WARNING) << "Invalid autoh stat : " << static_cast<unsigned>(stat_);
+      LOG(WARNING) << "Invalid auth stat : " << static_cast<unsigned>(stat_);
       return false;
   }
   return true;
 }
 
 // Update permission status
 bool PikaClientConn::AuthStat::ChecknUpdate(const std::string& message) {
-  // Situations to change autoh status
+  // Situations to change auth status
   if (message == "USER") {
     stat_ = kLimitAuthed;
   } else if (message == "ROOT") {

src/pika_repl_client.cc

@@ -122,9 +122,9 @@ Status PikaReplClient::SendMetaSync() {
   node->set_ip(local_ip);
   node->set_port(g_pika_server->port());
 
-  std::string masterautoh = g_pika_conf->masterautoh();
-  if (!masterautoh.empty()) {
-    meta_sync->set_autoh(masterautoh);
+  std::string masterauth = g_pika_conf->masterauth();
+  if (!masterauth.empty()) {
+    meta_sync->set_auth(masterauth);
   }
 
   std::string to_send;

src/pika_repl_server_conn.cc

@@ -27,13 +27,13 @@ void PikaReplServerConn::HandleMetaSyncRequest(void* arg) {
 
   InnerMessage::InnerRequest::MetaSync meta_sync_request = req->meta_sync();
   const InnerMessage::Node& node = meta_sync_request.node();
-  std::string masterautoh = meta_sync_request.has_autoh() ? meta_sync_request.autoh() : "";
+  std::string masterauth = meta_sync_request.has_auth() ? meta_sync_request.auth() : "";
 
   InnerMessage::InnerResponse response;
   response.set_type(InnerMessage::kMetaSync);
-  if (!g_pika_conf->requirepass().empty() && g_pika_conf->requirepass() != masterautoh) {
+  if (!g_pika_conf->requirepass().empty() && g_pika_conf->requirepass() != masterauth) {
     response.set_code(InnerMessage::kError);
-    response.set_reply("Auth with master error, Invalid masterautoh");
+    response.set_reply("Auth with master error, Invalid masterauth");
   } else {
     LOG(INFO) << "Receive MetaSync, Slave ip: " << node.ip() << ", Slave port:" << node.port();
     std::vector<TableStruct> table_structs = g_pika_conf->table_structs();