pyGoEdge-UserPanel/reference/goedge 文档/NodeService.md

# NodeService
> 边缘节点管理服务

---

## checkNodeLatestVersion
> 检查新版本

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/checkNodeLatestVersion`
- RPC：`rpc checkNodeLatestVersion (CheckNodeLatestVersionRequest) returns (CheckNodeLatestVersionResponse);`

**请求对象 (`CheckNodeLatestVersionRequest`)**

```json
{
  "os": "string",
  "arch": "string",
  "currentVersion": "string"
}
```

**响应对象 (`CheckNodeLatestVersionResponse`)**

```json
{
  "hasNewVersion": "bool",
  "newVersion": "string"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/checkNodeLatestVersion" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## copyNodeActionsToNodeCluster
> 复制动作设置到集群

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/copyNodeActionsToNodeCluster`
- RPC：`rpc copyNodeActionsToNodeCluster(CopyNodeActionsToNodeClusterRequest) returns (RPCSuccess);`

**请求对象 (`CopyNodeActionsToNodeClusterRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/copyNodeActionsToNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## copyNodeActionsToNodeGroup
> 复制动作设置到分组

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/copyNodeActionsToNodeGroup`
- RPC：`rpc copyNodeActionsToNodeGroup(CopyNodeActionsToNodeGroupRequest) returns (RPCSuccess);`

**请求对象 (`CopyNodeActionsToNodeGroupRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/copyNodeActionsToNodeGroup" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodes
> 所有可用的节点数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllEnabledNodes`
- RPC：`rpc countAllEnabledNodes (CountAllEnabledNodesRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodesRequest`)**

```json
{}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllEnabledNodes" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodesMatch
> 计算匹配的节点数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllEnabledNodesMatch`
- RPC：`rpc countAllEnabledNodesMatch (CountAllEnabledNodesMatchRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodesMatchRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "installState": "int32",
  "activeState": "int32",
  "keyword": "string // 关键词",
  "nodeGroupId": "int64",
  "nodeRegionId": "int64",
  "level": "int32"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllEnabledNodesMatch" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodesWithNodeGrantId
> 计算使用某个认证的节点数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllEnabledNodesWithNodeGrantId`
- RPC：`rpc countAllEnabledNodesWithNodeGrantId (CountAllEnabledNodesWithNodeGrantIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodesWithNodeGrantIdRequest`)**

```json
{
  "nodeGrantId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllEnabledNodesWithNodeGrantId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodesWithNodeGroupId
> 计算某个节点分组内的节点数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllEnabledNodesWithNodeGroupId`
- RPC：`rpc countAllEnabledNodesWithNodeGroupId (CountAllEnabledNodesWithNodeGroupIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodesWithNodeGroupIdRequest`)**

```json
{
  "nodeGroupId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllEnabledNodesWithNodeGroupId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllEnabledNodesWithNodeRegionId
> 计算某个区域下的节点数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllEnabledNodesWithNodeRegionId`
- RPC：`rpc countAllEnabledNodesWithNodeRegionId (CountAllEnabledNodesWithNodeRegionIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllEnabledNodesWithNodeRegionIdRequest`)**

```json
{
  "nodeRegionId": "int64"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllEnabledNodesWithNodeRegionId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllNodeRegionInfo
> 查找节点区域信息数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllNodeRegionInfo`
- RPC：`rpc countAllNodeRegionInfo(CountAllNodeRegionInfoRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllNodeRegionInfoRequest`)**

```json
{
  "nodeRegionId": "int64 // 区域ID，可选"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllNodeRegionInfo" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllNotInstalledNodesWithNodeClusterId
> 计算没有安装的节点数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllNotInstalledNodesWithNodeClusterId`
- RPC：`rpc countAllNotInstalledNodesWithNodeClusterId (CountAllNotInstalledNodesWithNodeClusterIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllNotInstalledNodesWithNodeClusterIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllNotInstalledNodesWithNodeClusterId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countAllUpgradeNodesWithNodeClusterId
> 计算需要升级的节点数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countAllUpgradeNodesWithNodeClusterId`
- RPC：`rpc countAllUpgradeNodesWithNodeClusterId (CountAllUpgradeNodesWithNodeClusterIdRequest) returns (RPCCountResponse);`

**请求对象 (`CountAllUpgradeNodesWithNodeClusterIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countAllUpgradeNodesWithNodeClusterId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## countNodeInitScript
> 查找节点区域信息数量

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/countNodeInitScript`
- RPC：`rpc countNodeInitScript(CountNodeInitScriptRequest) returns (RPCCountResponse);`

**请求对象 (`CountNodeInitScriptRequest`)**

```json
{}
```

**响应对象 (`RPCCountResponse`)**

```json
{
  "count": "int64 // 数量"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/countNodeInitScript" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## createNode
> 创建节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/createNode`
- RPC：`rpc createNode (CreateNodeRequest) returns (CreateNodeResponse);`

**请求对象 (`CreateNodeRequest`)**

```json
{
  "name": "string // 节点名称",
  "nodeClusterId": "int64 // 节点所属集群",
  "nodeLogin": "NodeLogin // 节点登录信息",
  "nodeGroupId": "int64 // 节点所属分组",
  "dnsRoutes": "[]string // 节点DNS线路列表",
  "nodeRegionId": "int64 // 节点所属区域"
}
```

**响应对象 (`CreateNodeResponse`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/createNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## createNodeInitScript
> 创建节点初始化脚本

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/createNodeInitScript`
- RPC：`rpc createNodeInitScript(CreateNodeInitScriptRequest) returns (CreateNodeInitScriptResponse);`

**请求对象 (`CreateNodeInitScriptRequest`)**

```json
{
  "name": "string // 脚本名称",
  "code": "string // 脚本代码"
}
```

**响应对象 (`CreateNodeInitScriptResponse`)**

```json
{
  "scriptId": "int64"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/createNodeInitScript" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## deleteNode
> 删除节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/deleteNode`
- RPC：`rpc deleteNode (DeleteNodeRequest) returns (RPCSuccess);`

**请求对象 (`DeleteNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/deleteNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## deleteNodeFromNodeCluster
> 从集群中删除节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/deleteNodeFromNodeCluster`
- RPC：`rpc deleteNodeFromNodeCluster (DeleteNodeFromNodeClusterRequest) returns (RPCSuccess);`

**请求对象 (`DeleteNodeFromNodeClusterRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/deleteNodeFromNodeCluster" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## deleteNodeInitScript
> 删除节点初始化脚本

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/deleteNodeInitScript`
- RPC：`rpc deleteNodeInitScript(DeleteNodeInitScriptRequest) returns(RPCSuccess);`

**请求对象 (`DeleteNodeInitScriptRequest`)**

```json
{
  "scriptId": "int64"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/deleteNodeInitScript" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodesDNSWithNodeClusterId
> 取得某个集群下的所有节点DNS信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findAllEnabledNodesDNSWithNodeClusterId`
- RPC：`rpc findAllEnabledNodesDNSWithNodeClusterId (FindAllEnabledNodesDNSWithNodeClusterIdRequest) returns (FindAllEnabledNodesDNSWithNodeClusterIdResponse);`

**请求对象 (`FindAllEnabledNodesDNSWithNodeClusterIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "isInstalled": "bool"
}
```

**响应对象 (`FindAllEnabledNodesDNSWithNodeClusterIdResponse`)**

```json
{
  "nodes": "[]NodeDNSInfo"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findAllEnabledNodesDNSWithNodeClusterId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodesWithNodeClusterId
> 根据集群查找所有节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findAllEnabledNodesWithNodeClusterId`
- RPC：`rpc findAllEnabledNodesWithNodeClusterId (FindAllEnabledNodesWithNodeClusterIdRequest) returns (FindAllEnabledNodesWithNodeClusterIdResponse);`

**请求对象 (`FindAllEnabledNodesWithNodeClusterIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID",
  "includeSecondary": "bool // 是否检查节点的从集群，如果为false，则只检查主集群ID"
}
```

**响应对象 (`FindAllEnabledNodesWithNodeClusterIdResponse`)**

```json
{
  "nodes": "[]Node"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findAllEnabledNodesWithNodeClusterId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllEnabledNodesWithNodeGrantId
> 查找使用某个认证的所有节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findAllEnabledNodesWithNodeGrantId`
- RPC：`rpc findAllEnabledNodesWithNodeGrantId (FindAllEnabledNodesWithNodeGrantIdRequest) returns (FindAllEnabledNodesWithNodeGrantIdResponse);`

**请求对象 (`FindAllEnabledNodesWithNodeGrantIdRequest`)**

```json
{
  "nodeGrantId": "int64"
}
```

**响应对象 (`FindAllEnabledNodesWithNodeGrantIdResponse`)**

```json
{
  "nodes": "[]Node"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findAllEnabledNodesWithNodeGrantId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllNodeInitScripts
> 获取一共节点初始化脚本

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findAllNodeInitScripts`
- RPC：`rpc findAllNodeInitScripts(FindAllNodeInitScriptsRequest) returns (FindAllNodeInitScriptsResponse);`

**请求对象 (`FindAllNodeInitScriptsRequest`)**

```json
{}
```

**响应对象 (`FindAllNodeInitScriptsResponse`)**

```json
{
  "nodeInitScripts": "[]NodeInitScript"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findAllNodeInitScripts" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllNodeScheduleInfoWithNodeClusterId
> 查找集群的节点调度信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findAllNodeScheduleInfoWithNodeClusterId`
- RPC：`rpc findAllNodeScheduleInfoWithNodeClusterId(FindAllNodeScheduleInfoWithNodeClusterIdRequest) returns (FindAllNodeScheduleInfoWithNodeClusterIdResponse);`

**请求对象 (`FindAllNodeScheduleInfoWithNodeClusterIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindAllNodeScheduleInfoWithNodeClusterIdResponse`)**

```json
{
  "nodes": "[]ScheduleInfo // 调动信息列表",
  "nodeId": "int64 // 节点ID",
  "nodeName": "string // 节点名称",
  "nodeGroupId": "int64 // 节点分组ID",
  "nodeGroupName": "string // 节点分组名称",
  "offlineDay": "string // 下线日期，格式YYYYMMDD",
  "isBackupForCluster": "bool // 是否为集群备份节点",
  "isBackupForGroup": "bool // 是否为分组备份节点",
  "backupIPs": "[]string // 备用IP",
  "actionStatusJSON": "bytes // 动作状态"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findAllNodeScheduleInfoWithNodeClusterId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllNotInstalledNodesWithNodeClusterId
> 列出所有未安装的节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findAllNotInstalledNodesWithNodeClusterId`
- RPC：`rpc findAllNotInstalledNodesWithNodeClusterId (FindAllNotInstalledNodesWithNodeClusterIdRequest) returns (FindAllNotInstalledNodesWithNodeClusterIdResponse);`

**请求对象 (`FindAllNotInstalledNodesWithNodeClusterIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindAllNotInstalledNodesWithNodeClusterIdResponse`)**

```json
{
  "nodes": "[]Node"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findAllNotInstalledNodesWithNodeClusterId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findAllUpgradeNodesWithNodeClusterId
> 列出所有需要升级的节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findAllUpgradeNodesWithNodeClusterId`
- RPC：`rpc findAllUpgradeNodesWithNodeClusterId (FindAllUpgradeNodesWithNodeClusterIdRequest) returns (FindAllUpgradeNodesWithNodeClusterIdResponse);`

**请求对象 (`FindAllUpgradeNodesWithNodeClusterIdRequest`)**

```json
{
  "nodeClusterId": "int64 // 集群ID"
}
```

**响应对象 (`FindAllUpgradeNodesWithNodeClusterIdResponse`)**

```json
{
  "nodes": "[]NodeUpgrade",
  "node": "Node",
  "os": "string",
  "arch": "string",
  "oldVersion": "string",
  "newVersion": "string"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findAllUpgradeNodesWithNodeClusterId" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledBasicNode
> 获取单个节点基本信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findEnabledBasicNode`
- RPC：`rpc findEnabledBasicNode (FindEnabledBasicNodeRequest) returns (FindEnabledBasicNodeResponse);`

**请求对象 (`FindEnabledBasicNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindEnabledBasicNodeResponse`)**

```json
{
  "node": "BasicNode // 节点基本信息"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findEnabledBasicNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNode
> 获取单个节点信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findEnabledNode`
- RPC：`rpc findEnabledNode (FindEnabledNodeRequest) returns (FindEnabledNodeResponse);`

**请求对象 (`FindEnabledNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindEnabledNodeResponse`)**

```json
{
  "node": "Node // 节点信息"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findEnabledNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeConfigInfo
> 取得节点的配置概要信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findEnabledNodeConfigInfo`
- RPC：`rpc findEnabledNodeConfigInfo (FindEnabledNodeConfigInfoRequest) returns (FindEnabledNodeConfigInfoResponse);`

**请求对象 (`FindEnabledNodeConfigInfoRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindEnabledNodeConfigInfoResponse`)**

```json
{
  "hasDNSInfo": "bool // 是否有DNS设置",
  "hasCacheInfo": "bool // 是否有缓存设置",
  "hasThresholds": "bool // 是否有阈值设置",
  "hasSSH": "bool // 是否有SSH设置",
  "hasSystemSettings": "bool // 是否有系统设置",
  "hasDDoSProtection": "bool // 是否有DDoS防护设置",
  "hasScheduleSettings": "bool // 是否有调度设置"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findEnabledNodeConfigInfo" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodeDNS
> 查找单个节点的域名解析信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findEnabledNodeDNS`
- RPC：`rpc findEnabledNodeDNS (FindEnabledNodeDNSRequest) returns (FindEnabledNodeDNSResponse);`

**请求对象 (`FindEnabledNodeDNSRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "nodeClusterId": "int64 // 集群ID",
  "nodeIPAddrId": "int64"
}
```

**响应对象 (`FindEnabledNodeDNSResponse`)**

```json
{
  "node": "NodeDNSInfo"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findEnabledNodeDNS" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findEnabledNodesWithIds
> 根据一组ID获取节点信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findEnabledNodesWithIds`
- RPC：`rpc findEnabledNodesWithIds (FindEnabledNodesWithIdsRequest) returns (FindEnabledNodesWithIdsResponse);`

**请求对象 (`FindEnabledNodesWithIdsRequest`)**

```json
{
  "nodeIds": "[]int64"
}
```

**响应对象 (`FindEnabledNodesWithIdsResponse`)**

```json
{
  "nodes": "[]Node"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findEnabledNodesWithIds" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeAPIConfig
> 查找单个节点的API相关配置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findNodeAPIConfig`
- RPC：`rpc findNodeAPIConfig(FindNodeAPIConfigRequest) returns (FindNodeAPIConfigResponse);`

**请求对象 (`FindNodeAPIConfigRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindNodeAPIConfigResponse`)**

```json
{
  "apiNodeAddrsJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findNodeAPIConfig" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeDDoSProtection
> 获取节点的DDoS设置

- 角色：`node`, `admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findNodeDDoSProtection`
- RPC：`rpc findNodeDDoSProtection(FindNodeDDoSProtectionRequest) returns (FindNodeDDoSProtectionResponse);`

**请求对象 (`FindNodeDDoSProtectionRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindNodeDDoSProtectionResponse`)**

```json
{
  "ddosProtectionJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findNodeDDoSProtection" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeDNSResolver
> 读取节点DNS Resolver

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findNodeDNSResolver`
- RPC：`rpc findNodeDNSResolver(FindNodeDNSResolverRequest) returns (FindNodeDNSResolverResponse);`

**请求对象 (`FindNodeDNSResolverRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindNodeDNSResolverResponse`)**

```json
{
  "dnsResolverJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findNodeDNSResolver" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeGlobalServerConfig
> 取得节点的服务全局配置

- 角色：`node`, `admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findNodeGlobalServerConfig`
- RPC：`rpc findNodeGlobalServerConfig(FindNodeGlobalServerConfigRequest) returns (FindNodeGlobalServerConfigResponse);`

**请求对象 (`FindNodeGlobalServerConfigRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindNodeGlobalServerConfigResponse`)**

```json
{
  "globalServerConfigJSON": "bytes"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findNodeGlobalServerConfig" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeInitScript
> 获取节点初始化脚本

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findNodeInitScript`
- RPC：`rpc findNodeInitScript(FindNodeInitScriptRequest) returns (FindNodeInitScriptResponse);`

**请求对象 (`FindNodeInitScriptRequest`)**

```json
{
  "scriptId": "int64"
}
```

**响应对象 (`FindNodeInitScriptResponse`)**

```json
{
  "nodeInitScript": "NodeInitScript"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findNodeInitScript" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeInstallStatus
> 读取节点安装状态

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findNodeInstallStatus`
- RPC：`rpc findNodeInstallStatus (FindNodeInstallStatusRequest) returns (FindNodeInstallStatusResponse);`

**请求对象 (`FindNodeInstallStatusRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindNodeInstallStatusResponse`)**

```json
{
  "installStatus": "NodeInstallStatus"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findNodeInstallStatus" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## findNodeScheduleInfo
> 查找节点调度信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/findNodeScheduleInfo`
- RPC：`rpc findNodeScheduleInfo(FindNodeScheduleInfoRequest) returns (FindNodeScheduleInfoResponse);`

**请求对象 (`FindNodeScheduleInfoRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`FindNodeScheduleInfoResponse`)**

```json
{
  "scheduleInfo": "ScheduleInfo // 调度信息",
  "offlineDay": "string // 下线日期，格式YYYYMMDD",
  "isBackupForCluster": "bool // 是否为集群备份节点",
  "isBackupForGroup": "bool // 是否为分组备份节点",
  "backupIPs": "[]string // 备用IP",
  "actionStatusJSON": "bytes // 动作状态"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/findNodeScheduleInfo" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## installNode
> 安装节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/installNode`
- RPC：`rpc installNode (InstallNodeRequest) returns (InstallNodeResponse);`

**请求对象 (`InstallNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "initScriptId": "int64"
}
```

**响应对象 (`InstallNodeResponse`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/installNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## listEnabledNodesMatch
> 列出单页节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/listEnabledNodesMatch`
- RPC：`rpc listEnabledNodesMatch (ListEnabledNodesMatchRequest) returns (ListEnabledNodesMatchResponse);`

**请求对象 (`ListEnabledNodesMatchRequest`)**

```json
{
  "offset": "int64 // 读取位置",
  "size": "int64 // 读取数量",
  "nodeClusterId": "int64 // 集群ID",
  "installState": "int32 // 安装状态",
  "activeState": "int32 // 在线状态",
  "keyword": "string // 关键词",
  "nodeGroupId": "int64 // 节点分组ID",
  "nodeRegionId": "int64 // 节点区域ID",
  "level": "int32 // 节点级别，目前只有1（L1）和2（L2）",
  "cpuAsc": "bool",
  "cpuDesc": "bool",
  "memoryAsc": "bool",
  "memoryDesc": "bool",
  "trafficInAsc": "bool",
  "trafficInDesc": "bool",
  "trafficOutAsc": "bool",
  "trafficOutDesc": "bool",
  "loadAsc": "bool",
  "loadDesc": "bool",
  "connectionsAsc": "bool",
  "connectionsDesc": "bool"
}
```

**响应对象 (`ListEnabledNodesMatchResponse`)**

```json
{
  "nodes": "[]Node"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/listEnabledNodesMatch" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## listNodeInitScript
> 列表节点初始化脚本

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/listNodeInitScript`
- RPC：`rpc listNodeInitScript(ListNodeInitScriptRequest) returns (ListNodeInitScriptResponse);`

**请求对象 (`ListNodeInitScriptRequest`)**

```json
{
  "offset": "int64 // 读取位置",
  "size": "int64 // 读取数量"
}
```

**响应对象 (`ListNodeInitScriptResponse`)**

```json
{
  "nodeInitScripts": "[]NodeInitScript"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/listNodeInitScript" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## listNodeRegionInfo
> 列出单页节点区域信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/listNodeRegionInfo`
- RPC：`rpc listNodeRegionInfo(ListNodeRegionInfoRequest) returns (ListNodeRegionInfoResponse);`

**请求对象 (`ListNodeRegionInfoRequest`)**

```json
{
  "nodeRegionId": "int64 // 区域ID，可选",
  "offset": "int64 // 读取位置",
  "size": "int64 // 数量，通常不能小于0"
}
```

**响应对象 (`ListNodeRegionInfoResponse`)**

```json
{
  "infoList": "[]Info",
  "id": "int64",
  "name": "string // 名称",
  "nodeRegion": "NodeRegion",
  "nodeCluster": "NodeCluster"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/listNodeRegionInfo" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## resetNodeActionStatus
> 重置节点动作状态

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/resetNodeActionStatus`
- RPC：`rpc resetNodeActionStatus(ResetNodeActionStatusRequest) returns (RPCSuccess);`

**请求对象 (`ResetNodeActionStatusRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/resetNodeActionStatus" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## sendCommandToNode
> 向节点发送命令

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/sendCommandToNode`
- RPC：`rpc sendCommandToNode (NodeStreamMessage) returns (NodeStreamMessage);`

**请求对象 (`NodeStreamMessage`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "requestId": "int64",
  "timeoutSeconds": "int32",
  "code": "string",
  "dataJSON": "bytes",
  "isOk": "bool",
  "message": "string"
}
```

**响应对象 (`NodeStreamMessage`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "requestId": "int64",
  "timeoutSeconds": "int32",
  "code": "string",
  "dataJSON": "bytes",
  "isOk": "bool",
  "message": "string"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/sendCommandToNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## startNode
> 启动节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/startNode`
- RPC：`rpc startNode (StartNodeRequest) returns (StartNodeResponse);`

**请求对象 (`StartNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`StartNodeResponse`)**

```json
{
  "isOk": "bool",
  "error": "string"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/startNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## stopNode
> 停止节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/stopNode`
- RPC：`rpc stopNode (StopNodeRequest) returns (StopNodeResponse);`

**请求对象 (`StopNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`StopNodeResponse`)**

```json
{
  "isOk": "bool // 是否成功",
  "error": "string // 失败时的错误信息"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/stopNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## uninstallNode
> 卸载节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/uninstallNode`
- RPC：`rpc uninstallNode(UninstallNodeRequest) returns (UninstallNodeResponse);`

**请求对象 (`UninstallNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID"
}
```

**响应对象 (`UninstallNodeResponse`)**

```json
{
  "isOk": "bool // 是否成功",
  "error": "string // 失败时的错误信息"
}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/uninstallNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNode
> 修改节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNode`
- RPC：`rpc updateNode (UpdateNodeRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "name": "string // 名称",
  "nodeClusterId": "int64 // 集群ID",
  "secondaryNodeClusterIds": "[]int64",
  "isOn": "bool // 是否启用",
  "nodeGroupId": "int64",
  "nodeRegionId": "int64",
  "level": "int32",
  "lnAddrs": "[]string // Ln节点访问地址",
  "enableIPLists": "bool // 是否启用IP名单"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeAPIConfig
> 修改某个节点的API相关配置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeAPIConfig`
- RPC：`rpc updateNodeAPIConfig(UpdateNodeAPIConfigRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeAPIConfigRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "apiNodeAddrsJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeAPIConfig" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeBypassMobile
> 修改节点是否过移动

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeBypassMobile`
- RPC：`rpc updateNodeBypassMobile(UpdateNodeBypassMobile) returns (RPCSuccess);`

**请求对象 (`UpdateNodeBypassMobile`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "bypassMobile": "int32"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeBypassMobile" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeCache
> 修改节点缓存设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeCache`
- RPC：`rpc updateNodeCache(UpdateNodeCacheRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeCacheRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "maxCacheDiskCapacity": "SizeCapacity // 磁盘容量限制",
  "maxCacheMemoryCapacity": "SizeCapacity // 内存容量限制",
  "cacheDiskDir": "string // 磁盘缓存目录",
  "cacheDiskSubDirsJSON": "bytes // 磁盘缓存子目录"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeCache" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeDDoSProtection
> 修改节点的DDoS设置

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeDDoSProtection`
- RPC：`rpc updateNodeDDoSProtection(UpdateNodeDDoSProtectionRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeDDoSProtectionRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "ddosProtectionJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeDDoSProtection" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeDNS
> 修改节点的DNS解析信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeDNS`
- RPC：`rpc updateNodeDNS (UpdateNodeDNSRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeDNSRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "ipAddr": "string",
  "nodeIPAddressId": "int64",
  "dnsDomainId": "int64",
  "routes": "[]string"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeDNS" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeDNSResolver
> 修改DNS Resolver

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeDNSResolver`
- RPC：`rpc updateNodeDNSResolver(UpdateNodeDNSResolverRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeDNSResolverRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "dnsResolverJSON": "bytes"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeDNSResolver" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeInitScript
> 更新节点初始化脚本

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeInitScript`
- RPC：`rpc updateNodeInitScript(UpdateNodeInitScriptRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeInitScriptRequest`)**

```json
{
  "scriptId": "int64",
  "name": "string // 名称",
  "code": "string"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeInitScript" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeIsInstalled
> 修改节点安装状态

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeIsInstalled`
- RPC：`rpc updateNodeIsInstalled (UpdateNodeIsInstalledRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeIsInstalledRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "isInstalled": "bool"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeIsInstalled" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeIsOn
> 修改节点的启用状态

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeIsOn`
- RPC：`rpc updateNodeIsOn(UpdateNodeIsOnRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeIsOnRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "isOn": "bool // 是否启用"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeIsOn" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeLogin
> 修改节点登录信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeLogin`
- RPC：`rpc updateNodeLogin (UpdateNodeLoginRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeLoginRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "nodeLogin": "NodeLogin"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeLogin" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeRegionInfo
> 修改节点区域信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeRegionInfo`
- RPC：`rpc updateNodeRegionInfo(UpdateNodeRegionInfoRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeRegionInfoRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "nodeRegionId": "int64"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeRegionInfo" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeScheduleInfo
> 修改节点调度信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeScheduleInfo`
- RPC：`rpc updateNodeScheduleInfo(UpdateNodeScheduleInfoRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeScheduleInfoRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "offlineDay": "string // 下线日期，格式YYYYMMDD",
  "isBackupForCluster": "bool // 是否为集群备份节点",
  "isBackupForGroup": "bool // 是否为分组备份节点",
  "backupIPs": "[]string // 备用IP"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeScheduleInfo" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeSystem
> 修改节点系统信息

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeSystem`
- RPC：`rpc updateNodeSystem(UpdateNodeSystemRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeSystemRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "maxCPU": "int32"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeSystem" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## updateNodeUp
> 设置节点上线状态

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/updateNodeUp`
- RPC：`rpc updateNodeUp (UpdateNodeUpRequest) returns (RPCSuccess);`

**请求对象 (`UpdateNodeUpRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "isUp": "bool"
}
```

**响应对象 (`RPCSuccess`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/updateNodeUp" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---

## upgradeNode
> 升级节点

- 角色：`admin`
- HTTP：`POST https://backend.dooki.cloud/NodeService/upgradeNode`
- RPC：`rpc upgradeNode (UpgradeNodeRequest) returns (UpgradeNodeResponse);`

**请求对象 (`UpgradeNodeRequest`)**

```json
{
  "nodeId": "int64 // 节点ID",
  "initScriptId": "int64"
}
```

**响应对象 (`UpgradeNodeResponse`)**

```json
{}
```

**调用示例**

```bash
curl -X POST "https://backend.dooki.cloud/NodeService/upgradeNode" \
  -H "Content-Type: application/json" \
  -H "X-Edge-Access-Token: <YOUR_TOKEN>" \
  -d '{
    ...
  }'
```

---