topology.proto

/*
 *  Copyright (c) 2020 NetEase Inc.
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

/*
 * Project: curve
 * Created Date: Fri Aug 17 2018
 * Author: xuchaojie
 */

syntax="proto2";
import "proto/common.proto";
package curve.mds.topology;
// HTTP web can use https://github.com/dcodeIO/protobuf.js to use proto buffer

option cc_generic_services = true;
option go_package = "proto/topology";

enum LogicalPoolType {
    PAGEFILE = 0;
    APPENDFILE = 1;
    APPENDECFILE = 2;
};

enum AllocateStatus {
    ALLOW = 0;
    DENY = 1;
}

enum ChunkServerStatus {
    READWRITE = 0;
    PENDDING = 1;
    RETIRED = 2;
}

enum DiskState {
    DISKNORMAL = 0;
    DISKERROR = 1;
}

enum OnlineState {
    ONLINE = 0;
    OFFLINE = 1;
    UNSTABLE = 2;
}

// etcd struct defination
message ClusterInfoData {
    required string clusterId = 1;
}

message LogicalPoolData {
    required uint32 logicalPoolId = 1;
    required string logicalPoolName = 2;
    required uint32 physicalPoolId = 3;
    required LogicalPoolType type = 4;
    required uint32 initialScatterWidth = 5;
    required uint64 createTime = 6;
    required AllocateStatus status = 7;
    required string redundanceAndPlacementPolicy = 8;
    required string userPolicy = 9;
    required bool availFlag = 10;
    optional bool scanEnable = 11;
}

message PhysicalPoolData {
    required uint32 physicalPoolId = 1;
    required string physicalPoolName = 2;
    required string desc = 3;
}

message ZoneData {
    required uint32 zoneId = 1;
    required string zoneName = 2;
    required uint32 physicalPoolId = 3;
    required string desc = 4;
}

message ServerData {
    required uint32 serverId = 1;
    required string hostName = 2;
    required string internalHostIP = 3;
    required uint32 internalPort = 4;
    required string externalHostIP = 5;
    required uint32 externalPort = 6;
    required uint32 zoneId = 7;
    required uint32 physicalPoolId = 8;
    required string desc = 9;
}

message ChunkServerData {
    required uint32 chunkserverId = 1;
    required string token = 2;
    required string diskType = 3;
    required string internalHostIP = 4;
    required uint32 port = 5;
    required uint32 serverId = 6;
    required ChunkServerStatus rwstatus = 7;
    required DiskState diskState = 8;
    required OnlineState onlineState = 9;
    required string mountPoint = 10;
    required int64 diskCapacity = 11;
    required int64 diskUsed = 12;
}

message CopysetData {
    required uint32 copysetId = 1;
    required uint32 logicalPoolId = 2;
    required uint64 epoch = 3;
    repeated uint32 chunkserverIds = 4;
    optional bool availFlag = 5;
    optional uint64 lastScanSec = 6;
    optional bool lastScanConsistent = 7;
}

// rpc struct defination

message ChunkServerInfo {
    required uint32 chunkServerID = 1;
    required string diskType = 2;
    required string hostIp = 3;
    required uint32 port = 4;

    required  ChunkServerStatus status = 5;
    required  DiskState         diskStatus = 6;
    required  OnlineState       onlineState = 7;

    required string mountPoint = 8;
    required uint64 diskCapacity = 9;
    required uint64 diskUsed = 10;
    optional string externalIp = 11;
}

//chunkserver message
message ChunkServerRegistRequest {
    required string diskType = 1;    //"nvme_ssd"
    required string diskPath = 2;
    required string hostIp = 3;
    required uint32 port = 4;
    optional string externalIp = 5;

    // already registed chunkserver should take chunkserverId & token
    optional uint32 chunkServerID = 6;
    optional string token = 7;
    optional uint64 chunkFilepoolSize = 8;
    optional bool   useChunkFilePoolAsWalPool = 9;
    optional uint32 useChunkFilePoolAsWalPoolReserve = 10;
};

message ChunkServerRegistResponse {
    required sint32 statusCode = 1;
    optional uint32 chunkServerID = 2;
    optional string token = 3;
    // <FileId, epoch>
    map<uint64, uint64> epochMap = 4;
};

