Repository: matrixorigin/matrixcube
Pull request #593 (2021-12-22 06:26:10)

Fix misspelling, destory -> destroy
**What type of PR is this?**

- [ ] API-change
- [ ] BUG
- [x] Improvement
- [ ] Documentation
- [ ] Feature
- [ ] Test and CI
- [ ] Code Refactoring

**Which issue(s) this PR fixes:**

Fixes #

**What this PR does / why we need it:**

Not Available

**Special notes for your reviewer:**

Not Available

**Additional documentation (e.g. design docs, usage docs, etc.):**

Not Available



Patch:
diff --git a/components/prophet/client.go b/components/prophet/client.go
index ca63b15..8f1ac9d 100644
--- a/components/prophet/client.go
+++ b/components/prophet/client.go
@@ -225,17 +225,17 @@ func (c *asyncClient) CreateDestroying(id uint64, index uint64, removeData bool,
 	}
 
 	req := &rpcpb.Request{}
-	req.Type = rpcpb.TypeCreateDestoryingReq
-	req.CreateDestorying.ID = id
-	req.CreateDestorying.Index = index
-	req.CreateDestorying.Replicas = replicas
-	req.CreateDestorying.RemoveData = removeData
+	req.Type = rpcpb.TypeCreateDestroyingReq
+	req.CreateDestroying.ID = id
+	req.CreateDestroying.Index = index
+	req.CreateDestroying.Replicas = replicas
+	req.CreateDestroying.RemoveData = removeData
 
 	rsp, err := c.syncDo(req)
 	if err != nil {
 		return metapb.ResourceState_Destroying, err
 	}
-	return rsp.CreateDestorying.State, nil
+	return rsp.CreateDestroying.State, nil
 }
 
 func (c *asyncClient) GetDestroying(id uint64) (*metapb.DestroyingStatus, error) {
@@ -244,15 +244,15 @@ func (c *asyncClient) GetDestroying(id uint64) (*metapb.DestroyingStatus, error)
 	}
 
 	req := &rpcpb.Request{}
-	req.Type = rpcpb.TypeGetDestoryingReq
-	req.GetDestorying.ID = id
+	req.Type = rpcpb.TypeGetDestroyingReq
+	req.GetDestroying.ID = id
 
 	rsp, err := c.syncDo(req)
 	if err != nil {
 		return nil, err
 	}
 
