Pacemaker管理工具中 pcs/pcsd 的关系

Contents

1 误解
2 实际套路
3 本地命令示例
4 远程命令示例

在 debug pacemaker/pcs/pcsd 的时候，我们通常需要知道，敲下 `pcs xxxx xxxx` 命令后，发生了什么动作。

在应用 pcs 进行管理的 pacemaker 集群中，每个节点都会启动一个 pcsd 守护进程，监听 2224/tcp 端口。随后，我们可以从任一节点中，通过 pcs 命令管理整个集群。

误解

按照套路，通常这是一种 client/server 架构， pcs 命令行工具向相应节点的 pcsd 发送请求， pcsd 在相应节点完成动作。

然而实际与此有所出入。

实际套路

实际上，真正对 pacemaker 执行操作的，是 pcs 这个命令行工具。pcsd 负责接收来自其他节点的请求，随之调用本地的 pcs 工具，最后由本地的 pcs 执行操作。

本地命令示例

以 `pcs cluster start` 命令为例。在 Node A 中执行 `pcs cluster start`， Node A 本地的 cluster 相关服务将被启动。

在此操作中，不需要经过 pcsd. 即， pcs ---> execute. 具体过程如下。

1. Node A 的 pcs 脚本被调用。

### pcs/pcs
10 from pcs import app
11
12 app.main(sys.argv[1:])

2. Node A 的 pcs 调起 app.py.

### pcs/app.py
14 from pcs import (
15 acl,
16 cluster,
17 config,
18 constraint,
19 node,
20 pcsd,
21 prop,
22 qdevice,
23 quorum,
24 resource,
25 settings,
26 status,
27 stonith,
28 usage,
29 utils,
30 alert,
31 )

### 找到 cluster 子命令对应的入口，cluster.cluster_cmd.
176 cmd_map = {
177 "resource": resource.resource_cmd,
178 "cluster": cluster.cluster_cmd,
179 "stonith": stonith.stonith_cmd,
180 "property": prop.property_cmd,
181 "constraint": constraint.constraint_cmd,
182 "acl": acl.acl_cmd,
183 "status": status.status_cmd,
184 "config": config.config_cmd,
185 "pcsd": pcsd.pcsd_cmd,
186 "node": node.node_cmd,
187 "quorum": lambda argv: quorum.quorum_cmd(
188 utils.get_library_wrapper(),
189 argv,
190 utils.get_modificators()
191 ),
192 "qdevice": lambda argv: qdevice.qdevice_cmd(
193 utils.get_library_wrapper(),
194 argv,
195 utils.get_modificators()
196 ),
197 "alert": lambda args: alert.alert_cmd(
198 utils.get_library_wrapper(),
199 args,
200 utils.get_modificators()
201 ),
202 }

3. 由于`pcs cluster start`后面没有接节点名或`--all`，所以判断为在本地节点进行操作。

可以看到，这个命令实际会在本地启动 corosync 和 pacemaker 服务。

###pcs/cluster.py

57 def cluster_cmd(argv):

86 elif (sub_cmd == "start"):
87 if "--all" in utils.pcs_options:
88 start_cluster_all()
89 else:
90 start_cluster(argv)

859 def start_cluster(argv):
860 wait = False
861 wait_timeout = None
862 if "--wait" in utils.pcs_options:
863 wait_timeout = utils.validate_wait_get_timeout(False)
864 wait = True
865
866 if len(argv) > 0: ###### <---------------- For remote node only.
867 start_cluster_nodes(argv)
868 if wait:
869 wait_for_nodes_started(argv, wait_timeout)
870 return
871
872 print("Starting Cluster...")
873 if utils.is_rhel6():
874 # Verify that CMAN_QUORUM_TIMEOUT is set, if not, then we set it to 0
875 retval, output = getstatusoutput('source /etc/sysconfig/cman ; [ -z "$CMAN_QUORUM_TIMEOUT" ]')
876 if retval == 0:
877 with open("/etc/sysconfig/cman", "a") as cman_conf_file:
878 cman_conf_file.write("\nCMAN_QUORUM_TIMEOUT=0\n")
879
880 output, retval = utils.run(["service", "cman","start"])
881 if retval != 0:
882 print(output)
883 utils.err("unable to start cman")
884 else:
885 output, retval = utils.run(["service", "corosync","start"]) #####<------ Work Horse 本地执行操作
886 if retval != 0:
887 print(output)
888 utils.err("unable to start corosync")
889 output, retval = utils.run(["service", "pacemaker", "start"])
890 if retval != 0:
891 print(output)
892 utils.err("unable to start pacemaker")
893 if wait:
894 wait_for_nodes_started([], wait_timeout)

远程命令示例

以`pcs cluster start --all`为例。在 Node A 执行该命令，会启动所有节点的的 cluster 相关服务。

这个命令会向每个节点的 pcsd 发送请求，随后每个节点的 pcsd 调用本地的 pcs 命令执行相应操作。

即， pcs ----> remote psdc ----> remote pcs ---> execute. 具体过程如下。

1. Node A 中执行 `pcs cluster start --all` 命令。由于存在`--all`参数，进入start_cluster_all()分支。

57 def cluster_cmd(argv):

86 elif (sub_cmd == "start"):
87 if "--all" in utils.pcs_options:
88 start_cluster_all()
89 else:
90 start_cluster(argv)
91 elif (sub_cmd == "stop"):
92 if "--all" in utils.pcs_options:
93 stop_cluster_all()
94 else:
95 stop_cluster(argv)

896 def start_cluster_all():
897 wait = False
898 wait_timeout = None
899 if "--wait" in utils.pcs_options:
900 wait_timeout = utils.validate_wait_get_timeout(False)
901 wait = True
902
903 all_nodes = utils.getNodesFromCorosyncConf() ######<------获取所有节点名字
904 start_cluster_nodes(all_nodes) ######<------在所有节点启动cluster
905
906 if wait:
907 wait_for_nodes_started(all_nodes, wait_timeout)

909 def start_cluster_nodes(nodes):
910 error_list = parallel_for_nodes(utils.startCluster, nodes, quiet=True)
911 if error_list:
912 utils.err("unable to start all nodes\n" + "\n".join(error_list))

2. Node A 向各节点的 pcsd 发送 http 请求。

### pcs/utils.py
246 def startCluster(node, quiet=False):
247 return sendHTTPRequest(node, 'remote/cluster_start', None, False, not quiet)

346 def sendHTTPRequest(host, request, data = None, printResult = True, printSuccess = True):
347 url = 'https://' + host + ':2224/' + request

3. 各节点(包括A)的 pcsd 接收到请求. 随后在本地执行 `pcs cluster start`. 后面的过程与上述本地的过程一致。

### pcsd/remote.rb

17 def remote(params, request, auth_user)
18 remote_cmd_without_pacemaker = {

39 :cluster_start => method(:cluster_start),

193 def cluster_start(params, request, auth_user)
194 if params[:name]
195 code, response = send_request_with_token(
196 auth_user, params[:name], 'cluster_start', true
197 )
198 else
199 if not allowed_for_local_cluster(auth_user, Permissions::WRITE)
200 return 403, 'Permission denied'
201 end
202 $logger.info "Starting Daemons"
203 output, stderr, retval = run_cmd(auth_user, PCS, 'cluster', 'start') ####<<<<------Call local pcs
204 $logger.debug output
205 if retval != 0
206 return [400, (output + stderr).join]
207 else
208 return output
209 end
210 end
211 end