#通过 ceph daemon 可以查看到相应的守护进程的信息
#ceph中每个 守护进程都对应一个 asok 文件

[root@node29 ~]# ls /var/run/ceph/
ceph-client.radosgw.gateway.28290.93853901817120.asok  ceph-mon.mon-node29.asok  ceph-osd.1.asok
ceph-mgr.node29.asok                                   ceph-osd.0.asok           ceph-osd.2.asok

# asok类型的文件就是 进程启动时生成的

[root@node29 run]# ceph daemon /var/run/ceph/ceph-osd.0.asok config
no valid command found; 7 closest matches:
config set <var> <val> [<val>...]
config help {<var>}
config diff
config get <var>
config diff get <var>
config show
config unset <var>

#获取全部配置内容
[root@node29 run]# ceph daemon /var/run/ceph/ceph-osd.0.asok config show | head -10
{
    "name": "osd.0",
    "cluster": "ceph",
    "admin_socket": "/var/run/ceph/ceph-osd.0.asok",
    "admin_socket_mode": "",
    "auth_client_required": "cephx",
    "auth_cluster_required": "cephx",
   ......
}

#获取指定配置内容
[root@node29 run]#  ceph daemon /var/run/ceph/ceph-osd.0.asok config get admin_socket
{
    "admin_socket": "/var/run/ceph/ceph-osd.0.asok"
}

[root@node29 run]#