message ListChunkServerRequest {
    //user either ip or serverID to list Chunkserver under server
    optional string ip = 1;
    optional uint32 port = 2;
    optional uint32 serverID = 3;
}

message ListChunkServerResponse {
    required sint32 statusCode = 1;
    repeated ChunkServerInfo chunkServerInfos = 2;
}

message GetChunkServerInfoRequest {
    //use either chunkServerID  or  hostIp&port to query chunkserver
    optional uint32 chunkServerID = 1;
    optional string hostIp = 2;
    optional uint32 port = 3;
}

message GetChunkServerInfoResponse {
    required sint32 statusCode = 1;
    optional ChunkServerInfo chunkServerInfo = 2;
}

message GetChunkServerInClusterRequest {
}

message GetChunkServerInClusterResponse {
    required sint32 statusCode = 1;
    repeated ChunkServerInfo chunkServerInfos = 2;
}

message DeleteChunkServerRequest {
    required uint32 chunkServerID = 1;
}

message DeleteChunkServerResponse {
    required sint32 statusCode = 1;
}

message SetChunkServerStatusRequest {
    required uint32 chunkServerID = 1;
    required ChunkServerStatus chunkServerStatus = 2;
}

message SetChunkServerStatusResponse {
    required sint32 statusCode = 1;
}

//server message
message ServerInfo {
    required uint32 serverID = 1;
    required string hostName = 2;
    required string internalIp = 3;
    required uint32 internalPort = 4;
    required string externalIp = 5;
    required uint32 externalPort = 6;
    required uint32 zoneID = 7;
    required string zoneName = 8;
    required uint32 physicalPoolID = 9;
    required string physicalPoolName = 10;
    required string desc = 11;
}

message ServerRegistRequest {
    required string hostName = 1;
    required string internalIp = 2; // for internal uses(between mds & chunkserver)
    optional uint32 internalPort = 3;
    required string externalIp = 4; // for client use (read & write & snapshot and so on)
    optional uint32 externalPort = 5;

    //user either zoneID&physicalPoolID  or zoneName&physicalPoolName
    optional uint32 zoneID = 6;
    optional string zoneName = 7;
    optional uint32 physicalPoolID = 8;
    optional string physicalPoolName = 9; //physicalPoolName is unique
    required string desc = 10;
}

message ServerRegistResponse {
    required sint32 statusCode = 1;
    optional uint32 serverID = 2;
}

message GetServerRequest {
    //use either  serverID  or  hostName  or hostIp(internalIP or externalIp) to getServer
    optional uint32 serverID = 1;
    optional string hostName = 2;
    optional string hostIp = 3;
    optional uint32 port = 4;
}

message GetServerResponse {
    required sint32 statusCode = 1;
    optional ServerInfo serverInfo = 2;
}

message DeleteServerRequest {
    //must use the serverID to delete the server
    required uint32 serverID = 1;
}

message DeleteServerResponse {
    required sint32 statusCode = 1;
}

//zone message
message ListZoneServerRequest {
    //user either zoneID  or zoneName&physicalPoolName to
    //List Servers under the zone
    optional uint32 zoneID = 1;
    optional string zoneName = 2;
    optional string physicalPoolName = 3;
}

message ListZoneServerResponse {
    required sint32 statusCode = 1;
    repeated ServerInfo serverInfo = 2;
}

message ZoneInfo {
    required uint32 zoneID  = 1;
    required string zoneName = 2;
    required uint32 physicalPoolID = 3;
    required string physicalPoolName = 4;
    optional string desc = 5;
}

message ZoneRequest {
    //use either zoneID or zoneName&physicalPoolName to locate zone
    optional uint32 zoneID = 1;
    optional string zoneName  = 2;
    optional string physicalPoolName = 3;
    optional string desc = 4;
}

message ZoneResponse {
    required sint32 statusCode = 1;
    optional ZoneInfo zoneInfo = 2;
}


//physicalpool message
message ListPoolZoneRequest {
    //use either  physicalPoolID or physicalPoolName
    optional uint32 physicalPoolID = 1;
    optional string physicalPoolName = 2;
}

message ListPoolZoneResponse {
    required sint32 statusCode = 1;
    repeated ZoneInfo zones = 2;
}

message PhysicalPoolInfo {
    required uint32 physicalPoolID = 1;
    required string physicalPoolName = 2;
    optional string desc = 3;
}

