generate proto files for descheduler

Signed-off-by: Garrybest <garrybest@foxmail.com>

hack/update-estimator-protobuf.sh

@@ -50,7 +50,7 @@ ${GOPATH}/bin/go-to-protobuf \
 # The `go-to-protobuf` tool will modify all import proto files in vendor, so we should use go mod vendor to prevent.
 go mod vendor
 
-SERVICE_PROTO_FILES=$(find . -not -path *./_tmp/* -name "service.proto")
+SERVICE_PROTO_FILES=$(find ./pkg/ -name "service.proto")
 
 for file in ${SERVICE_PROTO_FILES[*]}; do
   protoc \

pkg/estimator/pb/generated.pb.go

@@ -18,12 +18,14 @@ import (
 	math_bits "math/bits"
 	reflect "reflect"
 	strings "strings"
+	time "time"
 )
 
 // Reference imports to suppress errors if they are not otherwise used.
 var _ = proto.Marshal
 var _ = fmt.Errorf
 var _ = math.Inf
+var _ = time.Kitchen
 
 // This is a compile-time assertion to ensure that this generated file
 // is compatible with the proto package it is being compiled against.
@@ -115,10 +117,38 @@ func (m *NodeClaim) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_NodeClaim proto.InternalMessageInfo
 
+func (m *ObjectReference) Reset()      { *m = ObjectReference{} }
+func (*ObjectReference) ProtoMessage() {}
+func (*ObjectReference) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9773618571bdb725, []int{3}
+}
+func (m *ObjectReference) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *ObjectReference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+func (m *ObjectReference) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_ObjectReference.Merge(m, src)
+}
+func (m *ObjectReference) XXX_Size() int {
+	return m.Size()
+}
+func (m *ObjectReference) XXX_DiscardUnknown() {
+	xxx_messageInfo_ObjectReference.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_ObjectReference proto.InternalMessageInfo
+
 func (m *ReplicaRequirements) Reset()      { *m = ReplicaRequirements{} }
 func (*ReplicaRequirements) ProtoMessage() {}
 func (*ReplicaRequirements) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9773618571bdb725, []int{3}
+	return fileDescriptor_9773618571bdb725, []int{4}
 }
 func (m *ReplicaRequirements) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -146,7 +176,7 @@ var xxx_messageInfo_ReplicaRequirements proto.InternalMessageInfo
 func (m *UnimplementedEstimatorServer) Reset()      { *m = UnimplementedEstimatorServer{} }
 func (*UnimplementedEstimatorServer) ProtoMessage() {}
 func (*UnimplementedEstimatorServer) Descriptor() ([]byte, []int) {
-	return fileDescriptor_9773618571bdb725, []int{4}
+	return fileDescriptor_9773618571bdb725, []int{5}
 }
 func (m *UnimplementedEstimatorServer) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -171,14 +201,73 @@ func (m *UnimplementedEstimatorServer) XXX_DiscardUnknown() {
 
 var xxx_messageInfo_UnimplementedEstimatorServer proto.InternalMessageInfo
 
+func (m *UnschedulableReplicasRequest) Reset()      { *m = UnschedulableReplicasRequest{} }
+func (*UnschedulableReplicasRequest) ProtoMessage() {}
+func (*UnschedulableReplicasRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9773618571bdb725, []int{6}
+}
+func (m *UnschedulableReplicasRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *UnschedulableReplicasRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+func (m *UnschedulableReplicasRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UnschedulableReplicasRequest.Merge(m, src)
+}
+func (m *UnschedulableReplicasRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *UnschedulableReplicasRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_UnschedulableReplicasRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UnschedulableReplicasRequest proto.InternalMessageInfo
+
+func (m *UnschedulableReplicasResponse) Reset()      { *m = UnschedulableReplicasResponse{} }
+func (*UnschedulableReplicasResponse) ProtoMessage() {}
+func (*UnschedulableReplicasResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_9773618571bdb725, []int{7}
+}
+func (m *UnschedulableReplicasResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *UnschedulableReplicasResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	b = b[:cap(b)]
+	n, err := m.MarshalToSizedBuffer(b)
+	if err != nil {
+		return nil, err
+	}
+	return b[:n], nil
+}
+func (m *UnschedulableReplicasResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_UnschedulableReplicasResponse.Merge(m, src)
+}
+func (m *UnschedulableReplicasResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *UnschedulableReplicasResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_UnschedulableReplicasResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_UnschedulableReplicasResponse proto.InternalMessageInfo
+
 func init() {
 	proto.RegisterType((*MaxAvailableReplicasRequest)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.MaxAvailableReplicasRequest")
 	proto.RegisterType((*MaxAvailableReplicasResponse)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.MaxAvailableReplicasResponse")
 	proto.RegisterType((*NodeClaim)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.NodeClaim")
 	proto.RegisterMapType((map[string]string)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.NodeClaim.NodeSelectorEntry")
+	proto.RegisterType((*ObjectReference)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.ObjectReference")
 	proto.RegisterType((*ReplicaRequirements)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.ReplicaRequirements")
 	proto.RegisterMapType((k8s_io_api_core_v1.ResourceList)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.ReplicaRequirements.ResourceRequestEntry")
 	proto.RegisterType((*UnimplementedEstimatorServer)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.UnimplementedEstimatorServer")
+	proto.RegisterType((*UnschedulableReplicasRequest)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.UnschedulableReplicasRequest")
+	proto.RegisterType((*UnschedulableReplicasResponse)(nil), "github.com.karmada_io.karmada.pkg.estimator.pb.UnschedulableReplicasResponse")
 }
 
 func init() {
@@ -186,48 +275,60 @@ func init() {
 }
 
 var fileDescriptor_9773618571bdb725 = []byte{
-	// 649 bytes of a gzipped FileDescriptorProto
+	// 846 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0xcf, 0x6f, 0xd3, 0x4a,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x54, 0x41, 0x8f, 0xdb, 0x44,
-	0x10, 0x8e, 0x13, 0x55, 0x55, 0xd6, 0x7d, 0x6a, 0x9f, 0xdb, 0x43, 0x94, 0x56, 0x4e, 0x94, 0x53,
+	0x14, 0x8e, 0x93, 0xad, 0xda, 0x4c, 0xb6, 0xda, 0xad, 0x77, 0xa9, 0xa2, 0xb4, 0x75, 0x22, 0x9f,
-	0xde, 0xa1, 0x6b, 0x35, 0x7a, 0x48, 0x85, 0x03, 0xa8, 0x2e, 0x3d, 0x41, 0x2b, 0xb1, 0xa5, 0x08,
+	0x96, 0x43, 0xc7, 0x6a, 0x04, 0x52, 0xe1, 0x40, 0xb5, 0xde, 0xf6, 0x80, 0x4a, 0x17, 0x98, 0x76,
-	0x21, 0x21, 0xb4, 0x71, 0x26, 0xe9, 0x2a, 0xb6, 0xd7, 0xac, 0xd7, 0x51, 0x7b, 0x43, 0x20, 0xee,
+	0x2b, 0x40, 0x42, 0x68, 0x62, 0xbf, 0x24, 0x43, 0x6c, 0x8f, 0x19, 0x8f, 0xa3, 0x5d, 0x4e, 0x08,
-	0x88, 0xbf, 0xaa, 0xc7, 0x5e, 0x90, 0x7a, 0x21, 0x10, 0xf3, 0x5f, 0x70, 0x42, 0xfe, 0x15, 0x3b,
+	0xc4, 0x1d, 0xf1, 0x0f, 0xf8, 0x1b, 0xfc, 0x82, 0x3d, 0xf6, 0x82, 0xd4, 0x0b, 0x81, 0x84, 0x7f,
-	0xa9, 0x85, 0x54, 0xc4, 0x6d, 0x77, 0x67, 0xbe, 0x6f, 0x66, 0xbe, 0x6f, 0x6c, 0xf4, 0x70, 0xc4,
+	0xd1, 0x13, 0xf2, 0x78, 0x9c, 0x38, 0x59, 0x2f, 0xd2, 0x02, 0xb7, 0x99, 0x79, 0xdf, 0xfb, 0xde,
-	0xe4, 0x79, 0xd0, 0xc7, 0x16, 0x77, 0x8c, 0x31, 0x15, 0x0e, 0x1d, 0xd0, 0x5d, 0xc6, 0xb3, 0xa3,
+	0x37, 0x6f, 0xbe, 0x79, 0xe8, 0x83, 0x11, 0x93, 0xe3, 0x74, 0x80, 0x3d, 0x1e, 0x3a, 0x13, 0x2a,
-	0xe1, 0x8d, 0x47, 0x06, 0xf8, 0x92, 0x39, 0x54, 0x72, 0x61, 0x78, 0x7d, 0x63, 0x04, 0x2e, 0x08,
+	0x42, 0xea, 0xd3, 0xfb, 0x8c, 0x17, 0x4b, 0x27, 0x9e, 0x8c, 0x1c, 0x48, 0x24, 0x0b, 0xa9, 0xe4,
-	0x2a, 0x61, 0x80, 0x3d, 0xc1, 0x25, 0xd7, 0x70, 0x8e, 0xc7, 0x29, 0xe8, 0x0d, 0xe3, 0xd9, 0x11,
+	0xc2, 0x89, 0x07, 0xce, 0x08, 0x22, 0x10, 0x54, 0x82, 0x8f, 0x63, 0xc1, 0x25, 0x37, 0xf1, 0x2a,
-	0x7b, 0xe3, 0x11, 0x9e, 0xe3, 0xb1, 0xd7, 0x6f, 0xee, 0x16, 0xea, 0x8d, 0xf8, 0x88, 0x1b, 0x31,
+	0x1f, 0xeb, 0xa4, 0xaf, 0x18, 0x2f, 0x96, 0x38, 0x9e, 0x8c, 0xf0, 0x32, 0x1f, 0xc7, 0x83, 0xce,
-	0x4d, 0x3f, 0x18, 0xc6, 0xb7, 0xf8, 0x12, 0x9f, 0x12, 0xfa, 0x66, 0x67, 0xbc, 0xef, 0x63, 0xc6,
+	0xfd, 0x52, 0xbd, 0x11, 0x1f, 0x71, 0x47, 0xd1, 0x0c, 0xd2, 0xa1, 0xda, 0xa9, 0x8d, 0x5a, 0xe5,
-	0x0d, 0xea, 0x31, 0xc3, 0xe2, 0x02, 0x8c, 0xc9, 0xde, 0x72, 0x0b, 0xcd, 0xff, 0xf3, 0x1c, 0x87,
+	0xf4, 0x1d, 0x7b, 0xf2, 0x30, 0xc1, 0x8c, 0x3b, 0x34, 0x66, 0x8e, 0xc7, 0x05, 0x38, 0xd3, 0x07,
-	0x5a, 0xe7, 0xcc, 0x05, 0x71, 0x19, 0x37, 0x1e, 0x81, 0x04, 0xf8, 0x3c, 0x10, 0x16, 0x2c, 0xa3,
+	0x9b, 0x12, 0x3a, 0xef, 0xac, 0x30, 0x21, 0xf5, 0xc6, 0x2c, 0x02, 0x71, 0xa6, 0x84, 0x67, 0x49,
-	0x3a, 0x5f, 0x15, 0xb4, 0x7d, 0x4c, 0x2f, 0x0e, 0x26, 0x94, 0xd9, 0xb4, 0x6f, 0x03, 0x01, 0xcf,
+	0x02, 0x12, 0x9e, 0x0a, 0x0f, 0x36, 0xb3, 0xec, 0xdf, 0x0d, 0x74, 0xe7, 0x19, 0x3d, 0x3d, 0x9c,
-	0x66, 0x16, 0xf5, 0x09, 0xbc, 0x0d, 0xc0, 0x97, 0xda, 0x7f, 0x68, 0xd5, 0xb2, 0x03, 0x5f, 0x82,
+	0x52, 0x16, 0xd0, 0x41, 0x00, 0x04, 0xe2, 0x80, 0x79, 0x34, 0x21, 0xf0, 0x4d, 0x0a, 0x89, 0x34,
-	0x68, 0x28, 0x6d, 0xa5, 0x5b, 0x37, 0xd7, 0xaf, 0xa6, 0xad, 0x4a, 0x38, 0x6d, 0xad, 0x1e, 0x26,
+	0xdf, 0x46, 0xd7, 0xbd, 0x20, 0x4d, 0x24, 0x88, 0xb6, 0xd1, 0x33, 0x0e, 0x9a, 0xee, 0xce, 0xf9,
-	0xcf, 0x24, 0x8b, 0x6b, 0x9f, 0x15, 0xb4, 0x29, 0x12, 0x78, 0x84, 0x66, 0x02, 0x1c, 0x70, 0xa5,
+	0xac, 0x5b, 0x5b, 0xcc, 0xba, 0xd7, 0x8f, 0xf2, 0x63, 0x52, 0xc4, 0xcd, 0x9f, 0x0d, 0xb4, 0x27,
-	0xdf, 0xa8, 0xb6, 0x95, 0xae, 0xda, 0x3b, 0xbc, 0xa3, 0x44, 0x98, 0xdc, 0xa6, 0x32, 0xb7, 0xd3,
+	0xf2, 0xf4, 0x2c, 0x9b, 0x09, 0x08, 0x21, 0x92, 0x49, 0xbb, 0xde, 0x33, 0x0e, 0x5a, 0xfd, 0xa3,
-	0xe2, 0x9b, 0x25, 0x41, 0x52, 0x56, 0xbc, 0x73, 0x86, 0x76, 0xca, 0xc7, 0xf3, 0x3d, 0xee, 0xfa,
+	0x2b, 0xb6, 0x08, 0x93, 0x8b, 0x54, 0xee, 0x1d, 0x5d, 0x7c, 0xaf, 0x22, 0x48, 0xaa, 0x8a, 0xdb,
-	0xa0, 0xdd, 0x43, 0xaa, 0x43, 0x2f, 0xb2, 0xe7, 0x78, 0xc6, 0x15, 0x73, 0x33, 0x2d, 0xa3, 0x1e,
+	0x27, 0xe8, 0x6e, 0xf5, 0xf5, 0x92, 0x98, 0x47, 0x09, 0x98, 0xef, 0xa2, 0x56, 0x48, 0x4f, 0x8b,
-	0xe7, 0x21, 0x52, 0xcc, 0xeb, 0x7c, 0xa8, 0xa1, 0xfa, 0x09, 0x1f, 0xc0, 0xa1, 0x4d, 0x99, 0xa3,
+	0x63, 0x75, 0xc7, 0x6b, 0xee, 0x9e, 0x2e, 0xd3, 0x7a, 0xb6, 0x0a, 0x91, 0x32, 0xce, 0xfe, 0xa1,
-	0xbd, 0x40, 0x6b, 0x2e, 0x1f, 0xc0, 0xc1, 0x70, 0xc8, 0x5c, 0x26, 0x2f, 0x63, 0x16, 0xb5, 0xd7,
+	0x81, 0x9a, 0xc7, 0xdc, 0x87, 0xa3, 0x80, 0xb2, 0xd0, 0x7c, 0x89, 0xb6, 0x23, 0xee, 0xc3, 0xe1,
-	0xc6, 0x89, 0x23, 0x98, 0x7a, 0x0c, 0x47, 0xae, 0xe1, 0xc9, 0x1e, 0x8e, 0x40, 0xa7, 0x60, 0x83,
+	0x70, 0xc8, 0x22, 0x26, 0xcf, 0x14, 0x4b, 0xab, 0xdf, 0xc3, 0xf9, 0x8b, 0x60, 0x1a, 0x33, 0x9c,
-	0x25, 0xb9, 0x30, 0x37, 0xc2, 0x69, 0x6b, 0xed, 0xa4, 0x80, 0x24, 0x0b, 0x3c, 0xda, 0x47, 0x25,
+	0xbd, 0x1a, 0x9e, 0x3e, 0xc0, 0x59, 0xd2, 0x73, 0x08, 0xc0, 0x93, 0x5c, 0xb8, 0xbb, 0x8b, 0x59,
-	0x21, 0xce, 0x00, 0x8d, 0x6a, 0xbb, 0xd6, 0x55, 0x7b, 0x4f, 0xee, 0x2a, 0xe5, 0xbc, 0xd3, 0x85,
+	0x77, 0xfb, 0xb8, 0x94, 0x49, 0xd6, 0x78, 0xcc, 0x1f, 0x8d, 0x9c, 0xb8, 0x48, 0x68, 0xd7, 0x7b,
-	0xf2, 0x47, 0xae, 0x14, 0x97, 0xe6, 0x56, 0x3a, 0xeb, 0x5a, 0x31, 0x44, 0x16, 0xca, 0x6a, 0x67,
+	0x8d, 0x83, 0x56, 0xff, 0xe9, 0x55, 0x5b, 0xb9, 0x54, 0xba, 0x56, 0xfe, 0x49, 0x24, 0xc5, 0x99,
-	0x48, 0x95, 0xdc, 0x8e, 0xf6, 0x86, 0x71, 0xd7, 0x6f, 0xd4, 0xe2, 0x2e, 0xf4, 0xb2, 0xf1, 0x9e,
+	0xbb, 0xaf, 0xef, 0xba, 0x5d, 0x0e, 0x91, 0xb5, 0xb2, 0xe6, 0x09, 0x6a, 0x49, 0x1e, 0x64, 0xbe,
-	0xcf, 0xd3, 0x72, 0x11, 0xf3, 0x37, 0x9f, 0x14, 0x79, 0x9a, 0x8f, 0xd0, 0xbf, 0xb7, 0xfa, 0xd1,
+	0x61, 0x3c, 0x4a, 0xda, 0x0d, 0xa5, 0xc2, 0xaa, 0xba, 0xde, 0x8b, 0x25, 0x6c, 0xd5, 0xc4, 0xd5,
-	0x36, 0x50, 0x6d, 0x0c, 0x89, 0x84, 0x75, 0x12, 0x1d, 0xb5, 0x2d, 0xb4, 0x32, 0xa1, 0x76, 0x00,
+	0x59, 0x42, 0xca, 0x3c, 0x9d, 0x47, 0xe8, 0xd6, 0x05, 0x3d, 0xe6, 0x2e, 0x6a, 0x4c, 0x20, 0x6f,
-	0xf1, 0x22, 0xd5, 0x49, 0x72, 0x79, 0x50, 0xdd, 0x57, 0x3a, 0x5f, 0x6a, 0xa8, 0x6c, 0x13, 0xb4,
+	0x61, 0x93, 0x64, 0x4b, 0x73, 0x1f, 0x5d, 0x9b, 0xd2, 0x20, 0x05, 0x65, 0xa4, 0x26, 0xc9, 0x37,
-	0x21, 0xaa, 0xbb, 0xd9, 0xc8, 0xa9, 0x19, 0xf7, 0xff, 0x58, 0x33, 0xf3, 0x9f, 0x70, 0xda, 0xca,
+	0xef, 0xd7, 0x1f, 0x1a, 0xf6, 0xaf, 0x06, 0xda, 0xf9, 0x78, 0xf0, 0x35, 0x78, 0x92, 0xc0, 0x10,
-	0xcd, 0x26, 0x39, 0xb5, 0x36, 0x53, 0xd0, 0x7a, 0xf6, 0x65, 0xa5, 0x1f, 0x4c, 0x6a, 0xd1, 0xcb,
+	0x04, 0x44, 0x1e, 0x98, 0x7d, 0x84, 0x68, 0xcc, 0x5e, 0x82, 0x48, 0x18, 0x8f, 0xb4, 0x67, 0x4d,
-	0xbf, 0xb0, 0xed, 0x98, 0x2c, 0x52, 0x27, 0x7e, 0xbd, 0x4e, 0x65, 0x5d, 0x5f, 0x8a, 0xfe, 0x9c,
+	0x2d, 0x05, 0x1d, 0x7e, 0xf2, 0xa1, 0x8e, 0x90, 0x12, 0xca, 0xec, 0xa1, 0xad, 0x09, 0x8b, 0xfc,
-	0xb6, 0x5a, 0xb7, 0xff, 0x12, 0x73, 0x8e, 0xa7, 0xcc, 0x97, 0xef, 0xbf, 0xfd, 0x36, 0xe5, 0x84,
+	0xbc, 0x80, 0xbb, 0xad, 0xd1, 0x5b, 0x4f, 0x59, 0xe4, 0x13, 0x15, 0x31, 0x1d, 0xd4, 0x8c, 0x68,
-	0x3a, 0x40, 0x96, 0xe7, 0x69, 0x0a, 0xb4, 0x55, 0xd6, 0x47, 0x89, 0x4f, 0x8f, 0x8b, 0x3e, 0xa9,
+	0x08, 0x49, 0x4c, 0x3d, 0x68, 0x37, 0x14, 0xec, 0x96, 0x86, 0x35, 0x8f, 0x8b, 0x00, 0x59, 0x61,
-	0x3d, 0x5c, 0xd8, 0x8f, 0xf9, 0x0f, 0x29, 0x1e, 0x3c, 0x5a, 0x98, 0xac, 0x0c, 0x7e, 0x16, 0x50,
+	0x32, 0xca, 0x6c, 0xd3, 0xde, 0x5a, 0xa7, 0xcc, 0xb0, 0x44, 0x45, 0xec, 0xdf, 0x1a, 0xa8, 0xca,
-	0x57, 0x46, 0xab, 0x5f, 0xf0, 0x55, 0x47, 0x3b, 0x67, 0x2e, 0x73, 0x3c, 0x3b, 0x16, 0x02, 0x06,
+	0xc6, 0xe6, 0x10, 0x35, 0xa3, 0xe2, 0xbd, 0xb4, 0x93, 0xde, 0xfb, 0xd7, 0x0f, 0xee, 0xde, 0x54,
-	0x47, 0x99, 0x52, 0xa7, 0x20, 0x26, 0x20, 0xcc, 0xee, 0xd5, 0x4c, 0xaf, 0x5c, 0xcf, 0xf4, 0xca,
+	0x0a, 0x8b, 0x2d, 0x59, 0x51, 0x9b, 0x73, 0x03, 0xed, 0x14, 0x63, 0x41, 0xff, 0x76, 0xed, 0xaf,
-	0xcd, 0x4c, 0xaf, 0xbc, 0x0b, 0x75, 0xe5, 0x2a, 0xd4, 0x95, 0xeb, 0x50, 0x57, 0x6e, 0x42, 0x5d,
+	0xcf, 0xfe, 0x87, 0xaf, 0x8a, 0xc9, 0x3a, 0x75, 0x6e, 0xb6, 0x2f, 0x75, 0x1f, 0x76, 0x36, 0xa2,
-	0xf9, 0x1e, 0xea, 0xca, 0xa7, 0x1f, 0x7a, 0xe5, 0x55, 0xd5, 0xeb, 0xff, 0x0a, 0x00, 0x00, 0xff,
+	0x6f, 0x66, 0xdd, 0xee, 0xc5, 0x11, 0xb7, 0xe4, 0xf8, 0x88, 0x25, 0xf2, 0xfb, 0x3f, 0xfe, 0x11,
-	0xff, 0xe8, 0xc9, 0x85, 0xca, 0xd8, 0x05, 0x00, 0x00,
+	0xa2, 0x1a, 0xbb, 0x79, 0x9f, 0x8e, 0x40, 0xfb, 0x55, 0x3a, 0x2a, 0x4c, 0xf6, 0xb8, 0x6c, 0xb2,
+	0x56, 0x1f, 0x97, 0xcc, 0xbd, 0x9c, 0xa6, 0xea, 0xe2, 0x99, 0xdb, 0x8b, 0x32, 0xf8, 0xd3, 0x94,
+	0x46, 0x32, 0xfb, 0xb7, 0x25, 0x53, 0x5a, 0xe8, 0xee, 0x49, 0xc4, 0xc2, 0x38, 0x50, 0x8d, 0x00,
+	0xff, 0x49, 0xd1, 0xa9, 0xe7, 0x20, 0xa6, 0x20, 0xec, 0x5f, 0xea, 0x19, 0x20, 0xf1, 0xc6, 0xe0,
+	0xa7, 0xff, 0x75, 0xe4, 0x86, 0xe8, 0x46, 0xa1, 0x45, 0x0b, 0x7f, 0x74, 0xd5, 0xb7, 0xdb, 0xf8,
+	0x3f, 0xee, 0xae, 0x2e, 0x76, 0x63, 0xd9, 0xb8, 0x65, 0x09, 0x73, 0x84, 0x6e, 0xa7, 0x65, 0xe5,
+	0x2f, 0xc6, 0x02, 0x92, 0x31, 0x0f, 0x7c, 0xf5, 0x25, 0x1a, 0xae, 0xa3, 0x73, 0x6f, 0x9f, 0x54,
+	0xa2, 0xde, 0xcc, 0xba, 0x37, 0x25, 0x0b, 0x01, 0x3f, 0x4e, 0xf3, 0x11, 0x40, 0x2e, 0xa1, 0xb3,
+	0xbf, 0x45, 0xf7, 0x2e, 0x69, 0x91, 0x1e, 0xdb, 0x9f, 0xa3, 0x76, 0x48, 0x4f, 0x2b, 0x31, 0x7a,
+	0x86, 0xdf, 0xd3, 0x5a, 0xde, 0xaa, 0x26, 0xba, 0x34, 0xdd, 0x3d, 0x38, 0x9f, 0x5b, 0xb5, 0x57,
+	0x73, 0xab, 0xf6, 0x7a, 0x6e, 0xd5, 0xbe, 0x5b, 0x58, 0xc6, 0xf9, 0xc2, 0x32, 0x5e, 0x2d, 0x2c,
+	0xe3, 0xf5, 0xc2, 0x32, 0xfe, 0x5c, 0x58, 0xc6, 0x4f, 0x7f, 0x59, 0xb5, 0x2f, 0xea, 0xf1, 0xe0,
+	0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x34, 0x7f, 0xd7, 0x35, 0x08, 0x00, 0x00,
 }
 
 func (m *MaxAvailableReplicasRequest) Marshal() (dAtA []byte, err error) {
@@ -367,6 +468,49 @@ func (m *NodeClaim) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *ObjectReference) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ObjectReference) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *ObjectReference) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	i -= len(m.Name)
+	copy(dAtA[i:], m.Name)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Name)))
+	i--
+	dAtA[i] = 0x22
+	i -= len(m.Namespace)
+	copy(dAtA[i:], m.Namespace)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Namespace)))
+	i--
+	dAtA[i] = 0x1a
+	i -= len(m.Kind)
+	copy(dAtA[i:], m.Kind)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Kind)))
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.APIVersion)
+	copy(dAtA[i:], m.APIVersion)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.APIVersion)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
 func (m *ReplicaRequirements) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -454,6 +598,73 @@ func (m *UnimplementedEstimatorServer) MarshalToSizedBuffer(dAtA []byte) (int, e
 	return len(dAtA) - i, nil
 }
 
+func (m *UnschedulableReplicasRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *UnschedulableReplicasRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UnschedulableReplicasRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	i = encodeVarintGenerated(dAtA, i, uint64(m.UnschedulableThreshold))
+	i--
+	dAtA[i] = 0x18
+	{
+		size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i])
+		if err != nil {
+			return 0, err
+		}
+		i -= size
+		i = encodeVarintGenerated(dAtA, i, uint64(size))
+	}
+	i--
+	dAtA[i] = 0x12
+	i -= len(m.Cluster)
+	copy(dAtA[i:], m.Cluster)
+	i = encodeVarintGenerated(dAtA, i, uint64(len(m.Cluster)))
+	i--
+	dAtA[i] = 0xa
+	return len(dAtA) - i, nil
+}
+
+func (m *UnschedulableReplicasResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalToSizedBuffer(dAtA[:size])
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *UnschedulableReplicasResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *UnschedulableReplicasResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	i = encodeVarintGenerated(dAtA, i, uint64(m.UnschedulableReplicas))
+	i--
+	dAtA[i] = 0x8
+	return len(dAtA) - i, nil
+}
+
 func encodeVarintGenerated(dAtA []byte, offset int, v uint64) int {
 	offset -= sovGenerated(v)
 	base := offset
@@ -515,6 +726,23 @@ func (m *NodeClaim) Size() (n int) {
 	return n
 }
 
+func (m *ObjectReference) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.APIVersion)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Kind)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Namespace)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = len(m.Name)
+	n += 1 + l + sovGenerated(uint64(l))
+	return n
+}
+
 func (m *ReplicaRequirements) Size() (n int) {
 	if m == nil {
 		return 0
@@ -546,6 +774,30 @@ func (m *UnimplementedEstimatorServer) Size() (n int) {
 	return n
 }
 
+func (m *UnschedulableReplicasRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Cluster)
+	n += 1 + l + sovGenerated(uint64(l))
+	l = m.Resource.Size()
+	n += 1 + l + sovGenerated(uint64(l))
+	n += 1 + sovGenerated(uint64(m.UnschedulableThreshold))
+	return n
+}
+
+func (m *UnschedulableReplicasResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	n += 1 + sovGenerated(uint64(m.UnschedulableReplicas))
+	return n
+}
+
 func sovGenerated(x uint64) (n int) {
 	return (math_bits.Len64(x|1) + 6) / 7
 }
@@ -600,6 +852,19 @@ func (this *NodeClaim) String() string {
 	}, "")
 	return s
 }
+func (this *ObjectReference) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&ObjectReference{`,
+		`APIVersion:` + fmt.Sprintf("%v", this.APIVersion) + `,`,
+		`Kind:` + fmt.Sprintf("%v", this.Kind) + `,`,
+		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
+		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func (this *ReplicaRequirements) String() string {
 	if this == nil {
 		return "nil"
@@ -630,6 +895,28 @@ func (this *UnimplementedEstimatorServer) String() string {
 	}, "")
 	return s
 }
+func (this *UnschedulableReplicasRequest) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&UnschedulableReplicasRequest{`,
+		`Cluster:` + fmt.Sprintf("%v", this.Cluster) + `,`,
+		`Resource:` + strings.Replace(strings.Replace(this.Resource.String(), "ObjectReference", "ObjectReference", 1), `&`, ``, 1) + `,`,
+		`UnschedulableThreshold:` + fmt.Sprintf("%v", this.UnschedulableThreshold) + `,`,
+		`}`,
+	}, "")
+	return s
+}
+func (this *UnschedulableReplicasResponse) String() string {
+	if this == nil {
+		return "nil"
+	}
+	s := strings.Join([]string{`&UnschedulableReplicasResponse{`,
+		`UnschedulableReplicas:` + fmt.Sprintf("%v", this.UnschedulableReplicas) + `,`,
+		`}`,
+	}, "")
+	return s
+}
 func valueToStringGenerated(v interface{}) string {
 	rv := reflect.ValueOf(v)
 	if rv.IsNil() {
@@ -1069,6 +1356,184 @@ func (m *NodeClaim) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *ObjectReference) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ObjectReference: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ObjectReference: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field APIVersion", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.APIVersion = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Kind = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Namespace = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *ReplicaRequirements) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
@@ -1334,6 +1799,209 @@ func (m *UnimplementedEstimatorServer) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *UnschedulableReplicasRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: UnschedulableReplicasRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: UnschedulableReplicasRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= uint64(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Cluster = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Resource", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= int(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			postIndex := iNdEx + msglen
+			if postIndex < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnschedulableThreshold", wireType)
+			}
+			m.UnschedulableThreshold = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnschedulableThreshold |= time.Duration(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *UnschedulableReplicasResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowGenerated
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= uint64(b&0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: UnschedulableReplicasResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: UnschedulableReplicasResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field UnschedulableReplicas", wireType)
+			}
+			m.UnschedulableReplicas = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGenerated
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.UnschedulableReplicas |= int32(b&0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGenerated(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGenerated
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func skipGenerated(dAtA []byte) (n int, err error) {
 	l := len(dAtA)
 	iNdEx := 0

pkg/estimator/pb/generated.proto

@@ -48,6 +48,28 @@ message NodeClaim {
   repeated k8s.io.api.core.v1.Toleration tolerations = 3;
 }
 
+// ObjectReference contains enough information to locate the referenced object inside current cluster.
+message ObjectReference {
+  // APIVersion represents the API version of the referent.
+  // +required
+  optional string apiVersion = 1;
+
+  // Kind represents the Kind of the referent.
+  // +required
+  optional string kind = 2;
+
+  // Namespace represents the namespace for the referent.
+  // For non-namespace scoped resources(e.g. 'ClusterRole')，do not need specify Namespace,
+  // and for namespace scoped resources, Namespace is required.
+  // If Namespace is not specified, means the resource is non-namespace scoped.
+  // +required
+  optional string namespace = 3;
+
+  // Name represents the name of the referent.
+  // +required
+  optional string name = 4;
+}
+
 // ReplicaRequirements represents the requirements required by each replica.
 message ReplicaRequirements {
   // NodeClaim represents the NodeAffinity, NodeSelector and Tolerations required by each replica.
@@ -63,3 +85,26 @@ message ReplicaRequirements {
 message UnimplementedEstimatorServer {
 }
 
+// UnschedulableReplicasRequest represents the request that sent by gRPC client to calculate unschedulable replicas.
+message UnschedulableReplicasRequest {
+  // Cluster represents the cluster name.
+  // +required
+  optional string cluster = 1;
+
+  // Resource represents the Kubernetes resource to be propagated.
+  // +required
+  optional ObjectReference resource = 2;
+
+  // UnschedulableThreshold represents the period threshold of pod unscheduable condition.
+  // This value is considered as a classification standard of unscheduable replicas.
+  // +optional
+  optional int64 unschedulableThreshold = 3;
+}
+
+// UnschedulableReplicasResponse represents the response that sent by gRPC server to calculate unschedulable replicas.
+message UnschedulableReplicasResponse {
+  // UnschedulableReplicas represents the unschedulable replicas that the object contains.
+  // +required
+  optional int32 maxUnschedulableReplicas = 1;
+}
+

pkg/estimator/pb/service.pb.go

@@ -27,18 +27,20 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 func init() { proto.RegisterFile("pkg/estimator/pb/service.proto", fileDescriptor_f8ba5c092844dbe2) }
 
 var fileDescriptor_f8ba5c092844dbe2 = []byte{
-	// 173 bytes of a gzipped FileDescriptorProto
+	// 204 bytes of a gzipped FileDescriptorProto
 	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x2b, 0xc8, 0x4e, 0xd7,
 	0x4f, 0x2d, 0x2e, 0xc9, 0xcc, 0x4d, 0x2c, 0xc9, 0x2f, 0xd2, 0x2f, 0x48, 0xd2, 0x2f, 0x4e, 0x2d,
 	0x2a, 0xcb, 0x4c, 0x4e, 0xd5, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0xd2, 0x4b, 0xcf, 0x2c, 0xc9,
 	0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0xcb, 0x4e, 0x2c, 0xca, 0x4d, 0x4c, 0x49, 0x8c, 0xcf,
 	0xcc, 0x87, 0x31, 0xf5, 0x0a, 0xb2, 0xd3, 0xf5, 0xe0, 0xba, 0xf5, 0x0a, 0x92, 0xa4, 0x14, 0x30,
-	0xcc, 0x4b, 0x4f, 0xcd, 0x4b, 0x2d, 0x4a, 0x2c, 0x49, 0x4d, 0x81, 0x98, 0x68, 0x74, 0x90, 0x91,
+	0xcc, 0x4b, 0x4f, 0xcd, 0x4b, 0x2d, 0x4a, 0x2c, 0x49, 0x4d, 0x81, 0x98, 0x68, 0xf4, 0x97, 0x89,
 	0x8b, 0xd3, 0x15, 0xa6, 0x40, 0x68, 0x33, 0x23, 0x97, 0x88, 0x6f, 0x62, 0x85, 0x63, 0x59, 0x62,
 	0x66, 0x4e, 0x62, 0x52, 0x4e, 0x6a, 0x50, 0x6a, 0x41, 0x4e, 0x66, 0x72, 0x62, 0xb1, 0x90, 0x37,
 	0x89, 0x36, 0xeb, 0x61, 0x33, 0x25, 0x28, 0xb5, 0xb0, 0x34, 0xb5, 0xb8, 0x44, 0xca, 0x87, 0x3a,
-	0x86, 0x15, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x2a, 0x31, 0x38, 0xb1, 0x44, 0x31, 0x15, 0x24, 0x01,
+	0x86, 0x15, 0x17, 0xe4, 0xe7, 0x15, 0xa7, 0x2a, 0x31, 0x08, 0xed, 0x64, 0xe4, 0x92, 0x70, 0x4f,
-	0x02, 0x00, 0x00, 0xff, 0xff, 0x3b, 0x73, 0xbd, 0x33, 0x3c, 0x01, 0x00, 0x00,
+	0x2d, 0x09, 0xcd, 0x2b, 0x4e, 0xce, 0x48, 0x4d, 0x29, 0x45, 0x75, 0x39, 0xc9, 0x96, 0x61, 0x35,
+	0x06, 0xe6, 0x74, 0x5f, 0x2a, 0x99, 0x06, 0x73, 0xbb, 0x13, 0x4b, 0x14, 0x53, 0x41, 0x12, 0x20,
+	0x00, 0x00, 0xff, 0xff, 0xbb, 0x1d, 0x27, 0xc0, 0xf8, 0x01, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -54,6 +56,7 @@ const _ = grpc.SupportPackageIsVersion4
 // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
 type EstimatorClient interface {
 	MaxAvailableReplicas(ctx context.Context, in *MaxAvailableReplicasRequest, opts ...grpc.CallOption) (*MaxAvailableReplicasResponse, error)
+	GetUnschedulableReplicas(ctx context.Context, in *UnschedulableReplicasRequest, opts ...grpc.CallOption) (*UnschedulableReplicasResponse, error)
 }
 
 type estimatorClient struct {
@@ -73,9 +76,19 @@ func (c *estimatorClient) MaxAvailableReplicas(ctx context.Context, in *MaxAvail
 	return out, nil
 }
 
+func (c *estimatorClient) GetUnschedulableReplicas(ctx context.Context, in *UnschedulableReplicasRequest, opts ...grpc.CallOption) (*UnschedulableReplicasResponse, error) {
+	out := new(UnschedulableReplicasResponse)
+	err := c.cc.Invoke(ctx, "/github.com.karmada_io.karmada.pkg.estimator.pb.Estimator/GetUnschedulableReplicas", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // EstimatorServer is the server API for Estimator service.
 type EstimatorServer interface {
 	MaxAvailableReplicas(context.Context, *MaxAvailableReplicasRequest) (*MaxAvailableReplicasResponse, error)
+	GetUnschedulableReplicas(context.Context, *UnschedulableReplicasRequest) (*UnschedulableReplicasResponse, error)
 }
 
 // UnimplementedEstimatorServer can be embedded to have forward compatible implementations.
@@ -85,6 +98,9 @@ type UnimplementedEstimatorServer struct {
 func (*UnimplementedEstimatorServer) MaxAvailableReplicas(ctx context.Context, req *MaxAvailableReplicasRequest) (*MaxAvailableReplicasResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method MaxAvailableReplicas not implemented")
 }
+func (*UnimplementedEstimatorServer) GetUnschedulableReplicas(ctx context.Context, req *UnschedulableReplicasRequest) (*UnschedulableReplicasResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method GetUnschedulableReplicas not implemented")
+}
 
 func RegisterEstimatorServer(s *grpc.Server, srv EstimatorServer) {
 	s.RegisterService(&_Estimator_serviceDesc, srv)
@@ -108,6 +124,24 @@ func _Estimator_MaxAvailableReplicas_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
+func _Estimator_GetUnschedulableReplicas_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UnschedulableReplicasRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EstimatorServer).GetUnschedulableReplicas(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/github.com.karmada_io.karmada.pkg.estimator.pb.Estimator/GetUnschedulableReplicas",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EstimatorServer).GetUnschedulableReplicas(ctx, req.(*UnschedulableReplicasRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 var _Estimator_serviceDesc = grpc.ServiceDesc{
 	ServiceName: "github.com.karmada_io.karmada.pkg.estimator.pb.Estimator",
 	HandlerType: (*EstimatorServer)(nil),
@@ -116,6 +150,10 @@ var _Estimator_serviceDesc = grpc.ServiceDesc{
 			MethodName: "MaxAvailableReplicas",
 			Handler:    _Estimator_MaxAvailableReplicas_Handler,
 		},
+		{
+			MethodName: "GetUnschedulableReplicas",
+			Handler:    _Estimator_GetUnschedulableReplicas_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "pkg/estimator/pb/service.proto",