#修改 指定配置内容
[root@node29 ceph]# ceph daemon /var/run/ceph/ceph-osd.0.asok config set "mon_osd_initial_require_min_compat_client" "jewel"
{
    "success": ""
}
......
[root@node29 ~]# ceph daemon /var/run/ceph/ceph-osd.1.asok perf dump | head -n15
{
    "AsyncMessenger::Worker-0": {
        "msgr_recv_messages": 2665895,
        "msgr_send_messages": 2665927,
        "msgr_recv_bytes": 853128095,
        "msgr_send_bytes": 4958397491,
        "msgr_created_connections": 13,
        "msgr_active_connections": 2,
        "msgr_running_total_time": 600.146200311,
        "msgr_running_send_time": 223.453728410,
        "msgr_running_recv_time": 152.217070353,
        "msgr_running_fast_dispatch_time": 77.218817120
    },

CephContext::CephContext(uint32_t module_type_,
                         enum code_environment_t code_env,
                         int init_flags_){

//  ..............
  _admin_socket = new AdminSocket(this);
// ...............
  _admin_hook = new CephContextHook(this);
// 并添加了几个命令
  _admin_socket->register_command("assert", "assert", _admin_hook, "");
  _admin_socket->register_command("abort", "abort", _admin_hook, "");
  _admin_socket->register_command("perfcounters_dump", "perfcounters_dump", _admin_hook, "");
  _admin_socket->register_command("config show", "config show", _admin_hook, "dump current config settings");

//  ..............
}

//先看参数类型
//string_view 是和有着string一样功能，但没有涉及内存的额外分配（c++17特性）
// AdminSocketHook 也是一个类， call 是纯虚函数，说明肯定有某个类继承并重写 call
// hook后续会单独分析

class AdminSocketHook {
public:
  virtual bool call(std::string_view command, const cmdmap_t& cmdmap,
		    std::string_view format, bufferlist& out) = 0;
  virtual ~AdminSocketHook() {}
};

int AdminSocket::register_command(std::string_view command,
				  std::string_view cmddesc,
				  AdminSocketHook *hook,
				  std::string_view help)
{
  int ret;
  std::unique_lock l(lock);
// hooks 是AdminSocket 类里的一个 map，用来存命令的
// std::map<std::string, hook_info, std::less<>> hooks;
// hook_info 是一个包含函数的结构体
// 首先在 map中查有无 相对应的命令
  auto i = hooks.find(command);
  if (i != hooks.cend()) {
    ldout(m_cct, 5) << "register_command " << command << " hook " << hook
		    << " EEXIST" << dendl;
    ret = -EEXIST;
  } else {
    ldout(m_cct, 5) << "register_command " << command << " hook " << hook
		    << dendl;
    //  加入 将 命令和对应的AdminSocketHook加入 是AdminSocket中
    hooks.emplace_hint(i,
		       std::piecewise_construct,
		       std::forward_as_tuple(command),
		       std::forward_as_tuple(hook, cmddesc, help));
    ret = 0;
  }
  return ret;
}

//代码有点多，只留关键的代码
bool AdminSocket::init(const std::string& path)
{
  hrp("admin socket 初始化")
  /* Set up things for the new thread */
  std::string err;
  int pipe_rd = -1, pipe_wr = -1;
  err = create_shutdown_pipe(&pipe_rd, &pipe_wr);

  /* Create socket */
  int sock_fd;
  err = bind_and_listen(path, &sock_fd);

  /* Create new thread */
  m_sock_fd = sock_fd;
  m_shutdown_rd_fd = pipe_rd;
  m_shutdown_wr_fd = pipe_wr;
  m_path = path;
  hrp(m_path);
  version_hook = std::make_unique<VersionHook>();
  register_command("0", "0", version_hook.get(), "");
  .....

  th = make_named_thread("admin_socket", &AdminSocket::entry, this);
  add_cleanup_file(m_path.c_str());
  return true;
}

std::string AdminSocket::create_shutdown_pipe(int *pipe_rd, int *pipe_wr)
{
  int pipefd[2];
  if (pipe_cloexec(pipefd) < 0) {
    int e = errno;
    ostringstream oss;
    oss << "AdminSocket::create_shutdown_pipe error: " << cpp_strerror(e);
    return oss.str();
  }

  *pipe_rd = pipefd[0];
  *pipe_wr = pipefd[1];
  return "";
}

 /* Create new thread */
// 将上生成的 fd 保存到 类成员中
  m_sock_fd = sock_fd;
  m_shutdown_rd_fd = pipe_rd;
  m_shutdown_wr_fd = pipe_wr;
//这里path 是  asok文件路径
  m_path = path;
  hrp(m_path);
//VersionHook 继承了 AdminSocketHook 并实现 call接口
  version_hook = std::make_unique<VersionHook>();
  register_command("0", "0", version_hook.get(), "");
  register_command("version", "version", version_hook.get(), "get ceph version");
  register_command("git_version", "git_version", version_hook.get(),
		   "get git sha1");

//help_hook 也继承了 AdminSocketHook 并实现 call接口
  help_hook = std::make_unique<HelpHook>(this);
  register_command("help", "help", help_hook.get(),
		   "list available commands");
//同上， 这里可以出 针对不同的命令，用不同的类进行call 重写
  getdescs_hook = std::make_unique<GetdescsHook>(this);
  register_command("get_command_descriptions", "get_command_descriptions",
		   getdescs_hook.get(), "list available commands");

// 最后启动线程
// 函数设置了 线程名字，和线程启动时调用的函数 &AdminSocket::entry
  th = make_named_thread("admin_socket", &AdminSocket::entry, this);
  add_cleanup_file(m_path.c_str());

void AdminSocket::entry() noexcept
{
.....
  while (true) {
    struct pollfd fds[2];
    fds[0].fd = m_sock_fd;
    fds[0].events = POLLIN | POLLRDBAND;
    fds[1].fd = m_shutdown_rd_fd;
    fds[1].events = POLLIN | POLLRDBAND;

    int ret = poll(fds, 2, -1);
    if (ret < 0) {
      int err = errno;
      if (err == EINTR) {
	continue;
      }
      lderr(m_cct) << "AdminSocket: poll(2) error: '"
		   << cpp_strerror(err) << dendl;
      return;
    }

    if (fds[0].revents & POLLIN) {
      // Send out some data
      do_accept();
    }
    if (fds[1].revents & POLLIN) {
      // Parent wants us to shut down
      return;
    }
  }
  ldout(m_cct, 5) << "entry exit" << dendl;
}

std::unique_lock l(lock);
// 创建一个 hooks类型的 变量
  decltype(hooks)::iterator p;
// match 为参数命令
  while (match.size()) {
    p = hooks.find(match);
    if (p != hooks.cend())
      break;

    // drop right-most word
    size_t pos = match.rfind(' ');
    if (pos == std::string::npos) {
      match.clear();  // we fail
      break;
    } else {
      match.resize(pos);
    }
  }

  if (p == hooks.cend()) {
    lderr(m_cct) << "AdminSocket: request '" << cmd << "' not defined" << dendl;
    return false;
  }
  string args;
  if (match != cmd) {
    args = cmd.substr(match.length() + 1);
  }

  // Drop lock to avoid cycles in cases where the hook takes
  // the same lock that was held during calls to register/unregister,
  // and set in_hook to allow unregister to wait for us before
  // removing this hook.
  in_hook = true;
// p的key是 string， value是 struct hook_info，这个结构体包含了 hook
  auto match_hook = p->second.hook;
  l.unlock();
// match_hook 是 AdminSocketHook类 可以执行 call，也就是一开始注册的函数
  bool success = (validate(match, cmdmap, out) &&
      match_hook->call(match, cmdmap, format, out));
  l.lock();
  in_hook = false;
  in_hook_cond.notify_all();

def do_sockio(path, cmd_bytes):
    """ helper: do all the actual low-level stream I/O """
    #发起连接，connect的参数是 path，也就是 socket文件路径
    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    sock.connect(path)
    try:
        # 发送数据，即解析好的参数
        sock.sendall(cmd_bytes + b'\0')
        len_str = sock.recv(4)
        if len(len_str) < 4:
            raise RuntimeError("no data returned from admin socket")
        l, = struct.unpack(">I", len_str)
        sock_ret = b''
        # 读取数据
        got = 0
        while got < l:
            # recv() receives signed int, i.e max 2GB
            # workaround by capping READ_CHUNK_SIZE per call.
            want = min(l - got, READ_CHUNK_SIZE)
            bit = sock.recv(want)
            sock_ret += bit
            got += len(bit)

    except Exception as sock_e:
        raise RuntimeError('exception: ' + str(sock_e))
    return sock_ret

#命令 执行流程
#先获取命令集合
    try:
        cmd_json = do_sockio(asok_path,
                             b'{"prefix": "get_command_descriptions"}')

    except Exception as e:
        raise RuntimeError('exception getting command descriptions: ' + str(e))

# cmd和get_command_descriptions一样说明只是获取帮助
    if cmd == 'get_command_descriptions':
        return cmd_json

# 将命令集合 解析成字典
    sigdict = parse_json_funcsigs(cmd_json.decode('utf-8'), 'cli')
#查找对应的命令
    valid_dict = validate_command(sigdict, cmd)
    if not valid_dict:
        raise RuntimeError('invalid command')

    if format:
        valid_dict['format'] = format
# 在字典中查找到相应的命令，则调用 do_sockio
    try:
        ret = do_sockio(asok_path, json.dumps(valid_dict).encode('utf-8'))
    except Exception as e:
        raise RuntimeError('exception: ' + str(e))
    return ret