message PhysicalPoolRequest {
    //use either  physicalPoolID or physicalPoolName
    optional uint32 physicalPoolID = 1;
    optional string physicalPoolName = 2;
    optional string desc = 3;
}

message PhysicalPoolResponse {
    required sint32 statusCode = 1;
    optional PhysicalPoolInfo physicalPoolInfo = 2;
}

message ListPhysicalPoolRequest {
}

message ListPhysicalPoolResponse {
    required sint32 statusCode = 1;
    repeated PhysicalPoolInfo physicalPoolInfos = 2;
}

//logicalpool message
message LogicalPoolInfo {
    required uint32 logicalPoolID = 1;
    required string logicalPoolName = 2;
    required uint32 physicalPoolID = 3;
    required LogicalPoolType type = 4;
    required uint64 createTime = 5;
    required bytes redundanceAndPlaceMentPolicy = 6;  //json body
    required bytes userPolicy = 7;                    //json body
    required AllocateStatus allocateStatus = 8;
    optional bool scanEnable = 9;
}

message CreateLogicalPoolRequest {
    required string logicalPoolName = 1;
    optional uint32 physicalPoolID = 2;
    optional string physicalPoolName = 3;
    required LogicalPoolType type = 4;
    required bytes redundanceAndPlaceMentPolicy = 5;  //json body
    required bytes userPolicy = 6;                    //json body
    optional uint32 scatterWidth = 7;      //生成copyset依据的scatterWidth平均值
    optional AllocateStatus status = 8;
}

message CreateLogicalPoolResponse {
    required sint32 statusCode = 1;
    optional LogicalPoolInfo logicalPoolInfo = 2;
}

message  DeleteLogicalPoolRequest {
    //use either logicalPoolID  or  physicalPoolName & logicalPoolName
    optional uint32 logicalPoolID = 1;
    optional string logicalPoolName = 2;
    optional string physicalPoolName = 3;
}

message DeleteLogicalPoolResponse {
    required sint32 statusCode = 1;
}

message GetLogicalPoolRequest {
    //use either  logicalPoolID or logicalPoolName
    optional uint32 logicalPoolID = 1;
    optional string logicalPoolName = 2;
    optional string physicalPoolName = 3;
}

message GetLogicalPoolResponse {
    required sint32 statusCode = 1;
    optional LogicalPoolInfo logicalPoolInfo = 2;
}


message ListLogicalPoolRequest {
    //use either physicalPoolID or  physicalPoolName
    optional uint32 physicalPoolID = 1;
    optional string physicalPoolName = 2;
}

message ListLogicalPoolResponse {
    required sint32 statusCode = 1;
    repeated LogicalPoolInfo logicalPoolInfos = 2;
}

message SetLogicalPoolRequest {
    required uint32 logicalPoolID = 1;
    required AllocateStatus status = 2;
}

message SetLogicalPoolResponse {
    required sint32 statusCode = 1;
}

message SetLogicalPoolScanStateRequest {
    required uint32 logicalPoolID = 1;
    required bool scanEnable = 2;
}

message SetLogicalPoolScanStateResponse {
    required sint32 statusCode = 1;
}

//for client interface

message GetChunkServerListInCopySetsRequest {
    required uint32 logicalPoolId = 1;
    repeated uint32 copysetId = 2;
}

message CopySetServerInfo {
    required uint32 copysetId = 1;
    repeated common.ChunkServerLocation csLocs = 2;
}

message GetChunkServerListInCopySetsResponse {
    required sint32 statusCode = 1;
    repeated CopySetServerInfo csInfo = 2;
}

message GetCopySetsInChunkServerRequest {
    //use either chunkServerID  or  hostIp&port to get copusets on chunkserver
    optional uint32 chunkServerID = 1;
    optional string hostIp = 2;
    optional uint32 port = 3;
}

message GetCopySetsInChunkServerResponse {
    required sint32 statusCode = 1;
    repeated common.CopysetInfo copysetInfos = 2;
}

message GetClusterInfoRequest {
}

message GetClusterInfoResponse {
    required sint32 statusCode = 1;
    optional string clusterId = 2;
}

message GetCopySetsInClusterRequest {
    // Filter copysets which in scaning
    optional bool filterScaning = 1;
}