-	return rsp.GetDestorying.Status, nil
+	return rsp.GetDestroying.Status, nil
 }
 
 func (c *asyncClient) ReportDestroyed(id uint64, replicaID uint64) (metapb.ResourceState, error) {
@@ -261,16 +261,16 @@ func (c *asyncClient) ReportDestroyed(id uint64, replicaID uint64) (metapb.Resou
 	}
 
 	req := &rpcpb.Request{}
-	req.Type = rpcpb.TypeReportDestoryedReq
-	req.ReportDestoryed.ID = id
-	req.ReportDestoryed.ReplicaID = replicaID
+	req.Type = rpcpb.TypeReportDestroyedReq
+	req.ReportDestroyed.ID = id
+	req.ReportDestroyed.ReplicaID = replicaID
 
 	rsp, err := c.syncDo(req)
 	if err != nil {
 		return metapb.ResourceState_Destroying, err
 	}
 
-	return rsp.ReportDestoryed.State, nil
+	return rsp.ReportDestroyed.State, nil
 }
 
 func (c *asyncClient) PutContainer(container metadata.Container) error {
diff --git a/components/prophet/cluster/cluster_worker.go b/components/prophet/cluster/cluster_worker.go
index 7e4774c..cd9bc3c 100644
--- a/components/prophet/cluster/cluster_worker.go
+++ b/components/prophet/cluster/cluster_worker.go
@@ -37,7 +37,7 @@ func (c *RaftCluster) HandleResourceHeartbeat(res *core.CachedResource) error {
 
 	if err := c.processResourceHeartbeat(res); err != nil {
 		if err == errResourceDestroyed {
-			co.opController.DispatchDestoryDirectly(res, schedule.DispatchFromHeartBeat)
+			co.opController.DispatchDestroyDirectly(res, schedule.DispatchFromHeartBeat)
 			return nil
 		}
 		return err
@@ -47,8 +47,8 @@ func (c *RaftCluster) HandleResourceHeartbeat(res *core.CachedResource) error {
 	return nil
 }
 
-// HandleCreateDestorying handle create destroying
-func (c *RaftCluster) HandleCreateDestorying(req rpcpb.CreateDestoryingReq) (metapb.ResourceState, error) {
+// HandleCreateDestroying handle create destroying
+func (c *RaftCluster) HandleCreateDestroying(req rpcpb.CreateDestroyingReq) (metapb.ResourceState, error) {
 	c.Lock()
 	defer c.Unlock()
 
@@ -80,8 +80,8 @@ func (c *RaftCluster) HandleCreateDestorying(req rpcpb.CreateDestoryingReq) (met
 	return status.State, nil
 }
 
-// HandleReportDestoryed handle report destroyed
-func (c *RaftCluster) HandleReportDestoryed(req rpcpb.ReportDestoryedReq) (metapb.ResourceState, error) {
+// HandleReportDestroyed handle report destroyed
+func (c *RaftCluster) HandleReportDestroyed(req rpcpb.ReportDestroyedReq) (metapb.ResourceState, error) {
 	c.Lock()
 	defer c.Unlock()
 
@@ -124,8 +124,8 @@ func (c *RaftCluster) HandleReportDestoryed(req rpcpb.ReportDestoryedReq) (metap
 	return status.State, nil
 }
 
-// HandleGetDestorying returns resource destroying status
-func (c *RaftCluster) HandleGetDestorying(req rpcpb.GetDestoryingReq) (*metapb.DestroyingStatus, error) {
+// HandleGetDestroying returns resource destroying status
+func (c *RaftCluster) HandleGetDestroying(req rpcpb.GetDestroyingReq) (*metapb.DestroyingStatus, error) {
 	c.RLock()
 	defer c.RUnlock()
 
@@ -426,7 +426,7 @@ func (c *RaftCluster) saveDestroyingStatusLocked(id uint64, status *metapb.Destr
 	if status.State == metapb.ResourceState_Destroyed {
 		res := c.core.GetResource(id)
 		if res == nil {
-			c.logger.Fatal("missing resource to set destoryed",
+			c.logger.Fatal("missing resource to set destroyed",
 				zap.Uint64("resource", id))
 			return nil
 		}
diff --git a/components/prophet/pb/metapb/metapb.pb.go b/components/prophet/pb/metapb/metapb.pb.go
index 54339d1..124c756 100644
--- a/components/prophet/pb/metapb/metapb.pb.go
+++ b/components/prophet/pb/metapb/metapb.pb.go
@@ -84,7 +84,7 @@ const (
 	ContainerState_UP ContainerState = 0
 	// Offline is the unavailable state
 	ContainerState_Offline ContainerState = 1
-	// Tombstone is the destory state
+	// Tombstone is the destroy state
 	ContainerState_Tombstone ContainerState = 2
 )
 
@@ -122,7 +122,7 @@ const (
 	// this state normally cannot provide read and write services to the public,
 	// and the destruction process of resources has not yet been completed.
 	ResourceState_Destroying ResourceState = 2
-	// Destroyed is the destoryed state,
+	// Destroyed is the destroyed state,
 	// this state is normally not available for external read and write services,
 	// the resources have been destroyed in the whole cluster and cannot be used again.
 	ResourceState_Destroyed ResourceState = 3
diff --git a/components/prophet/pb/metapb/metapb.proto b/components/prophet/pb/metapb/metapb.proto
index 86f0a13..0876b23 100644
--- a/components/prophet/pb/metapb/metapb.proto
+++ b/components/prophet/pb/metapb/metapb.proto
@@ -26,7 +26,7 @@ enum ContainerState {
     UP        = 0;
     // Offline is the unavailable state
     Offline   = 1;
-    // Tombstone is the destory state
+    // Tombstone is the destroy state
     Tombstone = 2;
 }
 
@@ -42,7 +42,7 @@ enum ResourceState {
     // this state normally cannot provide read and write services to the public, 
     // and the destruction process of resources has not yet been completed.
     Destroying     = 2;
-    // Destroyed is the destoryed state,
+    // Destroyed is the destroyed state,
     // this state is normally not available for external read and write services, 
     // the resources have been destroyed in the whole cluster and cannot be used again.
     Destroyed      = 3;
@@ -263,4 +263,4 @@ message ScheduleGroupRule {
     uint64 groupID      = 2;
     string name         = 3;
     string groupByLabel = 4;
-}
\ No newline at end of file
+}
diff --git a/components/prophet/pb/rpcpb/rpcpb.pb.go b/components/prophet/pb/rpcpb/rpcpb.pb.go
index 73d9c16..888f954 100644
--- a/components/prophet/pb/rpcpb/rpcpb.pb.go
+++ b/components/prophet/pb/rpcpb/rpcpb.pb.go
@@ -42,12 +42,12 @@ const (
 	TypeAllocIDRsp              Type = 10
 	TypeAskBatchSplitReq        Type = 11
 	TypeAskBatchSplitRsp        Type = 12
-	TypeCreateDestoryingReq     Type = 13
-	TypeCreateDestoryingRsp     Type = 14
-	TypeReportDestoryedReq      Type = 15
-	TypeReportDestoryedRsp      Type = 16
-	TypeGetDestoryingReq        Type = 17
-	TypeGetDestoryingRsp        Type = 18
+	TypeCreateDestroyingReq     Type = 13
+	TypeCreateDestroyingRsp     Type = 14
+	TypeReportDestroyedReq      Type = 15
+	TypeReportDestroyedRsp      Type = 16
+	TypeGetDestroyingReq        Type = 17
+	TypeGetDestroyingRsp        Type = 18
 	TypeCreateWatcherReq        Type = 19
 	TypeEventNotify             Type = 20
 	TypeCreateResourcesReq      Type = 21
@@ -86,12 +86,12 @@ var Type_name = map[int32]string{
 	10: "TypeAllocIDRsp",
 	11: "TypeAskBatchSplitReq",
 	12: "TypeAskBatchSplitRsp",
-	13: "TypeCreateDestoryingReq",
-	14: "TypeCreateDestoryingRsp",
-	15: "TypeReportDestoryedReq",
-	16: "TypeReportDestoryedRsp",
-	17: "TypeGetDestoryingReq",
-	18: "TypeGetDestoryingRsp",
+	13: "TypeCreateDestroyingReq",
+	14: "TypeCreateDestroyingRsp",
+	15: "TypeReportDestroyedReq",
+	16: "TypeReportDestroyedRsp",
+	17: "TypeGetDestroyingReq",
+	18: "TypeGetDestroyingRsp",
 	19: "TypeCreateWatcherReq",
 	20: "TypeEventNotify",
 	21: "TypeCreateResourcesReq",
@@ -130,12 +130,12 @@ var Type_value = map[string]int32{
 	"TypeAllocIDRsp":              10,
 	"TypeAskBatchSplitReq":        11,
 	"TypeAskBatchSplitRsp":        12,
-	"TypeCreateDestoryingReq":     13,
-	"TypeCreateDestoryingRsp":     14,
-	"TypeReportDestoryedReq":      15,
-	"TypeReportDestoryedRsp":      16,
-	"TypeGetDestoryingReq":        17,
-	"TypeGetDestoryingRsp":        18,
+	"TypeCreateDestroyingReq":     13,
+	"TypeCreateDestroyingRsp":     14,
+	"TypeReportDestroyedReq":      15,
+	"TypeReportDestroyedRsp":      16,
+	"TypeGetDestroyingReq":        17,
+	"TypeGetDestroyingRsp":        18,
 	"TypeCreateWatcherReq":        19,
 	"TypeEventNotify":             20,
 	"TypeCreateResourcesReq":      21,
@@ -252,9 +252,9 @@ type Request struct {
 	GetContainer         GetContainerReq         `protobuf:"bytes,7,opt,name=getContainer,proto3" json:"getContainer"`
 	AllocID              AllocIDReq              `protobuf:"bytes,8,opt,name=allocID,proto3" json:"allocID"`
 	AskBatchSplit        AskBatchSplitReq        `protobuf:"bytes,9,opt,name=askBatchSplit,proto3" json:"askBatchSplit"`
-	CreateDestorying     CreateDestoryingReq     `protobuf:"bytes,10,opt,name=createDestorying,proto3" json:"createDestorying"`
-	ReportDestoryed      ReportDestoryedReq      `protobuf:"bytes,11,opt,name=ReportDestoryed,proto3" json:"ReportDestoryed"`
-	GetDestorying        GetDestoryingReq        `protobuf:"bytes,12,opt,name=getDestorying,proto3" json:"getDestorying"`
+	CreateDestroying     CreateDestroyingReq     `protobuf:"bytes,10,opt,name=createDestroying,proto3" json:"createDestroying"`
+	ReportDestroyed      ReportDestroyedReq      `protobuf:"bytes,11,opt,name=ReportDestroyed,proto3" json:"ReportDestroyed"`
+	GetDestroying        GetDestroyingReq        `protobuf:"bytes,12,opt,name=getDestroying,proto3" json:"getDestroying"`
 	CreateWatcher        CreateWatcherReq        `protobuf:"bytes,13,opt,name=createWatcher,proto3" json:"createWatcher"`
 	CreateResources      CreateResourcesReq      `protobuf:"bytes,14,opt,name=createResources,proto3" json:"createResources"`
 	RemoveResources      RemoveResourcesReq      `protobuf:"bytes,15,opt,name=removeResources,proto3" json:"removeResources"`
@@ -367,25 +367,25 @@ func (m *Request) GetAskBatchSplit() AskBatchSplitReq {
 	return AskBatchSplitReq{}
 }
 
-func (m *Request) GetCreateDestorying() CreateDestoryingReq {
+func (m *Request) GetCreateDestroying() CreateDestroyingReq {
 	if m != nil {
-		return m.CreateDestorying
+		return m.CreateDestroying
 	}
-	return CreateDestoryingReq{}
+	return CreateDestroyingReq{}
 }
 
-func (m *Request) GetReportDestoryed() ReportDestoryedReq {
+func (m *Request) GetReportDestroyed() ReportDestroyedReq {
 	if m != nil {
-		return m.ReportDestoryed
+		return m.ReportDestroyed
 	}
-	return ReportDestoryedReq{}
+	return ReportDestroyedReq{}
 }
 
-func (m *Request) GetGetDestorying() GetDestoryingReq {
+func (m *Request) GetGetDestroying() GetDestroyingReq {
 	if m != nil {
-		return m.GetDestorying
+		return m.GetDestroying
 	}
-	return GetDestoryingReq{}
+	return GetDestroyingReq{}
 }
 
 func (m *Request) GetCreateWatcher() CreateWatcherReq {
@@ -477,9 +477,9 @@ type Response struct {
 	GetContainer         GetContainerRsp         `protobuf:"bytes,8,opt,name=getContainer,proto3" json:"getContainer"`
 	AllocID              AllocIDRsp              `protobuf:"bytes,9,opt,name=allocID,proto3" json:"allocID"`
 	AskBatchSplit        AskBatchSplitRsp        `protobuf:"bytes,10,opt,name=askBatchSplit,proto3" json:"askBatchSplit"`
-	CreateDestorying     CreateDestoryingRsp     `protobuf:"bytes,11,opt,name=createDestorying,proto3" json:"createDestorying"`
-	ReportDestoryed      ReportDestoryedRsp      `protobuf:"bytes,12,opt,name=ReportDestoryed,proto3" json:"ReportDestoryed"`
-	GetDestorying        GetDestoryingRsp        `protobuf:"bytes,13,opt,name=getDestorying,proto3" json:"getDestorying"`
+	CreateDestroying     CreateDestroyingRsp     `protobuf:"bytes,11,opt,name=createDestroying,proto3" json:"createDestroying"`
+	ReportDestroyed      ReportDestroyedRsp      `protobuf:"bytes,12,opt,name=ReportDestroyed,proto3" json:"ReportDestroyed"`
+	GetDestroying        GetDestroyingRsp        `protobuf:"bytes,13,opt,name=getDestroying,proto3" json:"getDestroying"`
 	Event                EventNotify             `protobuf:"bytes,14,opt,name=event,proto3" json:"event"`
 	CreateResources      CreateResourcesRsp      `protobuf:"bytes,15,opt,name=createResources,proto3" json:"createResources"`
 	RemoveResources      RemoveResourcesRsp      `protobuf:"bytes,16,opt,name=removeResources,proto3" json:"removeResources"`
@@ -599,25 +599,25 @@ func (m *Response) GetAskBatchSplit() AskBatchSplitRsp {
 	return AskBatchSplitRsp{}
 }
 
-func (m *Response) GetCreateDestorying() CreateDestoryingRsp {
+func (m *Response) GetCreateDestroying() CreateDestroyingRsp {
 	if m != nil {
-		return m.CreateDestorying
+		return m.CreateDestroying
 	}
-	return CreateDestoryingRsp{}
+	return CreateDestroyingRsp{}
 }
 
-func (m *Response) GetReportDestoryed() ReportDestoryedRsp {
+func (m *Response) GetReportDestroyed() ReportDestroyedRsp {
 	if m != nil {
-		return m.ReportDestoryed
+		return m.ReportDestroyed
 	}
-	return ReportDestoryedRsp{}
+	return ReportDestroyedRsp{}
 }
 
-func (m *Response) GetGetDestorying() GetDestoryingRsp {
+func (m *Response) GetGetDestroying() GetDestroyingRsp {
 	if m != nil {
-		return m.GetDestorying
+		return m.GetDestroying
 	}
-	return GetDestoryingRsp{}
+	return GetDestroyingRsp{}
 }
 
 func (m *Response) GetEvent() EventNotify {
@@ -827,8 +827,8 @@ type ResourceHeartbeatRsp struct {
 	Merge          *Merge          `protobuf:"bytes,6,opt,name=merge,proto3" json:"merge,omitempty"`
 	SplitResource  *SplitResource  `protobuf:"bytes,7,opt,name=splitResource,proto3" json:"splitResource,omitempty"`
 	ConfigChangeV2 *ConfigChangeV2 `protobuf:"bytes,8,opt,name=configChangeV2,proto3" json:"configChangeV2,omitempty"`
-	// DestoryDirectly the resource has been removed, destory directly without raft.
-	DestoryDirectly      bool     `protobuf:"varint,9,opt,name=destoryDirectly,proto3" json:"destoryDirectly,omitempty"`
+	// DestroyDirectly the resource has been removed, destroy directly without raft.
+	DestroyDirectly      bool     `protobuf:"varint,9,opt,name=destroyDirectly,proto3" json:"destroyDirectly,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
@@ -923,9 +923,9 @@ func (m *ResourceHeartbeatRsp) GetConfigChangeV2() *ConfigChangeV2 {
 	return nil
 }
 
-func (m *ResourceHeartbeatRsp) GetDestoryDirectly() bool {
+func (m *ResourceHeartbeatRsp) GetDestroyDirectly() bool {
 	if m != nil {
-		return m.DestoryDirectly
+		return m.DestroyDirectly
 	}
 	return false
 }
@@ -1426,8 +1426,8 @@ func (m *AskBatchSplitRsp) GetSplitIDs() []SplitID {
 	return nil
 }
 
-// CreateDestoryingReq create destorying status request
-type CreateDestoryingReq struct {
+// CreateDestroyingReq create destroying status request
+type CreateDestroyingReq struct {
 	ID                   uint64   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
 	Index                uint64   `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"`
 	Replicas             []uint64 `protobuf:"varint,3,rep,packed,name=replicas,proto3" json:"replicas,omitempty"`
@@ -1437,18 +1437,18 @@ type CreateDestoryingReq struct {
 	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *CreateDestoryingReq) Reset()         { *m = CreateDestoryingReq{} }
-func (m *CreateDestoryingReq) String() string { return proto.CompactTextString(m) }
-func (*CreateDestoryingReq) ProtoMessage()    {}
-func (*CreateDestoryingReq) Descriptor() ([]byte, []int) {
+func (m *CreateDestroyingReq) Reset()         { *m = CreateDestroyingReq{} }
+func (m *CreateDestroyingReq) String() string { return proto.CompactTextString(m) }
+func (*CreateDestroyingReq) ProtoMessage()    {}
+func (*CreateDestroyingReq) Descriptor() ([]byte, []int) {
 	return fileDescriptor_25e491924c678914, []int{14}
 }
-func (m *CreateDestoryingReq) XXX_Unmarshal(b []byte) error {
+func (m *CreateDestroyingReq) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *CreateDestoryingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *CreateDestroyingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_CreateDestoryingReq.Marshal(b, m, deterministic)
+		return xxx_messageInfo_CreateDestroyingReq.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1458,66 +1458,66 @@ func (m *CreateDestoryingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
-func (m *CreateDestoryingReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateDestoryingReq.Merge(m, src)
+func (m *CreateDestroyingReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateDestroyingReq.Merge(m, src)
 }
-func (m *CreateDestoryingReq) XXX_Size() int {
+func (m *CreateDestroyingReq) XXX_Size() int {
 	return m.Size()
 }
-func (m *CreateDestoryingReq) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateDestoryingReq.DiscardUnknown(m)
+func (m *CreateDestroyingReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateDestroyingReq.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_CreateDestoryingReq proto.InternalMessageInfo
+var xxx_messageInfo_CreateDestroyingReq proto.InternalMessageInfo
 
-func (m *CreateDestoryingReq) GetID() uint64 {
+func (m *CreateDestroyingReq) GetID() uint64 {
 	if m != nil {
 		return m.ID
 	}
 	return 0
 }
 
-func (m *CreateDestoryingReq) GetIndex() uint64 {
+func (m *CreateDestroyingReq) GetIndex() uint64 {
 	if m != nil {
 		return m.Index
 	}
 	return 0
 }
 
-func (m *CreateDestoryingReq) GetReplicas() []uint64 {
+func (m *CreateDestroyingReq) GetReplicas() []uint64 {
 	if m != nil {
 		return m.Replicas
 	}
 	return nil
 }
 
-func (m *CreateDestoryingReq) GetRemoveData() bool {
+func (m *CreateDestroyingReq) GetRemoveData() bool {
 	if m != nil {
 		return m.RemoveData
 	}
 	return false
 }
 
-// CreateDestoryingRsp create destorying status response
-type CreateDestoryingRsp struct {
+// CreateDestroyingRsp create destroying status response
+type CreateDestroyingRsp struct {
 	State                metapb.ResourceState `protobuf:"varint,1,opt,name=state,proto3,enum=metapb.ResourceState" json:"state,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
 	XXX_unrecognized     []byte               `json:"-"`
 	XXX_sizecache        int32                `json:"-"`
 }
 
-func (m *CreateDestoryingRsp) Reset()         { *m = CreateDestoryingRsp{} }
-func (m *CreateDestoryingRsp) String() string { return proto.CompactTextString(m) }
-func (*CreateDestoryingRsp) ProtoMessage()    {}
-func (*CreateDestoryingRsp) Descriptor() ([]byte, []int) {
+func (m *CreateDestroyingRsp) Reset()         { *m = CreateDestroyingRsp{} }
+func (m *CreateDestroyingRsp) String() string { return proto.CompactTextString(m) }
+func (*CreateDestroyingRsp) ProtoMessage()    {}
+func (*CreateDestroyingRsp) Descriptor() ([]byte, []int) {
 	return fileDescriptor_25e491924c678914, []int{15}
 }
-func (m *CreateDestoryingRsp) XXX_Unmarshal(b []byte) error {
+func (m *CreateDestroyingRsp) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *CreateDestoryingRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *CreateDestroyingRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_CreateDestoryingRsp.Marshal(b, m, deterministic)
+		return xxx_messageInfo_CreateDestroyingRsp.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1527,45 +1527,45 @@ func (m *CreateDestoryingRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
-func (m *CreateDestoryingRsp) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_CreateDestoryingRsp.Merge(m, src)
+func (m *CreateDestroyingRsp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_CreateDestroyingRsp.Merge(m, src)
 }
-func (m *CreateDestoryingRsp) XXX_Size() int {
+func (m *CreateDestroyingRsp) XXX_Size() int {
 	return m.Size()
 }
-func (m *CreateDestoryingRsp) XXX_DiscardUnknown() {
-	xxx_messageInfo_CreateDestoryingRsp.DiscardUnknown(m)
+func (m *CreateDestroyingRsp) XXX_DiscardUnknown() {
+	xxx_messageInfo_CreateDestroyingRsp.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_CreateDestoryingRsp proto.InternalMessageInfo
+var xxx_messageInfo_CreateDestroyingRsp proto.InternalMessageInfo
 
-func (m *CreateDestoryingRsp) GetState() metapb.ResourceState {
+func (m *CreateDestroyingRsp) GetState() metapb.ResourceState {
 	if m != nil {
 		return m.State
 	}
 	return metapb.ResourceState_Running
 }
 
-// GetDestoryingReq get destorying status request
-type GetDestoryingReq struct {
+// GetDestroyingReq get destroying status request
+type GetDestroyingReq struct {
 	ID                   uint64   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
 	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *GetDestoryingReq) Reset()         { *m = GetDestoryingReq{} }
-func (m *GetDestoryingReq) String() string { return proto.CompactTextString(m) }
-func (*GetDestoryingReq) ProtoMessage()    {}
-func (*GetDestoryingReq) Descriptor() ([]byte, []int) {
+func (m *GetDestroyingReq) Reset()         { *m = GetDestroyingReq{} }
+func (m *GetDestroyingReq) String() string { return proto.CompactTextString(m) }
+func (*GetDestroyingReq) ProtoMessage()    {}
+func (*GetDestroyingReq) Descriptor() ([]byte, []int) {
 	return fileDescriptor_25e491924c678914, []int{16}
 }
-func (m *GetDestoryingReq) XXX_Unmarshal(b []byte) error {
+func (m *GetDestroyingReq) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *GetDestoryingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *GetDestroyingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_GetDestoryingReq.Marshal(b, m, deterministic)
+		return xxx_messageInfo_GetDestroyingReq.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1575,45 +1575,45 @@ func (m *GetDestoryingReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
-func (m *GetDestoryingReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetDestoryingReq.Merge(m, src)
+func (m *GetDestroyingReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetDestroyingReq.Merge(m, src)
 }
-func (m *GetDestoryingReq) XXX_Size() int {
+func (m *GetDestroyingReq) XXX_Size() int {
 	return m.Size()
 }
-func (m *GetDestoryingReq) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetDestoryingReq.DiscardUnknown(m)
+func (m *GetDestroyingReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetDestroyingReq.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_GetDestoryingReq proto.InternalMessageInfo
+var xxx_messageInfo_GetDestroyingReq proto.InternalMessageInfo
 
-func (m *GetDestoryingReq) GetID() uint64 {
+func (m *GetDestroyingReq) GetID() uint64 {
 	if m != nil {
 		return m.ID
 	}
 	return 0
 }
 
-// GetDestoryingRsp get destorying status response
-type GetDestoryingRsp struct {
+// GetDestroyingRsp get destroying status response
+type GetDestroyingRsp struct {
 	Status               *metapb.DestroyingStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
 	XXX_unrecognized     []byte                   `json:"-"`
 	XXX_sizecache        int32                    `json:"-"`
 }
 
-func (m *GetDestoryingRsp) Reset()         { *m = GetDestoryingRsp{} }
-func (m *GetDestoryingRsp) String() string { return proto.CompactTextString(m) }
-func (*GetDestoryingRsp) ProtoMessage()    {}
-func (*GetDestoryingRsp) Descriptor() ([]byte, []int) {
+func (m *GetDestroyingRsp) Reset()         { *m = GetDestroyingRsp{} }
+func (m *GetDestroyingRsp) String() string { return proto.CompactTextString(m) }
+func (*GetDestroyingRsp) ProtoMessage()    {}
+func (*GetDestroyingRsp) Descriptor() ([]byte, []int) {
 	return fileDescriptor_25e491924c678914, []int{17}
 }
-func (m *GetDestoryingRsp) XXX_Unmarshal(b []byte) error {
+func (m *GetDestroyingRsp) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *GetDestoryingRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *GetDestroyingRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_GetDestoryingRsp.Marshal(b, m, deterministic)
+		return xxx_messageInfo_GetDestroyingRsp.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1623,27 +1623,27 @@ func (m *GetDestoryingRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, er
 		return b[:n], nil
 	}
 }
-func (m *GetDestoryingRsp) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_GetDestoryingRsp.Merge(m, src)
+func (m *GetDestroyingRsp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_GetDestroyingRsp.Merge(m, src)
 }
-func (m *GetDestoryingRsp) XXX_Size() int {
+func (m *GetDestroyingRsp) XXX_Size() int {
 	return m.Size()
 }
-func (m *GetDestoryingRsp) XXX_DiscardUnknown() {
-	xxx_messageInfo_GetDestoryingRsp.DiscardUnknown(m)
+func (m *GetDestroyingRsp) XXX_DiscardUnknown() {
+	xxx_messageInfo_GetDestroyingRsp.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_GetDestoryingRsp proto.InternalMessageInfo
+var xxx_messageInfo_GetDestroyingRsp proto.InternalMessageInfo
 
-func (m *GetDestoryingRsp) GetStatus() *metapb.DestroyingStatus {
+func (m *GetDestroyingRsp) GetStatus() *metapb.DestroyingStatus {
 	if m != nil {
 		return m.Status
 	}
 	return nil
 }
 
-// ReportDestoryedReq report destroying request
-type ReportDestoryedReq struct {
+// ReportDestroyedReq report destroying request
+type ReportDestroyedReq struct {
 	ID                   uint64   `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
 	ReplicaID            uint64   `protobuf:"varint,2,opt,name=replicaID,proto3" json:"replicaID,omitempty"`
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
@@ -1651,18 +1651,18 @@ type ReportDestoryedReq struct {
 	XXX_sizecache        int32    `json:"-"`
 }
 
-func (m *ReportDestoryedReq) Reset()         { *m = ReportDestoryedReq{} }
-func (m *ReportDestoryedReq) String() string { return proto.CompactTextString(m) }
-func (*ReportDestoryedReq) ProtoMessage()    {}
-func (*ReportDestoryedReq) Descriptor() ([]byte, []int) {
+func (m *ReportDestroyedReq) Reset()         { *m = ReportDestroyedReq{} }
+func (m *ReportDestroyedReq) String() string { return proto.CompactTextString(m) }
+func (*ReportDestroyedReq) ProtoMessage()    {}
+func (*ReportDestroyedReq) Descriptor() ([]byte, []int) {
 	return fileDescriptor_25e491924c678914, []int{18}
 }
-func (m *ReportDestoryedReq) XXX_Unmarshal(b []byte) error {
+func (m *ReportDestroyedReq) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ReportDestoryedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ReportDestroyedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ReportDestoryedReq.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ReportDestroyedReq.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1672,52 +1672,52 @@ func (m *ReportDestoryedReq) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
-func (m *ReportDestoryedReq) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReportDestoryedReq.Merge(m, src)
+func (m *ReportDestroyedReq) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReportDestroyedReq.Merge(m, src)
 }
-func (m *ReportDestoryedReq) XXX_Size() int {
+func (m *ReportDestroyedReq) XXX_Size() int {
 	return m.Size()
 }
-func (m *ReportDestoryedReq) XXX_DiscardUnknown() {
-	xxx_messageInfo_ReportDestoryedReq.DiscardUnknown(m)
+func (m *ReportDestroyedReq) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReportDestroyedReq.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_ReportDestoryedReq proto.InternalMessageInfo
+var xxx_messageInfo_ReportDestroyedReq proto.InternalMessageInfo
 
-func (m *ReportDestoryedReq) GetID() uint64 {
+func (m *ReportDestroyedReq) GetID() uint64 {
 	if m != nil {
 		return m.ID
 	}
 	return 0
 }
 
-func (m *ReportDestoryedReq) GetReplicaID() uint64 {
+func (m *ReportDestroyedReq) GetReplicaID() uint64 {
 	if m != nil {
 		return m.ReplicaID
 	}
 	return 0
 }
 
-// ReportDestoryedRsp report destroying rsp
-type ReportDestoryedRsp struct {
+// ReportDestroyedRsp report destroying rsp
+type ReportDestroyedRsp struct {
 	State                metapb.ResourceState `protobuf:"varint,1,opt,name=state,proto3,enum=metapb.ResourceState" json:"state,omitempty"`
 	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
 	XXX_unrecognized     []byte               `json:"-"`
 	XXX_sizecache        int32                `json:"-"`
 }
 
-func (m *ReportDestoryedRsp) Reset()         { *m = ReportDestoryedRsp{} }
-func (m *ReportDestoryedRsp) String() string { return proto.CompactTextString(m) }
-func (*ReportDestoryedRsp) ProtoMessage()    {}
-func (*ReportDestoryedRsp) Descriptor() ([]byte, []int) {
+func (m *ReportDestroyedRsp) Reset()         { *m = ReportDestroyedRsp{} }
+func (m *ReportDestroyedRsp) String() string { return proto.CompactTextString(m) }
+func (*ReportDestroyedRsp) ProtoMessage()    {}
+func (*ReportDestroyedRsp) Descriptor() ([]byte, []int) {
 	return fileDescriptor_25e491924c678914, []int{19}
 }
-func (m *ReportDestoryedRsp) XXX_Unmarshal(b []byte) error {
+func (m *ReportDestroyedRsp) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
 }
-func (m *ReportDestoryedRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+func (m *ReportDestroyedRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 	if deterministic {
-		return xxx_messageInfo_ReportDestoryedRsp.Marshal(b, m, deterministic)
+		return xxx_messageInfo_ReportDestroyedRsp.Marshal(b, m, deterministic)
 	} else {
 		b = b[:cap(b)]
 		n, err := m.MarshalToSizedBuffer(b)
@@ -1727,19 +1727,19 @@ func (m *ReportDestoryedRsp) XXX_Marshal(b []byte, deterministic bool) ([]byte,
 		return b[:n], nil
 	}
 }
-func (m *ReportDestoryedRsp) XXX_Merge(src proto.Message) {
-	xxx_messageInfo_ReportDestoryedRsp.Merge(m, src)
+func (m *ReportDestroyedRsp) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ReportDestroyedRsp.Merge(m, src)
 }
-func (m *ReportDestoryedRsp) XXX_Size() int {
+func (m *ReportDestroyedRsp) XXX_Size() int {
 	return m.Size()
 }
-func (m *ReportDestoryedRsp) XXX_DiscardUnknown() {
-	xxx_messageInfo_ReportDestoryedRsp.DiscardUnknown(m)
+func (m *ReportDestroyedRsp) XXX_DiscardUnknown() {
+	xxx_messageInfo_ReportDestroyedRsp.DiscardUnknown(m)
 }
 
-var xxx_messageInfo_ReportDestoryedRsp proto.InternalMessageInfo
+var xxx_messageInfo_ReportDestroyedRsp proto.InternalMessageInfo
 
-func (m *ReportDestoryedRsp) GetState() metapb.ResourceState {
+func (m *ReportDestroyedRsp) GetState() metapb.ResourceState {
 	if m != nil {
 		return m.State
 	}
@@ -3531,12 +3531,12 @@ func init() {
 	proto.RegisterType((*AllocIDRsp)(nil), "rpcpb.AllocIDRsp")
 	proto.RegisterType((*AskBatchSplitReq)(nil), "rpcpb.AskBatchSplitReq")
 	proto.RegisterType((*AskBatchSplitRsp)(nil), "rpcpb.AskBatchSplitRsp")
-	proto.RegisterType((*CreateDestoryingReq)(nil), "rpcpb.CreateDestoryingReq")
-	proto.RegisterType((*CreateDestoryingRsp)(nil), "rpcpb.CreateDestoryingRsp")
-	proto.RegisterType((*GetDestoryingReq)(nil), "rpcpb.GetDestoryingReq")
-	proto.RegisterType((*GetDestoryingRsp)(nil), "rpcpb.GetDestoryingRsp")
-	proto.RegisterType((*ReportDestoryedReq)(nil), "rpcpb.ReportDestoryedReq")
-	proto.RegisterType((*ReportDestoryedRsp)(nil), "rpcpb.ReportDestoryedRsp")
+	proto.RegisterType((*CreateDestroyingReq)(nil), "rpcpb.CreateDestroyingReq")
+	proto.RegisterType((*CreateDestroyingRsp)(nil), "rpcpb.CreateDestroyingRsp")
+	proto.RegisterType((*GetDestroyingReq)(nil), "rpcpb.GetDestroyingReq")
+	proto.RegisterType((*GetDestroyingRsp)(nil), "rpcpb.GetDestroyingRsp")
+	proto.RegisterType((*ReportDestroyedReq)(nil), "rpcpb.ReportDestroyedReq")
+	proto.RegisterType((*ReportDestroyedRsp)(nil), "rpcpb.ReportDestroyedRsp")
 	proto.RegisterType((*SplitID)(nil), "rpcpb.SplitID")
 	proto.RegisterType((*CreateWatcherReq)(nil), "rpcpb.CreateWatcherReq")
 	proto.RegisterType((*CreateResourcesReq)(nil), "rpcpb.CreateResourcesReq")
@@ -3575,170 +3575,170 @@ func init() {
 func init() { proto.RegisterFile("rpcpb.proto", fileDescriptor_25e491924c678914) }
 
 var fileDescriptor_25e491924c678914 = []byte{
-	// 2604 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x5a, 0xcd, 0x53, 0x1c, 0xc7,
-	0x15, 0xd7, 0x7e, 0xb3, 0x8f, 0xdd, 0xa5, 0x69, 0x16, 0x18, 0x90, 0x0c, 0x64, 0xec, 0xc8, 0x04,
-	0x25, 0x10, 0xa3, 0xb8, 0x9c, 0x72, 0xc5, 0x4e, 0x80, 0xc5, 0x12, 0x8a, 0x22, 0x53, 0x83, 0xa3,
-	0xf8, 0x96, 0x9a, 0xdd, 0x6d, 0x2d, 0x13, 0x2d, 0x33, 0xad, 0xe9, 0x59, 0x49, 0x9c, 0x72, 0x48,
-	0xe5, 0x98, 0xff, 0xcb, 0x47, 0x9f, 0x73, 0x50, 0xc5, 0xfa, 0x0f, 0x72, 0xce, 0x25, 0xd5, 0x5f,
-	0x33, 0xd3, 0xf3, 0xb1, 0xa0, 0x93, 0xb6, 0xdf, 0xc7, 0x6f, 0xba, 0x5f, 0xbf, 0xee, 0xdf, 0x7b,
-	0x2d, 0x60, 0x31, 0xa4, 0x23, 0x3a, 0xdc, 0xa7, 0x61, 0x10, 0x05, 0xb8, 0x21, 0x06, 0x9b, 0x4f,
-	0x27, 0x5e, 0x74, 0x39, 0x1b, 0xee, 0x8f, 0x82, 0xab, 0x83, 0x2b, 0x37, 0x0a, 0xbd, 0xb7, 0x41,
-	0xe8, 0x4d, 0x3c, 0x5f, 0x0d, 0x46, 0xb3, 0x21, 0x39, 0x18, 0x05, 0x57, 0x34, 0xf0, 0x89, 0x1f,
-	0xb1, 0x03, 0x1a, 0x06, 0xf4, 0x92, 0x44, 0x07, 0x74, 0x78, 0x70, 0x45, 0x22, 0x37, 0xfe, 0x47,
-	0x82, 0x6e, 0xfe, 0x2a, 0x85, 0x36, 0x09, 0x26, 0xc1, 0x81, 0x10, 0x0f, 0x67, 0x2f, 0xc4, 0x48,
-	0x0c, 0xc4, 0x2f, 0x69, 0x6e, 0xff, 0xab, 0x03, 0x2d, 0x87, 0xbc, 0x9a, 0x11, 0x16, 0xe1, 0x35,
-	0xa8, 0x7a, 0x63, 0xab, 0xb2, 0x53, 0xd9, 0xad, 0x1f, 0x37, 0xdf, 0xbf, 0xdb, 0xae, 0x9e, 0x0d,
-	0x9c, 0xaa, 0x37, 0xc6, 0x3b, 0xb0, 0x38, 0x0a, 0xfc, 0xc8, 0xf5, 0x7c, 0x12, 0x9e, 0x0d, 0xac,
-	0x2a, 0x37, 0x70, 0xd2, 0x22, 0xbc, 0x0d, 0xf5, 0xe8, 0x9a, 0x12, 0xab, 0xb6, 0x53, 0xd9, 0xed,
-	0x1d, 0x2e, 0xee, 0xcb, 0x55, 0x7e, 0x77, 0x4d, 0x89, 0x23, 0x14, 0xf8, 0x5b, 0x58, 0x0e, 0x09,
-	0x0b, 0x66, 0xe1, 0x88, 0x3c, 0x26, 0x6e, 0x18, 0x0d, 0x89, 0x1b, 0x59, 0xf5, 0x9d, 0xca, 0xee,
-	0xe2, 0xe1, 0x5d, 0x65, 0xed, 0x64, 0xf5, 0x0e, 0x79, 0x75, 0x5c, 0xff, 0xe1, 0xdd, 0xf6, 0x1d,
-	0x27, 0xef, 0x8b, 0x1d, 0xc0, 0xf1, 0x04, 0x12, 0xc4, 0x86, 0x40, 0xbc, 0xa7, 0x10, 0x4f, 0x72,
-	0x06, 0x09, 0x64, 0x81, 0x37, 0xfe, 0x03, 0x74, 0xe8, 0x2c, 0x8a, 0xbd, 0xac, 0xa6, 0x40, 0x5b,
-	0x53, 0x68, 0xe7, 0x29, 0x55, 0x82, 0x63, 0x78, 0x70, 0x84, 0x09, 0x49, 0x21, 0xb4, 0x0c, 0x84,
-	0x47, 0xa4, 0x10, 0x21, 0xed, 0x81, 0x3f, 0x83, 0x96, 0x3b, 0x9d, 0x06, 0xa3, 0xb3, 0x81, 0xb5,
-	0x20, 0x9c, 0x97, 0x95, 0xf3, 0x91, 0x94, 0x26, 0x7e, 0xda, 0x0e, 0x9f, 0x40, 0xd7, 0x65, 0x2f,
-	0x8f, 0xdd, 0x68, 0x74, 0x79, 0x41, 0xa7, 0x5e, 0x64, 0xb5, 0x85, 0xe3, 0xba, 0x76, 0x4c, 0xeb,
-	0x12, 0x77, 0xd3, 0x07, 0x3f, 0x05, 0x34, 0x0a, 0x89, 0x1b, 0x91, 0x01, 0x61, 0x51, 0x10, 0x5e,
-	0x7b, 0xfe, 0xc4, 0x02, 0x81, 0xb3, 0xa9, 0xa3, 0x99, 0x51, 0x27, 0x50, 0x39, 0x4f, 0x7c, 0x06,
-	0x4b, 0x0e, 0xa1, 0x41, 0x18, 0x29, 0x19, 0x19, 0x5b, 0x8b, 0x02, 0x6c, 0x23, 0xde, 0x6c, 0x43,
-	0x9b, 0x60, 0x65, 0xfd, 0xf8, 0xea, 0x26, 0x24, 0x4a, 0xcd, 0xaa, 0x63, 0xac, 0xee, 0x51, 0x5a,
-	0x97, 0x5a, 0x9d, 0xe1, 0xc3, 0x41, 0xe4, 0x1c, 0xff, 0xc2, 0x57, 0x4c, 0x42, 0xab, 0x6b, 0x80,
-	0x9c, 0xa4, 0x75, 0x29, 0x10, 0xc3, 0x87, 0x2f, 0x4a, 0x0a, 0x74, 0xa6, 0x32, 0xab, 0x67, 0x2c,
-	0xea, 0xc4, 0xd4, 0xa6, 0x16, 0x95, 0xf1, 0xe3, 0x50, 0x21, 0xb9, 0x0a, 0x5e, 0xa7, 0xa0, 0x96,
-	0x32, 0xf1, 0x31, 0xb4, 0x29, 0xa8, 0x8c, 0x9f, 0x38, 0x08, 0x97, 0x64, 0xf4, 0x52, 0x4b, 0x2e,
-	0x22, 0x37, 0x22, 0x16, 0x32, 0x0f, 0x42, 0xce, 0x20, 0x7d, 0x10, 0x72, 0x4a, 0x9e, 0x0c, 0x74,
-	0x16, 0x9d, 0x4f, 0xdd, 0x11, 0xb9, 0x22, 0x7e, 0xe4, 0xcc, 0xa6, 0xc4, 0x5a, 0x36, 0x92, 0xe1,
-	0x3c, 0xa3, 0x4e, 0x25, 0x43, 0xd6, 0x93, 0x2f, 0x76, 0x42, 0xa2, 0x23, 0x4a, 0xa7, 0x1e, 0x19,
-	0x73, 0x09, 0xb3, 0xb0, 0xb1, 0xd8, 0x47, 0xa6, 0x36, 0xb5, 0xd8, 0x8c, 0x1f, 0xfe, 0x02, 0xda,
-	0x32, 0x94, 0x4f, 0x82, 0xa1, 0xb5, 0x22, 0x40, 0x56, 0x8c, 0xe0, 0x3f, 0x09, 0x86, 0x89, 0x7b,
-	0x62, 0xcb, 0x1d, 0x65, 0xe0, 0xb8, 0x63, 0xdf, 0x70, 0x74, 0xb4, 0x3c, 0xe5, 0x18, 0xdb, 0xe2,
-	0x2f, 0x01, 0xc8, 0x5b, 0x32, 0x9a, 0xc9, 0x4f, 0xae, 0x0a, 0xcf, 0xbe, 0xf2, 0x3c, 0x8d, 0x15,
-	0x89, 0x6b, 0xca, 0x1a, 0x7f, 0x0f, 0x7d, 0x77, 0x3c, 0xbe, 0x18, 0x5d, 0x92, 0xf1, 0x6c, 0x4a,
-	0x1e, 0x85, 0xc1, 0x8c, 0x8a, 0x50, 0xae, 0x09, 0x94, 0x2d, 0x7d, 0x3e, 0x0b, 0x4c, 0x12, 0xbc,
-	0x42, 0x04, 0x8e, 0x3c, 0x21, 0x51, 0x1e, 0x79, 0xdd, 0x40, 0x7e, 0x54, 0x60, 0x92, 0x42, 0x2e,
-	0x42, 0xb0, 0xff, 0xd9, 0x81, 0x05, 0x87, 0x30, 0x1a, 0xf8, 0x8c, 0x94, 0x12, 0x82, 0xbe, 0xee,
-	0xab, 0x65, 0xd7, 0x7d, 0x1f, 0x1a, 0x24, 0x0c, 0x83, 0x50, 0x10, 0x42, 0xdb, 0x91, 0x03, 0xbc,
-	0x06, 0xcd, 0x29, 0x71, 0xc7, 0x24, 0x14, 0x37, 0x7f, 0xdb, 0x51, 0xa3, 0x62, 0x72, 0x68, 0xdc,
-	0x40, 0x0e, 0x8c, 0x7e, 0x28, 0x39, 0x34, 0x6f, 0x22, 0x87, 0x18, 0xf2, 0x36, 0xe4, 0xd0, 0x2a,
-	0x27, 0x87, 0x18, 0x67, 0x3e, 0x39, 0x2c, 0x94, 0x93, 0x43, 0x82, 0x50, 0x46, 0x0e, 0xed, 0x42,
-	0x72, 0x88, 0xfd, 0xca, 0xc9, 0x01, 0xe6, 0x90, 0x43, 0xec, 0x7e, 0x0b, 0x72, 0x58, 0x9c, 0x4f,
-	0x0e, 0x31, 0xd4, 0xad, 0xc8, 0xa1, 0x33, 0x97, 0x1c, 0x62, 0xac, 0x9b, 0xc9, 0xa1, 0x3b, 0x87,
-	0x1c, 0x92, 0xd5, 0x99, 0xe4, 0xb0, 0x0f, 0x0d, 0xf2, 0x9a, 0xf8, 0x91, 0xba, 0xcd, 0xb1, 0x3e,
-	0xdd, 0x5c, 0xf6, 0x2c, 0x88, 0xbc, 0x17, 0xd7, 0xca, 0x4f, 0x9a, 0x15, 0xf1, 0xc0, 0xd2, 0x5c,
-	0x1e, 0x48, 0xe6, 0x7f, 0x0b, 0x1e, 0x40, 0x73, 0x79, 0x20, 0x81, 0xba, 0x1d, 0x0f, 0x2c, 0xdf,
-	0xc4, 0x03, 0xa9, 0x9c, 0xbf, 0x1d, 0x0f, 0xe0, 0xf9, 0x3c, 0x90, 0xec, 0xfb, 0x6d, 0x78, 0x60,
-	0x65, 0x2e, 0x0f, 0x24, 0x8b, 0x9d, 0xcb, 0x03, 0xfd, 0x12, 0x1e, 0x88, 0xdd, 0xcb, 0x78, 0x60,
-	0xb5, 0x84, 0x07, 0x12, 0xc7, 0x32, 0x1e, 0x58, 0x2b, 0xe3, 0x81, 0xd8, 0xf5, 0x36, 0x3c, 0xb0,
-	0x7e, 0x33, 0x0f, 0xc4, 0x78, 0x1f, 0xc6, 0x03, 0xd6, 0xcd, 0x3c, 0x90, 0x20, 0x17, 0xf2, 0xc0,
-	0x4f, 0x55, 0xe8, 0x17, 0x55, 0xe4, 0xd9, 0x66, 0xa0, 0x92, 0x6f, 0x06, 0x36, 0x61, 0x41, 0x5f,
-	0xc9, 0x82, 0x21, 0x3a, 0x4e, 0x3c, 0xc6, 0x18, 0xea, 0x11, 0x09, 0xaf, 0x04, 0x2f, 0xd4, 0x1d,
-	0xf1, 0x1b, 0x7f, 0x6a, 0xd0, 0xc2, 0xe2, 0xe1, 0xd2, 0xbe, 0x6a, 0x68, 0x1c, 0x42, 0xa7, 0xde,
-	0xc8, 0x8d, 0x79, 0xe2, 0x6b, 0xe8, 0x8c, 0x83, 0x37, 0xbe, 0x12, 0x33, 0xab, 0xb1, 0x53, 0x13,
-	0xbb, 0x60, 0x9a, 0xf3, 0xd4, 0x65, 0xfa, 0xfa, 0x4c, 0xdb, 0xe3, 0xdf, 0xc3, 0x12, 0x25, 0xfe,
-	0x58, 0x14, 0x8a, 0x0a, 0xa2, 0x29, 0x20, 0xb2, 0x5f, 0xd4, 0x69, 0x97, 0xb1, 0xc6, 0x9f, 0x41,
-	0x83, 0x71, 0x74, 0x75, 0xf9, 0xaf, 0x26, 0x6e, 0xc9, 0xa9, 0xd1, 0x9f, 0x96, 0x96, 0x3c, 0x18,
-	0x13, 0x1e, 0xd4, 0x3f, 0x92, 0x6b, 0x71, 0xe1, 0xb7, 0x9d, 0x78, 0x6c, 0xff, 0xb7, 0x56, 0x14,
-	0x63, 0x46, 0xf1, 0x16, 0x80, 0x8e, 0x58, 0x1c, 0xe2, 0x94, 0x04, 0x1f, 0x41, 0x57, 0x8f, 0x4e,
-	0x69, 0x30, 0xba, 0x14, 0x61, 0x2e, 0x98, 0x8f, 0x50, 0xea, 0x4b, 0xcf, 0xf0, 0xc0, 0x9f, 0x43,
-	0x37, 0x72, 0xc3, 0x09, 0x89, 0xd4, 0xe2, 0xc4, 0x8e, 0x14, 0xc4, 0xde, 0xb4, 0xc2, 0x5f, 0x40,
-	0x67, 0x14, 0xf8, 0x2f, 0xbc, 0xc9, 0xc9, 0xa5, 0xeb, 0x4f, 0x88, 0xda, 0xb1, 0x95, 0x84, 0x53,
-	0x63, 0x95, 0x63, 0x18, 0xe2, 0xaf, 0xa0, 0x17, 0x85, 0xae, 0xcf, 0x5e, 0x90, 0xf0, 0xa9, 0xdc,
-	0xec, 0x86, 0x9a, 0xb3, 0x2a, 0x1e, 0x0c, 0xa5, 0x93, 0x31, 0xc6, 0x36, 0x34, 0xae, 0x48, 0x38,
-	0x21, 0x8a, 0xc4, 0x3b, 0xca, 0xeb, 0x4f, 0x5c, 0xe6, 0x48, 0x15, 0xfe, 0x12, 0xba, 0x4c, 0xf6,
-	0x38, 0x2a, 0xf9, 0x5a, 0xc6, 0x29, 0xbd, 0x48, 0xeb, 0x1c, 0xd3, 0x94, 0x4f, 0x2f, 0x3d, 0xdd,
-	0xe7, 0x87, 0x8a, 0x9d, 0x57, 0x0b, 0x56, 0xf6, 0xfc, 0xd0, 0xc9, 0x18, 0xe3, 0x5d, 0x58, 0x1a,
-	0x4b, 0x42, 0x19, 0x78, 0x21, 0x19, 0x45, 0xd3, 0x6b, 0x41, 0xd0, 0x0b, 0x4e, 0x56, 0x6c, 0x1f,
-	0xc0, 0x52, 0xa6, 0x91, 0xc4, 0xf7, 0xa0, 0x1d, 0x1f, 0x1f, 0xb1, 0xd9, 0x1d, 0x27, 0x11, 0xd8,
-	0x5f, 0x65, 0x1c, 0x18, 0xc5, 0x7b, 0x80, 0x38, 0x6c, 0x18, 0x5c, 0x27, 0xb4, 0x21, 0xfd, 0x72,
-	0x72, 0xfb, 0xaf, 0xb0, 0x5a, 0xd8, 0x06, 0xe3, 0x43, 0x9d, 0xcb, 0x15, 0x55, 0x86, 0xa8, 0x8d,
-	0x8f, 0xad, 0x0b, 0x92, 0x19, 0x43, 0x7d, 0xec, 0x46, 0xae, 0x3a, 0xd5, 0xe2, 0xb7, 0xfd, 0xa0,
-	0xf0, 0x03, 0x8c, 0xc6, 0xc6, 0x95, 0x94, 0xf1, 0x2f, 0x60, 0x29, 0xd3, 0x04, 0x97, 0xd5, 0x98,
-	0xf6, 0x45, 0xc6, 0xb4, 0x18, 0x11, 0xff, 0x52, 0x2f, 0xa3, 0x3a, 0x6f, 0x19, 0x6a, 0x01, 0x76,
-	0x07, 0x20, 0xe9, 0xa3, 0xed, 0x4f, 0x92, 0x11, 0xa3, 0xa5, 0x13, 0xf9, 0x1d, 0xa0, 0x6c, 0x0b,
-	0x5d, 0x38, 0x93, 0x3e, 0x34, 0x46, 0xc1, 0xcc, 0x8f, 0xc4, 0x4c, 0xba, 0x8e, 0x1c, 0xd8, 0x83,
-	0xac, 0x37, 0xa3, 0xf8, 0xd7, 0xb0, 0x20, 0xb2, 0xef, 0x6c, 0xc0, 0xa3, 0xcf, 0x2f, 0xa0, 0x5e,
-	0x3a, 0x47, 0xcf, 0x06, 0x2a, 0xea, 0xb1, 0x95, 0xfd, 0x77, 0x58, 0x29, 0x68, 0xbf, 0x4b, 0xeb,
-	0xf3, 0x3e, 0x34, 0x3c, 0x7f, 0x4c, 0xde, 0xaa, 0xa7, 0x1a, 0x39, 0x90, 0xf7, 0xb2, 0xba, 0xf7,
-	0x6a, 0x3b, 0xb5, 0xdd, 0xba, 0x13, 0x8f, 0xe5, 0x8d, 0xc3, 0xb9, 0x6e, 0xc0, 0x97, 0x55, 0x17,
-	0xb9, 0x9b, 0x92, 0xd8, 0xc7, 0x05, 0x13, 0x60, 0x14, 0x3f, 0x90, 0xd1, 0x27, 0x62, 0x0e, 0xbd,
-	0xe2, 0x0b, 0x91, 0xc8, 0xe0, 0x13, 0x7b, 0x0f, 0x50, 0xb6, 0x5b, 0x2f, 0x0d, 0xfa, 0x20, 0x6b,
-	0x2b, 0xc2, 0xd6, 0xe4, 0x40, 0x33, 0x9d, 0xb2, 0x96, 0xfe, 0xda, 0x40, 0x26, 0xbd, 0xe7, 0x4f,
-	0x2e, 0x84, 0xde, 0x51, 0x76, 0xf6, 0x13, 0xc0, 0xf9, 0x87, 0x86, 0xd2, 0xa8, 0xdd, 0xe3, 0xb5,
-	0x81, 0x88, 0x47, 0xfc, 0xc8, 0x95, 0x08, 0xec, 0xa3, 0x3c, 0xd6, 0x87, 0x06, 0xe0, 0x14, 0x5a,
-	0x6a, 0x83, 0xf9, 0x0e, 0xf9, 0xe4, 0x4d, 0x7c, 0xb9, 0xcb, 0x01, 0xfe, 0x04, 0xba, 0x3e, 0x79,
-	0xe3, 0xe8, 0x6f, 0xf2, 0xa4, 0xe6, 0xdb, 0x64, 0x0a, 0xed, 0xfb, 0x80, 0xb2, 0x0f, 0x16, 0x3c,
-	0x21, 0x5f, 0x4c, 0xdd, 0x89, 0x80, 0xeb, 0x3a, 0xe2, 0xb7, 0xfd, 0x3d, 0xe0, 0xfc, 0x8b, 0x84,
-	0x5c, 0x65, 0x72, 0x6b, 0xd4, 0xf8, 0x6d, 0x13, 0x0b, 0xf8, 0x0c, 0xa6, 0xc4, 0x65, 0x51, 0x4c,
-	0x90, 0x6a, 0x06, 0x86, 0xd0, 0xee, 0xe7, 0x91, 0x19, 0xb5, 0x0f, 0x78, 0x84, 0xb2, 0xcf, 0x16,
-	0x78, 0x03, 0x6a, 0xde, 0x58, 0x7e, 0xa9, 0x7e, 0xdc, 0x7a, 0xff, 0x6e, 0xbb, 0x76, 0x36, 0x60,
-	0x0e, 0x97, 0x71, 0x98, 0x7c, 0x7d, 0x6b, 0x1f, 0xc2, 0x6a, 0xe1, 0x7b, 0x45, 0x82, 0x54, 0xd9,
-	0xed, 0x64, 0x90, 0xfe, 0x5c, 0xe8, 0xc3, 0x28, 0x5f, 0xad, 0xba, 0x12, 0xc9, 0x58, 0xdf, 0xad,
-	0xb1, 0x80, 0x67, 0xfd, 0x38, 0xce, 0x1d, 0x75, 0xab, 0xa5, 0x24, 0xf6, 0x29, 0xac, 0x14, 0x3c,
-	0x74, 0xe0, 0x7d, 0xa8, 0x87, 0xbc, 0xca, 0xaa, 0x18, 0xfc, 0x62, 0x98, 0xa9, 0x13, 0x2c, 0xec,
-	0xec, 0xd5, 0x02, 0x18, 0x46, 0xed, 0xdf, 0x00, 0xce, 0xbf, 0x7c, 0xdc, 0xc4, 0xfd, 0xf6, 0x37,
-	0x79, 0x2f, 0x71, 0x36, 0x1a, 0xa1, 0xa8, 0xa8, 0x2b, 0xaa, 0x26, 0x2a, 0x9f, 0x93, 0x34, 0xb4,
-	0x1f, 0x42, 0x27, 0xfd, 0x64, 0x82, 0x3f, 0x86, 0xda, 0xdf, 0x82, 0xa1, 0x5a, 0xd3, 0xa2, 0xce,
-	0xe3, 0x27, 0xc1, 0x50, 0xb9, 0x71, 0xad, 0xdd, 0x4b, 0x3b, 0x31, 0xca, 0x41, 0xd2, 0xcf, 0x27,
-	0xb7, 0x06, 0x49, 0xd7, 0xda, 0xf6, 0x63, 0xe8, 0x1a, 0x2f, 0x29, 0xb7, 0x42, 0x29, 0xe4, 0xa2,
-	0x8f, 0x0d, 0xa4, 0x12, 0x0e, 0x7a, 0x06, 0xeb, 0x25, 0x4f, 0x2e, 0xf8, 0xa1, 0xb1, 0xb1, 0x1b,
-	0xfa, 0xcb, 0x39, 0x5b, 0x63, 0x77, 0x37, 0x4a, 0xf0, 0x18, 0xe5, 0xaa, 0x92, 0x37, 0x18, 0xfb,
-	0xbc, 0x44, 0xc5, 0x28, 0xfe, 0xdc, 0xdc, 0xcb, 0x1b, 0xa7, 0xa1, 0x36, 0xf4, 0x7f, 0x55, 0x58,
-	0x4c, 0xf5, 0xac, 0x18, 0x41, 0x8d, 0x91, 0x57, 0x2a, 0x83, 0xf8, 0x4f, 0x51, 0x7c, 0xeb, 0x67,
-	0x9b, 0xae, 0x7a, 0xa9, 0x39, 0x84, 0xb6, 0xe7, 0x7b, 0x91, 0x70, 0x54, 0x35, 0xa0, 0x4e, 0x9e,
-	0x33, 0x2d, 0xe7, 0x0c, 0xe0, 0x24, 0x66, 0xf8, 0xeb, 0x54, 0xf9, 0x29, 0xfc, 0xea, 0xea, 0x3e,
-	0x36, 0xdf, 0x6a, 0x12, 0x5f, 0xd3, 0x1c, 0x1f, 0x89, 0x62, 0x4b, 0xd2, 0xb3, 0x04, 0x68, 0x98,
-	0xfd, 0xb3, 0xa1, 0x14, 0x08, 0x19, 0x07, 0x7c, 0x0a, 0x38, 0x4c, 0x17, 0xdd, 0x12, 0xa6, 0x39,
-	0xa7, 0x2c, 0x77, 0x0a, 0x1c, 0xf0, 0x63, 0x58, 0x19, 0x19, 0x85, 0x82, 0xc4, 0x69, 0xcd, 0xad,
-	0x25, 0x8a, 0x5c, 0xec, 0x09, 0x74, 0x8d, 0x78, 0xdd, 0x70, 0xcf, 0x5a, 0xd0, 0x92, 0x4d, 0x8d,
-	0xbe, 0x61, 0xf5, 0x90, 0x9f, 0xff, 0x18, 0x5f, 0xf2, 0x74, 0xc7, 0x49, 0x49, 0xec, 0x57, 0xb0,
-	0x9c, 0x0b, 0x70, 0x61, 0x3d, 0x92, 0xbc, 0xb6, 0x49, 0x2e, 0xd3, 0x5d, 0x94, 0x05, 0x2d, 0x49,
-	0xec, 0x63, 0xb1, 0xdf, 0x0b, 0x8e, 0x1e, 0x72, 0x0f, 0xd9, 0x29, 0xab, 0x02, 0x40, 0x8d, 0xec,
-	0x5d, 0xc0, 0xf9, 0x2d, 0x29, 0x3c, 0x5b, 0xd7, 0xd0, 0x49, 0x57, 0xca, 0xf8, 0x80, 0x7f, 0x4b,
-	0xf6, 0x17, 0x95, 0xc2, 0xfe, 0x42, 0x3f, 0x57, 0x29, 0x2b, 0xfc, 0x5b, 0x80, 0x91, 0x70, 0xfd,
-	0x2e, 0x79, 0x5f, 0xb4, 0x52, 0xfb, 0x10, 0x43, 0x8b, 0xc7, 0xc6, 0x94, 0xad, 0x7d, 0x04, 0x3d,
-	0xb3, 0x87, 0xf8, 0xe0, 0x8f, 0xdb, 0xa7, 0xd0, 0x33, 0xeb, 0x7c, 0xfc, 0x10, 0x5a, 0xf2, 0x13,
-	0xfa, 0x30, 0x16, 0x75, 0x3a, 0x1a, 0x46, 0x59, 0xda, 0xdb, 0xd0, 0x10, 0x7d, 0x09, 0x8f, 0xa7,
-	0xec, 0x9e, 0x54, 0x8c, 0xd4, 0xc8, 0x3e, 0x87, 0xae, 0xd1, 0x8c, 0xe0, 0x07, 0xd0, 0xa4, 0xc1,
-	0xd4, 0x1b, 0x5d, 0xab, 0x32, 0x62, 0x25, 0x5e, 0x31, 0x27, 0xb5, 0x73, 0xa1, 0x72, 0x94, 0x09,
-	0x8f, 0xfb, 0x4b, 0x72, 0x2d, 0xf3, 0xa6, 0xe3, 0x88, 0xdf, 0x36, 0x81, 0xa5, 0xa7, 0xee, 0x90,
-	0x4c, 0x4f, 0x02, 0x9f, 0x45, 0xa1, 0xeb, 0xf9, 0x11, 0x3f, 0xfe, 0x2f, 0x89, 0x04, 0x6c, 0x3b,
-	0xfc, 0x27, 0xde, 0x85, 0x6a, 0x40, 0xe3, 0x98, 0xca, 0x75, 0x64, 0xbc, 0xbe, 0xa5, 0x4e, 0x35,
-	0xe0, 0xa5, 0x70, 0xf3, 0xb5, 0x3b, 0x9d, 0x11, 0x99, 0x7f, 0x6d, 0x47, 0x8d, 0xec, 0x7f, 0xd4,
-	0xa0, 0x6b, 0xbe, 0xe9, 0x24, 0xb5, 0x54, 0xdb, 0xa8, 0xa5, 0x2c, 0x68, 0x89, 0x36, 0x57, 0x55,
-	0x52, 0x6d, 0x47, 0x0f, 0x93, 0xda, 0xb4, 0x26, 0xcb, 0xe4, 0xb8, 0x36, 0x0d, 0x5e, 0x93, 0x30,
-	0xf4, 0xc6, 0x3a, 0xf9, 0xe2, 0x31, 0xd7, 0xb1, 0xc8, 0x0d, 0x23, 0xde, 0x42, 0x37, 0xe4, 0x7b,
-	0x82, 0x1e, 0xf3, 0x99, 0x12, 0x7f, 0xcc, 0x35, 0x4d, 0x19, 0x62, 0x39, 0xc2, 0x7b, 0x50, 0x0f,
-	0x83, 0xa9, 0x6c, 0x01, 0x7b, 0xf1, 0x1b, 0xab, 0x6e, 0x6a, 0x83, 0xa9, 0xcc, 0x1f, 0x61, 0x93,
-	0x14, 0xee, 0x0b, 0xa9, 0xc2, 0x1d, 0x3f, 0x06, 0x34, 0x35, 0x83, 0xc3, 0xac, 0xb6, 0xc8, 0x81,
-	0xb5, 0xe2, 0xd8, 0xe9, 0x77, 0xaf, 0xac, 0x17, 0xbe, 0x0f, 0xbd, 0x69, 0x30, 0x72, 0x23, 0x2f,
-	0xf0, 0x85, 0x0b, 0xb3, 0x40, 0x44, 0x35, 0x23, 0xe5, 0x76, 0x1e, 0x0b, 0xa6, 0x52, 0x44, 0x5e,
-	0x93, 0xa9, 0x78, 0x63, 0x6d, 0x3b, 0x19, 0xe9, 0xde, 0xbf, 0x17, 0xa0, 0xce, 0xa7, 0x8f, 0x37,
-	0x60, 0x55, 0x2c, 0x83, 0x4c, 0x3c, 0x16, 0x91, 0x30, 0x3e, 0xa3, 0xe8, 0x0e, 0xbe, 0x07, 0x96,
-	0x54, 0xe5, 0x5f, 0x70, 0x50, 0xa5, 0x5c, 0xcb, 0x28, 0xaa, 0xe2, 0x8f, 0x60, 0x83, 0x6b, 0x0b,
-	0xdb, 0x46, 0x54, 0x9b, 0xa3, 0x66, 0x14, 0xd5, 0xf1, 0x3a, 0xac, 0x70, 0x75, 0xa6, 0xc9, 0x45,
-	0x8d, 0x42, 0x05, 0xa3, 0xa8, 0xa9, 0x15, 0x99, 0xc6, 0x10, 0xb5, 0x0a, 0x15, 0x8c, 0xa2, 0x05,
-	0x8c, 0xa1, 0xc7, 0x15, 0x49, 0x2b, 0x87, 0xda, 0x59, 0x19, 0xa3, 0x08, 0xb0, 0x05, 0x7d, 0x21,
-	0xcb, 0xb4, 0x6f, 0x68, 0xb1, 0x58, 0xc3, 0x28, 0xea, 0xe0, 0xbb, 0xb0, 0x2e, 0x96, 0x97, 0x6f,
-	0xb7, 0x50, 0xb7, 0x54, 0xc9, 0x28, 0xea, 0xe1, 0x4d, 0x58, 0x93, 0x51, 0xcd, 0x76, 0x1c, 0x68,
-	0xa9, 0x4c, 0xc7, 0x28, 0x42, 0x7a, 0x2e, 0xd9, 0xde, 0x08, 0x2d, 0x17, 0x6b, 0x18, 0x45, 0x58,
-	0x6b, 0xb2, 0x7d, 0x00, 0x5a, 0xc1, 0x2b, 0xb0, 0xc4, 0x35, 0xa9, 0x4a, 0x00, 0xf5, 0xf5, 0xe7,
-	0xf3, 0xed, 0x00, 0x5a, 0x2d, 0xd3, 0x31, 0x8a, 0xd6, 0x92, 0x69, 0x67, 0xcb, 0x7a, 0xb4, 0x5e,
-	0xa6, 0x63, 0x14, 0x59, 0x71, 0x8e, 0x14, 0xd5, 0xf1, 0x68, 0x63, 0x8e, 0x9a, 0x51, 0xb4, 0xa9,
-	0xa3, 0x5c, 0x50, 0x7a, 0xa3, 0xbb, 0xa5, 0x4a, 0x46, 0xd1, 0x3d, 0x3d, 0xa7, 0x7c, 0x59, 0x8d,
-	0x3e, 0x2a, 0xd3, 0x31, 0x8a, 0xb6, 0x70, 0x1f, 0x50, 0x12, 0x03, 0x59, 0x85, 0xa2, 0xed, 0xbc,
-	0x94, 0x51, 0xb4, 0xa3, 0xa5, 0xe9, 0xba, 0x17, 0xfd, 0x2c, 0x2f, 0x65, 0x14, 0xd9, 0x78, 0x15,
-	0x96, 0xc5, 0x66, 0xa4, 0xcb, 0x5b, 0xf4, 0x71, 0x81, 0x98, 0x51, 0xf4, 0x09, 0xde, 0x86, 0xbb,
-	0x22, 0x29, 0x8b, 0xab, 0x53, 0xf4, 0xf3, 0xb9, 0x06, 0x8c, 0xa2, 0xfb, 0xda, 0xa0, 0xa4, 0xe8,
-	0x44, 0x9f, 0xce, 0x35, 0x60, 0x14, 0xed, 0xee, 0x9d, 0x88, 0xff, 0x9c, 0x49, 0xdf, 0x92, 0xb8,
-	0x0d, 0x8d, 0xe7, 0x41, 0x24, 0xae, 0x15, 0x80, 0xa6, 0x24, 0x57, 0x54, 0xc1, 0x1d, 0x58, 0xf8,
-	0x26, 0x98, 0x4e, 0x83, 0x37, 0x24, 0x44, 0x55, 0xbc, 0x08, 0xad, 0xa7, 0xc4, 0x0d, 0xf9, 0xed,
-	0x53, 0xdb, 0x3b, 0x82, 0xe5, 0x1c, 0xb1, 0xe0, 0x26, 0x54, 0xcf, 0x7c, 0x74, 0x87, 0xc3, 0x3d,
-	0x0b, 0xa2, 0x33, 0x1f, 0x55, 0x38, 0xdc, 0xe9, 0x5b, 0x8f, 0x45, 0x0c, 0x55, 0x71, 0x17, 0xda,
-	0xcf, 0x82, 0x48, 0x0d, 0x6b, 0xc7, 0xe8, 0xc7, 0x9f, 0xb6, 0xee, 0xfc, 0xf0, 0x7e, 0xab, 0xf2,
-	0xe3, 0xfb, 0xad, 0xca, 0x7f, 0xde, 0x6f, 0x55, 0x86, 0x4d, 0xf1, 0x07, 0x2b, 0x0f, 0xff, 0x1f,
-	0x00, 0x00, 0xff, 0xff, 0x70, 0xd5, 0x4b, 0xe5, 0x43, 0x23, 0x00, 0x00,
+	// 2597 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x5a, 0x49, 0x73, 0xdc, 0xc6,
+	0x15, 0xd6, 0xec, 0x9c, 0xc7, 0x99, 0x61, 0xb3, 0x39, 0x24, 0x41, 0x4a, 0x26, 0x19, 0xd8, 0xb1,
+	0x19, 0x3a, 0x21, 0x63, 0x2a, 0x2e, 0xa7, 0x5c, 0xb1, 0x13, 0x6e, 0x96, 0xa8, 0x28, 0x32, 0x0b,
+	0x74, 0x1c, 0xdf, 0x52, 0x98, 0x99, 0xd6, 0x10, 0x11, 0x08, 0xb4, 0xd0, 0x18, 0x49, 0x3c, 0xe5,
+	0x90, 0xca, 0x31, 0xff, 0xcb, 0x47, 0x9f, 0x73, 0x70, 0xc5, 0xfa, 0x07, 0x39, 0xe7, 0x92, 0xea,
+	0x0d, 0x40, 0x63, 0x19, 0x52, 0x27, 0x4d, 0xbf, 0xe5, 0x43, 0xf7, 0xeb, 0xe5, 0x7b, 0xef, 0x89,
+	0xb0, 0x18, 0xd1, 0x31, 0x1d, 0xed, 0xd3, 0x28, 0x8c, 0x43, 0xdc, 0x12, 0x83, 0xcd, 0xa7, 0x53,
+	0x2f, 0xbe, 0x9a, 0x8d, 0xf6, 0xc7, 0xe1, 0xf5, 0xc1, 0xb5, 0x1b, 0x47, 0xde, 0x9b, 0x30, 0xf2,
+	0xa6, 0x5e, 0xa0, 0x06, 0xe3, 0xd9, 0x88, 0x1c, 0x8c, 0xc3, 0x6b, 0x1a, 0x06, 0x24, 0x88, 0xd9,
+	0x01, 0x8d, 0x42, 0x7a, 0x45, 0xe2, 0x03, 0x3a, 0x3a, 0xb8, 0x26, 0xb1, 0x9b, 0xfc, 0x23, 0x41,
+	0x37, 0x7f, 0x95, 0x41, 0x9b, 0x86, 0xd3, 0xf0, 0x40, 0x88, 0x47, 0xb3, 0xe7, 0x62, 0x24, 0x06,
+	0xe2, 0x97, 0x34, 0xb7, 0xff, 0xd5, 0x83, 0x8e, 0x43, 0x5e, 0xce, 0x08, 0x8b, 0xf1, 0x1a, 0xd4,
+	0xbd, 0x89, 0x55, 0xdb, 0xa9, 0xed, 0x36, 0x8f, 0xdb, 0x6f, 0x7f, 0xdc, 0xae, 0x9f, 0x9f, 0x3a,
+	0x75, 0x6f, 0x82, 0x77, 0x60, 0x71, 0x1c, 0x06, 0xb1, 0xeb, 0x05, 0x24, 0x3a, 0x3f, 0xb5, 0xea,
+	0xdc, 0xc0, 0xc9, 0x8a, 0xf0, 0x36, 0x34, 0xe3, 0x1b, 0x4a, 0xac, 0xc6, 0x4e, 0x6d, 0x77, 0x70,
+	0xb8, 0xb8, 0x2f, 0x57, 0xf9, 0xcd, 0x0d, 0x25, 0x8e, 0x50, 0xe0, 0xaf, 0x61, 0x39, 0x22, 0x2c,
+	0x9c, 0x45, 0x63, 0xf2, 0x98, 0xb8, 0x51, 0x3c, 0x22, 0x6e, 0x6c, 0x35, 0x77, 0x6a, 0xbb, 0x8b,
+	0x87, 0xf7, 0x95, 0xb5, 0x93, 0xd7, 0x3b, 0xe4, 0xe5, 0x71, 0xf3, 0xfb, 0x1f, 0xb7, 0xef, 0x39,
+	0x45, 0x5f, 0xec, 0x00, 0x4e, 0x26, 0x90, 0x22, 0xb6, 0x04, 0xe2, 0x03, 0x85, 0x78, 0x52, 0x30,
+	0x48, 0x21, 0x4b, 0xbc, 0xf1, 0x1f, 0xa0, 0x47, 0x67, 0x71, 0xe2, 0x65, 0xb5, 0x05, 0xda, 0x9a,
+	0x42, 0xbb, 0xc8, 0xa8, 0x52, 0x1c, 0xc3, 0x83, 0x23, 0x4c, 0x49, 0x06, 0xa1, 0x63, 0x20, 0x3c,
+	0x22, 0xa5, 0x08, 0x59, 0x0f, 0xfc, 0x09, 0x74, 0x5c, 0xdf, 0x0f, 0xc7, 0xe7, 0xa7, 0xd6, 0x82,
+	0x70, 0x5e, 0x56, 0xce, 0x47, 0x52, 0x9a, 0xfa, 0x69, 0x3b, 0x7c, 0x02, 0x7d, 0x97, 0xbd, 0x38,
+	0x76, 0xe3, 0xf1, 0xd5, 0x25, 0xf5, 0xbd, 0xd8, 0xea, 0x0a, 0xc7, 0x75, 0xed, 0x98, 0xd5, 0xa5,
+	0xee, 0xa6, 0x0f, 0x7e, 0x0a, 0x68, 0x1c, 0x11, 0x37, 0x26, 0xa7, 0x84, 0xc5, 0x51, 0x78, 0xe3,
+	0x05, 0x53, 0x0b, 0x04, 0xce, 0xa6, 0x8e, 0x66, 0x4e, 0x9d, 0x42, 0x15, 0x3c, 0xf1, 0x39, 0x2c,
+	0x39, 0x84, 0x86, 0x51, 0xac, 0x64, 0x64, 0x62, 0x2d, 0x0a, 0xb0, 0x8d, 0x64, 0xb3, 0x0d, 0x6d,
+	0x8a, 0x95, 0xf7, 0xe3, 0xab, 0x9b, 0x92, 0x38, 0x33, 0xab, 0x9e, 0xb1, 0xba, 0x47, 0x59, 0x5d,
+	0x66, 0x75, 0x86, 0x0f, 0x07, 0x91, 0x73, 0xfc, 0x0b, 0x5f, 0x31, 0x89, 0xac, 0xbe, 0x01, 0x72,
+	0x92, 0xd5, 0x65, 0x40, 0x0c, 0x1f, 0xbe, 0x28, 0x29, 0xd0, 0x27, 0x95, 0x59, 0x03, 0x63, 0x51,
+	0x27, 0xa6, 0x36, 0xb3, 0xa8, 0x9c, 0x1f, 0x87, 0x8a, 0xc8, 0x75, 0xf8, 0x2a, 0x03, 0xb5, 0x94,
+	0x8b, 0x8f, 0xa1, 0xcd, 0x40, 0xe5, 0xfc, 0xc4, 0x45, 0xb8, 0x22, 0xe3, 0x17, 0x5a, 0x72, 0x19,
+	0xbb, 0x31, 0xb1, 0x90, 0x79, 0x11, 0x0a, 0x06, 0xd9, 0x8b, 0x50, 0x50, 0xf2, 0xc3, 0x40, 0x67,
+	0xf1, 0x85, 0xef, 0x8e, 0xc9, 0x35, 0x09, 0x62, 0x67, 0xe6, 0x13, 0x6b, 0xd9, 0x38, 0x0c, 0x17,
+	0x39, 0x75, 0xe6, 0x30, 0xe4, 0x3d, 0xf9, 0x62, 0xa7, 0x24, 0x3e, 0xa2, 0xd4, 0xf7, 0xc8, 0x84,
+	0x4b, 0x98, 0x85, 0x8d, 0xc5, 0x3e, 0x32, 0xb5, 0x99, 0xc5, 0xe6, 0xfc, 0xf0, 0x67, 0xd0, 0x95,
+	0xa1, 0x7c, 0x12, 0x8e, 0xac, 0x15, 0x01, 0xb2, 0x62, 0x04, 0xff, 0x49, 0x38, 0x4a, 0xdd, 0x53,
+	0x5b, 0xee, 0x28, 0x03, 0xc7, 0x1d, 0x87, 0x86, 0xa3, 0xa3, 0xe5, 0x19, 0xc7, 0xc4, 0x16, 0x7f,
+	0x0e, 0x40, 0xde, 0x90, 0xf1, 0x4c, 0x7e, 0x72, 0x55, 0x78, 0x0e, 0x95, 0xe7, 0x59, 0xa2, 0x48,
+	0x5d, 0x33, 0xd6, 0xf8, 0x3b, 0x18, 0xba, 0x93, 0xc9, 0xe5, 0xf8, 0x8a, 0x4c, 0x66, 0x3e, 0x79,
+	0x14, 0x85, 0x33, 0x2a, 0x42, 0xb9, 0x26, 0x50, 0xb6, 0xf4, 0xfd, 0x2c, 0x31, 0x49, 0xf1, 0x4a,
+	0x11, 0x38, 0xf2, 0x94, 0xc4, 0x45, 0xe4, 0x75, 0x03, 0xf9, 0x51, 0x89, 0x49, 0x06, 0xb9, 0x0c,
+	0xc1, 0xfe, 0x67, 0x0f, 0x16, 0x1c, 0xc2, 0x68, 0x18, 0x30, 0x52, 0x49, 0x08, 0xfa, 0xb9, 0xaf,
+	0x57, 0x3d, 0xf7, 0x43, 0x68, 0x91, 0x28, 0x0a, 0x23, 0x41, 0x08, 0x5d, 0x47, 0x0e, 0xf0, 0x1a,
+	0xb4, 0x7d, 0xe2, 0x4e, 0x48, 0x24, 0x5e, 0xfe, 0xae, 0xa3, 0x46, 0xe5, 0xe4, 0xd0, 0xba, 0x85,
+	0x1c, 0x18, 0x7d, 0x57, 0x72, 0x68, 0xdf, 0x46, 0x0e, 0x09, 0xe4, 0x5d, 0xc8, 0xa1, 0x53, 0x4d,
+	0x0e, 0x09, 0xce, 0x7c, 0x72, 0x58, 0xa8, 0x26, 0x87, 0x14, 0xa1, 0x8a, 0x1c, 0xba, 0xa5, 0xe4,
+	0x90, 0xf8, 0x55, 0x93, 0x03, 0xcc, 0x21, 0x87, 0xc4, 0xfd, 0x0e, 0xe4, 0xb0, 0x38, 0x9f, 0x1c,
+	0x12, 0xa8, 0x3b, 0x91, 0x43, 0x6f, 0x2e, 0x39, 0x24, 0x58, 0xb7, 0x93, 0x43, 0x7f, 0x0e, 0x39,
+	0xa4, 0xab, 0x33, 0xc9, 0x61, 0x1f, 0x5a, 0xe4, 0x15, 0x09, 0x62, 0xf5, 0x9a, 0x63, 0x7d, 0xbb,
+	0xb9, 0xec, 0x59, 0x18, 0x7b, 0xcf, 0x6f, 0x94, 0x9f, 0x34, 0x2b, 0xe3, 0x81, 0xa5, 0xb9, 0x3c,
+	0x90, 0xce, 0xff, 0x0e, 0x3c, 0x80, 0xe6, 0xf2, 0x40, 0x0a, 0x75, 0x37, 0x1e, 0x58, 0xbe, 0x8d,
+	0x07, 0x32, 0x67, 0xfe, 0x6e, 0x3c, 0x80, 0xe7, 0xf3, 0x40, 0xba, 0xef, 0x77, 0xe1, 0x81, 0x95,
+	0xb9, 0x3c, 0x90, 0x2e, 0x76, 0x2e, 0x0f, 0x0c, 0x2b, 0x78, 0x20, 0x71, 0xaf, 0xe2, 0x81, 0xd5,
+	0x0a, 0x1e, 0x48, 0x1d, 0xab, 0x78, 0x60, 0xad, 0x8a, 0x07, 0x12, 0xd7, 0xbb, 0xf0, 0xc0, 0xfa,
+	0xed, 0x3c, 0x90, 0xe0, 0xbd, 0x1b, 0x0f, 0x58, 0xb7, 0xf3, 0x40, 0x8a, 0x5c, 0xca, 0x03, 0x3f,
+	0xd5, 0x61, 0x58, 0x96, 0x91, 0xe7, 0x8b, 0x81, 0x5a, 0xb1, 0x18, 0xd8, 0x84, 0x05, 0xfd, 0x24,
+	0x0b, 0x86, 0xe8, 0x39, 0xc9, 0x18, 0x63, 0x68, 0xc6, 0x24, 0xba, 0x16, 0xbc, 0xd0, 0x74, 0xc4,
+	0x6f, 0xfc, 0x91, 0x41, 0x0b, 0x8b, 0x87, 0x4b, 0xfb, 0xaa, 0xa0, 0x71, 0x08, 0xf5, 0xbd, 0xb1,
+	0x9b, 0xf0, 0xc4, 0x97, 0xd0, 0x9b, 0x84, 0xaf, 0x03, 0x25, 0x66, 0x56, 0x6b, 0xa7, 0x21, 0x76,
+	0xc1, 0x34, 0xe7, 0x47, 0x97, 0xe9, 0xe7, 0x33, 0x6b, 0x8f, 0x7f, 0x0f, 0x4b, 0x94, 0x04, 0x13,
+	0x91, 0x28, 0x2a, 0x88, 0xb6, 0x80, 0xc8, 0x7f, 0x51, 0x1f, 0xbb, 0x9c, 0x35, 0xfe, 0x04, 0x5a,
+	0x8c, 0xa3, 0xab, 0xc7, 0x7f, 0x35, 0x75, 0x4b, 0x6f, 0x8d, 0xfe, 0xb4, 0xb4, 0xe4, 0xc1, 0x98,
+	0xf2, 0xa0, 0xfe, 0x91, 0xdc, 0x88, 0x07, 0xbf, 0xeb, 0x24, 0x63, 0xfb, 0xbf, 0x8d, 0xb2, 0x18,
+	0x33, 0x8a, 0xb7, 0x00, 0x74, 0xc4, 0x92, 0x10, 0x67, 0x24, 0xf8, 0x08, 0xfa, 0x7a, 0x74, 0x46,
+	0xc3, 0xf1, 0x95, 0x08, 0x73, 0xc9, 0x7c, 0x84, 0x52, 0x3f, 0x7a, 0x86, 0x07, 0xfe, 0x14, 0xfa,
+	0xb1, 0x1b, 0x4d, 0x49, 0xac, 0x16, 0x27, 0x76, 0xa4, 0x24, 0xf6, 0xa6, 0x15, 0xfe, 0x0c, 0x7a,
+	0xe3, 0x30, 0x78, 0xee, 0x4d, 0x4f, 0xae, 0xdc, 0x60, 0x4a, 0xd4, 0x8e, 0xad, 0xa4, 0x9c, 0x9a,
+	0xa8, 0x1c, 0xc3, 0x10, 0x7f, 0x01, 0x83, 0x38, 0x72, 0x03, 0xf6, 0x9c, 0x44, 0x4f, 0xe5, 0x66,
+	0xb7, 0xd4, 0x9c, 0x55, 0xf2, 0x60, 0x28, 0x9d, 0x9c, 0x31, 0xb6, 0xa1, 0x75, 0x4d, 0xa2, 0x29,
+	0x51, 0x24, 0xde, 0x53, 0x5e, 0x7f, 0xe2, 0x32, 0x47, 0xaa, 0xf0, 0xe7, 0xd0, 0x67, 0xb2, 0xc6,
+	0x51, 0x87, 0xaf, 0x63, 0xdc, 0xd2, 0xcb, 0xac, 0xce, 0x31, 0x4d, 0xf9, 0xf4, 0xb2, 0xd3, 0xfd,
+	0xf6, 0x50, 0xb1, 0xf3, 0x6a, 0xc9, 0xca, 0xbe, 0x3d, 0x74, 0x72, 0xc6, 0x78, 0x17, 0x96, 0x26,
+	0x92, 0x50, 0x4e, 0xbd, 0x88, 0x8c, 0x63, 0xff, 0x46, 0x10, 0xf4, 0x82, 0x93, 0x17, 0xdb, 0x07,
+	0xb0, 0x94, 0x2b, 0x24, 0xf1, 0x03, 0xe8, 0x26, 0xd7, 0x47, 0x6c, 0x76, 0xcf, 0x49, 0x05, 0xf6,
+	0x17, 0x39, 0x07, 0x46, 0xf1, 0x1e, 0x20, 0x05, 0x9b, 0xd2, 0x86, 0xf4, 0x2b, 0xc8, 0xed, 0xbf,
+	0xc2, 0x6a, 0x69, 0x19, 0x8c, 0x0f, 0xf5, 0x59, 0xae, 0xa9, 0x34, 0x44, 0x6d, 0x7c, 0x62, 0x5d,
+	0x72, 0x98, 0x31, 0x34, 0x27, 0x6e, 0xec, 0xaa, 0x5b, 0x2d, 0x7e, 0xdb, 0x1f, 0x97, 0x7e, 0x80,
+	0xd1, 0xc4, 0xb8, 0x96, 0x31, 0xfe, 0x05, 0x2c, 0xe5, 0x8a, 0xe0, 0xaa, 0x1c, 0xd3, 0xbe, 0xcc,
+	0x99, 0x96, 0x23, 0xe2, 0x5f, 0xea, 0x65, 0xd4, 0xe7, 0x2d, 0x43, 0x2d, 0xc0, 0xee, 0x01, 0xa4,
+	0x75, 0xb4, 0xfd, 0x41, 0x3a, 0x62, 0xb4, 0x72, 0x22, 0xbf, 0x03, 0x94, 0x2f, 0xa1, 0x4b, 0x67,
+	0x32, 0x84, 0xd6, 0x38, 0x9c, 0x05, 0xb1, 0x98, 0x49, 0xdf, 0x91, 0x03, 0xfb, 0x34, 0xef, 0xcd,
+	0x28, 0xfe, 0x35, 0x2c, 0x88, 0xd3, 0x77, 0x7e, 0xca, 0xa3, 0xcf, 0x1f, 0xa0, 0x41, 0xf6, 0x8c,
+	0x9e, 0x9f, 0xaa, 0xa8, 0x27, 0x56, 0xf6, 0xdf, 0x61, 0xa5, 0xa4, 0xfc, 0xae, 0xcc, 0xcf, 0x87,
+	0xd0, 0xf2, 0x82, 0x09, 0x79, 0xa3, 0x5a, 0x35, 0x72, 0x20, 0xdf, 0x65, 0xf5, 0xee, 0x35, 0x76,
+	0x1a, 0xbb, 0x4d, 0x27, 0x19, 0xcb, 0x17, 0x87, 0x73, 0xdd, 0x29, 0x5f, 0x56, 0x53, 0x9c, 0xdd,
+	0x8c, 0xc4, 0x3e, 0x2e, 0x99, 0x00, 0xa3, 0xf8, 0x63, 0x19, 0x7d, 0x22, 0xe6, 0x30, 0x28, 0x7f,
+	0x10, 0x89, 0x0c, 0x3e, 0xb1, 0xf7, 0x00, 0xe5, 0xab, 0xf5, 0xca, 0xa0, 0x9f, 0xe6, 0x6d, 0x45,
+	0xd8, 0xda, 0x1c, 0x68, 0xa6, 0x8f, 0xac, 0xa5, 0xbf, 0x96, 0x9a, 0x5d, 0x0a, 0xbd, 0xa3, 0xec,
+	0xec, 0x27, 0x80, 0x8b, 0x8d, 0x86, 0xca, 0xa8, 0x3d, 0xe0, 0xb9, 0x81, 0x88, 0x47, 0xd2, 0xe4,
+	0x4a, 0x05, 0xf6, 0x51, 0x11, 0xeb, 0x5d, 0x03, 0x70, 0x06, 0x1d, 0xb5, 0xc1, 0x7c, 0x87, 0x02,
+	0xf2, 0x3a, 0x79, 0xdc, 0xe5, 0x00, 0x7f, 0x00, 0xfd, 0x80, 0xbc, 0x76, 0xf4, 0x37, 0xf9, 0xa1,
+	0xe6, 0xdb, 0x64, 0x0a, 0xed, 0x0f, 0x01, 0xe5, 0x1b, 0x16, 0xfc, 0x40, 0x3e, 0xf7, 0xdd, 0xa9,
+	0x80, 0xeb, 0x3b, 0xe2, 0xb7, 0xfd, 0x1d, 0xe0, 0x62, 0x47, 0x42, 0xae, 0x32, 0x7d, 0x35, 0x1a,
+	0xfc, 0xb5, 0x49, 0x04, 0x7c, 0x06, 0x3e, 0x71, 0x59, 0x9c, 0x10, 0xa4, 0x9a, 0x81, 0x21, 0xb4,
+	0x87, 0x45, 0x64, 0x46, 0xed, 0x03, 0x1e, 0xa1, 0x7c, 0xdb, 0x02, 0x6f, 0x40, 0xc3, 0x9b, 0xc8,
+	0x2f, 0x35, 0x8f, 0x3b, 0x6f, 0x7f, 0xdc, 0x6e, 0x9c, 0x9f, 0x32, 0x87, 0xcb, 0x38, 0x4c, 0x31,
+	0xbf, 0xb5, 0x0f, 0x61, 0xb5, 0xb4, 0x5f, 0x91, 0x22, 0xd5, 0x76, 0x7b, 0x39, 0xa4, 0x3f, 0x97,
+	0xfa, 0x30, 0xca, 0x57, 0x3b, 0x49, 0xaa, 0x0c, 0xf5, 0xb6, 0x26, 0x02, 0x7e, 0xea, 0x27, 0x69,
+	0xed, 0x20, 0x5f, 0xb5, 0x8c, 0xc4, 0x3e, 0x83, 0x95, 0x92, 0x46, 0x07, 0xde, 0x87, 0x66, 0xc4,
+	0xb3, 0xac, 0x9a, 0xc1, 0x2f, 0x86, 0x99, 0xba, 0xc1, 0xc2, 0xce, 0x5e, 0x2d, 0x81, 0x61, 0xd4,
+	0xfe, 0x0d, 0xe0, 0x62, 0xe7, 0xe3, 0x36, 0xee, 0xb7, 0xbf, 0x2a, 0x7a, 0x89, 0xbb, 0xd1, 0x8a,
+	0x44, 0x46, 0x5d, 0x53, 0x39, 0x51, 0xf5, 0x9c, 0xa4, 0xa1, 0xfd, 0x10, 0x7a, 0xd9, 0x96, 0x09,
+	0x7e, 0x1f, 0x1a, 0x7f, 0x0b, 0x47, 0x6a, 0x4d, 0x8b, 0xfa, 0x1c, 0x3f, 0x09, 0x47, 0xca, 0x8d,
+	0x6b, 0xed, 0x41, 0xd6, 0x89, 0x51, 0x0e, 0x92, 0x6d, 0x9f, 0xdc, 0x19, 0x24, 0x9b, 0x6b, 0xdb,
+	0x8f, 0xa1, 0x6f, 0x74, 0x52, 0xee, 0x84, 0x52, 0xca, 0x45, 0xef, 0x1b, 0x48, 0x15, 0x1c, 0xf4,
+	0x0c, 0xd6, 0x2b, 0x5a, 0x2e, 0xf8, 0xa1, 0xb1, 0xb1, 0x1b, 0xfa, 0xcb, 0x05, 0x5b, 0x63, 0x77,
+	0x37, 0x2a, 0xf0, 0x18, 0xe5, 0xaa, 0x8a, 0x1e, 0x8c, 0x7d, 0x51, 0xa1, 0x62, 0x14, 0x7f, 0x6a,
+	0xee, 0xe5, 0xad, 0xd3, 0x50, 0x1b, 0xfa, 0xbf, 0x3a, 0x2c, 0x66, 0x6a, 0x56, 0x8c, 0xa0, 0xc1,
+	0xc8, 0x4b, 0x75, 0x82, 0xf8, 0x4f, 0x91, 0x7c, 0xeb, 0xb6, 0x4d, 0x5f, 0x75, 0x6a, 0x0e, 0xa1,
+	0xeb, 0x05, 0x5e, 0x2c, 0x1c, 0x55, 0x0e, 0xa8, 0x0f, 0xcf, 0xb9, 0x96, 0x73, 0x06, 0x70, 0x52,
+	0x33, 0xfc, 0x65, 0x26, 0xfd, 0x14, 0x7e, 0x4d, 0xf5, 0x1e, 0x9b, 0xbd, 0x9a, 0xd4, 0xd7, 0x34,
+	0xc7, 0x47, 0x22, 0xd9, 0x92, 0xf4, 0x2c, 0x01, 0x5a, 0x66, 0xfd, 0x6c, 0x28, 0x05, 0x42, 0xce,
+	0x01, 0x9f, 0x01, 0x8e, 0xb2, 0x49, 0xb7, 0x84, 0x69, 0xcf, 0x49, 0xcb, 0x9d, 0x12, 0x07, 0xfc,
+	0x18, 0x56, 0xc6, 0x46, 0xa2, 0x20, 0x71, 0x3a, 0x73, 0x73, 0x89, 0x32, 0x17, 0x7b, 0x0a, 0x7d,
+	0x23, 0x5e, 0xb7, 0xbc, 0xb3, 0x16, 0x74, 0x64, 0x51, 0xa3, 0x5f, 0x58, 0x3d, 0xe4, 0xf7, 0x3f,
+	0xc1, 0x97, 0x3c, 0xdd, 0x73, 0x32, 0x12, 0xfb, 0x25, 0x2c, 0x17, 0x02, 0x5c, 0x9a, 0x8f, 0xa4,
+	0xdd, 0x36, 0xc9, 0x65, 0xba, 0x8a, 0xb2, 0xa0, 0x23, 0x89, 0x7d, 0x22, 0xf6, 0x7b, 0xc1, 0xd1,
+	0x43, 0xee, 0x21, 0x2b, 0x65, 0x95, 0x00, 0xa8, 0x91, 0xbd, 0x0b, 0xb8, 0xb8, 0x25, 0xa5, 0x77,
+	0xeb, 0x06, 0x7a, 0xd9, 0x4c, 0x19, 0x1f, 0xf0, 0x6f, 0xc9, 0xfa, 0xa2, 0x56, 0x5a, 0x5f, 0xe8,
+	0x76, 0x95, 0xb2, 0xc2, 0xbf, 0x05, 0x18, 0x0b, 0xd7, 0x6f, 0xd2, 0xfe, 0xa2, 0x95, 0xd9, 0x87,
+	0x04, 0x5a, 0x34, 0x1b, 0x33, 0xb6, 0xf6, 0x11, 0x0c, 0xcc, 0x1a, 0xe2, 0x9d, 0x3f, 0x6e, 0x9f,
+	0xc1, 0xc0, 0xcc, 0xf3, 0xf1, 0x43, 0xe8, 0xc8, 0x4f, 0xe8, 0xcb, 0x58, 0x56, 0xe9, 0x68, 0x18,
+	0x65, 0x69, 0x6f, 0x43, 0x4b, 0xd4, 0x25, 0x3c, 0x9e, 0xb2, 0x7a, 0x52, 0x31, 0x52, 0x23, 0xfb,
+	0x02, 0xfa, 0x46, 0x31, 0x82, 0x3f, 0x86, 0x36, 0x0d, 0x7d, 0x6f, 0x7c, 0xa3, 0xd2, 0x88, 0x95,
+	0x64, 0xc5, 0x9c, 0xd4, 0x2e, 0x84, 0xca, 0x51, 0x26, 0x3c, 0xee, 0x2f, 0xc8, 0x8d, 0x3c, 0x37,
+	0x3d, 0x47, 0xfc, 0xb6, 0x09, 0x2c, 0x3d, 0x75, 0x47, 0xc4, 0x3f, 0x09, 0x03, 0x16, 0x47, 0xae,
+	0x17, 0xc4, 0xfc, 0xfa, 0xbf, 0x20, 0x12, 0xb0, 0xeb, 0xf0, 0x9f, 0x78, 0x17, 0xea, 0x21, 0x4d,
+	0x62, 0x2a, 0xd7, 0x91, 0xf3, 0xfa, 0x9a, 0x3a, 0xf5, 0x90, 0xa7, 0xc2, 0xed, 0x57, 0xae, 0x3f,
+	0x23, 0xf2, 0xfc, 0x75, 0x1d, 0x35, 0xb2, 0xff, 0xd1, 0x80, 0xbe, 0xd9, 0xd3, 0x49, 0x73, 0xa9,
+	0xae, 0x91, 0x4b, 0x59, 0xd0, 0x11, 0x65, 0xae, 0xca, 0xa4, 0xba, 0x8e, 0x1e, 0xa6, 0xb9, 0x69,
+	0x43, 0xa6, 0xc9, 0x49, 0x6e, 0x1a, 0xbe, 0x22, 0x51, 0xe4, 0x4d, 0xf4, 0xe1, 0x4b, 0xc6, 0x5c,
+	0xc7, 0x62, 0x37, 0x8a, 0x79, 0x09, 0xdd, 0x92, 0xfd, 0x04, 0x3d, 0xe6, 0x33, 0x25, 0xc1, 0x84,
+	0x6b, 0xda, 0x32, 0xc4, 0x72, 0x84, 0xf7, 0xa0, 0x19, 0x85, 0xbe, 0x2c, 0x01, 0x07, 0x49, 0x8f,
+	0x55, 0x17, 0xb5, 0xa1, 0x2f, 0xcf, 0x8f, 0xb0, 0x49, 0x13, 0xf7, 0x85, 0x4c, 0xe2, 0x8e, 0x1f,
+	0x03, 0xf2, 0xcd, 0xe0, 0x30, 0xab, 0x2b, 0xce, 0xc0, 0x5a, 0x79, 0xec, 0x74, 0xdf, 0x2b, 0xef,
+	0x85, 0x3f, 0x84, 0x81, 0x1f, 0x8e, 0xdd, 0xd8, 0x0b, 0x03, 0xe1, 0xc2, 0x2c, 0x10, 0x51, 0xcd,
+	0x49, 0xb9, 0x9d, 0xc7, 0x42, 0x5f, 0x8a, 0xc8, 0x2b, 0xe2, 0x8b, 0x1e, 0x6b, 0xd7, 0xc9, 0x49,
+	0xf7, 0xfe, 0xbd, 0x00, 0x4d, 0x3e, 0x7d, 0xbc, 0x01, 0xab, 0x62, 0x19, 0x64, 0xea, 0xb1, 0x98,
+	0x44, 0xc9, 0x1d, 0x45, 0xf7, 0xf0, 0x03, 0xb0, 0xa4, 0xaa, 0xd8, 0xc1, 0x41, 0xb5, 0x6a, 0x2d,
+	0xa3, 0xa8, 0x8e, 0xdf, 0x83, 0x0d, 0xae, 0x2d, 0x2d, 0x1b, 0x51, 0x63, 0x8e, 0x9a, 0x51, 0xd4,
+	0xc4, 0xeb, 0xb0, 0xc2, 0xd5, 0xb9, 0x22, 0x17, 0xb5, 0x4a, 0x15, 0x8c, 0xa2, 0xb6, 0x56, 0xe4,
+	0x0a, 0x43, 0xd4, 0x29, 0x55, 0x30, 0x8a, 0x16, 0x30, 0x86, 0x01, 0x57, 0xa4, 0xa5, 0x1c, 0xea,
+	0xe6, 0x65, 0x8c, 0x22, 0xc0, 0x16, 0x0c, 0x85, 0x2c, 0x57, 0xbe, 0xa1, 0xc5, 0x72, 0x0d, 0xa3,
+	0xa8, 0x87, 0xef, 0xc3, 0xba, 0x58, 0x5e, 0xb1, 0xdc, 0x42, 0xfd, 0x4a, 0x25, 0xa3, 0x68, 0x80,
+	0x37, 0x61, 0x4d, 0x46, 0x35, 0x5f, 0x71, 0xa0, 0xa5, 0x2a, 0x1d, 0xa3, 0x08, 0xe9, 0xb9, 0xe4,
+	0x6b, 0x23, 0xb4, 0x5c, 0xae, 0x61, 0x14, 0x61, 0xad, 0xc9, 0xd7, 0x01, 0x68, 0x05, 0xaf, 0xc0,
+	0x12, 0xd7, 0x64, 0x32, 0x01, 0x34, 0xd4, 0x9f, 0x2f, 0x96, 0x03, 0x68, 0xb5, 0x4a, 0xc7, 0x28,
+	0x5a, 0x4b, 0xa7, 0x9d, 0x4f, 0xeb, 0xd1, 0x7a, 0x95, 0x8e, 0x51, 0x64, 0x25, 0x67, 0xa4, 0x2c,
+	0x8f, 0x47, 0x1b, 0x73, 0xd4, 0x8c, 0xa2, 0x4d, 0x1d, 0xe5, 0x92, 0xd4, 0x1b, 0xdd, 0xaf, 0x54,
+	0x32, 0x8a, 0x1e, 0xe8, 0x39, 0x15, 0xd3, 0x6a, 0xf4, 0x5e, 0x95, 0x8e, 0x51, 0xb4, 0x85, 0x87,
+	0x80, 0xd2, 0x18, 0xc8, 0x2c, 0x14, 0x6d, 0x17, 0xa5, 0x8c, 0xa2, 0x1d, 0x2d, 0xcd, 0xe6, 0xbd,
+	0xe8, 0x67, 0x45, 0x29, 0xa3, 0xc8, 0xc6, 0xab, 0xb0, 0x2c, 0x36, 0x23, 0x9b, 0xde, 0xa2, 0xf7,
+	0x4b, 0xc4, 0x8c, 0xa2, 0x0f, 0xf0, 0x36, 0xdc, 0x17, 0x87, 0xb2, 0x3c, 0x3b, 0x45, 0x3f, 0x9f,
+	0x6b, 0xc0, 0x28, 0xfa, 0x50, 0x1b, 0x54, 0x24, 0x9d, 0xe8, 0xa3, 0xb9, 0x06, 0x8c, 0xa2, 0xdd,
+	0xbd, 0x13, 0xf1, 0x9f, 0x33, 0xd9, 0x57, 0x12, 0x77, 0xa1, 0xf5, 0x6d, 0x18, 0x8b, 0x67, 0x05,
+	0xa0, 0x2d, 0xc9, 0x15, 0xd5, 0x70, 0x0f, 0x16, 0xbe, 0x0a, 0x7d, 0x3f, 0x7c, 0x4d, 0x22, 0x54,
+	0xc7, 0x8b, 0xd0, 0x79, 0x4a, 0xdc, 0x88, 0xbf, 0x3e, 0x8d, 0xbd, 0x23, 0x58, 0x2e, 0x10, 0x0b,
+	0x6e, 0x43, 0xfd, 0x3c, 0x40, 0xf7, 0x38, 0xdc, 0xb3, 0x30, 0x3e, 0x0f, 0x50, 0x8d, 0xc3, 0x9d,
+	0xbd, 0xf1, 0x58, 0xcc, 0x50, 0x1d, 0xf7, 0xa1, 0xfb, 0x2c, 0x8c, 0xd5, 0xb0, 0x71, 0x8c, 0x7e,
+	0xf8, 0x69, 0xeb, 0xde, 0xf7, 0x6f, 0xb7, 0x6a, 0x3f, 0xbc, 0xdd, 0xaa, 0xfd, 0xe7, 0xed, 0x56,
+	0x6d, 0xd4, 0x16, 0x7f, 0xb0, 0xf2, 0xf0, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0x72, 0xce, 0xe2,
+	0xff, 0x43, 0x23, 0x00, 0x00,
 }
 
 func (m *Request) Marshal() (dAtA []byte, err error) {
@@ -3892,7 +3892,7 @@ func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x6a
 	{
-		size, err := m.GetDestorying.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.GetDestroying.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -3902,7 +3902,7 @@ func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x62
 	{
-		size, err := m.ReportDestoryed.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.ReportDestroyed.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -3912,7 +3912,7 @@ func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x5a
 	{
-		size, err := m.CreateDestorying.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.CreateDestroying.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4152,7 +4152,7 @@ func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x72
 	{
-		size, err := m.GetDestorying.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.GetDestroying.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4162,7 +4162,7 @@ func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x6a
 	{
-		size, err := m.ReportDestoryed.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.ReportDestroyed.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4172,7 +4172,7 @@ func (m *Response) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i--
 	dAtA[i] = 0x62
 	{
-		size, err := m.CreateDestorying.MarshalToSizedBuffer(dAtA[:i])
+		size, err := m.CreateDestroying.MarshalToSizedBuffer(dAtA[:i])
 		if err != nil {
 			return 0, err
 		}
@@ -4393,9 +4393,9 @@ func (m *ResourceHeartbeatRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 		i -= len(m.XXX_unrecognized)
 		copy(dAtA[i:], m.XXX_unrecognized)
 	}
-	if m.DestoryDirectly {
+	if m.DestroyDirectly {
 		i--
-		if m.DestoryDirectly {
+		if m.DestroyDirectly {
 			dAtA[i] = 1
 		} else {
 			dAtA[i] = 0
@@ -4856,7 +4856,7 @@ func (m *AskBatchSplitRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *CreateDestoryingReq) Marshal() (dAtA []byte, err error) {
+func (m *CreateDestroyingReq) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4866,12 +4866,12 @@ func (m *CreateDestoryingReq) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *CreateDestoryingReq) MarshalTo(dAtA []byte) (int, error) {
+func (m *CreateDestroyingReq) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *CreateDestoryingReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *CreateDestroyingReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -4921,7 +4921,7 @@ func (m *CreateDestoryingReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *CreateDestoryingRsp) Marshal() (dAtA []byte, err error) {
+func (m *CreateDestroyingRsp) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4931,12 +4931,12 @@ func (m *CreateDestoryingRsp) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *CreateDestoryingRsp) MarshalTo(dAtA []byte) (int, error) {
+func (m *CreateDestroyingRsp) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *CreateDestoryingRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *CreateDestroyingRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -4953,7 +4953,7 @@ func (m *CreateDestoryingRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *GetDestoryingReq) Marshal() (dAtA []byte, err error) {
+func (m *GetDestroyingReq) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4963,12 +4963,12 @@ func (m *GetDestoryingReq) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *GetDestoryingReq) MarshalTo(dAtA []byte) (int, error) {
+func (m *GetDestroyingReq) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *GetDestoryingReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *GetDestroyingReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -4985,7 +4985,7 @@ func (m *GetDestoryingReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *GetDestoryingRsp) Marshal() (dAtA []byte, err error) {
+func (m *GetDestroyingRsp) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -4995,12 +4995,12 @@ func (m *GetDestoryingRsp) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *GetDestoryingRsp) MarshalTo(dAtA []byte) (int, error) {
+func (m *GetDestroyingRsp) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *GetDestoryingRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *GetDestroyingRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -5024,7 +5024,7 @@ func (m *GetDestoryingRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *ReportDestoryedReq) Marshal() (dAtA []byte, err error) {
+func (m *ReportDestroyedReq) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5034,12 +5034,12 @@ func (m *ReportDestoryedReq) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ReportDestoryedReq) MarshalTo(dAtA []byte) (int, error) {
+func (m *ReportDestroyedReq) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ReportDestoryedReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ReportDestroyedReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -5061,7 +5061,7 @@ func (m *ReportDestoryedReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
-func (m *ReportDestoryedRsp) Marshal() (dAtA []byte, err error) {
+func (m *ReportDestroyedRsp) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
 	n, err := m.MarshalToSizedBuffer(dAtA[:size])
@@ -5071,12 +5071,12 @@ func (m *ReportDestoryedRsp) Marshal() (dAtA []byte, err error) {
 	return dAtA[:n], nil
 }
 
-func (m *ReportDestoryedRsp) MarshalTo(dAtA []byte) (int, error) {
+func (m *ReportDestroyedRsp) MarshalTo(dAtA []byte) (int, error) {
 	size := m.Size()
 	return m.MarshalToSizedBuffer(dAtA[:size])
 }
 
-func (m *ReportDestoryedRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+func (m *ReportDestroyedRsp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	i := len(dAtA)
 	_ = i
 	var l int
@@ -6522,11 +6522,11 @@ func (m *Request) Size() (n int) {
 	n += 1 + l + sovRpcpb(uint64(l))
 	l = m.AskBatchSplit.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
-	l = m.CreateDestorying.Size()
+	l = m.CreateDestroying.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
-	l = m.ReportDestoryed.Size()
+	l = m.ReportDestroyed.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
-	l = m.GetDestorying.Size()
+	l = m.GetDestroying.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
 	l = m.CreateWatcher.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
@@ -6588,11 +6588,11 @@ func (m *Response) Size() (n int) {
 	n += 1 + l + sovRpcpb(uint64(l))
 	l = m.AskBatchSplit.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
-	l = m.CreateDestorying.Size()
+	l = m.CreateDestroying.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
-	l = m.ReportDestoryed.Size()
+	l = m.ReportDestroyed.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
-	l = m.GetDestorying.Size()
+	l = m.GetDestroying.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
 	l = m.Event.Size()
 	n += 1 + l + sovRpcpb(uint64(l))
@@ -6701,7 +6701,7 @@ func (m *ResourceHeartbeatRsp) Size() (n int) {
 		l = m.ConfigChangeV2.Size()
 		n += 1 + l + sovRpcpb(uint64(l))
 	}
-	if m.DestoryDirectly {
+	if m.DestroyDirectly {
 		n += 2
 	}
 	if m.XXX_unrecognized != nil {
@@ -6875,7 +6875,7 @@ func (m *AskBatchSplitRsp) Size() (n int) {
 	return n
 }
 
-func (m *CreateDestoryingReq) Size() (n int) {
+func (m *CreateDestroyingReq) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6903,7 +6903,7 @@ func (m *CreateDestoryingReq) Size() (n int) {
 	return n
 }
 
-func (m *CreateDestoryingRsp) Size() (n int) {
+func (m *CreateDestroyingRsp) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6918,7 +6918,7 @@ func (m *CreateDestoryingRsp) Size() (n int) {
 	return n
 }
 
-func (m *GetDestoryingReq) Size() (n int) {
+func (m *GetDestroyingReq) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6933,7 +6933,7 @@ func (m *GetDestoryingReq) Size() (n int) {
 	return n
 }
 
-func (m *GetDestoryingRsp) Size() (n int) {
+func (m *GetDestroyingRsp) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6949,7 +6949,7 @@ func (m *GetDestoryingRsp) Size() (n int) {
 	return n
 }
 
-func (m *ReportDestoryedReq) Size() (n int) {
+func (m *ReportDestroyedReq) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -6967,7 +6967,7 @@ func (m *ReportDestoryedReq) Size() (n int) {
 	return n
 }
 
-func (m *ReportDestoryedRsp) Size() (n int) {
+func (m *ReportDestroyedRsp) Size() (n int) {
 	if m == nil {
 		return 0
 	}
@@ -7893,7 +7893,7 @@ func (m *Request) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 10:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CreateDestorying", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateDestroying", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7920,13 +7920,13 @@ func (m *Request) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.CreateDestorying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.CreateDestroying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 11:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReportDestoryed", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ReportDestroyed", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7953,13 +7953,13 @@ func (m *Request) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.ReportDestoryed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.ReportDestroyed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 12:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GetDestorying", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field GetDestroying", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -7986,7 +7986,7 @@ func (m *Request) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.GetDestorying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.GetDestroying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -8706,7 +8706,7 @@ func (m *Response) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 11:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field CreateDestorying", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateDestroying", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8733,13 +8733,13 @@ func (m *Response) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.CreateDestorying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.CreateDestroying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 12:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field ReportDestoryed", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field ReportDestroyed", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8766,13 +8766,13 @@ func (m *Response) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.ReportDestoryed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.ReportDestroyed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
 		case 13:
 			if wireType != 2 {
-				return fmt.Errorf("proto: wrong wireType = %d for field GetDestorying", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field GetDestroying", wireType)
 			}
 			var msglen int
 			for shift := uint(0); ; shift += 7 {
@@ -8799,7 +8799,7 @@ func (m *Response) Unmarshal(dAtA []byte) error {
 			if postIndex > l {
 				return io.ErrUnexpectedEOF
 			}
-			if err := m.GetDestorying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+			if err := m.GetDestroying.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 				return err
 			}
 			iNdEx = postIndex
@@ -9779,7 +9779,7 @@ func (m *ResourceHeartbeatRsp) Unmarshal(dAtA []byte) error {
 			iNdEx = postIndex
 		case 9:
 			if wireType != 0 {
-				return fmt.Errorf("proto: wrong wireType = %d for field DestoryDirectly", wireType)
+				return fmt.Errorf("proto: wrong wireType = %d for field DestroyDirectly", wireType)
 			}
 			var v int
 			for shift := uint(0); ; shift += 7 {
@@ -9796,7 +9796,7 @@ func (m *ResourceHeartbeatRsp) Unmarshal(dAtA []byte) error {
 					break
 				}
 			}
-			m.DestoryDirectly = bool(v != 0)
+			m.DestroyDirectly = bool(v != 0)
 		default:
 			iNdEx = preIndex
 			skippy, err := skipRpcpb(dAtA[iNdEx:])
@@ -10693,7 +10693,7 @@ func (m *AskBatchSplitRsp) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CreateDestoryingReq) Unmarshal(dAtA []byte) error {
+func (m *CreateDestroyingReq) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10716,10 +10716,10 @@ func (m *CreateDestoryingReq) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CreateDestoryingReq: wiretype end group for non-group")
+			return fmt.Errorf("proto: CreateDestroyingReq: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CreateDestoryingReq: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CreateDestroyingReq: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -10878,7 +10878,7 @@ func (m *CreateDestoryingReq) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *CreateDestoryingRsp) Unmarshal(dAtA []byte) error {
+func (m *CreateDestroyingRsp) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10901,10 +10901,10 @@ func (m *CreateDestoryingRsp) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: CreateDestoryingRsp: wiretype end group for non-group")
+			return fmt.Errorf("proto: CreateDestroyingRsp: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: CreateDestoryingRsp: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: CreateDestroyingRsp: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -10948,7 +10948,7 @@ func (m *CreateDestoryingRsp) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetDestoryingReq) Unmarshal(dAtA []byte) error {
+func (m *GetDestroyingReq) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -10971,10 +10971,10 @@ func (m *GetDestoryingReq) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetDestoryingReq: wiretype end group for non-group")
+			return fmt.Errorf("proto: GetDestroyingReq: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetDestoryingReq: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: GetDestroyingReq: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -11018,7 +11018,7 @@ func (m *GetDestoryingReq) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *GetDestoryingRsp) Unmarshal(dAtA []byte) error {
+func (m *GetDestroyingRsp) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11041,10 +11041,10 @@ func (m *GetDestoryingRsp) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: GetDestoryingRsp: wiretype end group for non-group")
+			return fmt.Errorf("proto: GetDestroyingRsp: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: GetDestoryingRsp: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: GetDestroyingRsp: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -11105,7 +11105,7 @@ func (m *GetDestoryingRsp) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ReportDestoryedReq) Unmarshal(dAtA []byte) error {
+func (m *ReportDestroyedReq) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11128,10 +11128,10 @@ func (m *ReportDestoryedReq) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ReportDestoryedReq: wiretype end group for non-group")
+			return fmt.Errorf("proto: ReportDestroyedReq: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ReportDestoryedReq: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ReportDestroyedReq: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
@@ -11194,7 +11194,7 @@ func (m *ReportDestoryedReq) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
-func (m *ReportDestoryedRsp) Unmarshal(dAtA []byte) error {
+func (m *ReportDestroyedRsp) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
 	for iNdEx < l {
@@ -11217,10 +11217,10 @@ func (m *ReportDestoryedRsp) Unmarshal(dAtA []byte) error {
 		fieldNum := int32(wire >> 3)
 		wireType := int(wire & 0x7)
 		if wireType == 4 {
-			return fmt.Errorf("proto: ReportDestoryedRsp: wiretype end group for non-group")
+			return fmt.Errorf("proto: ReportDestroyedRsp: wiretype end group for non-group")
 		}
 		if fieldNum <= 0 {
-			return fmt.Errorf("proto: ReportDestoryedRsp: illegal tag %d (wire type %d)", fieldNum, wire)
+			return fmt.Errorf("proto: ReportDestroyedRsp: illegal tag %d (wire type %d)", fieldNum, wire)
 		}
 		switch fieldNum {
 		case 1:
diff --git a/components/prophet/pb/rpcpb/rpcpb.proto b/components/prophet/pb/rpcpb/rpcpb.proto
index 2593b84..2617955 100644
--- a/components/prophet/pb/rpcpb/rpcpb.proto
+++ b/components/prophet/pb/rpcpb/rpcpb.proto
@@ -24,12 +24,12 @@ enum Type {
 	TypeAllocIDRsp            = 10;
     TypeAskBatchSplitReq      = 11;
 	TypeAskBatchSplitRsp      = 12;
-    TypeCreateDestoryingReq   = 13;
-    TypeCreateDestoryingRsp   = 14;
-    TypeReportDestoryedReq   = 15;
-    TypeReportDestoryedRsp   = 16;
-    TypeGetDestoryingReq      = 17;
-	TypeGetDestoryingRsp      = 18;
+    TypeCreateDestroyingReq   = 13;
+    TypeCreateDestroyingRsp   = 14;
+    TypeReportDestroyedReq   = 15;
+    TypeReportDestroyedRsp   = 16;
+    TypeGetDestroyingReq      = 17;
+	TypeGetDestroyingRsp      = 18;
     TypeCreateWatcherReq      = 19;
     TypeEventNotify           = 20;
     TypeCreateResourcesReq    = 21;
@@ -65,9 +65,9 @@ message Request {
     GetContainerReq       getContainer       = 7  [(gogoproto.nullable) = false];
     AllocIDReq            allocID            = 8  [(gogoproto.nullable) = false];
     AskBatchSplitReq      askBatchSplit      = 9  [(gogoproto.nullable) = false];
-    CreateDestoryingReq   createDestorying   = 10 [(gogoproto.nullable) = false];
-    ReportDestoryedReq   ReportDestoryed   = 11 [(gogoproto.nullable) = false];
-    GetDestoryingReq      getDestorying      = 12 [(gogoproto.nullable) = false];
+    CreateDestroyingReq   createDestroying   = 10 [(gogoproto.nullable) = false];
+    ReportDestroyedReq   ReportDestroyed   = 11 [(gogoproto.nullable) = false];
+    GetDestroyingReq      getDestroying      = 12 [(gogoproto.nullable) = false];
     CreateWatcherReq      createWatcher      = 13 [(gogoproto.nullable) = false];
     CreateResourcesReq    createResources    = 14 [(gogoproto.nullable) = false];
     RemoveResourcesReq    removeResources    = 15 [(gogoproto.nullable) = false];
@@ -93,9 +93,9 @@ message Response {
     GetContainerRsp       getContainer       = 8  [(gogoproto.nullable) = false];
     AllocIDRsp            allocID            = 9  [(gogoproto.nullable) = false];
     AskBatchSplitRsp      askBatchSplit      = 10 [(gogoproto.nullable) = false];
-    CreateDestoryingRsp   createDestorying   = 11 [(gogoproto.nullable) = false];
-    ReportDestoryedRsp   ReportDestoryed   = 12 [(gogoproto.nullable) = false];
-    GetDestoryingRsp      getDestorying      = 13 [(gogoproto.nullable) = false];
+    CreateDestroyingRsp   createDestroying   = 11 [(gogoproto.nullable) = false];
+    ReportDestroyedRsp   ReportDestroyed   = 12 [(gogoproto.nullable) = false];
+    GetDestroyingRsp      getDestroying      = 13 [(gogoproto.nullable) = false];
     EventNotify           event              = 14 [(gogoproto.nullable) = false];
     CreateResourcesRsp    createResources    = 15 [(gogoproto.nullable) = false];
     RemoveResourcesRsp    removeResources    = 16 [(gogoproto.nullable) = false];
@@ -147,8 +147,8 @@ message ResourceHeartbeatRsp {
     Merge                merge           = 6;
     SplitResource        splitResource   = 7;
     ConfigChangeV2         configChangeV2    = 8;
-    // DestoryDirectly the resource has been removed, destory directly without raft.
-    bool                 destoryDirectly = 9;
+    // DestroyDirectly the resource has been removed, destroy directly without raft.
+    bool                 destroyDirectly = 9;
 }
 
 // PutContainerReq put container request
@@ -204,37 +204,37 @@ message AskBatchSplitRsp {
 }
 
 
-// CreateDestoryingReq create destorying status request
-message CreateDestoryingReq {
+// CreateDestroyingReq create destroying status request
+message CreateDestroyingReq {
     uint64            id        = 1 [(gogoproto.customname) = "ID"];
     uint64            index     = 2;
     repeated uint64 replicas    = 3;
     bool             removeData = 4;
 }
 
-// CreateDestoryingRsp create destorying status response
-message CreateDestoryingRsp {
+// CreateDestroyingRsp create destroying status response
+message CreateDestroyingRsp {
     metapb.ResourceState state = 1;
 }
 
-// GetDestoryingReq get destorying status request
-message GetDestoryingReq {
+// GetDestroyingReq get destroying status request
+message GetDestroyingReq {
     uint64            id        = 1 [(gogoproto.customname) = "ID"];
 }
 
-// GetDestoryingRsp get destorying status response
-message GetDestoryingRsp {
+// GetDestroyingRsp get destroying status response
+message GetDestroyingRsp {
     metapb.DestroyingStatus status = 1;
 }
 
-// ReportDestoryedReq report destroying request
-message ReportDestoryedReq {
+// ReportDestroyedReq report destroying request
+message ReportDestroyedReq {
     uint64            id        = 1 [(gogoproto.customname) = "ID"];
     uint64            replicaID = 2;
 }
 
-// ReportDestoryedRsp report destroying rsp
-message ReportDestoryedRsp {
+// ReportDestroyedRsp report destroying rsp
+message ReportDestroyedRsp {
     metapb.ResourceState state = 1;
 }
 
diff --git a/components/prophet/prophet_handler.go b/components/prophet/prophet_handler.go
index 5234e54..564f5e8 100755
--- a/components/prophet/prophet_handler.go
+++ b/components/prophet/prophet_handler.go
@@ -86,21 +86,21 @@ func (p *defaultProphet) handleRPCRequest(rs goetty.IOSession, data interface{},
 		if err != nil {
 			resp.Error = err.Error()
 		}
-	case rpcpb.TypeCreateDestoryingReq:
-		resp.Type = rpcpb.TypeCreateDestoryingRsp
-		err := p.handleCreateDestorying(rc, req, resp)
+	case rpcpb.TypeCreateDestroyingReq:
+		resp.Type = rpcpb.TypeCreateDestroyingRsp
+		err := p.handleCreateDestroying(rc, req, resp)
 		if err != nil {
 			resp.Error = err.Error()
 		}
-	case rpcpb.TypeReportDestoryedReq:
-		resp.Type = rpcpb.TypeReportDestoryedRsp
-		err := p.handleReportDestoryed(rc, req, resp)
+	case rpcpb.TypeReportDestroyedReq:
+		resp.Type = rpcpb.TypeReportDestroyedRsp
+		err := p.handleReportDestroyed(rc, req, resp)
 		if err != nil {
 			resp.Error = err.Error()
 		}
-	case rpcpb.TypeGetDestoryingReq:
-		resp.Type = rpcpb.TypeGetDestoryingRsp
-		err := p.handleGetDestorying(rc, req, resp)
+	case rpcpb.TypeGetDestroyingReq:
+		resp.Type = rpcpb.TypeGetDestroyingRsp
+		err := p.handleGetDestroying(rc, req, resp)
 		if err != nil {
 			resp.Error = err.Error()
 		}
@@ -284,30 +284,30 @@ func (p *defaultProphet) handleContainerHeartbeat(rc *cluster.RaftCluster, req *
 	return nil
 }
 
-func (p *defaultProphet) handleCreateDestorying(rc *cluster.RaftCluster, req *rpcpb.Request, resp *rpcpb.Response) error {
-	state, err := rc.HandleCreateDestorying(req.CreateDestorying)
+func (p *defaultProphet) handleCreateDestroying(rc *cluster.RaftCluster, req *rpcpb.Request, resp *rpcpb.Response) error {
+	state, err := rc.HandleCreateDestroying(req.CreateDestroying)
 	if err != nil {
 		return err
 	}
-	resp.CreateDestorying.State = state
+	resp.CreateDestroying.State = state
 	return nil
 }
 
-func (p *defaultProphet) handleGetDestorying(rc *cluster.RaftCluster, req *rpcpb.Request, resp *rpcpb.Response) error {
-	status, err := rc.HandleGetDestorying(req.GetDestorying)
+func (p *defaultProphet) handleGetDestroying(rc *cluster.RaftCluster, req *rpcpb.Request, resp *rpcpb.Response) error {
+	status, err := rc.HandleGetDestroying(req.GetDestroying)
 	if err != nil {
 		return err
 	}
-	resp.GetDestorying.Status = status
+	resp.GetDestroying.Status = status
 	return nil
 }
 
-func (p *defaultProphet) handleReportDestoryed(rc *cluster.RaftCluster, req *rpcpb.Request, resp *rpcpb.Response) error {
-	state, err := rc.HandleReportDestoryed(req.ReportDestoryed)
+func (p *defaultProphet) handleReportDestroyed(rc *cluster.RaftCluster, req *rpcpb.Request, resp *rpcpb.Response) error {
+	state, err := rc.HandleReportDestroyed(req.ReportDestroyed)
 	if err != nil {
 		return err
 	}
-	resp.ReportDestoryed.State = state
+	resp.ReportDestroyed.State = state
 	return nil
 }
 
diff --git a/components/prophet/schedule/operator/step.go b/components/prophet/schedule/operator/step.go
index 10cb864..efb0483 100644
--- a/components/prophet/schedule/operator/step.go
+++ b/components/prophet/schedule/operator/step.go
@@ -789,29 +789,29 @@ func (cpl ChangePeerV2Leave) CheckSafety(res *core.CachedResource) error {
 // Influence calculates the container difference that current step makes.
 func (cpl ChangePeerV2Leave) Influence(opInfluence OpInfluence, res *core.CachedResource) {}
 
-// DestoryDirectly is an OpStep that destory current peer directly without raft.
-type DestoryDirectly struct {
+// DestroyDirectly is an OpStep that destroy current peer directly without raft.
+type DestroyDirectly struct {
 }
 
 // ConfVerChanged returns the delta value for version increased by this step.
-func (tl DestoryDirectly) ConfVerChanged(res *core.CachedResource) uint64 {
+func (tl DestroyDirectly) ConfVerChanged(res *core.CachedResource) uint64 {
 	return 0 // RemoveDirectly never change the conf version
 }
 
-func (tl DestoryDirectly) String() string {
-	return "destory peer directly"
+func (tl DestroyDirectly) String() string {
+	return "destroy peer directly"
 }
 
 // IsFinish checks if current step is finished.
-func (tl DestoryDirectly) IsFinish(res *core.CachedResource) bool {
+func (tl DestroyDirectly) IsFinish(res *core.CachedResource) bool {
 	return true
 }
 
 // CheckSafety checks if the step meets the safety properties.
-func (tl DestoryDirectly) CheckSafety(res *core.CachedResource) error {
+func (tl DestroyDirectly) CheckSafety(res *core.CachedResource) error {
 	return nil
 }
 
 // Influence calculates the container difference that current step makes.
-func (tl DestoryDirectly) Influence(opInfluence OpInfluence, res *core.CachedResource) {
+func (tl DestroyDirectly) Influence(opInfluence OpInfluence, res *core.CachedResource) {
 }
diff --git a/components/prophet/schedule/operator_controller.go b/components/prophet/schedule/operator_controller.go
index e762336..8c7264c 100644
--- a/components/prophet/schedule/operator_controller.go
+++ b/components/prophet/schedule/operator_controller.go
@@ -98,10 +98,10 @@ func (oc *OperatorController) GetCluster() opt.Cluster {
 	return oc.cluster
 }
 
-// DispatchDestoryDirectly send DestoryDirect cmd to the current container, because
+// DispatchDestroyDirectly send DestroyDirect cmd to the current container, because
 // the resource has been removed.
-func (oc *OperatorController) DispatchDestoryDirectly(res *core.CachedResource, source string) {
-	oc.SendScheduleCommand(res, operator.DestoryDirectly{}, source)
+func (oc *OperatorController) DispatchDestroyDirectly(res *core.CachedResource, source string) {
+	oc.SendScheduleCommand(res, operator.DestroyDirectly{}, source)
 }
 
 // Dispatch is used to dispatch the operator of a resource.
@@ -618,9 +618,9 @@ func (oc *OperatorController) SendScheduleCommand(res *core.CachedResource, step
 
 	var cmd *rpcpb.ResourceHeartbeatRsp
 	switch st := step.(type) {
-	case operator.DestoryDirectly:
+	case operator.DestroyDirectly:
 		cmd = &rpcpb.ResourceHeartbeatRsp{
-			DestoryDirectly: true,
+			DestroyDirectly: true,
 		}
 	case operator.TransferLeader:
 		p, _ := res.GetContainerPeer(st.ToContainer)
diff --git a/components/prophet/schedulers/balance_resource.go b/components/prophet/schedulers/balance_resource.go
index 06095e7..24e263f 100644
--- a/components/prophet/schedulers/balance_resource.go
+++ b/components/prophet/schedulers/balance_resource.go
@@ -227,7 +227,7 @@ func (s *balanceResourceScheduler) scheduleByGroup(groupKey string, cluster opt.
 					rebalanceResourceField,
 					s.scheduleField,
 					resourceField(res.Meta.ID()))
-				schedulerCounter.WithLabelValues(s.GetName(), "destory").Inc()
+				schedulerCounter.WithLabelValues(s.GetName(), "destroy").Inc()
 				continue
 			}
 
diff --git a/raftstore/prophet_adapter.go b/raftstore/prophet_adapter.go
index a79bf5a..a555eb5 100644
--- a/raftstore/prophet_adapter.go
+++ b/raftstore/prophet_adapter.go
@@ -505,7 +505,7 @@ func (s *store) startHandleResourceHeartbeat() {
 }
 
 func (s *store) doResourceHeartbeatRsp(rsp rpcpb.ResourceHeartbeatRsp) {
-	if rsp.DestoryDirectly {
+	if rsp.DestroyDirectly {
 		s.destroyReplica(rsp.ResourceID, true, true, "remove by pd")
 		return
 	}
diff --git a/raftstore/replica.go b/raftstore/replica.go
index 9d4cf64..b0d290a 100644
--- a/raftstore/replica.go
+++ b/raftstore/replica.go
@@ -106,8 +106,8 @@ type replica struct {
 	// lastCommittedIndex last committed log
 	lastCommittedIndex uint64
 
-	destoryTaskFactory destroyReplicaTaskFactory
-	destoryTaskMu      struct {
+	destroyTaskFactory destroyReplicaTaskFactory
+	destroyTaskMu      struct {
 		sync.Mutex
 		hasTask bool
 		reason  string
@@ -179,7 +179,7 @@ func newReplica(store *store, shard Shard, r Replica, reason string) (*replica,
 		func() *replicaCreator {
 			return newReplicaCreator(store)
 		})
-	pr.destoryTaskFactory = newDefaultDestroyReplicaTaskFactory(pr.addAction,
+	pr.destroyTaskFactory = newDefaultDestroyReplicaTaskFactory(pr.addAction,
 		pr.prophetClient, defaultCheckInterval)
 	return pr, nil
 }
diff --git a/raftstore/replica_apply_result.go b/raftstore/replica_apply_result.go
index dbe3099..7f7ed0c 100644
--- a/raftstore/replica_apply_result.go
+++ b/raftstore/replica_apply_result.go
@@ -213,7 +213,7 @@ func (pr *replica) applyConfChange(cp configChangeResult) {
 }
 
 func (pr *replica) applySplit(result splitResult) {
-	pr.logger.Info("shard split applied, current shard will destory",
+	pr.logger.Info("shard split applied, current shard will destroy",
 		zap.Int("new-shards-count", len(result.newShards)))
 
 	if ce := pr.logger.Check(zap.DebugLevel, "shard split detail"); ce != nil {
@@ -257,5 +257,5 @@ func (pr *replica) applySplit(result splitResult) {
 		pr.aware.Splited(pr.getShard())
 	}
 
-	pr.startDestoryReplicaTaskAfterSplitted(pr.appliedIndex)
+	pr.startDestroyReplicaTaskAfterSplitted(pr.appliedIndex)
 }
diff --git a/raftstore/replica_destroy.go b/raftstore/replica_destroy.go
index d1459ee..134a0ef 100644
--- a/raftstore/replica_destroy.go
+++ b/raftstore/replica_destroy.go
@@ -58,7 +58,7 @@ func (csp *createShardsProtector) addDestroyed(id uint64) {
 	csp.destroyedShards.Add(id)
 }
 
-func (csp *createShardsProtector) inDestoryState(id uint64) bool {
+func (csp *createShardsProtector) inDestroyState(id uint64) bool {
 	csp.RLock()
 	defer csp.RUnlock()
 
@@ -147,7 +147,7 @@ func (s *store) vacuum(t vacuumTask) error {
 }
 
 func (pr *replica) destroy(shardRemoved bool, reason string) error {
-	pr.logger.Info("begin to destory",
+	pr.logger.Info("begin to destroy",
 		zap.Bool("shard-removed", shardRemoved),
 		log.ShardField("metadata", pr.getShard()),
 		log.ReasonField(reason))
diff --git a/raftstore/replica_destory_task.go b/raftstore/replica_destroy_task.go
similarity index 84%
rename from raftstore/replica_destory_task.go
rename to raftstore/replica_destroy_task.go
index 491dfab..193a7d1 100644
--- a/raftstore/replica_destory_task.go
+++ b/raftstore/replica_destroy_task.go
@@ -40,32 +40,32 @@ type destroyingStorage interface {
 	GetDestroying(shardID uint64) (*metapb.DestroyingStatus, error)
 }
 
-// startDestoryReplicaTaskAfterSplitted starts a task used to destory old replicas. We cannot directly delete the current replica,
+// startDestroyReplicaTaskAfterSplitted starts a task used to destroy old replicas. We cannot directly delete the current replica,
 // because once deleted, it may result in some Replica not receiving Split's Log.
 // So we start a timer that periodically detects the replication of the Log, and once all the Replica are replicated,
 // set the condition on `Prophet` that the Shard can be deleted (AppliedIndex >= SplitLogIndex).
-func (pr *replica) startDestoryReplicaTaskAfterSplitted(splitRequestLogIndex uint64) {
-	pr.startDestoryReplicaTask(splitRequestLogIndex, false, "splitted")
+func (pr *replica) startDestroyReplicaTaskAfterSplitted(splitRequestLogIndex uint64) {
+	pr.startDestroyReplicaTask(splitRequestLogIndex, false, "splitted")
 }
 
-// startDestoryReplicaTask starts a task to destory all replicas of the shard after the specified Log applied.
-func (pr *replica) startDestoryReplicaTask(targetIndex uint64, removeData bool, reason string) {
-	pr.destoryTaskMu.Lock()
-	defer pr.destoryTaskMu.Unlock()
+// startDestroyReplicaTask starts a task to destroy all replicas of the shard after the specified Log applied.
+func (pr *replica) startDestroyReplicaTask(targetIndex uint64, removeData bool, reason string) {
+	pr.destroyTaskMu.Lock()
+	defer pr.destroyTaskMu.Unlock()
 
-	if pr.destoryTaskMu.hasTask {
-		pr.logger.Error("async task for destory replica already started",
+	if pr.destroyTaskMu.hasTask {
+		pr.logger.Error("async task for destroy replica already started",
 			log.ReasonField(reason),
-			zap.String("last-reason", pr.destoryTaskMu.reason),
+			zap.String("last-reason", pr.destroyTaskMu.reason),
 			destroyShardTaskField)
 		return
 	}
 
-	pr.destoryTaskMu.hasTask = true
-	pr.destoryTaskMu.reason = reason
-	task := pr.destoryTaskFactory.new(pr, targetIndex, removeData, reason)
+	pr.destroyTaskMu.hasTask = true
+	pr.destroyTaskMu.reason = reason
+	task := pr.destroyTaskFactory.new(pr, targetIndex, removeData, reason)
 	if err := pr.readStopper.RunNamedTask(context.Background(), reason, task.run); err != nil {
-		pr.logger.Error("failed to start async task for destory replica",
+		pr.logger.Error("failed to start async task for destroy replica",
 			zap.Error(err))
 	}
 }
@@ -111,8 +111,8 @@ type defaultDestroyReplicaTask struct {
 	doCheckApply         bool
 	checkInterval        time.Duration
 	checkTimer           *time.Timer
-	doSaveDestoryC       chan []uint64
-	doRealDestoryC       chan struct{}
+	doSaveDestroyC       chan []uint64
+	doRealDestroyC       chan struct{}
 }
 
 func newDestroyReplicaTask(pr *replica, targetIndex uint64,
@@ -131,14 +131,14 @@ func newDestroyReplicaTask(pr *replica, targetIndex uint64,
 		doCheckDestroyExists: true,
 		doCheckLog:           false,
 		doCheckApply:         false,
-		doSaveDestoryC:       make(chan []uint64, 1),
-		doRealDestoryC:       make(chan struct{}, 1),
+		doSaveDestroyC:       make(chan []uint64, 1),
+		doRealDestroyC:       make(chan struct{}, 1),
 		checkInterval:        checkInterval,
 		checkTimer:           time.NewTimer(checkInterval),
 	}
 }
 
-// destoryReplicaAfterLogApplied this task will be executed on all Replicas of a Shard. The task has 4 steps:
+// destroyReplicaAfterLogApplied this task will be executed on all Replicas of a Shard. The task has 4 steps:
 // 1. Periodically check all replicas for CommitIndex >= TargetIndex
 // 2. Put the check result into storage
 // 3. Periodically check all replicas for AppliedIndex >= TargetIndex
@@ -157,7 +157,7 @@ func (t *defaultDestroyReplicaTask) run(ctx context.Context) {
 		case <-ctx.Done():
 			return
 		case <-t.checkTimer.C:
-			// we need check the destory record exist if restart.
+			// we need check the destroy record exist if restart.
 			t.maybeCheckDestroyExists()
 			// step 1
 			t.maybeCheckLog()
@@ -165,14 +165,14 @@ func (t *defaultDestroyReplicaTask) run(ctx context.Context) {
 			t.maybeCheckTargetLogApplied()
 
 			t.checkTimer.Reset(t.checkInterval)
-		case replicas := <-t.doSaveDestoryC: // step 2
+		case replicas := <-t.doSaveDestroyC: // step 2
 			// leader path, only leader node can reach here.
 			// Reaching here means that all Replicas of the Shard have completed the log replication of
 			// the TargetIndex and have been Committed.
-			// Only if the Destoryed information corresponding to the Shard is set in storage, all replicas
+			// Only if the Destroyed information corresponding to the Shard is set in storage, all replicas
 			// can be safely deleted.
 			t.createDestroying(replicas)
-		case <-t.doRealDestoryC: // step 4
+		case <-t.doRealDestroyC: // step 4
 			if t.performDestroy() {
 				return
 			}
@@ -182,15 +182,15 @@ func (t *defaultDestroyReplicaTask) run(ctx context.Context) {
 
 func (t *defaultDestroyReplicaTask) close() {
 	t.checkTimer.Stop()
-	close(t.doSaveDestoryC)
-	close(t.doRealDestoryC)
+	close(t.doSaveDestroyC)
+	close(t.doRealDestroyC)
 }
 
 func (t *defaultDestroyReplicaTask) maybeCheckDestroyExists() {
 	if t.doCheckDestroyExists {
 		status, err := t.ds.GetDestroying(t.pr.shardID)
 		if err != nil {
-			t.pr.logger.Error("failed to get shard destory metadata, retry later",
+			t.pr.logger.Error("failed to get shard destroy metadata, retry later",
 				destroyShardTaskField,
 				zap.Error(err))
 			t.watiToRetry()
@@ -198,7 +198,7 @@ func (t *defaultDestroyReplicaTask) maybeCheckDestroyExists() {
 		}
 
 		if status == nil {
-			// no destorying record exists means we need check log committed info, start step 1
+			// no destroying record exists means we need check log committed info, start step 1
 			t.doCheckLog = true
 			t.pr.logger.Debug("begin to check log committed",
 				destroyShardTaskField)
@@ -224,7 +224,7 @@ func (t *defaultDestroyReplicaTask) maybeCheckLog() {
 			actionType:  checkLogCommittedAction,
 			targetIndex: t.targetIndex,
 			actionCallback: func(replicas interface{}) {
-				t.doSaveDestoryC <- replicas.([]uint64)
+				t.doSaveDestroyC <- replicas.([]uint64)
 				t.pr.logger.Debug("log committed on all replicas",
 					destroyShardTaskField)
 			},
@@ -237,12 +237,12 @@ func (t *defaultDestroyReplicaTask) createDestroying(replicas []uint64) {
 
 	_, err := t.ds.CreateDestroying(t.pr.shardID, t.targetIndex, t.removeData, replicas)
 	if err != nil {
-		t.pr.logger.Error("failed to save replica destory metadata, retry later",
+		t.pr.logger.Error("failed to save replica destroy metadata, retry later",
 			destroyShardTaskField,
 			zap.Error(err))
 		t.watiToRetry()
 		select {
-		case t.doSaveDestoryC <- replicas: // retry
+		case t.doSaveDestroyC <- replicas: // retry
 		default:
 		}
 		return
@@ -250,7 +250,7 @@ func (t *defaultDestroyReplicaTask) createDestroying(replicas []uint64) {
 
 	t.doCheckApply = true
 	t.doCheckDestroyExists = false
-	t.pr.logger.Debug("destory metadata saved",
+	t.pr.logger.Debug("destroy metadata saved",
 		destroyShardTaskField)
 }
 
@@ -261,7 +261,7 @@ func (t *defaultDestroyReplicaTask) performDestroy() bool {
 			zap.Error(err))
 		t.watiToRetry()
 		select {
-		case t.doRealDestoryC <- struct{}{}: // retry
+		case t.doRealDestroyC <- struct{}{}: // retry
 		default:
 		}
 		return false
@@ -279,7 +279,7 @@ func (t *defaultDestroyReplicaTask) maybeCheckTargetLogApplied() {
 			actionType:  checkLogAppliedAction,
 			targetIndex: t.targetIndex,
 			actionCallback: func(i interface{}) {
-				t.doRealDestoryC <- struct{}{}
+				t.doRealDestroyC <- struct{}{}
 				t.pr.logger.Debug("log applied",
 					destroyShardTaskField)
 			},
diff --git a/raftstore/store.go b/raftstore/store.go
index 12f8390..dae91b8 100644
--- a/raftstore/store.go
+++ b/raftstore/store.go
@@ -419,7 +419,7 @@ func (s *store) startShards() {
 
 	var tomebstones []Shard
 	shards := make(map[uint64]Shard)
-	localDestoryings := make(map[uint64]meta.ShardMetadata)
+	localDestroyings := make(map[uint64]meta.ShardMetadata)
 	confirmShards := roaring64.New()
 	s.cfg.Storage.ForeachDataStorageFunc(func(ds storage.DataStorage) {
 		initStates, err := ds.GetInitialStates()
@@ -455,7 +455,7 @@ func (s *store) startShards() {
 
 			if metadata.Metadata.Shard.State == metapb.ResourceState_Destroying {
 				s.createShardsProtector.addDestroyed(sls.Shard.ID)
-				localDestoryings[metadata.ShardID] = metadata
+				localDestroyings[metadata.ShardID] = metadata
 			} else {
 				confirmShards.Add(sls.Shard.ID)
 			}
@@ -492,8 +492,8 @@ func (s *store) startShards() {
 	newReplicaCreator(s).
 		withReason("restart").
 		withStartReplica(nil, func(r *replica) {
-			if metadata, ok := localDestoryings[r.shardID]; ok {
-				r.startDestoryReplicaTask(metadata.LogIndex, metadata.Metadata.RemoveData, "restart")
+			if metadata, ok := localDestroyings[r.shardID]; ok {
+				r.startDestroyReplicaTask(metadata.LogIndex, metadata.Metadata.RemoveData, "restart")
 			}
 		}).
 		create(readyBootstrapShards)
diff --git a/raftstore/store_handler.go b/raftstore/store_handler.go
index a9e8d3c..1adc881 100644
--- a/raftstore/store_handler.go
+++ b/raftstore/store_handler.go
@@ -125,7 +125,7 @@ func (s *store) tryToCreateReplicate(msg meta.RaftMessage) bool {
 		}
 	}
 
-	// If we found stale peer, we will destory it
+	// If we found stale peer, we will destroy it
 	if stalePeer.ID > 0 {
 		s.logger.Info("found stale peer, need to remove self replica",
 			s.storeField(),
@@ -174,7 +174,7 @@ func (s *store) tryToCreateReplicate(msg meta.RaftMessage) bool {
 		return false
 	}
 
-	if s.createShardsProtector.inDestoryState(msg.ShardID) {
+	if s.createShardsProtector.inDestroyState(msg.ShardID) {
 		s.logger.Debug("skip create replica",
 			s.storeField(),
 			log.ReasonField("shard in destroy state"),
diff --git a/raftstore/store_timer_task.go b/raftstore/store_timer_task.go
index 6ed9874..962b897 100644
--- a/raftstore/store_timer_task.go
+++ b/raftstore/store_timer_task.go
@@ -104,7 +104,7 @@ func (s *store) handleShardStateCheckTask() {
 				// the delete process.
 
 				// We don't known which log index destroy at and whether to remove data or not.
-				pr.startDestoryReplicaTask(0, false, "replicas state check")
+				pr.startDestroyReplicaTask(0, false, "replicas state check")
 			}
 		}
 	}
diff --git a/storage/kv/kv_base_storage.go b/storage/kv/kv_base_storage.go
index 4c3e35c..ddbdd1a 100644
--- a/storage/kv/kv_base_storage.go
+++ b/storage/kv/kv_base_storage.go
@@ -237,6 +237,9 @@ func (s *BaseStorage) ApplySnapshot(shardID uint64, path string) error {
 		return err
 	}
 	defer f.Close()
+	batch := s.kv.NewWriteBatch().(util.WriteBatch)
+	defer batch.Close()
+
 	start, err := readBytes(f)
 	if err != nil {
 		return err
@@ -267,15 +270,9 @@ func (s *BaseStorage) ApplySnapshot(shardID uint64, path string) error {
 	if err != nil {
 		return err
 	}
-	if err := s.kv.RangeDelete(start, end, false); err != nil {
-		return errors.Wrapf(err, "RangeDelete failed in ApplySnapshot")
-	}
-	if err := s.kv.Set(appliedIndexKey, appliedIndexValue, false); err != nil {
-		return err
-	}
-	if err := s.kv.Set(metadataKey, metadataValue, false); err != nil {
-		return err
-	}
+	batch.DeleteRange(start, end)
+	batch.Set(appliedIndexKey, appliedIndexValue)
+	batch.Set(metadataKey, metadataValue)
 
 	for {
 		key, err := readBytes(f)
@@ -292,9 +289,10 @@ func (s *BaseStorage) ApplySnapshot(shardID uint64, path string) error {
 		if len(value) == 0 {
 			panic("key specified without value")
 		}
-		if err := s.kv.Set(key, value, false); err != nil {
-			return err
-		}
+		batch.Set(key, value)
+	}
+	if err := s.kv.Write(batch, true); err != nil {
+		return err
 	}
 
 	return s.kv.Sync()


Test patch:
diff --git a/components/prophet/cluster/cluster_worker_test.go b/components/prophet/cluster/cluster_worker_test.go
index 9e6f00b..e9bd3f8 100644
--- a/components/prophet/cluster/cluster_worker_test.go
+++ b/components/prophet/cluster/cluster_worker_test.go
@@ -215,7 +215,7 @@ func TestResourceHeartbeatAtRemovedState(t *testing.T) {
 	assert.NoError(t, cluster.HandleResourceHeartbeat(resources[1]))
 	rsp := stream.Recv()
 	assert.NotNil(t, rsp)
-	assert.True(t, rsp.DestoryDirectly)
+	assert.True(t, rsp.DestroyDirectly)
 }
 
 func TestHandleCheckResourceState(t *testing.T) {
diff --git a/raftstore/integration_split_test.go b/raftstore/integration_split_test.go
index ba8bf81..b2085c5 100644
--- a/raftstore/integration_split_test.go
+++ b/raftstore/integration_split_test.go
@@ -112,7 +112,7 @@ func TestSplitWithCase1(t *testing.T) {
 	sid := c.GetShardByIndex(0, 0).ID
 	c.EveryStore(func(i int, s Store) {
 		pr := s.(*store).getReplica(sid, false)
-		pr.destoryTaskFactory = newTestDestroyReplicaTaskFactory(true) // skip destory task
+		pr.destroyTaskFactory = newTestDestroyReplicaTaskFactory(true) // skip destroy task
 	})
 
 	prepareSplit(t, c, nil, []int{3, 3, 3})
diff --git a/raftstore/replica_apply_result_test.go b/raftstore/replica_apply_result_test.go
index 7dff7e5..4a32042 100644
--- a/raftstore/replica_apply_result_test.go
+++ b/raftstore/replica_apply_result_test.go
@@ -45,7 +45,7 @@ func TestApplySplit(t *testing.T) {
 	s.droppedVoteMsgs.Store(uint64(2), meta.RaftMessage{})
 	s.droppedVoteMsgs.Store(uint64(3), meta.RaftMessage{})
 
-	pr.destoryTaskFactory = newTestDestroyReplicaTaskFactory(true)
+	pr.destroyTaskFactory = newTestDestroyReplicaTaskFactory(true)
 	pr.applySplit(result)
 	_, ok := s.droppedVoteMsgs.Load(uint64(2))
 	assert.False(t, ok)
diff --git a/raftstore/replica_destory_task_test.go b/raftstore/replica_destroy_task_test.go
similarity index 84%
rename from raftstore/replica_destory_task_test.go
rename to raftstore/replica_destroy_task_test.go
index bba1e08..a0bda26 100644
--- a/raftstore/replica_destory_task_test.go
+++ b/raftstore/replica_destroy_task_test.go
@@ -24,22 +24,22 @@ import (
 	"github.com/stretchr/testify/assert"
 )
 
-type testDestoryMetadataStorage struct {
+type testDestroyMetadataStorage struct {
 	sync.Mutex
 	data     map[uint64]*metapb.DestroyingStatus
 	c        chan struct{}
 	watchPut bool
 }
 
-func newTestDestoryMetadataStorage(watchPut bool) *testDestoryMetadataStorage {
-	return &testDestoryMetadataStorage{
+func newTestDestroyMetadataStorage(watchPut bool) *testDestroyMetadataStorage {
+	return &testDestroyMetadataStorage{
 		data:     make(map[uint64]*metapb.DestroyingStatus),
 		c:        make(chan struct{}),
 		watchPut: watchPut,
 	}
 }
 
-func (s *testDestoryMetadataStorage) CreateDestroying(shardID uint64, index uint64, removeData bool, replicas []uint64) (metapb.ResourceState, error) {
+func (s *testDestroyMetadataStorage) CreateDestroying(shardID uint64, index uint64, removeData bool, replicas []uint64) (metapb.ResourceState, error) {
 	s.Lock()
 	defer s.Unlock()
 
@@ -60,14 +60,14 @@ func (s *testDestoryMetadataStorage) CreateDestroying(shardID uint64, index uint
 	return metapb.ResourceState_Destroying, nil
 }
 
-func (s *testDestoryMetadataStorage) GetDestroying(shardID uint64) (*metapb.DestroyingStatus, error) {
+func (s *testDestroyMetadataStorage) GetDestroying(shardID uint64) (*metapb.DestroyingStatus, error) {
 	s.Lock()
 	defer s.Unlock()
 
 	return s.data[shardID], nil
 }
 
-func (s *testDestoryMetadataStorage) ReportDestroyed(shardID uint64, replicaID uint64) (metapb.ResourceState, error) {
+func (s *testDestroyMetadataStorage) ReportDestroyed(shardID uint64, replicaID uint64) (metapb.ResourceState, error) {
 	s.Lock()
 	defer s.Unlock()
 
@@ -91,20 +91,20 @@ func (s *testDestoryMetadataStorage) ReportDestroyed(shardID uint64, replicaID u
 	return status.State, nil
 }
 
-func TestDestoryTaskWithMultiTimes(t *testing.T) {
+func TestDestroyTaskWithMultiTimes(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 
 	s, cancel := newTestStore(t)
 	defer cancel()
 	pr := newTestReplica(Shard{ID: 1}, Replica{ID: 1}, s)
-	pr.destoryTaskMu.hasTask = true
-	pr.destoryTaskMu.reason = "1"
+	pr.destroyTaskMu.hasTask = true
+	pr.destroyTaskMu.reason = "1"
 
-	pr.startDestoryReplicaTask(0, false, "2")
-	assert.Equal(t, "1", pr.destoryTaskMu.reason)
+	pr.startDestroyReplicaTask(0, false, "2")
+	assert.Equal(t, "1", pr.destroyTaskMu.reason)
 }
 
-func TestDestoryTaskWithStartCheckLogCommittedStep(t *testing.T) {
+func TestDestroyTaskWithStartCheckLogCommittedStep(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 
 	s, cancel := newTestStore(t)
@@ -114,7 +114,7 @@ func TestDestoryTaskWithStartCheckLogCommittedStep(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	dms := newTestDestoryMetadataStorage(false)
+	dms := newTestDestroyMetadataStorage(false)
 	c := make(chan []uint64)
 	f := newTestDestroyReplicaTaskFactory(false).setDestroyingStorage(dms).setActionHandler(func(a action) {
 		if a.actionType == checkLogCommittedAction {
@@ -122,7 +122,7 @@ func TestDestoryTaskWithStartCheckLogCommittedStep(t *testing.T) {
 			c <- []uint64{1, 2, 3}
 		}
 	}).setCheckInterval(time.Millisecond * 10)
-	go f.new(pr, 100, false, "TestDestoryTaskWithStartCheckLogCommittedStep").run(ctx)
+	go f.new(pr, 100, false, "TestDestroyTaskWithStartCheckLogCommittedStep").run(ctx)
 	select {
 	case <-c:
 		break
@@ -131,7 +131,7 @@ func TestDestoryTaskWithStartCheckLogCommittedStep(t *testing.T) {
 	}
 }
 
-func TestDestoryTaskWithCompleteCheckLogCommittedStep(t *testing.T) {
+func TestDestroyTaskWithCompleteCheckLogCommittedStep(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 
 	s, cancel := newTestStore(t)
@@ -141,14 +141,14 @@ func TestDestoryTaskWithCompleteCheckLogCommittedStep(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	defer cancel()
 
-	dms := newTestDestoryMetadataStorage(true)
+	dms := newTestDestroyMetadataStorage(true)
 	f := newTestDestroyReplicaTaskFactory(false).setDestroyingStorage(dms).setActionHandler(func(a action) {
 		if a.actionType == checkLogCommittedAction {
 			assert.NotNil(t, a.actionCallback)
 			go a.actionCallback([]uint64{1, 2, 3})
 		}
 	}).setCheckInterval(time.Millisecond * 10)
-	go f.new(pr, 100, false, "TestDestoryTaskWithCompleteCheckLogCommittedStep").run(ctx)
+	go f.new(pr, 100, false, "TestDestroyTaskWithCompleteCheckLogCommittedStep").run(ctx)
 
 	select {
 	case <-dms.c:
@@ -161,7 +161,7 @@ func TestDestoryTaskWithCompleteCheckLogCommittedStep(t *testing.T) {
 	}
 }
 
-func TestDestoryTaskWithStartCheckLogAppliedStep(t *testing.T) {
+func TestDestroyTaskWithStartCheckLogAppliedStep(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 
 	s, cancel := newTestStore(t)
@@ -172,7 +172,7 @@ func TestDestoryTaskWithStartCheckLogAppliedStep(t *testing.T) {
 	defer cancel()
 
 	c := make(chan struct{})
-	dms := newTestDestoryMetadataStorage(false)
+	dms := newTestDestroyMetadataStorage(false)
 	dms.CreateDestroying(pr.shardID, 100, false, []uint64{1, 2, 3})
 
 	f := newTestDestroyReplicaTaskFactory(false).setDestroyingStorage(dms).setActionHandler(func(a action) {
@@ -181,7 +181,7 @@ func TestDestoryTaskWithStartCheckLogAppliedStep(t *testing.T) {
 			c <- struct{}{}
 		}
 	}).setCheckInterval(time.Millisecond * 10)
-	go f.new(pr, 100, false, "TestDestoryTaskWithStartCheckLogAppliedStep").run(ctx)
+	go f.new(pr, 100, false, "TestDestroyTaskWithStartCheckLogAppliedStep").run(ctx)
 
 	select {
 	case <-c:
@@ -191,7 +191,7 @@ func TestDestoryTaskWithStartCheckLogAppliedStep(t *testing.T) {
 	}
 }
 
-func TestDestoryTaskWithStartCompleteCheckLogAppliedStep(t *testing.T) {
+func TestDestroyTaskWithStartCompleteCheckLogAppliedStep(t *testing.T) {
 	defer leaktest.AfterTest(t)()
 
 	s, cancel := newTestStore(t)
@@ -203,7 +203,7 @@ func TestDestoryTaskWithStartCompleteCheckLogAppliedStep(t *testing.T) {
 	defer cancel()
 
 	c := make(chan struct{})
-	dms := newTestDestoryMetadataStorage(false)
+	dms := newTestDestroyMetadataStorage(false)
 	dms.CreateDestroying(pr.shardID, 100, false, []uint64{1, 2, 3})
 
 	f := newTestDestroyReplicaTaskFactory(false).setDestroyingStorage(dms).setActionHandler(func(a action) {
@@ -212,7 +212,7 @@ func TestDestoryTaskWithStartCompleteCheckLogAppliedStep(t *testing.T) {
 		}
 	}).setCheckInterval(time.Millisecond * 10)
 	go func() {
-		f.new(pr, 100, false, "TestDestoryTaskWithStartCompleteCheckLogAppliedStep").run(ctx)
+		f.new(pr, 100, false, "TestDestroyTaskWithStartCompleteCheckLogAppliedStep").run(ctx)
 		close(c)
 	}()
 	select {
diff --git a/util/btree_shard_test.go b/util/btree_shard_test.go
index a894232..507138d 100644
--- a/util/btree_shard_test.go
+++ b/util/btree_shard_test.go
@@ -131,7 +131,7 @@ func TestTreeOverlap(t *testing.T) {
 	assert.Equal(t, uint64(1), s.ID)
 }
 
-func TestAddDestoryShard(t *testing.T) {
+func TestAddDestroyShard(t *testing.T) {
 	tree := NewShardTree()
 	tree.Update(
 		meta.Shard{