message GetCopySetsInClusterResponse {
    required sint32 statusCode = 1;
    repeated common.CopysetInfo copysetInfos = 2;
}

message GetCopysetRequest {
    required uint32 logicalPoolId = 1;
    required uint32 copysetId = 2;
}

message GetCopysetResponse {
    required sint32 statusCode = 1;
    optional common.CopysetInfo copysetInfo = 2;
}

message SetCopysetsAvailFlagRequest {
    required bool availFlag = 1;
    repeated common.CopysetInfo copysets = 2;
}

message SetCopysetsAvailFlagResponse {
    required sint32 statusCode = 1;
}

message ListUnAvailCopySetsRequest {
}

message ListUnAvailCopySetsResponse {
    required sint32 statusCode = 1;
    repeated common.CopysetInfo copysets = 2;
}

//TODO(hzsunjianliang): update userPolicy and so on
service TopologyService {
    rpc RegistChunkServer(ChunkServerRegistRequest) returns (ChunkServerRegistResponse);
    rpc ListChunkServer(ListChunkServerRequest) returns (ListChunkServerResponse);
    rpc GetChunkServer(GetChunkServerInfoRequest) returns (GetChunkServerInfoResponse);
    rpc GetChunkServerInCluster(GetChunkServerInClusterRequest) returns (GetChunkServerInClusterResponse);
    rpc DeleteChunkServer(DeleteChunkServerRequest) returns (DeleteChunkServerResponse);
    rpc SetChunkServer(SetChunkServerStatusRequest) returns (SetChunkServerStatusResponse);

    rpc RegistServer(ServerRegistRequest)            returns (ServerRegistResponse);
    rpc GetServer(GetServerRequest)           returns (GetServerResponse);
    rpc DeleteServer(DeleteServerRequest)     returns (DeleteServerResponse);
    rpc ListZoneServer(ListZoneServerRequest) returns (ListZoneServerResponse);

    rpc CreateZone(ZoneRequest)               returns (ZoneResponse);
    rpc DeleteZone(ZoneRequest)               returns (ZoneResponse);
    rpc GetZone(ZoneRequest)                  returns (ZoneResponse);
    rpc ListPoolZone(ListPoolZoneRequest)     returns (ListPoolZoneResponse);


    rpc CreatePhysicalPool(PhysicalPoolRequest)     returns (PhysicalPoolResponse);
    rpc DeletePhysicalPool(PhysicalPoolRequest)     returns (PhysicalPoolResponse);
    rpc GetPhysicalPool(PhysicalPoolRequest)        returns (PhysicalPoolResponse);
    rpc ListPhysicalPool(ListPhysicalPoolRequest)   returns (ListPhysicalPoolResponse);

    rpc CreateLogicalPool(CreateLogicalPoolRequest)       returns (CreateLogicalPoolResponse);
    rpc DeleteLogicalPool(DeleteLogicalPoolRequest)    returns (DeleteLogicalPoolResponse);
    rpc GetLogicalPool(GetLogicalPoolRequest)           returns (GetLogicalPoolResponse);
    rpc ListLogicalPool(ListLogicalPoolRequest)         returns (ListLogicalPoolResponse);
    rpc SetLogicalPool(SetLogicalPoolRequest) returns(SetLogicalPoolResponse);
    rpc SetLogicalPoolScanState(SetLogicalPoolScanStateRequest) returns (SetLogicalPoolScanStateResponse);

    rpc GetChunkServerListInCopySets(GetChunkServerListInCopySetsRequest) returns (GetChunkServerListInCopySetsResponse);
    rpc GetCopySetsInChunkServer(GetCopySetsInChunkServerRequest) returns (GetCopySetsInChunkServerResponse);
    rpc GetCopySetsInCluster(GetCopySetsInClusterRequest) returns (GetCopySetsInClusterResponse);
    rpc GetCopyset(GetCopysetRequest) returns (GetCopysetResponse);
    rpc GetClusterInfo(GetClusterInfoRequest) returns (GetClusterInfoResponse);
    rpc SetCopysetsAvailFlag(SetCopysetsAvailFlagRequest) returns (SetCopysetsAvailFlagResponse);
    rpc ListUnAvailCopySets(ListUnAvailCopySetsRequest) returns (ListUnAvailCopySetsResponse);
}