diff --git a/integration/microservices_test.go b/integration/microservices_test.go
index de29de970..e54ce2fd4 100644
--- a/integration/microservices_test.go
+++ b/integration/microservices_test.go
@@ -207,7 +207,7 @@ var _ = Describe("MicroService Api Test", func() {
 					resp, _ := scclient.Do(req)
 					respbody, _ := ioutil.ReadAll(resp.Body)
 					Expect(resp.StatusCode).To(Equal(http.StatusOK))
-					Expect(string(respbody)).To(Equal("{}"))
+					Expect(strings.TrimSpace(string(respbody))).To(Equal("{}"))
 				})
 			})
 
diff --git a/integration/rules_test.go b/integration/rules_test.go
index 11dd6dbbe..341524fcc 100644
--- a/integration/rules_test.go
+++ b/integration/rules_test.go
@@ -183,13 +183,17 @@ var _ = Describe("MicroService Api Test", func() {
 				Expect(resp.StatusCode).To(Equal(http.StatusOK))
 
 				//Duplicate Request
+				bodyBuf = bytes.NewReader(body)
 				req, _ = http.NewRequest(POST, SCURL+url, bodyBuf)
 				req.Header.Set("X-Domain-Name", "default")
 				resp, err = scclient.Do(req)
 				Expect(err).To(BeNil())
 				defer resp.Body.Close()
 
-				Expect(resp.StatusCode).To(Equal(http.StatusBadRequest))
+				Expect(resp.StatusCode).To(Equal(http.StatusOK))
+
+				respbody, _ := ioutil.ReadAll(resp.Body)
+				Expect(strings.TrimSpace(string(respbody))).To(Equal("{}"))
 			})
 		})
 
@@ -243,7 +247,7 @@ var _ = Describe("MicroService Api Test", func() {
 				resp, _ := scclient.Do(req)
 				respbody, _ := ioutil.ReadAll(resp.Body)
 				Expect(resp.StatusCode).To(Equal(http.StatusOK))
-				Expect(string(respbody)).To(Equal("{}"))
+				Expect(strings.TrimSpace(string(respbody))).To(Equal("{}"))
 			})
 
 			It("Get Rules for Invalid MicroService", func() {
@@ -482,7 +486,7 @@ var _ = Describe("MicroService Api Test", func() {
 				resp, _ = scclient.Do(req)
 				respbody, _ = ioutil.ReadAll(resp.Body)
 				Expect(resp.StatusCode).To(Equal(http.StatusOK))
-				Expect(string(respbody)).To(Equal("{}"))
+				Expect(strings.TrimSpace(string(respbody))).To(Equal("{}"))
 			})
 
 			It("Delete MicroService rules with non-exsisting ruleID", func() {
diff --git a/server/core/proto/services.go b/server/core/proto/services.go
index afe316103..e54a4ba56 100644
--- a/server/core/proto/services.go
+++ b/server/core/proto/services.go
@@ -46,6 +46,8 @@ const (
 	EXISTENCE_SCHEMA string = "schema"
 
 	PROP_ALLOW_CROSS_APP = "allowCrossApp"
+
+	Response_SUCCESS int32 = 0
 )
 
 type SerivceInstanceCtrlServerEx interface {
@@ -68,7 +70,7 @@ type SystemConfig struct {
 	Version string `json:"version"`
 }
 
-func CreateResponse(code Response_Code, message string) *Response {
+func CreateResponse(code int32, message string) *Response {
 	resp := &Response{
 		Code:    code,
 		Message: message,
diff --git a/server/core/proto/services.pb.go b/server/core/proto/services.pb.go
index 8ec0032b7..0780ad639 100644
--- a/server/core/proto/services.pb.go
+++ b/server/core/proto/services.pb.go
@@ -119,30 +119,6 @@ var _ = math.Inf
 // proto package needs to be updated.
 const _ = proto1.ProtoPackageIsVersion2 // please upgrade the proto package
 
-type Response_Code int32
-
-const (
-	Response_UNKNOWN Response_Code = 0
-	Response_SUCCESS Response_Code = 1
-	Response_FAIL    Response_Code = 2
-)
-
-var Response_Code_name = map[int32]string{
-	0: "UNKNOWN",
-	1: "SUCCESS",
-	2: "FAIL",
-}
-var Response_Code_value = map[string]int32{
-	"UNKNOWN": 0,
-	"SUCCESS": 1,
-	"FAIL":    2,
-}
-
-func (x Response_Code) String() string {
-	return proto1.EnumName(Response_Code_name, int32(x))
-}
-func (Response_Code) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{18, 0} }
-
 type ModifySchemasRequest struct {
 	ServiceId string    `protobuf:"bytes,1,opt,name=serviceId" json:"serviceId,omitempty"`
 	Schemas   []*Schema `protobuf:"bytes,2,rep,name=schemas" json:"schemas,omitempty"`
@@ -776,8 +752,8 @@ func (m *ServicePath) GetProperty() map[string]string {
 }
 
 type Response struct {
-	Code    Response_Code `protobuf:"varint,1,opt,name=code,enum=com.huawei.paas.cse.serviceregistry.api.Response_Code" json:"code,omitempty"`
-	Message string        `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+	Code    int32  `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
+	Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
 }
 
 func (m *Response) Reset()                    { *m = Response{} }
@@ -785,11 +761,11 @@ func (m *Response) String() string            { return proto1.CompactTextString(
 func (*Response) ProtoMessage()               {}
 func (*Response) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} }
 
-func (m *Response) GetCode() Response_Code {
+func (m *Response) GetCode() int32 {
 	if m != nil {
 		return m.Code
 	}
-	return Response_UNKNOWN
+	return 0
 }
 
 func (m *Response) GetMessage() string {
@@ -2822,7 +2798,6 @@ func init() {
 	proto1.RegisterType((*DelServicesRequest)(nil), "com.huawei.paas.cse.serviceregistry.api.DelServicesRequest")
 	proto1.RegisterType((*DelServicesRspInfo)(nil), "com.huawei.paas.cse.serviceregistry.api.DelServicesRspInfo")
 	proto1.RegisterType((*DelServicesResponse)(nil), "com.huawei.paas.cse.serviceregistry.api.DelServicesResponse")
-	proto1.RegisterEnum("com.huawei.paas.cse.serviceregistry.api.Response_Code", Response_Code_name, Response_Code_value)
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -4079,212 +4054,209 @@ var _GovernServiceCtrl_serviceDesc = grpc.ServiceDesc{
 func init() { proto1.RegisterFile("services.proto", fileDescriptor0) }
 
 var fileDescriptor0 = []byte{
-	// 3307 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x3c, 0x4b, 0x6f, 0x1b, 0xd7,
-	0xd5, 0xdf, 0xa5, 0x48, 0x49, 0x3c, 0xb4, 0x6c, 0xf9, 0x5a, 0xb2, 0x68, 0x7e, 0xf9, 0x02, 0x7f,
-	0x83, 0x00, 0x5f, 0xf0, 0x21, 0x60, 0x53, 0xa5, 0x6d, 0xd2, 0xc4, 0x8e, 0x2d, 0xd1, 0x8e, 0x2d,
-	0xdb, 0xb2, 0x9c, 0xa1, 0x6c, 0x23, 0x8f, 0x26, 0x18, 0x91, 0x57, 0xd4, 0xc4, 0xe4, 0x0c, 0x33,
-	0x73, 0xa9, 0x44, 0xdd, 0x14, 0x09, 0xd2, 0x67, 0xda, 0xb4, 0x41, 0xdb, 0x55, 0x0a, 0x74, 0x51,
-	0x64, 0xd7, 0x4d, 0x80, 0x02, 0x6d, 0x11, 0x34, 0xe8, 0x63, 0xdb, 0xa2, 0x8b, 0x2e, 0x0a, 0x14,
-	0x68, 0x37, 0xdd, 0x76, 0x53, 0xf4, 0x07, 0xb4, 0xb8, 0x8f, 0x99, 0xb9, 0xf3, 0x20, 0xcd, 0x99,
-	0xe1, 0x24, 0xc8, 0x4a, 0x73, 0xef, 0xf0, 0x9e, 0x7b, 0xde, 0xf7, 0x9c, 0x73, 0x8f, 0x06, 0x8e,
-	0xbb, 0xc4, 0x39, 0x34, 0x3b, 0xc4, 0x6d, 0x0e, 0x1d, 0x9b, 0xda, 0xf8, 0xff, 0x3a, 0xf6, 0xa0,
-	0x79, 0x30, 0x32, 0x5e, 0x23, 0x66, 0x73, 0x68, 0x18, 0x6e, 0xb3, 0xe3, 0x92, 0xa6, 0xfc, 0x8d,
-	0x43, 0x7a, 0xa6, 0x4b, 0x9d, 0xa3, 0xa6, 0x31, 0x34, 0xb5, 0xaf, 0xc0, 0xca, 0xb6, 0xdd, 0x35,
-	0xf7, 0x8f, 0xda, 0x9d, 0x03, 0x32, 0x30, 0x5c, 0x9d, 0xbc, 0x3a, 0x22, 0x2e, 0xc5, 0x0f, 0x40,
-	0x55, 0xfe, 0x7c, 0xab, 0x5b, 0x47, 0x67, 0xd1, 0xc3, 0x55, 0x3d, 0x98, 0xc0, 0x5b, 0xb0, 0xe0,
-	0x8a, 0xdf, 0xd7, 0x4b, 0x67, 0xe7, 0x1e, 0xae, 0xad, 0x7f, 0xa6, 0x39, 0xe5, 0x86, 0x4d, 0xb1,
-	0x8f, 0xee, 0xad, 0xd7, 0xee, 0xc0, 0xbc, 0x98, 0xc2, 0x0d, 0x58, 0x14, 0x93, 0xfe, 0x8e, 0xfe,
-	0x18, 0xd7, 0x61, 0xc1, 0x1d, 0x0d, 0x06, 0x86, 0x73, 0x54, 0x2f, 0xf1, 0x57, 0xde, 0x10, 0x9f,
-	0x86, 0x79, 0xf1, 0xab, 0xfa, 0x1c, 0x7f, 0x21, 0x47, 0xda, 0x3e, 0xac, 0x46, 0x08, 0x73, 0x87,
-	0xb6, 0xe5, 0x12, 0xbc, 0x0d, 0x8b, 0x8e, 0x7c, 0xe6, 0xdb, 0xd4, 0xd6, 0x3f, 0x3b, 0x35, 0xf2,
-	0x1e, 0x10, 0xdd, 0x07, 0xa1, 0xbd, 0x0a, 0xa7, 0xae, 0x12, 0xc3, 0xa1, 0x7b, 0xc4, 0xa0, 0x6d,
-	0x42, 0x3d, 0xfe, 0x3d, 0x0f, 0x55, 0xd3, 0x72, 0xa9, 0x61, 0x75, 0x88, 0x5b, 0x47, 0x9c, 0x47,
-	0xe7, 0xa6, 0xde, 0x46, 0x05, 0x78, 0xb9, 0x4f, 0x06, 0xc4, 0xa2, 0x7a, 0x00, 0x4e, 0x6b, 0x87,
-	0xb7, 0x94, 0xbf, 0xb8, 0x8f, 0xc8, 0x1e, 0x04, 0xf0, 0x20, 0x6c, 0x75, 0x25, 0x13, 0x95, 0x19,
-	0xed, 0x43, 0x04, 0x2b, 0x61, 0x42, 0x0a, 0xe1, 0x17, 0xde, 0x55, 0x19, 0x23, 0x94, 0xe7, 0x0b,
-	0x53, 0xc3, 0xdb, 0x92, 0x2b, 0xaf, 0xee, 0xe9, 0x6e, 0x88, 0x25, 0x03, 0x58, 0x0a, 0xbd, 0xcb,
-	0xc7, 0x0c, 0xf6, 0x9e, 0x38, 0xce, 0x36, 0x71, 0x5d, 0xa3, 0x47, 0xa4, 0x62, 0x29, 0x33, 0x5a,
-	0x0b, 0xaa, 0x6d, 0xda, 0x16, 0xe0, 0xf0, 0x0a, 0x54, 0x3a, 0xf6, 0xc8, 0xa2, 0x7c, 0x9b, 0x39,
-	0x5d, 0x0c, 0xf0, 0x59, 0xa8, 0xd9, 0x56, 0xdf, 0xb4, 0x48, 0x8b, 0xbf, 0x2b, 0xf1, 0x77, 0xea,
-	0x94, 0xa6, 0x01, 0xb4, 0xa9, 0x87, 0x75, 0x32, 0x14, 0xed, 0x7f, 0xa0, 0xd2, 0xa6, 0x1b, 0xc3,
-	0xe1, 0x98, 0xd7, 0xff, 0x42, 0x0c, 0x86, 0x41, 0x4d, 0x97, 0x9a, 0x1d, 0x17, 0xdf, 0x84, 0x45,
-	0xcf, 0x0f, 0x48, 0x51, 0xad, 0x4f, 0x6f, 0x97, 0x1e, 0x3d, 0xba, 0x0f, 0x03, 0x3f, 0x1b, 0x96,
-	0x15, 0x03, 0xf8, 0x58, 0x0a, 0x80, 0x1e, 0x6d, 0x8a, 0xa0, 0xf0, 0x26, 0x94, 0x8d, 0xe1, 0xd0,
-	0xe5, 0x3c, 0xad, 0xad, 0x37, 0x53, 0x40, 0xdb, 0x18, 0x0e, 0x75, 0xbe, 0x56, 0xbb, 0x01, 0xa7,
-	0xaf, 0x10, 0x0f, 0x5d, 0x77, 0xcb, 0xda, 0xb7, 0x3d, 0xab, 0xab, 0xc3, 0x82, 0x3d, 0xa4, 0xa6,
-	0x6d, 0x09, 0x9b, 0xab, 0xea, 0xde, 0x90, 0xbd, 0xb1, 0xec, 0x96, 0xd1, 0x39, 0x20, 0x9c, 0x90,
-	0x45, 0xdd, 0x1b, 0x6a, 0x3f, 0x29, 0xc1, 0x5a, 0x0c, 0x5c, 0x31, 0xba, 0xdf, 0x85, 0x93, 0x46,
-	0xbf, 0xef, 0xed, 0x74, 0x89, 0x50, 0xc3, 0xec, 0xa7, 0xb6, 0x01, 0xb9, 0x5c, 0xac, 0xd6, 0xe3,
-	0x00, 0x71, 0x1b, 0xc0, 0xf5, 0x75, 0x42, 0x32, 0x3a, 0x8d, 0xd8, 0xbc, 0xa5, 0xba, 0x02, 0x46,
-	0xfb, 0x0d, 0x82, 0x13, 0xdb, 0x66, 0xc7, 0xb1, 0xe5, 0x66, 0xd7, 0x09, 0x77, 0xbd, 0x94, 0x58,
-	0x86, 0x54, 0xca, 0xaa, 0x2e, 0x47, 0x8c, 0xd7, 0x43, 0xc7, 0x7e, 0x85, 0x74, 0xa8, 0xe7, 0xac,
-	0xe5, 0x90, 0x69, 0xb1, 0x31, 0x1c, 0x6e, 0x75, 0xa5, 0x49, 0x89, 0x01, 0x33, 0x15, 0x89, 0xc9,
-	0x4d, 0x63, 0x40, 0xea, 0x65, 0xfe, 0x4e, 0x9d, 0x62, 0x10, 0x0f, 0x89, 0xe3, 0x9a, 0xb6, 0x55,
-	0xaf, 0x08, 0x88, 0x72, 0xc8, 0x20, 0xba, 0x94, 0x19, 0xe9, 0xbc, 0x80, 0xc8, 0x07, 0x7c, 0x9f,
-	0xbe, 0x69, 0xb8, 0xf5, 0x05, 0xb9, 0x0f, 0x1b, 0x68, 0xbf, 0x98, 0x87, 0x63, 0x2a, 0x0d, 0xf7,
-	0x71, 0x12, 0x3e, 0xb2, 0xa5, 0x09, 0xc8, 0xce, 0x4d, 0x44, 0xb6, 0x1c, 0x46, 0xf6, 0x2c, 0xd4,
-	0xba, 0xc4, 0xed, 0x38, 0x26, 0x57, 0x4a, 0x49, 0x8a, 0x3a, 0xc5, 0xf6, 0xec, 0x93, 0x43, 0xd2,
-	0xf7, 0xc8, 0xe1, 0x03, 0x7e, 0xfa, 0xc9, 0xe3, 0x76, 0x41, 0xa8, 0xb5, 0x1c, 0xe2, 0x6b, 0x50,
-	0x19, 0x1a, 0xf4, 0xc0, 0xad, 0x03, 0xd7, 0xa2, 0xcf, 0xa5, 0xd5, 0xa2, 0x5b, 0x06, 0x3d, 0xd0,
-	0x05, 0x08, 0x7e, 0x92, 0x52, 0x83, 0x8e, 0xdc, 0xfa, 0xa2, 0x3c, 0x49, 0xf9, 0x08, 0x13, 0x80,
-	0xa1, 0x63, 0x0f, 0x89, 0x43, 0x4d, 0xe2, 0xd6, 0xab, 0x7c, 0xa3, 0xcb, 0x53, 0x6f, 0xa4, 0x32,
-	0xbc, 0x79, 0xcb, 0x87, 0x73, 0xd9, 0xa2, 0xce, 0x91, 0xae, 0x00, 0x66, 0xc2, 0xa0, 0xe6, 0x80,
-	0xb8, 0xd4, 0x18, 0x0c, 0xeb, 0x35, 0x21, 0x0c, 0x7f, 0x02, 0xbf, 0x04, 0xd5, 0xa1, 0x63, 0x1f,
-	0x9a, 0x5d, 0xe2, 0xb8, 0xf5, 0x63, 0x1c, 0x87, 0x8b, 0x53, 0xe3, 0x70, 0x89, 0x0c, 0x89, 0xd5,
-	0x25, 0x56, 0xe7, 0x68, 0xdb, 0x74, 0x02, 0x74, 0xf4, 0x00, 0x64, 0xa0, 0x31, 0x4b, 0x8a, 0xc6,
-	0x30, 0xd2, 0x6f, 0x6c, 0xb6, 0xa9, 0x63, 0x50, 0xd2, 0x3b, 0xaa, 0x1f, 0xcf, 0x43, 0x7a, 0x00,
-	0x47, 0x92, 0x1e, 0x4c, 0x60, 0x0d, 0x8e, 0x0d, 0xec, 0xee, 0xae, 0x4f, 0xfd, 0x09, 0x8e, 0x43,
-	0x68, 0xae, 0x71, 0x1e, 0x4e, 0x44, 0xb8, 0x87, 0x97, 0x61, 0xee, 0x1e, 0x39, 0x92, 0x8a, 0xcb,
-	0x1e, 0x19, 0x15, 0x87, 0x46, 0x7f, 0x44, 0x3c, 0x95, 0xe5, 0x83, 0x27, 0x4b, 0x4f, 0x20, 0xb6,
-	0x3c, 0x82, 0x41, 0x9a, 0xe5, 0xda, 0x5f, 0x11, 0xd4, 0x3c, 0xae, 0x8d, 0xfa, 0x84, 0xe9, 0x8a,
-	0x33, 0xea, 0x07, 0x66, 0x23, 0x47, 0x2c, 0x86, 0x63, 0x4f, 0xbb, 0x47, 0x43, 0x0f, 0x88, 0x3f,
-	0x66, 0x02, 0x36, 0x28, 0x75, 0xcc, 0xbd, 0x11, 0xf5, 0xec, 0x26, 0x98, 0xe0, 0x4e, 0xc3, 0xa0,
-	0x94, 0x38, 0xbe, 0xd5, 0xc8, 0xe1, 0x14, 0x56, 0x13, 0x52, 0x9d, 0xf9, 0xa8, 0xea, 0x44, 0xb9,
-	0xbb, 0x10, 0xe7, 0xae, 0xf6, 0x0e, 0x82, 0xd3, 0x1b, 0xdd, 0xee, 0x8e, 0x73, 0x7b, 0xd8, 0x35,
-	0x28, 0x51, 0x49, 0x55, 0x49, 0x42, 0x93, 0x48, 0x2a, 0x4d, 0x20, 0x69, 0x6e, 0x22, 0x49, 0xe5,
-	0x18, 0x49, 0xda, 0x47, 0x01, 0xc3, 0x99, 0x8d, 0x62, 0x0c, 0x65, 0x66, 0xa5, 0x12, 0x03, 0xfe,
-	0x8c, 0x5f, 0x82, 0x45, 0x69, 0x3f, 0x47, 0xf2, 0x14, 0xd9, 0xcc, 0x62, 0xff, 0x9e, 0x55, 0x4a,
-	0xc5, 0xf4, 0x61, 0x36, 0x9e, 0x82, 0xa5, 0xd0, 0xab, 0x54, 0x1a, 0xf3, 0x23, 0x04, 0x8b, 0xfe,
-	0x39, 0x7a, 0x0d, 0xca, 0x1d, 0xbb, 0x2b, 0xf8, 0x77, 0x3c, 0xc5, 0x59, 0xe7, 0x01, 0x68, 0xb6,
-	0xec, 0x2e, 0xd1, 0x39, 0x0c, 0xc6, 0xd5, 0x81, 0x0c, 0xcc, 0xe4, 0xe9, 0x22, 0x87, 0xda, 0xff,
-	0x43, 0x99, 0xfd, 0x0e, 0xd7, 0x60, 0xe1, 0xf6, 0xcd, 0xeb, 0x37, 0x77, 0xee, 0xde, 0x5c, 0xfe,
-	0x2f, 0x36, 0x68, 0xdf, 0x6e, 0xb5, 0x2e, 0xb7, 0xdb, 0xcb, 0x08, 0x2f, 0x42, 0xf9, 0x99, 0x8d,
-	0xad, 0x1b, 0xcb, 0x25, 0xed, 0x8f, 0x08, 0x4e, 0x5d, 0x21, 0xf4, 0xf2, 0xeb, 0xa6, 0x4b, 0x09,
-	0x8b, 0x51, 0x64, 0x04, 0x81, 0xa1, 0x4c, 0x03, 0x49, 0xf3, 0xe7, 0x02, 0x0e, 0x82, 0xd0, 0xc1,
-	0x53, 0x89, 0x1e, 0x3c, 0x6a, 0x22, 0x34, 0x1f, 0x4f, 0x84, 0xbc, 0x38, 0x66, 0x21, 0x1c, 0xc7,
-	0xfc, 0x12, 0xc1, 0x4a, 0x98, 0xa2, 0x62, 0x82, 0x98, 0x10, 0xee, 0xa5, 0x49, 0xb8, 0xcf, 0x8d,
-	0x4f, 0xe2, 0xca, 0xa1, 0x24, 0x4e, 0xfb, 0x60, 0x0e, 0x56, 0x5a, 0x0e, 0x51, 0x2c, 0x4f, 0x8a,
-	0x63, 0x07, 0x16, 0x24, 0x6c, 0x89, 0xfa, 0xe7, 0x33, 0x79, 0x5f, 0xdd, 0x83, 0x82, 0x6f, 0x43,
-	0x85, 0x59, 0xaf, 0x97, 0x7a, 0x5c, 0x98, 0x1a, 0x5c, 0xb2, 0x77, 0xd0, 0x05, 0x34, 0xfc, 0x02,
-	0x94, 0xa9, 0xd1, 0x63, 0xd1, 0x16, 0x83, 0x7a, 0x65, 0x6a, 0xa8, 0x49, 0x44, 0x37, 0x77, 0x8d,
-	0x9e, 0x3c, 0x1f, 0x39, 0x50, 0xfc, 0x82, 0x1a, 0x86, 0x97, 0xf9, 0x0e, 0xe7, 0x33, 0xb1, 0x21,
-	0x21, 0x20, 0x6f, 0x3c, 0x0e, 0x55, 0x7f, 0xbf, 0x54, 0x06, 0xfe, 0x16, 0x82, 0xd5, 0x08, 0xfa,
-	0x9f, 0x80, 0xc2, 0x69, 0xd7, 0x60, 0xe5, 0x12, 0xe9, 0x93, 0x98, 0xe6, 0xdc, 0x37, 0xb6, 0xdb,
-	0xb7, 0x9d, 0x8e, 0x97, 0x0c, 0x88, 0x81, 0xb6, 0x0f, 0xab, 0x11, 0x58, 0xc5, 0xd4, 0x0c, 0xae,
-	0xc3, 0xc9, 0x20, 0xe3, 0x98, 0x0e, 0xe1, 0xf1, 0xf9, 0xcb, 0xcf, 0x10, 0x60, 0x15, 0x5a, 0x31,
-	0x42, 0x50, 0x0c, 0xb1, 0x34, 0x0b, 0x43, 0xd4, 0x9a, 0x2a, 0xd6, 0xae, 0x92, 0xc0, 0x79, 0x64,
-	0xa2, 0x30, 0x99, 0x3f, 0x17, 0x0e, 0x3b, 0x58, 0x50, 0x0c, 0x9d, 0xcf, 0x2a, 0x29, 0xb4, 0x70,
-	0x11, 0x19, 0x09, 0xf5, 0xc1, 0x68, 0xff, 0x40, 0x70, 0x26, 0xe4, 0x38, 0xd8, 0xa1, 0x3a, 0x65,
-	0xa1, 0xcd, 0x09, 0xc5, 0xde, 0x02, 0x21, 0x7d, 0x6a, 0x84, 0xc6, 0xee, 0x3a, 0x29, 0x10, 0xcf,
-	0x19, 0x69, 0x6a, 0xf7, 0xa0, 0x91, 0xb4, 0x6f, 0x31, 0x96, 0x74, 0x4b, 0x2d, 0x05, 0x30, 0x87,
-	0xec, 0xce, 0xc0, 0x9c, 0xd6, 0x62, 0x20, 0x8b, 0xd1, 0xb5, 0x6b, 0xe1, 0xb3, 0x28, 0x75, 0xf2,
-	0xa6, 0x1c, 0x40, 0xda, 0xfb, 0x08, 0xea, 0xf1, 0xd3, 0x69, 0x2a, 0x5e, 0x04, 0xb1, 0x7c, 0x29,
-	0x14, 0xcb, 0xb7, 0xa1, 0xcc, 0x9e, 0x64, 0x05, 0x21, 0xf7, 0x49, 0xc9, 0x81, 0x69, 0xaf, 0x44,
-	0x6c, 0x41, 0xa0, 0x59, 0x8c, 0x72, 0x7c, 0x47, 0x04, 0xf5, 0xe9, 0xb5, 0xa3, 0x98, 0x20, 0x41,
-	0x7b, 0x13, 0xc1, 0x5a, 0x0c, 0x9f, 0x62, 0x54, 0xab, 0x0e, 0x0b, 0x3a, 0x97, 0xa2, 0xa0, 0xa1,
-	0xaa, 0x7b, 0x43, 0xad, 0x0d, 0x67, 0xc2, 0x67, 0x5c, 0x2a, 0xa3, 0x71, 0xc2, 0x40, 0xe5, 0x90,
-	0xd9, 0x7c, 0x12, 0xd0, 0x62, 0xc4, 0xba, 0x03, 0xab, 0x81, 0x81, 0xb2, 0xd8, 0x25, 0xaf, 0xc9,
-	0xff, 0x1b, 0xa9, 0x5e, 0x44, 0x40, 0x2c, 0x46, 0x2c, 0x5f, 0x92, 0x61, 0xa2, 0xd0, 0xab, 0xad,
-	0xa9, 0x41, 0x25, 0x63, 0x17, 0x0d, 0x14, 0xb3, 0xc7, 0x72, 0x2f, 0xc3, 0x5a, 0x48, 0x6b, 0x77,
-	0x8d, 0xde, 0x74, 0x4c, 0x95, 0x9b, 0x94, 0x12, 0x36, 0x99, 0x53, 0x36, 0xd1, 0xcc, 0x88, 0x77,
-	0xe2, 0x1b, 0x14, 0xa3, 0x1e, 0xbf, 0x47, 0xb0, 0x1a, 0x58, 0xd9, 0xf4, 0xfa, 0xf1, 0x62, 0x48,
-	0x36, 0x57, 0xd3, 0xd8, 0x7c, 0x7c, 0xaf, 0xd9, 0x89, 0xa6, 0xa7, 0xfa, 0xb0, 0x02, 0x75, 0x53,
-	0xbb, 0x01, 0xf5, 0x90, 0x0d, 0x4f, 0xcf, 0x39, 0x0c, 0xe5, 0x7b, 0xe4, 0xc8, 0x73, 0x0a, 0xfc,
-	0x99, 0xf9, 0xf9, 0x04, 0x68, 0xc5, 0x60, 0x7e, 0x04, 0xb5, 0xab, 0xc4, 0xe8, 0xd3, 0x83, 0xd6,
-	0x01, 0xe9, 0xdc, 0x63, 0xe8, 0x0c, 0xbc, 0x62, 0x43, 0x55, 0xe7, 0xcf, 0xbc, 0x7c, 0x62, 0x3b,
-	0xa2, 0x1e, 0x5d, 0xd1, 0xf9, 0x33, 0x4b, 0x55, 0x4d, 0x8b, 0x12, 0xe7, 0xd0, 0xe8, 0x73, 0x65,
-	0xad, 0xe8, 0xfe, 0x98, 0xc9, 0x83, 0x17, 0x90, 0x78, 0xa2, 0x5a, 0xd1, 0xc5, 0x80, 0xc9, 0x6d,
-	0xe4, 0xf4, 0x65, 0xc2, 0xce, 0x1e, 0xb5, 0x7f, 0x96, 0x61, 0x25, 0x29, 0xc3, 0x8a, 0xdc, 0x30,
-	0xa1, 0xd8, 0x0d, 0xd3, 0xe4, 0x2c, 0xfa, 0x01, 0xa8, 0x12, 0xab, 0x3b, 0xb4, 0x4d, 0x8b, 0x8a,
-	0x9c, 0xb2, 0xaa, 0x07, 0x13, 0x0c, 0xf1, 0x03, 0xdb, 0xa5, 0x4a, 0xb1, 0xdc, 0x1f, 0x2b, 0x45,
-	0xdc, 0x4a, 0xa8, 0x88, 0x3b, 0x08, 0x05, 0x92, 0xf3, 0x5c, 0xc7, 0xb7, 0x73, 0x25, 0x91, 0x13,
-	0x8b, 0xb9, 0x77, 0xa0, 0x76, 0x10, 0x88, 0x84, 0x97, 0x2a, 0xd2, 0x04, 0x38, 0x8a, 0x38, 0x75,
-	0x15, 0x50, 0xb8, 0xd2, 0xb7, 0x18, 0xad, 0xf4, 0xbd, 0x0c, 0xc7, 0xbb, 0x06, 0x35, 0x5a, 0x84,
-	0x89, 0x71, 0xcb, 0xda, 0xb7, 0xeb, 0x55, 0xbe, 0xf1, 0xe3, 0xd3, 0x57, 0x8a, 0x43, 0xcb, 0xf5,
-	0x08, 0x38, 0x7c, 0x16, 0x6a, 0xc4, 0x3a, 0x34, 0x1d, 0xdb, 0x1a, 0x10, 0x8b, 0xd6, 0x41, 0xd4,
-	0x7c, 0x94, 0xa9, 0x58, 0xb1, 0xb1, 0x36, 0xf3, 0x52, 0xae, 0xb6, 0x07, 0xc7, 0xc3, 0x68, 0x32,
-	0xed, 0xb6, 0x98, 0x32, 0x48, 0x8d, 0xb7, 0xa4, 0x22, 0x30, 0xca, 0x6c, 0xcb, 0x8f, 0xea, 0xf8,
-	0x08, 0x3f, 0x04, 0x4b, 0xc6, 0xa1, 0x61, 0xf6, 0x8d, 0xbd, 0x3e, 0x79, 0xde, 0xb6, 0x3c, 0x3f,
-	0x1d, 0x9e, 0xd4, 0xee, 0xc2, 0x5a, 0x92, 0xcc, 0xaf, 0x93, 0xa3, 0x7c, 0x9a, 0xad, 0x51, 0x58,
-	0xd3, 0x39, 0xc3, 0x19, 0xea, 0xb2, 0x1a, 0x21, 0x9d, 0xcc, 0x73, 0xcc, 0x1e, 0xc5, 0x94, 0xf4,
-	0x0a, 0x39, 0xab, 0x1c, 0x3e, 0x38, 0xed, 0x9b, 0x08, 0xea, 0xf1, 0x6d, 0x8b, 0x39, 0xe3, 0xef,
-	0x77, 0xd1, 0xfe, 0x1c, 0x9c, 0xb9, 0x6d, 0x39, 0x63, 0x78, 0x90, 0xef, 0x0e, 0x9f, 0xa5, 0x5e,
-	0x09, 0xa0, 0x8b, 0x4a, 0xbd, 0x96, 0xfd, 0x7e, 0x81, 0xd9, 0xa0, 0xbf, 0x07, 0x27, 0x15, 0x88,
-	0xc5, 0x60, 0xfd, 0x37, 0x04, 0x2b, 0xcf, 0x98, 0x56, 0xd7, 0xe3, 0x8e, 0x7f, 0xc4, 0x3d, 0x02,
-	0x27, 0x3b, 0xb6, 0xe5, 0x8e, 0x06, 0xc4, 0x69, 0x47, 0x48, 0x88, 0xbf, 0xc8, 0x5c, 0x12, 0x3e,
-	0x0b, 0x35, 0x59, 0x03, 0x66, 0x21, 0xb2, 0x57, 0xf8, 0x57, 0xa6, 0x78, 0x01, 0x9a, 0x85, 0x21,
-	0x15, 0x71, 0x98, 0xf2, 0x02, 0xe0, 0x32, 0xcc, 0x11, 0xeb, 0x50, 0xd6, 0x82, 0xd9, 0xe3, 0x84,
-	0x32, 0xf0, 0xef, 0x10, 0xac, 0x46, 0x08, 0x2c, 0x46, 0xcf, 0x5f, 0x88, 0x37, 0x72, 0xcc, 0xac,
-	0x2a, 0xa9, 0xfd, 0x1d, 0xf1, 0x20, 0x7f, 0xc7, 0x22, 0x51, 0x0b, 0x49, 0x27, 0xa7, 0x47, 0xe0,
-	0xa4, 0x77, 0xc7, 0xd7, 0x8e, 0x38, 0xa5, 0xf8, 0x0b, 0xdc, 0x04, 0xec, 0x4d, 0x6e, 0x05, 0x8a,
-	0x2a, 0xc4, 0x98, 0xf0, 0xc6, 0x97, 0x55, 0x39, 0x2e, 0xab, 0x4a, 0xa2, 0xac, 0xe6, 0xc3, 0xb2,
-	0xfa, 0xad, 0x48, 0x3c, 0x42, 0x54, 0x16, 0x23, 0x2c, 0xd5, 0xb7, 0x96, 0x66, 0xeb, 0x5b, 0x3f,
-	0x10, 0x85, 0xb9, 0x9c, 0x06, 0x95, 0x4e, 0x50, 0x58, 0x29, 0xb7, 0x47, 0x18, 0x5f, 0x4e, 0x64,
-	0x7c, 0x25, 0xc6, 0xf8, 0x95, 0x30, 0xce, 0x9f, 0x42, 0x1b, 0x71, 0xe1, 0xbf, 0x45, 0x4e, 0xe5,
-	0xbd, 0x6c, 0xf3, 0x50, 0x6f, 0x26, 0xbe, 0x58, 0x89, 0x23, 0xe7, 0xd4, 0x38, 0x52, 0x1b, 0xc0,
-	0x03, 0xc9, 0x9b, 0x16, 0xe3, 0xae, 0xdf, 0x29, 0x79, 0xd5, 0x44, 0x6f, 0xbf, 0x14, 0xc5, 0xd3,
-	0xfb, 0xd1, 0xe8, 0x86, 0x62, 0x62, 0x71, 0x75, 0xd3, 0x4e, 0x59, 0x5c, 0x4d, 0x42, 0xab, 0xc8,
-	0xea, 0x6a, 0x3f, 0x2a, 0xf4, 0x42, 0xcb, 0xab, 0xe7, 0x60, 0xe5, 0xae, 0x41, 0x3b, 0x07, 0x51,
-	0x27, 0xfc, 0x10, 0x2c, 0xb9, 0xa4, 0xbf, 0x1f, 0xb5, 0xeb, 0xf0, 0xa4, 0xf6, 0x7e, 0x09, 0x56,
-	0x23, 0xcb, 0x8b, 0x31, 0xb3, 0xd3, 0x30, 0x6f, 0x74, 0xa8, 0x12, 0xeb, 0x8a, 0x11, 0xbe, 0x26,
-	0x18, 0x2b, 0x0a, 0x98, 0x4f, 0x64, 0x32, 0xbc, 0xeb, 0xe4, 0x48, 0x88, 0x44, 0xf5, 0xa0, 0xe5,
-	0xd9, 0x7a, 0xd0, 0x7d, 0x58, 0xbe, 0x42, 0xa8, 0x6c, 0x8c, 0x9d, 0x4a, 0xb3, 0xd5, 0x5b, 0xd6,
-	0xd2, 0xf8, 0x1b, 0xe2, 0xb9, 0xb0, 0xd7, 0xfb, 0xb2, 0xb8, 0x76, 0x92, 0xfb, 0x14, 0x26, 0x0a,
-	0xd9, 0x8e, 0x5b, 0x0a, 0xb5, 0xe3, 0xee, 0xc0, 0x29, 0x59, 0x0f, 0x98, 0x0d, 0x99, 0x1a, 0xf1,
-	0xef, 0xfd, 0x8a, 0xa4, 0x47, 0x7b, 0x03, 0xc1, 0x29, 0xb5, 0x8f, 0x38, 0xbf, 0x7c, 0xc6, 0x34,
-	0x2c, 0x4f, 0xb8, 0x1d, 0x27, 0xe1, 0x1e, 0xed, 0x02, 0x49, 0x3d, 0x23, 0x2e, 0x74, 0xfd, 0x7e,
-	0x29, 0x33, 0x38, 0xce, 0xbb, 0x70, 0xac, 0xab, 0x4c, 0xcb, 0x9e, 0xe6, 0x8b, 0x29, 0x6c, 0x40,
-	0xe9, 0xbc, 0x0a, 0x1a, 0xb2, 0xf4, 0x10, 0x54, 0x86, 0xc3, 0xda, 0x98, 0x6e, 0xad, 0x20, 0xe6,
-	0x46, 0x13, 0x62, 0xee, 0xd2, 0xc4, 0x36, 0x8c, 0xb9, 0x31, 0xcd, 0x83, 0x65, 0xa5, 0x79, 0x50,
-	0xfb, 0x33, 0x62, 0xc9, 0x6f, 0x22, 0xb6, 0xf8, 0x45, 0x58, 0xf4, 0x62, 0x17, 0xc9, 0xf2, 0xfc,
-	0x5d, 0x68, 0x3e, 0xc4, 0x70, 0x93, 0x5b, 0x69, 0xe6, 0x4d, 0x6e, 0x2c, 0x3f, 0x4c, 0x12, 0x70,
-	0x91, 0x57, 0x73, 0x49, 0xaa, 0x94, 0xb5, 0x4e, 0xff, 0x6b, 0x04, 0x8d, 0x2b, 0x84, 0xb6, 0x6c,
-	0xeb, 0x63, 0xc0, 0x1f, 0xb7, 0xe3, 0xc2, 0xc8, 0x78, 0x15, 0xac, 0x48, 0x40, 0x92, 0x70, 0xcb,
-	0xb1, 0x3f, 0x26, 0x12, 0x3c, 0xdd, 0xca, 0x4b, 0x82, 0x0f, 0x47, 0xfb, 0x4b, 0x09, 0x4e, 0xc8,
-	0xe9, 0x9d, 0x43, 0xf6, 0x97, 0xbc, 0x86, 0x9f, 0x83, 0x63, 0x03, 0xf9, 0x73, 0xf3, 0x30, 0x6f,
-	0xaf, 0x4e, 0x08, 0x54, 0xa1, 0x21, 0x34, 0xbe, 0x13, 0x6a, 0xdb, 0x49, 0xdd, 0x3d, 0xe7, 0xd1,
-	0x3f, 0xbb, 0x6a, 0xff, 0x9f, 0x2a, 0xb0, 0x14, 0x6a, 0xf0, 0xfe, 0xd4, 0xb2, 0xf6, 0x59, 0xa8,
-	0xc9, 0x23, 0xcf, 0xda, 0xb7, 0x3d, 0x0e, 0xa7, 0xfe, 0x37, 0x21, 0x15, 0x46, 0x70, 0x5f, 0x5e,
-	0xce, 0x7d, 0x5f, 0x1e, 0xb6, 0xee, 0xca, 0x6c, 0xac, 0x3b, 0x6c, 0x6f, 0xf3, 0xb3, 0xb1, 0x37,
-	0xbc, 0x2b, 0x75, 0x74, 0x21, 0xe5, 0x79, 0x10, 0x52, 0xa3, 0x58, 0x4f, 0xd9, 0x3a, 0xac, 0x0c,
-	0x94, 0x0d, 0xef, 0x88, 0x13, 0xd1, 0xad, 0x2f, 0xf2, 0x8c, 0x3a, 0xf1, 0x5d, 0x76, 0xad, 0xfe,
-	0x10, 0x41, 0x3d, 0xb8, 0xc2, 0x94, 0xff, 0xb9, 0x50, 0x90, 0xcf, 0xbb, 0x15, 0x6d, 0x54, 0xca,
-	0xfa, 0x9f, 0x15, 0x7e, 0xa7, 0xd2, 0x35, 0xc0, 0x97, 0x48, 0x3f, 0xda, 0xa9, 0xf4, 0x20, 0x80,
-	0x7f, 0x66, 0x79, 0xff, 0x6d, 0xa2, 0xcc, 0x8c, 0xe9, 0x30, 0xd3, 0xc3, 0xb0, 0xdc, 0x21, 0xaf,
-	0xdf, 0x87, 0xff, 0xdd, 0x08, 0x45, 0xff, 0xdd, 0xe8, 0x3e, 0x25, 0xf5, 0x5f, 0x21, 0x1e, 0x5b,
-	0x17, 0xdd, 0x19, 0x75, 0x37, 0xd6, 0x19, 0xf5, 0x54, 0x8a, 0xd8, 0x24, 0x4a, 0x73, 0xd0, 0x1f,
-	0xb5, 0xfe, 0xde, 0x19, 0xbf, 0xd5, 0xb9, 0x45, 0x9d, 0x3e, 0x7e, 0x0b, 0x41, 0x85, 0xbc, 0x6e,
-	0xba, 0x14, 0x9f, 0x4b, 0x73, 0x41, 0x1e, 0x6d, 0xe5, 0x6d, 0x9c, 0xcf, 0xb8, 0x5a, 0xd2, 0xfb,
-	0x75, 0x04, 0xf3, 0x1d, 0x1e, 0x2d, 0xe1, 0xf3, 0xb9, 0xfa, 0x39, 0x1b, 0x4f, 0x67, 0x5d, 0xae,
-	0x60, 0xd2, 0xe5, 0xb9, 0x4e, 0x0a, 0x4c, 0x92, 0x9a, 0x22, 0x53, 0x60, 0x92, 0xdc, 0x07, 0xf9,
-	0x06, 0x82, 0xf9, 0x1e, 0x2f, 0x58, 0xe2, 0x27, 0x33, 0x34, 0x2f, 0x78, 0x68, 0x3c, 0x95, 0x69,
-	0xad, 0xc4, 0xe1, 0x1b, 0x08, 0x6a, 0xbd, 0xa0, 0x11, 0x10, 0x67, 0x01, 0xe6, 0x59, 0x71, 0xe3,
-	0x5c, 0xb6, 0xc5, 0x12, 0x95, 0xf7, 0x10, 0x2c, 0x8f, 0x78, 0x35, 0x26, 0x28, 0xe9, 0xe0, 0xcd,
-	0xfc, 0xed, 0x79, 0x8d, 0x56, 0x2e, 0x18, 0x12, 0xbb, 0x6f, 0x23, 0x58, 0x30, 0xba, 0x5d, 0x7e,
-	0xab, 0x70, 0x21, 0x43, 0x3b, 0x83, 0xda, 0x19, 0xd4, 0xb8, 0x98, 0x1d, 0x80, 0x82, 0x4e, 0x8f,
-	0xd0, 0x94, 0xe8, 0x24, 0x77, 0xf7, 0xa5, 0x40, 0x67, 0x5c, 0x2f, 0xdf, 0xf7, 0x11, 0x80, 0x90,
-	0x1d, 0xc7, 0x68, 0x23, 0x1b, 0xc7, 0x95, 0x2e, 0xbb, 0xc6, 0x66, 0x1e, 0x10, 0x12, 0xab, 0x1f,
-	0x22, 0x00, 0x61, 0xea, 0x1c, 0xab, 0xcd, 0x8c, 0xf6, 0xaa, 0xb2, 0xaa, 0x95, 0x0b, 0x86, 0xc4,
-	0xeb, 0x5b, 0x42, 0x97, 0xd8, 0xf1, 0x8f, 0x9f, 0xce, 0xd7, 0x1a, 0xd3, 0xb8, 0x90, 0x79, 0xbd,
-	0x82, 0x4c, 0x8f, 0xd0, 0x94, 0xc8, 0x24, 0xf6, 0x8c, 0x35, 0x2e, 0xe4, 0xec, 0xc1, 0xc2, 0xdf,
-	0x43, 0x50, 0x15, 0x7a, 0xb4, 0x6b, 0xf4, 0xf0, 0xc5, 0x6c, 0x3a, 0x10, 0xf4, 0x5b, 0x35, 0x36,
-	0x72, 0x40, 0x50, 0x54, 0x5b, 0x28, 0x11, 0x67, 0xd1, 0x46, 0x36, 0x05, 0x50, 0xb9, 0xb4, 0x99,
-	0x07, 0x84, 0xc4, 0xea, 0x6b, 0x08, 0x96, 0x7a, 0x5e, 0xf9, 0x91, 0x87, 0x3d, 0x5f, 0x4c, 0xc5,
-	0x7b, 0xb5, 0xfc, 0xd6, 0x78, 0x32, 0xcb, 0x52, 0x89, 0xc8, 0xdb, 0x08, 0x8e, 0x75, 0x95, 0xd2,
-	0x61, 0x8a, 0x30, 0x23, 0xa1, 0x84, 0xd9, 0x38, 0x9f, 0x71, 0xb5, 0x82, 0xcd, 0x40, 0xa9, 0xee,
-	0xa5, 0xc0, 0x26, 0xa1, 0x2e, 0x99, 0x02, 0x9b, 0xc4, 0x92, 0xe2, 0x3b, 0x08, 0x96, 0x54, 0x6c,
-	0x5c, 0x9c, 0x0d, 0xa0, 0x9b, 0x3e, 0xe2, 0x48, 0xfe, 0x5a, 0xc3, 0x4f, 0x11, 0xfc, 0x6f, 0x27,
-	0x56, 0xb3, 0x7a, 0xc6, 0x76, 0xb6, 0x4d, 0xa7, 0xe3, 0xc7, 0x00, 0x9b, 0x29, 0x23, 0xac, 0x84,
-	0xaa, 0x54, 0x0a, 0x3f, 0x39, 0xa1, 0x86, 0xf6, 0x63, 0x04, 0x6b, 0x3d, 0x5e, 0xdf, 0xe1, 0x29,
-	0xa1, 0xfa, 0x9b, 0x74, 0x87, 0x5e, 0x3e, 0x0c, 0x27, 0x94, 0x98, 0x24, 0x86, 0x2d, 0x99, 0x5f,
-	0x7e, 0x82, 0x18, 0x8e, 0xab, 0xe3, 0xbd, 0x8d, 0xe0, 0x78, 0x57, 0x75, 0x23, 0x69, 0x62, 0xbc,
-	0x78, 0xa6, 0xd6, 0x38, 0x97, 0x6d, 0xb1, 0xc0, 0x66, 0xfd, 0x0f, 0x35, 0x38, 0x15, 0x29, 0x73,
-	0xf0, 0x2c, 0xe5, 0xbb, 0x88, 0xa5, 0x57, 0xa2, 0xd5, 0x26, 0x85, 0xdb, 0x1f, 0xd3, 0xfc, 0x94,
-	0xc2, 0xed, 0x8f, 0xed, 0x63, 0x62, 0xb1, 0xc3, 0xc8, 0x6f, 0xff, 0x49, 0x13, 0x87, 0x8e, 0x6b,
-	0x47, 0x4a, 0x13, 0x87, 0x8e, 0xef, 0x3b, 0x7a, 0x13, 0x41, 0xf5, 0xc0, 0xeb, 0xeb, 0x49, 0xe1,
-	0xf4, 0xa3, 0xdd, 0x45, 0x29, 0x9c, 0x7e, 0xbc, 0x8d, 0xe8, 0xab, 0x08, 0xca, 0xfb, 0xa6, 0xd5,
-	0x4d, 0xe1, 0xcf, 0x92, 0xda, 0x84, 0x52, 0xf8, 0xb3, 0xe4, 0x26, 0x1c, 0xe6, 0xee, 0x7b, 0x4a,
-	0xe7, 0x41, 0xba, 0x1c, 0x37, 0x86, 0xce, 0xf9, 0x8c, 0xab, 0x25, 0x36, 0xef, 0x22, 0x38, 0xde,
-	0x0b, 0x35, 0xa0, 0xa4, 0x0b, 0xa8, 0xe2, 0xfd, 0x39, 0xe9, 0x02, 0xaa, 0xa4, 0xce, 0x97, 0xf7,
-	0x10, 0x1c, 0x13, 0x01, 0x95, 0x68, 0x2d, 0xc0, 0x97, 0x32, 0x5e, 0xc9, 0x87, 0xda, 0x21, 0x1a,
-	0x97, 0x73, 0x42, 0x91, 0xd8, 0xbd, 0x8f, 0xa0, 0x3e, 0x8a, 0x5d, 0xc0, 0xcb, 0xd4, 0xaf, 0x35,
-	0x83, 0xe6, 0x81, 0xc6, 0xa5, 0x7c, 0x40, 0x82, 0x2c, 0xb9, 0xf2, 0x9a, 0x41, 0x3b, 0x07, 0x29,
-	0x14, 0x3e, 0xe9, 0xaa, 0x3f, 0x85, 0xc2, 0x27, 0x5e, 0xf5, 0x3f, 0x8a, 0xb8, 0xca, 0x1f, 0x28,
-	0x5f, 0x16, 0xc2, 0xd9, 0x3e, 0x84, 0x94, 0x5e, 0xe5, 0x93, 0x3e, 0x67, 0xb4, 0xfe, 0x51, 0x09,
-	0x4e, 0x5e, 0xb1, 0x0f, 0x89, 0x63, 0xa9, 0x35, 0xa7, 0x77, 0x11, 0x2c, 0xf7, 0x22, 0x15, 0xca,
-	0x5c, 0x25, 0x8e, 0x8d, 0x0c, 0x6b, 0x23, 0x85, 0xd1, 0x1f, 0x20, 0x38, 0xd1, 0x0b, 0x7f, 0x98,
-	0x26, 0x53, 0xe2, 0xac, 0x7e, 0x21, 0x27, 0x53, 0xe2, 0x1c, 0xfa, 0x26, 0xce, 0xe6, 0xa3, 0x30,
-	0xed, 0xc7, 0xc5, 0x9e, 0xaf, 0xf0, 0x8f, 0x91, 0xed, 0xcd, 0xf3, 0x3f, 0x8f, 0xfd, 0x27, 0x00,
-	0x00, 0xff, 0xff, 0x4b, 0x17, 0x8e, 0xdf, 0xa5, 0x4c, 0x00, 0x00,
+	// 3253 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x1c, 0x4d, 0x6f, 0x24, 0x47,
+	0x55, 0x35, 0x9e, 0xb1, 0x3d, 0x6f, 0xec, 0xfd, 0xa8, 0xf5, 0xae, 0x67, 0x87, 0x10, 0x2d, 0xad,
+	0x48, 0xe4, 0x10, 0x99, 0xe0, 0x00, 0x09, 0xc9, 0x6e, 0x76, 0x6d, 0xef, 0x66, 0xd7, 0xbb, 0x71,
+	0x76, 0xd3, 0xe3, 0x6c, 0x94, 0x0f, 0x12, 0xb5, 0x67, 0xca, 0xe3, 0xce, 0xce, 0x74, 0x4f, 0xba,
+	0x6b, 0x9c, 0x98, 0x0b, 0x4a, 0x14, 0x3e, 0x03, 0x81, 0x08, 0x38, 0xe5, 0xc0, 0x01, 0xe5, 0xc6,
+	0x25, 0x12, 0x12, 0xa0, 0x88, 0x88, 0x8f, 0x2b, 0x88, 0x03, 0x07, 0x24, 0x24, 0xb8, 0x70, 0xe5,
+	0x82, 0xf8, 0x01, 0xa0, 0xfa, 0xe8, 0xee, 0xaa, 0xee, 0x9e, 0xd9, 0xe9, 0xee, 0xe9, 0x44, 0x39,
+	0xb9, 0xab, 0x7a, 0xea, 0xd5, 0xfb, 0xae, 0xf7, 0x5e, 0x3d, 0x37, 0x1c, 0xf3, 0x89, 0x77, 0x68,
+	0x77, 0x88, 0xbf, 0x36, 0xf4, 0x5c, 0xea, 0xe2, 0xcf, 0x77, 0xdc, 0xc1, 0xda, 0xc1, 0xc8, 0x7a,
+	0x8d, 0xd8, 0x6b, 0x43, 0xcb, 0xf2, 0xd7, 0x3a, 0x3e, 0x59, 0x93, 0xbf, 0xf1, 0x48, 0xcf, 0xf6,
+	0xa9, 0x77, 0xb4, 0x66, 0x0d, 0x6d, 0xe3, 0x1b, 0xb0, 0xb2, 0xe3, 0x76, 0xed, 0xfd, 0xa3, 0x76,
+	0xe7, 0x80, 0x0c, 0x2c, 0xdf, 0x24, 0xaf, 0x8e, 0x88, 0x4f, 0xf1, 0x3d, 0x50, 0x97, 0x3f, 0xdf,
+	0xee, 0x36, 0xd1, 0x39, 0x74, 0x7f, 0xdd, 0x8c, 0x26, 0xf0, 0x36, 0x2c, 0xf8, 0xe2, 0xf7, 0xcd,
+	0xca, 0xb9, 0xb9, 0xfb, 0x1b, 0xeb, 0x5f, 0x58, 0x9b, 0x72, 0xc3, 0x35, 0xb1, 0x8f, 0x19, 0xac,
+	0x37, 0x6e, 0xc3, 0xbc, 0x98, 0xc2, 0x2d, 0x58, 0x14, 0x93, 0xe1, 0x8e, 0xe1, 0x18, 0x37, 0x61,
+	0xc1, 0x1f, 0x0d, 0x06, 0x96, 0x77, 0xd4, 0xac, 0xf0, 0x57, 0xc1, 0x10, 0x9f, 0x81, 0x79, 0xf1,
+	0xab, 0xe6, 0x1c, 0x7f, 0x21, 0x47, 0xc6, 0x3e, 0x9c, 0x8e, 0x11, 0xe6, 0x0f, 0x5d, 0xc7, 0x27,
+	0x78, 0x07, 0x16, 0x3d, 0xf9, 0xcc, 0xb7, 0x69, 0xac, 0x7f, 0x71, 0x6a, 0xe4, 0x03, 0x20, 0x66,
+	0x08, 0xc2, 0x78, 0x15, 0x4e, 0x5d, 0x23, 0x96, 0x47, 0xf7, 0x88, 0x45, 0xdb, 0x84, 0x06, 0xfc,
+	0x7b, 0x1e, 0xea, 0xb6, 0xe3, 0x53, 0xcb, 0xe9, 0x10, 0xbf, 0x89, 0x38, 0x8f, 0xce, 0x4f, 0xbd,
+	0x8d, 0x0a, 0xf0, 0x4a, 0x9f, 0x0c, 0x88, 0x43, 0xcd, 0x08, 0x9c, 0xd1, 0xd6, 0xb7, 0x94, 0xbf,
+	0xb8, 0x8b, 0xc8, 0xee, 0x05, 0x08, 0x20, 0x6c, 0x77, 0x25, 0x13, 0x95, 0x19, 0xe3, 0x43, 0x04,
+	0x2b, 0x3a, 0x21, 0xa5, 0xf0, 0x0b, 0xef, 0xaa, 0x8c, 0x11, 0xca, 0xf3, 0x95, 0xa9, 0xe1, 0x6d,
+	0xcb, 0x95, 0xd7, 0xf6, 0x4c, 0x5f, 0x63, 0xc9, 0x00, 0x96, 0xb5, 0x77, 0xc5, 0x98, 0xc1, 0xde,
+	0x13, 0xcf, 0xdb, 0x21, 0xbe, 0x6f, 0xf5, 0x88, 0x54, 0x2c, 0x65, 0xc6, 0xd8, 0x82, 0x7a, 0x9b,
+	0xb6, 0x05, 0x38, 0xbc, 0x02, 0xb5, 0x8e, 0x3b, 0x72, 0x28, 0xdf, 0x66, 0xce, 0x14, 0x03, 0x7c,
+	0x0e, 0x1a, 0xae, 0xd3, 0xb7, 0x1d, 0xb2, 0xc5, 0xdf, 0x55, 0xf8, 0x3b, 0x75, 0xca, 0x30, 0x00,
+	0xda, 0x34, 0xc0, 0x3a, 0x1d, 0x8a, 0xf1, 0x59, 0xa8, 0xb5, 0xe9, 0xc6, 0x70, 0x38, 0xe6, 0xf5,
+	0x7f, 0x11, 0x83, 0x61, 0x51, 0xdb, 0xa7, 0x76, 0xc7, 0xc7, 0x4f, 0xc1, 0x62, 0xe0, 0x07, 0xa4,
+	0xa8, 0xd6, 0xa7, 0xb7, 0xcb, 0x80, 0x1e, 0x33, 0x84, 0x81, 0x9f, 0xd6, 0x65, 0xc5, 0x00, 0x3e,
+	0x94, 0x01, 0x60, 0x40, 0x9b, 0x22, 0x28, 0xbc, 0x09, 0x55, 0x6b, 0x38, 0xf4, 0x39, 0x4f, 0x1b,
+	0xeb, 0x6b, 0x19, 0xa0, 0x6d, 0x0c, 0x87, 0x26, 0x5f, 0x6b, 0x3c, 0x09, 0x67, 0xae, 0x92, 0x00,
+	0x5d, 0x7f, 0xdb, 0xd9, 0x77, 0x03, 0xab, 0x6b, 0xc2, 0x82, 0x3b, 0xa4, 0xb6, 0xeb, 0x08, 0x9b,
+	0xab, 0x9b, 0xc1, 0x90, 0xbd, 0x71, 0xdc, 0x2d, 0xab, 0x73, 0x40, 0x38, 0x21, 0x8b, 0x66, 0x30,
+	0x34, 0x7e, 0x5e, 0x81, 0xd5, 0x04, 0xb8, 0x72, 0x74, 0xbf, 0x0b, 0x27, 0xad, 0x7e, 0x3f, 0xd8,
+	0xe9, 0x32, 0xa1, 0x96, 0xdd, 0xcf, 0x6c, 0x03, 0x72, 0xb9, 0x58, 0x6d, 0x26, 0x01, 0xe2, 0x36,
+	0x80, 0x1f, 0xea, 0x84, 0x64, 0x74, 0x16, 0xb1, 0x05, 0x4b, 0x4d, 0x05, 0x8c, 0xf1, 0x7b, 0x04,
+	0xc7, 0x77, 0xec, 0x8e, 0xe7, 0xca, 0xcd, 0x6e, 0x10, 0xee, 0x7a, 0x29, 0x71, 0x2c, 0xa9, 0x94,
+	0x75, 0x53, 0x8e, 0x18, 0xaf, 0x87, 0x9e, 0xfb, 0x0a, 0xe9, 0xd0, 0xc0, 0x59, 0xcb, 0x21, 0xd3,
+	0x62, 0x6b, 0x38, 0xdc, 0xee, 0x4a, 0x93, 0x12, 0x03, 0x66, 0x2a, 0x12, 0x93, 0xa7, 0xac, 0x01,
+	0x69, 0x56, 0xf9, 0x3b, 0x75, 0x8a, 0x41, 0x3c, 0x24, 0x9e, 0x6f, 0xbb, 0x4e, 0xb3, 0x26, 0x20,
+	0xca, 0x21, 0x83, 0xe8, 0x53, 0x66, 0xa4, 0xf3, 0x02, 0x22, 0x1f, 0xf0, 0x7d, 0xfa, 0xb6, 0xe5,
+	0x37, 0x17, 0xe4, 0x3e, 0x6c, 0x60, 0xfc, 0x7a, 0x1e, 0x96, 0x54, 0x1a, 0xee, 0xe2, 0x24, 0x42,
+	0x64, 0x2b, 0x13, 0x90, 0x9d, 0x9b, 0x88, 0x6c, 0x55, 0x47, 0xf6, 0x1c, 0x34, 0xba, 0xc4, 0xef,
+	0x78, 0x36, 0x57, 0x4a, 0x49, 0x8a, 0x3a, 0xc5, 0xf6, 0xec, 0x93, 0x43, 0xd2, 0x0f, 0xc8, 0xe1,
+	0x03, 0x7e, 0xfa, 0xc9, 0xe3, 0x76, 0x41, 0xa8, 0xb5, 0x1c, 0xe2, 0xeb, 0x50, 0x1b, 0x5a, 0xf4,
+	0xc0, 0x6f, 0x02, 0xd7, 0xa2, 0x2f, 0x65, 0xd5, 0xa2, 0x5b, 0x16, 0x3d, 0x30, 0x05, 0x08, 0x7e,
+	0x92, 0x52, 0x8b, 0x8e, 0xfc, 0xe6, 0xa2, 0x3c, 0x49, 0xf9, 0x08, 0x13, 0x80, 0xa1, 0xe7, 0x0e,
+	0x89, 0x47, 0x6d, 0xe2, 0x37, 0xeb, 0x7c, 0xa3, 0x2b, 0x53, 0x6f, 0xa4, 0x32, 0x7c, 0xed, 0x56,
+	0x08, 0xe7, 0x8a, 0x43, 0xbd, 0x23, 0x53, 0x01, 0xcc, 0x84, 0x41, 0xed, 0x01, 0xf1, 0xa9, 0x35,
+	0x18, 0x36, 0x1b, 0x42, 0x18, 0xe1, 0x04, 0x7e, 0x09, 0xea, 0x43, 0xcf, 0x3d, 0xb4, 0xbb, 0xc4,
+	0xf3, 0x9b, 0x4b, 0x1c, 0x87, 0x4b, 0x53, 0xe3, 0x70, 0x99, 0x0c, 0x89, 0xd3, 0x25, 0x4e, 0xe7,
+	0x68, 0xc7, 0xf6, 0x22, 0x74, 0xcc, 0x08, 0x64, 0xa4, 0x31, 0xcb, 0x8a, 0xc6, 0x30, 0xd2, 0x9f,
+	0xdc, 0x6c, 0x53, 0xcf, 0xa2, 0xa4, 0x77, 0xd4, 0x3c, 0x56, 0x84, 0xf4, 0x08, 0x8e, 0x24, 0x3d,
+	0x9a, 0xc0, 0x06, 0x2c, 0x0d, 0xdc, 0xee, 0x6e, 0x48, 0xfd, 0x71, 0x8e, 0x83, 0x36, 0xd7, 0xba,
+	0x00, 0xc7, 0x63, 0xdc, 0xc3, 0x27, 0x60, 0xee, 0x0e, 0x39, 0x92, 0x8a, 0xcb, 0x1e, 0x19, 0x15,
+	0x87, 0x56, 0x7f, 0x44, 0x02, 0x95, 0xe5, 0x83, 0x47, 0x2b, 0x8f, 0x20, 0xb6, 0x3c, 0x86, 0x41,
+	0x96, 0xe5, 0xc6, 0x3f, 0x10, 0x34, 0x02, 0xae, 0x8d, 0xfa, 0x84, 0xe9, 0x8a, 0x37, 0xea, 0x47,
+	0x66, 0x23, 0x47, 0x2c, 0x86, 0x63, 0x4f, 0xbb, 0x47, 0xc3, 0x00, 0x48, 0x38, 0x66, 0x02, 0xb6,
+	0x28, 0xf5, 0xec, 0xbd, 0x11, 0x0d, 0xec, 0x26, 0x9a, 0xe0, 0x4e, 0xc3, 0xa2, 0x94, 0x78, 0xa1,
+	0xd5, 0xc8, 0xe1, 0x14, 0x56, 0xa3, 0xa9, 0xce, 0x7c, 0x5c, 0x75, 0xe2, 0xdc, 0x5d, 0x48, 0x72,
+	0xd7, 0x78, 0x07, 0xc1, 0x99, 0x8d, 0x6e, 0xf7, 0xa6, 0xf7, 0xcc, 0xb0, 0x6b, 0x51, 0xa2, 0x92,
+	0xaa, 0x92, 0x84, 0x26, 0x91, 0x54, 0x99, 0x40, 0xd2, 0xdc, 0x44, 0x92, 0xaa, 0x09, 0x92, 0x8c,
+	0x8f, 0x22, 0x86, 0x33, 0x1b, 0xc5, 0x18, 0xaa, 0xcc, 0x4a, 0x25, 0x06, 0xfc, 0x19, 0xbf, 0x04,
+	0x8b, 0xd2, 0x7e, 0x8e, 0xe4, 0x29, 0xb2, 0x99, 0xc7, 0xfe, 0x03, 0xab, 0x94, 0x8a, 0x19, 0xc2,
+	0x6c, 0x3d, 0x06, 0xcb, 0xda, 0xab, 0x4c, 0x1a, 0xf3, 0x08, 0x2c, 0x86, 0xc7, 0x28, 0x86, 0x6a,
+	0xc7, 0xed, 0x0a, 0xf6, 0xd5, 0x4c, 0xfe, 0xcc, 0x98, 0x33, 0x90, 0xf1, 0x95, 0x3c, 0x24, 0xe4,
+	0xd0, 0xf8, 0x0b, 0x82, 0x53, 0x57, 0x09, 0xbd, 0xf2, 0xba, 0xed, 0x53, 0xc2, 0xc2, 0x07, 0x79,
+	0xb8, 0x63, 0xa8, 0xd2, 0x48, 0x08, 0xfc, 0xb9, 0x04, 0x1f, 0xad, 0x9d, 0x09, 0xb5, 0xf8, 0x99,
+	0xa0, 0xe6, 0x28, 0xf3, 0xc9, 0x1c, 0x25, 0x08, 0x31, 0x16, 0xf4, 0x10, 0xe3, 0x37, 0x08, 0x56,
+	0x74, 0x8a, 0xca, 0x89, 0x2f, 0x34, 0xdc, 0x2b, 0x93, 0x70, 0x9f, 0x1b, 0x9f, 0x5f, 0x55, 0xb5,
+	0xfc, 0xca, 0xf8, 0x60, 0x0e, 0x56, 0xb6, 0x3c, 0xa2, 0x18, 0x85, 0x14, 0xc7, 0x4d, 0x58, 0x90,
+	0xb0, 0x25, 0xea, 0x5f, 0xce, 0xe5, 0x18, 0xcd, 0x00, 0x0a, 0x7e, 0x06, 0x6a, 0xcc, 0xb0, 0x82,
+	0xac, 0xe0, 0xe2, 0xd4, 0xe0, 0xd2, 0x0d, 0xd7, 0x14, 0xd0, 0xf0, 0x0b, 0x50, 0xa5, 0x56, 0x8f,
+	0x05, 0x42, 0x0c, 0xea, 0xd5, 0xa9, 0xa1, 0xa6, 0x11, 0xbd, 0xb6, 0x6b, 0xf5, 0xe4, 0xd1, 0xc5,
+	0x81, 0xe2, 0x17, 0xd4, 0x08, 0xb9, 0xca, 0x77, 0xb8, 0x90, 0x8b, 0x0d, 0x29, 0xb1, 0x72, 0xeb,
+	0x61, 0xa8, 0x87, 0xfb, 0x65, 0xb2, 0xbd, 0xb7, 0x10, 0x9c, 0x8e, 0xa1, 0xff, 0x09, 0x28, 0x9c,
+	0x71, 0x1d, 0x56, 0x2e, 0x93, 0x3e, 0x49, 0x68, 0xce, 0x5d, 0xc3, 0xae, 0x7d, 0xd7, 0xeb, 0x04,
+	0x71, 0xba, 0x18, 0xb0, 0x74, 0x3e, 0x06, 0xab, 0x9c, 0x74, 0xfe, 0x06, 0x9c, 0x8c, 0x92, 0x81,
+	0xe9, 0x10, 0x1e, 0x9f, 0x5a, 0xfc, 0x12, 0x01, 0x56, 0xa1, 0x95, 0x23, 0x04, 0xc5, 0x10, 0x2b,
+	0xb3, 0x30, 0x44, 0x63, 0x4d, 0xc5, 0xda, 0x57, 0x72, 0xab, 0x80, 0x4c, 0xa4, 0x93, 0xf9, 0x2b,
+	0xe1, 0xb0, 0xa3, 0x05, 0xe5, 0xd0, 0xf9, 0xb4, 0x92, 0xdd, 0x0a, 0x17, 0x91, 0x93, 0xd0, 0x10,
+	0x8c, 0xf1, 0x6f, 0x04, 0x67, 0x35, 0xc7, 0xc1, 0xce, 0xbb, 0x29, 0x6b, 0x60, 0x9e, 0x16, 0x16,
+	0x0b, 0x84, 0xcc, 0xa9, 0x11, 0x1a, 0xbb, 0xeb, 0xa4, 0x18, 0xb9, 0x60, 0x10, 0x68, 0xdc, 0x81,
+	0x56, 0xda, 0xbe, 0xe5, 0x58, 0xd2, 0x2d, 0x35, 0x4b, 0x67, 0x0e, 0xd9, 0x9f, 0x81, 0x39, 0xad,
+	0x26, 0x40, 0x96, 0xa3, 0x6b, 0xd7, 0xf5, 0xb3, 0x28, 0x73, 0x5e, 0xa5, 0x1c, 0x40, 0xc6, 0xfb,
+	0x08, 0x9a, 0xc9, 0xd3, 0x69, 0x2a, 0x5e, 0x44, 0x61, 0x76, 0x45, 0x0b, 0xb3, 0xdb, 0x50, 0x65,
+	0x4f, 0x32, 0xb9, 0x2f, 0x7c, 0x52, 0x72, 0x60, 0xc6, 0x2b, 0x31, 0x5b, 0x10, 0x68, 0x96, 0xa3,
+	0x1c, 0x3f, 0x10, 0xf1, 0x76, 0x76, 0xed, 0x28, 0x27, 0x48, 0x30, 0xde, 0x44, 0xb0, 0x9a, 0xc0,
+	0xa7, 0x1c, 0xd5, 0x6a, 0xc2, 0x82, 0xc9, 0xa5, 0x28, 0x68, 0xa8, 0x9b, 0xc1, 0xd0, 0x68, 0xc3,
+	0x59, 0xfd, 0x8c, 0xcb, 0x64, 0x34, 0x9e, 0x0e, 0x54, 0x0e, 0x99, 0xcd, 0xa7, 0x01, 0x2d, 0x47,
+	0xac, 0x37, 0xe1, 0x74, 0x64, 0xa0, 0x2c, 0x76, 0x29, 0x6a, 0xf2, 0xff, 0x43, 0xaa, 0x17, 0x11,
+	0x10, 0xcb, 0x11, 0xcb, 0xd7, 0x64, 0x98, 0x28, 0xf4, 0x6a, 0x7b, 0x6a, 0x50, 0xe9, 0xd8, 0xc5,
+	0x03, 0xc5, 0xfc, 0xb1, 0xdc, 0xcb, 0xb0, 0xaa, 0x69, 0xed, 0xae, 0xd5, 0x9b, 0x8e, 0xa9, 0x72,
+	0x93, 0x4a, 0xca, 0x26, 0x73, 0xca, 0x26, 0x86, 0x1d, 0xf3, 0x4e, 0x7c, 0x83, 0x72, 0xd4, 0xe3,
+	0x4f, 0x08, 0x4e, 0x47, 0x56, 0x36, 0xbd, 0x7e, 0xbc, 0xa8, 0xc9, 0xe6, 0x5a, 0x16, 0x9b, 0x4f,
+	0xee, 0x35, 0x3b, 0xd1, 0xf4, 0x54, 0x1f, 0x56, 0xa2, 0x6e, 0x1a, 0x4f, 0x42, 0x53, 0xb3, 0xe1,
+	0xe9, 0x39, 0x87, 0xa1, 0x7a, 0x87, 0x1c, 0x05, 0x4e, 0x81, 0x3f, 0x33, 0x3f, 0x9f, 0x02, 0xad,
+	0x1c, 0xcc, 0x8f, 0xa0, 0x71, 0x8d, 0x58, 0x7d, 0x7a, 0xb0, 0x75, 0x40, 0x3a, 0x77, 0x18, 0x3a,
+	0x83, 0xa0, 0x10, 0x50, 0x37, 0xf9, 0x33, 0xaf, 0x6c, 0xb8, 0x9e, 0x28, 0x15, 0xd7, 0x4c, 0xfe,
+	0xcc, 0x52, 0x55, 0xdb, 0xa1, 0xc4, 0x3b, 0xb4, 0xfa, 0x5c, 0x59, 0x6b, 0x66, 0x38, 0x66, 0xf2,
+	0xe0, 0xb5, 0x1d, 0x9e, 0xa8, 0xd6, 0x4c, 0x31, 0x60, 0x72, 0x1b, 0x79, 0x7d, 0x99, 0xb0, 0xb3,
+	0x47, 0xe3, 0x3f, 0x55, 0x58, 0x49, 0xcb, 0xb0, 0x62, 0x97, 0x3f, 0x28, 0x71, 0xf9, 0x33, 0x39,
+	0x8b, 0xbe, 0x07, 0xea, 0xc4, 0xe9, 0x0e, 0x5d, 0xdb, 0xa1, 0x22, 0xa7, 0xac, 0x9b, 0xd1, 0x04,
+	0x43, 0xfc, 0xc0, 0xf5, 0xa9, 0x52, 0xc7, 0x0e, 0xc7, 0x4a, 0x7d, 0xb5, 0xa6, 0xd5, 0x57, 0x07,
+	0x5a, 0x20, 0x39, 0xcf, 0x75, 0x7c, 0xa7, 0x50, 0x12, 0x39, 0xb1, 0xce, 0x7a, 0x1b, 0x1a, 0x07,
+	0x91, 0x48, 0x78, 0xa9, 0x22, 0x4b, 0x80, 0xa3, 0x88, 0xd3, 0x54, 0x01, 0xe9, 0x45, 0xb8, 0xc5,
+	0x78, 0x11, 0xee, 0x65, 0x38, 0xd6, 0xb5, 0xa8, 0xb5, 0x45, 0x98, 0x18, 0xb7, 0x9d, 0x7d, 0xb7,
+	0x59, 0xe7, 0x1b, 0x3f, 0x3c, 0x7d, 0x11, 0x57, 0x5b, 0x6e, 0xc6, 0xc0, 0xe1, 0x73, 0xd0, 0x20,
+	0xce, 0xa1, 0xed, 0xb9, 0xce, 0x80, 0x38, 0xb4, 0x09, 0xa2, 0xe6, 0xa3, 0x4c, 0x25, 0xea, 0x80,
+	0x8d, 0x99, 0x57, 0x59, 0x8d, 0x3d, 0x38, 0xa6, 0xa3, 0xc9, 0xb4, 0xdb, 0x61, 0xca, 0x20, 0x35,
+	0xde, 0x91, 0x8a, 0xc0, 0x28, 0x73, 0x9d, 0x30, 0xaa, 0xe3, 0x23, 0x7c, 0x1f, 0x2c, 0x5b, 0x87,
+	0x96, 0xdd, 0xb7, 0xf6, 0xfa, 0xe4, 0x79, 0xd7, 0x09, 0xfc, 0xb4, 0x3e, 0x69, 0x3c, 0x0b, 0xab,
+	0x69, 0x32, 0xbf, 0x41, 0x8e, 0x8a, 0x69, 0xb6, 0x41, 0x61, 0xd5, 0xe4, 0x0c, 0x67, 0xa8, 0xcb,
+	0x6a, 0x84, 0x74, 0x32, 0xcf, 0x31, 0x7b, 0x14, 0x53, 0xd2, 0x2b, 0x14, 0xac, 0x72, 0x84, 0xe0,
+	0x8c, 0xef, 0x22, 0x68, 0x26, 0xb7, 0x2d, 0xe7, 0x8c, 0xbf, 0xdb, 0x1d, 0xf8, 0x73, 0x70, 0xf6,
+	0x19, 0xc7, 0x1b, 0xc3, 0x83, 0x62, 0xd7, 0xeb, 0x2c, 0xf5, 0x4a, 0x01, 0x5d, 0x56, 0xea, 0x75,
+	0x22, 0xbc, 0xca, 0x9f, 0x0d, 0xfa, 0x7b, 0x70, 0x52, 0x81, 0x58, 0x0e, 0xd6, 0xff, 0x44, 0xb0,
+	0xf2, 0x84, 0xed, 0x74, 0x03, 0xee, 0x84, 0x47, 0xdc, 0x03, 0x70, 0xb2, 0xe3, 0x3a, 0xfe, 0x68,
+	0x40, 0xbc, 0x76, 0x8c, 0x84, 0xe4, 0x8b, 0xdc, 0x25, 0xe1, 0x73, 0xd0, 0x90, 0x35, 0x60, 0x16,
+	0x22, 0x07, 0x35, 0x79, 0x65, 0x8a, 0x17, 0xa0, 0x59, 0x18, 0x52, 0x13, 0x87, 0x29, 0x2f, 0x00,
+	0x9e, 0x80, 0x39, 0xe2, 0x1c, 0xca, 0x5a, 0x30, 0x7b, 0x9c, 0x50, 0x06, 0xfe, 0x23, 0x82, 0xd3,
+	0x31, 0x02, 0xcb, 0xd1, 0xf3, 0x17, 0x92, 0x3d, 0x16, 0x33, 0xab, 0x4a, 0x1a, 0xff, 0x42, 0x3c,
+	0xc8, 0xbf, 0xe9, 0x90, 0xb8, 0x85, 0x64, 0x93, 0xd3, 0x03, 0x70, 0x32, 0xb8, 0x7e, 0x6b, 0xc7,
+	0x9c, 0x52, 0xf2, 0x05, 0x5e, 0x03, 0x1c, 0x4c, 0x6e, 0x47, 0x8a, 0x2a, 0xc4, 0x98, 0xf2, 0x26,
+	0x94, 0x55, 0x35, 0x29, 0xab, 0x5a, 0xaa, 0xac, 0xe6, 0x75, 0x59, 0xfd, 0x41, 0x24, 0x1e, 0x1a,
+	0x95, 0xe5, 0x08, 0x4b, 0xf5, 0xad, 0x95, 0xd9, 0xfa, 0xd6, 0x0f, 0x44, 0x61, 0xae, 0xa0, 0x41,
+	0x65, 0x13, 0x14, 0x56, 0xca, 0xed, 0x31, 0xc6, 0x57, 0x53, 0x19, 0x5f, 0x4b, 0x30, 0x7e, 0x45,
+	0xc7, 0xf9, 0x53, 0x68, 0x23, 0x3e, 0x7c, 0x46, 0xe4, 0x54, 0xc1, 0xcb, 0x36, 0x0f, 0xf5, 0x66,
+	0xe2, 0x8b, 0x95, 0x38, 0x72, 0x4e, 0x8d, 0x23, 0x8d, 0x01, 0xdc, 0x93, 0xbe, 0x69, 0x39, 0xee,
+	0xfa, 0x9d, 0x4a, 0x50, 0x4d, 0x0c, 0xf6, 0xcb, 0x50, 0x3c, 0xbd, 0x1b, 0x8d, 0xbe, 0x16, 0x13,
+	0x8b, 0xab, 0x9b, 0x76, 0xc6, 0xe2, 0x6a, 0x1a, 0x5a, 0x65, 0x56, 0x57, 0xfb, 0x71, 0xa1, 0x97,
+	0x5a, 0x5e, 0x3d, 0x0f, 0x2b, 0xcf, 0x5a, 0xb4, 0x73, 0x10, 0x77, 0xc2, 0xf7, 0xc1, 0xb2, 0x4f,
+	0xfa, 0xfb, 0x71, 0xbb, 0xd6, 0x27, 0x8d, 0xf7, 0x2b, 0x70, 0x3a, 0xb6, 0xbc, 0x1c, 0x33, 0x3b,
+	0x03, 0xf3, 0x56, 0x87, 0x2a, 0xb1, 0xae, 0x18, 0xe1, 0xeb, 0x82, 0xb1, 0xa2, 0x80, 0xf9, 0x48,
+	0x2e, 0xc3, 0xbb, 0x41, 0x8e, 0x84, 0x48, 0x54, 0x0f, 0x5a, 0x9d, 0xad, 0x07, 0xdd, 0x87, 0x13,
+	0x57, 0x09, 0x95, 0x3d, 0xab, 0x53, 0x69, 0xb6, 0x7a, 0xcb, 0x5a, 0x19, 0x7f, 0x43, 0x3c, 0xa7,
+	0x7b, 0xbd, 0xaf, 0x8b, 0x6b, 0x27, 0xb9, 0x4f, 0x69, 0xa2, 0x90, 0x9d, 0xb2, 0x15, 0xad, 0x53,
+	0xf6, 0x26, 0x9c, 0x92, 0xf5, 0x80, 0xd9, 0x90, 0x69, 0x90, 0xf0, 0xde, 0xaf, 0x4c, 0x7a, 0x8c,
+	0x37, 0x10, 0x9c, 0x52, 0x5b, 0x7c, 0x8b, 0xcb, 0x67, 0x4c, 0x2f, 0xf1, 0x84, 0xdb, 0x71, 0xa2,
+	0xb7, 0x4f, 0x97, 0x48, 0xea, 0x59, 0x71, 0xa1, 0x1b, 0xb6, 0x32, 0xd9, 0xd1, 0x71, 0xde, 0x85,
+	0xa5, 0xae, 0x32, 0x2d, 0xdb, 0x8d, 0x2f, 0x65, 0xb0, 0x01, 0xa5, 0x29, 0x2a, 0xea, 0x95, 0x32,
+	0x35, 0xa8, 0x0c, 0x87, 0xd5, 0x31, 0x8d, 0x54, 0x51, 0xcc, 0x8d, 0x26, 0xc4, 0xdc, 0x95, 0x89,
+	0x6d, 0x18, 0x73, 0x63, 0xfa, 0xfa, 0xaa, 0x4a, 0x5f, 0x9f, 0xf1, 0x37, 0xc4, 0x92, 0xdf, 0x54,
+	0x6c, 0xf1, 0x8b, 0xb0, 0x18, 0xc4, 0x2e, 0x92, 0xe5, 0xc5, 0x1b, 0xc4, 0x42, 0x88, 0x7a, 0xff,
+	0x59, 0x65, 0xe6, 0xfd, 0x67, 0x2c, 0x3f, 0x4c, 0x13, 0x70, 0x99, 0x57, 0x73, 0x69, 0xaa, 0x94,
+	0xb7, 0x4e, 0xff, 0x3b, 0x04, 0xad, 0xab, 0x84, 0x6e, 0xb9, 0xce, 0xc7, 0x80, 0x3f, 0x6e, 0x27,
+	0x85, 0x91, 0xf3, 0x2a, 0x58, 0x91, 0x80, 0x24, 0xe1, 0x96, 0xe7, 0x7e, 0x4c, 0x24, 0x04, 0xba,
+	0x55, 0x94, 0x84, 0x10, 0x8e, 0xf1, 0xf7, 0x0a, 0x1c, 0x97, 0xd3, 0x37, 0x0f, 0xd9, 0x5f, 0xf2,
+	0x1a, 0x7e, 0x0e, 0x96, 0x06, 0xf2, 0xe7, 0xf6, 0x61, 0xd1, 0x5e, 0x1d, 0x0d, 0x54, 0xa9, 0x21,
+	0x34, 0xbe, 0xad, 0xb5, 0xed, 0x64, 0x6e, 0x6c, 0x0b, 0xe8, 0x9f, 0x5d, 0xb5, 0xff, 0xaf, 0x35,
+	0x58, 0xd6, 0x7a, 0xaf, 0x3f, 0xb5, 0xac, 0x7d, 0x1a, 0x1a, 0xf2, 0xc8, 0x73, 0xf6, 0xdd, 0x80,
+	0xc3, 0x99, 0xff, 0x83, 0x47, 0x85, 0x11, 0xdd, 0x97, 0x57, 0x0b, 0xdf, 0x97, 0xeb, 0xd6, 0x5d,
+	0x9b, 0x8d, 0x75, 0xeb, 0xf6, 0x36, 0x3f, 0x1b, 0x7b, 0xc3, 0xbb, 0x52, 0x47, 0x17, 0x32, 0x9e,
+	0x07, 0x9a, 0x1a, 0x25, 0x7a, 0xca, 0xd6, 0x61, 0x65, 0xa0, 0x6c, 0x78, 0x5b, 0x9c, 0x88, 0x7e,
+	0x73, 0x91, 0x67, 0xd4, 0xa9, 0xef, 0xf2, 0x6b, 0xf5, 0x87, 0x08, 0x9a, 0xd1, 0x15, 0xa6, 0xfc,
+	0xa7, 0x82, 0x92, 0x7c, 0xde, 0xad, 0x78, 0xa3, 0x52, 0xde, 0x7f, 0x7a, 0x08, 0x3b, 0x95, 0xae,
+	0x03, 0xbe, 0x4c, 0xfa, 0xf1, 0x4e, 0xa5, 0x7b, 0x01, 0xc2, 0x33, 0x2b, 0xf8, 0x47, 0x10, 0x65,
+	0x66, 0x4c, 0x87, 0x99, 0xa9, 0xc3, 0xf2, 0x87, 0xbc, 0x7e, 0xaf, 0xff, 0x27, 0x10, 0x8a, 0xff,
+	0x27, 0xd0, 0x5d, 0x4a, 0xea, 0xbf, 0x45, 0x3c, 0xb6, 0x2e, 0xbb, 0x33, 0xea, 0xd9, 0x44, 0x67,
+	0xd4, 0x63, 0x19, 0x62, 0x93, 0x38, 0xcd, 0x51, 0x7f, 0xd4, 0xfa, 0x7b, 0x67, 0xc3, 0x2e, 0xe4,
+	0x2d, 0xea, 0xf5, 0xf1, 0x5b, 0x08, 0x6a, 0xe4, 0x75, 0xdb, 0xa7, 0xf8, 0x7c, 0x96, 0x0b, 0xf2,
+	0x78, 0x2b, 0x6f, 0xeb, 0x42, 0xce, 0xd5, 0x92, 0xde, 0x6f, 0x23, 0x98, 0xef, 0xf0, 0x68, 0x09,
+	0x5f, 0x28, 0xd4, 0xcf, 0xd9, 0x7a, 0x3c, 0xef, 0x72, 0x05, 0x93, 0x2e, 0xcf, 0x75, 0x32, 0x60,
+	0x92, 0xd6, 0x14, 0x99, 0x01, 0x93, 0xf4, 0x3e, 0xc8, 0x37, 0x10, 0xcc, 0xf7, 0x78, 0xc1, 0x12,
+	0x3f, 0x9a, 0xa3, 0x79, 0x21, 0x40, 0xe3, 0xb1, 0x5c, 0x6b, 0x25, 0x0e, 0xdf, 0x41, 0xd0, 0xe8,
+	0x45, 0x8d, 0x80, 0x38, 0x0f, 0xb0, 0xc0, 0x8a, 0x5b, 0xe7, 0xf3, 0x2d, 0x96, 0xa8, 0xbc, 0x87,
+	0xe0, 0xc4, 0x88, 0x57, 0x63, 0xa2, 0x92, 0x0e, 0xde, 0x2c, 0xde, 0x9e, 0xd7, 0xda, 0x2a, 0x04,
+	0x43, 0x62, 0xf7, 0x7d, 0x04, 0x0b, 0x56, 0xb7, 0xcb, 0x6f, 0x15, 0x2e, 0xe6, 0x68, 0x67, 0x50,
+	0x3b, 0x83, 0x5a, 0x97, 0xf2, 0x03, 0x50, 0xd0, 0xe9, 0x11, 0x9a, 0x11, 0x9d, 0xf4, 0xee, 0xbe,
+	0x0c, 0xe8, 0x8c, 0xeb, 0xe5, 0xfb, 0x31, 0x02, 0x10, 0xb2, 0xe3, 0x18, 0x6d, 0xe4, 0xe3, 0xb8,
+	0xd2, 0x65, 0xd7, 0xda, 0x2c, 0x02, 0x42, 0x62, 0xf5, 0x53, 0x04, 0x20, 0x4c, 0x9d, 0x63, 0xb5,
+	0x99, 0xd3, 0x5e, 0x55, 0x56, 0x6d, 0x15, 0x82, 0x21, 0xf1, 0xfa, 0x9e, 0xd0, 0x25, 0x76, 0xfc,
+	0xe3, 0xc7, 0x8b, 0xb5, 0xc6, 0xb4, 0x2e, 0xe6, 0x5e, 0xaf, 0x20, 0xd3, 0x23, 0x34, 0x23, 0x32,
+	0xa9, 0x3d, 0x63, 0xad, 0x8b, 0x05, 0x7b, 0xb0, 0xf0, 0x8f, 0x10, 0xd4, 0x85, 0x1e, 0xed, 0x5a,
+	0x3d, 0x7c, 0x29, 0x9f, 0x0e, 0x44, 0xfd, 0x56, 0xad, 0x8d, 0x02, 0x10, 0x14, 0xd5, 0x16, 0x4a,
+	0xc4, 0x59, 0xb4, 0x91, 0x4f, 0x01, 0x54, 0x2e, 0x6d, 0x16, 0x01, 0x21, 0xb1, 0xfa, 0x16, 0x82,
+	0xe5, 0x5e, 0x50, 0x7e, 0xe4, 0x61, 0xcf, 0x57, 0x33, 0xf1, 0x5e, 0x2d, 0xbf, 0xb5, 0x1e, 0xcd,
+	0xb3, 0x54, 0x22, 0xf2, 0x36, 0x82, 0xa5, 0xae, 0x52, 0x3a, 0xcc, 0x10, 0x66, 0xa4, 0x94, 0x30,
+	0x5b, 0x17, 0x72, 0xae, 0x56, 0xb0, 0x19, 0x28, 0xd5, 0xbd, 0x0c, 0xd8, 0xa4, 0xd4, 0x25, 0x33,
+	0x60, 0x93, 0x5a, 0x52, 0x7c, 0x07, 0xc1, 0xb2, 0x8a, 0x8d, 0x8f, 0xf3, 0x01, 0xf4, 0xb3, 0x47,
+	0x1c, 0xe9, 0x1f, 0x52, 0xf8, 0x05, 0x82, 0xcf, 0x75, 0x12, 0x35, 0xab, 0x27, 0x5c, 0x6f, 0xc7,
+	0xf6, 0x3a, 0x61, 0x0c, 0xb0, 0x99, 0x31, 0xc2, 0x4a, 0xa9, 0x4a, 0x65, 0xf0, 0x93, 0x13, 0x6a,
+	0x68, 0x3f, 0x43, 0xb0, 0xda, 0xe3, 0xf5, 0x1d, 0x9e, 0x12, 0xaa, 0xbf, 0xc9, 0x76, 0xe8, 0x15,
+	0xc3, 0x70, 0x42, 0x89, 0x49, 0x62, 0xb8, 0x25, 0xf3, 0xcb, 0x4f, 0x10, 0xc3, 0x71, 0x75, 0xbc,
+	0xb7, 0x11, 0x1c, 0xeb, 0xaa, 0x6e, 0x24, 0x4b, 0x8c, 0x97, 0xcc, 0xd4, 0x5a, 0xe7, 0xf3, 0x2d,
+	0x16, 0xd8, 0xac, 0xff, 0xb9, 0x01, 0xa7, 0x62, 0x65, 0x0e, 0x9e, 0xa5, 0xfc, 0x10, 0xb1, 0xf4,
+	0x4a, 0xb4, 0xda, 0x64, 0x70, 0xfb, 0x63, 0x9a, 0x9f, 0x32, 0xb8, 0xfd, 0xb1, 0x7d, 0x4c, 0x2c,
+	0x76, 0x18, 0x85, 0xed, 0x3f, 0x59, 0xe2, 0xd0, 0x71, 0xed, 0x48, 0x59, 0xe2, 0xd0, 0xf1, 0x7d,
+	0x47, 0x6f, 0x22, 0xa8, 0x1f, 0x04, 0x7d, 0x3d, 0x19, 0x9c, 0x7e, 0xbc, 0xbb, 0x28, 0x83, 0xd3,
+	0x4f, 0xb6, 0x11, 0x7d, 0x13, 0x41, 0x75, 0xdf, 0x76, 0xba, 0x19, 0xfc, 0x59, 0x5a, 0x9b, 0x50,
+	0x06, 0x7f, 0x96, 0xde, 0x84, 0xc3, 0xdc, 0x7d, 0x4f, 0xe9, 0x3c, 0xc8, 0x96, 0xe3, 0x26, 0xd0,
+	0xb9, 0x90, 0x73, 0xb5, 0xc4, 0xe6, 0x5d, 0x04, 0xc7, 0x7a, 0x5a, 0x03, 0x4a, 0xb6, 0x80, 0x2a,
+	0xd9, 0x9f, 0x93, 0x2d, 0xa0, 0x4a, 0xeb, 0x7c, 0x79, 0x0f, 0xc1, 0x92, 0x08, 0xa8, 0x44, 0x6b,
+	0x01, 0xbe, 0x9c, 0xf3, 0x4a, 0x5e, 0x6b, 0x87, 0x68, 0x5d, 0x29, 0x08, 0x45, 0x62, 0xf7, 0x3e,
+	0x82, 0xe6, 0x28, 0x71, 0x01, 0x2f, 0x53, 0xbf, 0xad, 0x19, 0x34, 0x0f, 0xb4, 0x2e, 0x17, 0x03,
+	0x12, 0x65, 0xc9, 0xb5, 0xd7, 0x2c, 0xda, 0x39, 0xc8, 0xa0, 0xf0, 0x69, 0x57, 0xfd, 0x19, 0x14,
+	0x3e, 0xf5, 0xaa, 0xff, 0x41, 0xc4, 0x55, 0xfe, 0x40, 0xf9, 0xe8, 0x0f, 0xce, 0xf7, 0x8d, 0xa2,
+	0xec, 0x2a, 0x9f, 0xf6, 0xa5, 0xa1, 0xf5, 0x8f, 0x2a, 0x70, 0xf2, 0xaa, 0x7b, 0x48, 0x3c, 0x47,
+	0xad, 0x39, 0xbd, 0x8b, 0xe0, 0x44, 0x2f, 0x56, 0xa1, 0x2c, 0x54, 0xe2, 0xd8, 0xc8, 0xb1, 0x36,
+	0x56, 0x18, 0xfd, 0x09, 0x82, 0xe3, 0x3d, 0xfd, 0x9b, 0x31, 0xb9, 0x12, 0x67, 0xf5, 0xe3, 0x35,
+	0xb9, 0x12, 0x67, 0xed, 0x73, 0x35, 0x9b, 0x0f, 0xc2, 0xb4, 0xdf, 0xfd, 0x7a, 0xbe, 0xc6, 0xbf,
+	0x13, 0xb6, 0x37, 0xcf, 0xff, 0x3c, 0xf4, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6d, 0x81, 0xd0,
+	0x6a, 0x40, 0x4c, 0x00, 0x00,
 }
diff --git a/server/core/proto/services.proto b/server/core/proto/services.proto
index d62190591..b8db2b012 100644
--- a/server/core/proto/services.proto
+++ b/server/core/proto/services.proto
@@ -174,12 +174,7 @@ message ServicePath {
 }
 
 message Response {
-    enum Code {
-        UNKNOWN = 0;
-        SUCCESS = 1;
-        FAIL = 2;
-    }
-    Code code = 1;
+    int32 code = 1;
     string message = 2;
 }
 
diff --git a/server/error/error.go b/server/error/error.go
new file mode 100644
index 000000000..74224f70e
--- /dev/null
+++ b/server/error/error.go
@@ -0,0 +1,126 @@
+//Copyright 2017 Huawei Technologies Co., Ltd
+//
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+package error
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/ServiceComb/service-center/pkg/util"
+	"net/http"
+)
+
+var errors = map[int32]string{
+	ErrInvalidParams: "Invalid parameter(s)",
+
+	ErrServiceAlreadyExists: "Micro-service already exists",
+	ErrServiceNotExists:     "Micro-service does not exist",
+	ErrDeployedInstance:     "Micro-service has deployed instance(s)",
+	ErrDependedOnConsumer:   "Consumer(s) depends on this micro-service",
+
+	ErrUndefinedSchemaId:    "Undefined schema id",
+	ErrModifySchemaNotAllow: "Not allowed to modify schema",
+	ErrSchemaNotExists:      "Schema does not exist",
+
+	ErrInstanceNotExists: "Instance does not exist",
+	ErrPermissionDeny:    "Access micro-service refused",
+
+	ErrTagNotExists: "Tag does not exist",
+
+	ErrRuleAlreadyExists:  "Rule already exist",
+	ErrBlackAndWhiteRule:  "Can not have both 'BLACK' and 'WHITE'",
+	ErrModifyRuleNotAllow: "Not allowed to modify the type of the rule",
+	ErrRuleNotExists:      "Rule does not exist",
+
+	ErrNotEnoughQuota: "Not enough quota",
+
+	ErrUnauthorized: "Request unauthorized",
+
+	ErrInternal:           "Internal server error",
+	ErrUnavailableBackend: "Registry service is unavailable",
+	ErrUnavailableQuota:   "Quota service is unavailable",
+}
+
+const (
+	ErrInvalidParams int32 = 400001
+	ErrUnauthorized  int32 = 401002
+	ErrInternal      int32 = 500003
+
+	ErrServiceAlreadyExists int32 = 400010
+	ErrUnavailableBackend   int32 = 500011
+
+	ErrServiceNotExists int32 = 400012
+
+	ErrDeployedInstance int32 = 400013
+
+	ErrUndefinedSchemaId    int32 = 400014
+	ErrModifySchemaNotAllow int32 = 400015
+	ErrSchemaNotExists      int32 = 400016
+
+	ErrInstanceNotExists int32 = 400017
+
+	ErrTagNotExists int32 = 400018
+
+	ErrRuleAlreadyExists  int32 = 400019
+	ErrBlackAndWhiteRule  int32 = 400020
+	ErrModifyRuleNotAllow int32 = 400021
+	ErrRuleNotExists      int32 = 400022
+
+	ErrDependedOnConsumer int32 = 400023
+
+	ErrPermissionDeny int32 = 400024
+
+	ErrNotEnoughQuota   int32 = 400100
+	ErrUnavailableQuota int32 = 500101
+)
+
+type Error struct {
+	Code    int32  `json:"errorCode,string"`
+	Message string `json:"errorMessage"`
+	Detail  string `json:"detail,omitempty"`
+}
+
+func (e Error) Error() string {
+	if len(e.Detail) == 0 {
+		return e.Message
+	}
+	return e.Message + "(" + e.Detail + ")"
+}
+
+func (e Error) toJson() string {
+	bs, _ := json.Marshal(e)
+	return util.BytesToStringWithNoCopy(bs)
+}
+
+func (e Error) StatusCode() int {
+	if e.Code >= 500000 {
+		return http.StatusInternalServerError
+	}
+	return http.StatusBadRequest
+}
+
+func (e Error) HttpWrite(w http.ResponseWriter) {
+	status := e.StatusCode()
+	w.Header().Add("X-Response-Status", fmt.Sprint(status))
+	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+	w.WriteHeader(status)
+	fmt.Fprintln(w, e.toJson())
+}
+
+func NewError(code int32, detail string) *Error {
+	return &Error{
+		Code:    code,
+		Message: errors[code],
+		Detail:  detail,
+	}
+}
diff --git a/server/handler/auth/handler.go b/server/handler/auth/handler.go
index 5a555238c..5819f28a6 100644
--- a/server/handler/auth/handler.go
+++ b/server/handler/auth/handler.go
@@ -17,34 +17,18 @@ import (
 	"github.com/ServiceComb/service-center/pkg/chain"
 	"github.com/ServiceComb/service-center/pkg/rest"
 	"github.com/ServiceComb/service-center/pkg/util"
-	"github.com/ServiceComb/service-center/server/infra/auth"
-	"github.com/astaxie/beego"
+	scerr "github.com/ServiceComb/service-center/server/error"
+	"github.com/ServiceComb/service-center/server/plugin/dynamic"
+	"github.com/ServiceComb/service-center/server/rest/controller"
 	"net/http"
 )
 
-var plugin auth.Auth
-
-func init() {
-	name := beego.AppConfig.String("auth_plugin")
-	if pluginBuilder, ok := auth.AuthPlugins[name]; ok {
-		util.Logger().Warnf(nil, "service center is in '%s' mode", name)
-		plugin = pluginBuilder()
-		return
-	}
-	util.Logger().Warnf(nil, "service center is in 'noAuth' mode")
-}
-
 type AuthRequest struct {
 }
 
 func (h *AuthRequest) Handle(i *chain.Invocation) {
-	if plugin == nil {
-		i.Next()
-		return
-	}
-
 	r := i.Context().Value(rest.CTX_REQUEST).(*http.Request)
-	err := plugin.Identify(r)
+	err := dynamic.Identify(r)
 	if err == nil {
 		i.Next()
 		return
@@ -53,7 +37,8 @@ func (h *AuthRequest) Handle(i *chain.Invocation) {
 	util.Logger().Errorf(err, "authenticate request failed, %s %s", r.Method, r.RequestURI)
 
 	w := i.Context().Value(rest.CTX_RESPONSE).(http.ResponseWriter)
-	http.Error(w, "Request Unauthorized", http.StatusUnauthorized)
+	controller.WriteError(w, scerr.ErrUnauthorized, err.Error())
+
 	i.Fail(nil)
 }
 
diff --git a/server/plugin/dynamic/auth.go b/server/plugin/dynamic/auth.go
new file mode 100644
index 000000000..b2b5f8487
--- /dev/null
+++ b/server/plugin/dynamic/auth.go
@@ -0,0 +1,58 @@
+//Copyright 2017 Huawei Technologies Co., Ltd
+//
+//Licensed under the Apache License, Version 2.0 (the "License");
+//you may not use this file except in compliance with the License.
+//You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+//Unless required by applicable law or agreed to in writing, software
+//distributed under the License is distributed on an "AS IS" BASIS,
+//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//See the License for the specific language governing permissions and
+//limitations under the License.
+package dynamic
+
+import (
+	"github.com/ServiceComb/service-center/pkg/plugin"
+	"github.com/ServiceComb/service-center/pkg/util"
+	"github.com/ServiceComb/service-center/server/infra/auth"
+	"github.com/astaxie/beego"
+	"net/http"
+)
+
+var authLib auth.Auth
+
+func init() {
+	name := beego.AppConfig.String("auth_plugin")
+	if pluginBuilder, ok := auth.AuthPlugins[name]; ok {
+		util.Logger().Warnf(nil, "static load plugin '%s' successfully.", name)
+		authLib = pluginBuilder()
+		return
+	}
+}
+
+func buildinAuthFunc(r *http.Request) error {
+	if authLib == nil {
+		return nil
+	}
+	return authLib.Identify(r)
+}
+
+func findAuthFunc(funcName string) func(*http.Request) error {
+	ff, err := plugin.FindFunc("auth", funcName)
+	if err != nil {
+		return buildinAuthFunc
+	}
+	f, ok := ff.(func(*http.Request) error)
+	if !ok {
+		util.Logger().Warnf(nil, "unexpected function '%s' format found in plugin 'auth'.", funcName)
+		return buildinAuthFunc
+	}
+	return f
+}
+
+func Identify(r *http.Request) error {
+	f := findAuthFunc("Identify")
+	return f(r)
+}
diff --git a/server/rest/controller/rest_util.go b/server/rest/controller/rest_util.go
index 51e0c46a6..da97c6dd9 100644
--- a/server/rest/controller/rest_util.go
+++ b/server/rest/controller/rest_util.go
@@ -18,58 +18,39 @@ import (
 	"fmt"
 	"github.com/ServiceComb/service-center/pkg/util"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	"github.com/ServiceComb/service-center/server/error"
 	"net/http"
-	"strconv"
 )
 
-func WriteJsonObject(status int, obj interface{}, w http.ResponseWriter) {
-	serviceJSON, err := json.Marshal(obj)
-	if err != nil {
-		util.Logger().Error("marshal response error", err)
-		WriteText(http.StatusInternalServerError, fmt.Sprintf("marshal response error, %s", err.Error()), w)
-		return
-	}
-	WriteJson(status, serviceJSON, w)
-}
-
-func WriteJson(status int, json []byte, w http.ResponseWriter) {
-	w.Header().Set("Content-Type", "application/json;charset=utf-8")
-	w.Header().Add("x-response-status", strconv.Itoa(status))
-	w.WriteHeader(status)
-	w.Write(json)
+func WriteError(w http.ResponseWriter, code int32, detail string) {
+	err := error.NewError(code, detail)
+	err.HttpWrite(w)
 }
 
-func WriteText(status int, text string, w http.ResponseWriter) {
-	w.Header().Add("x-response-status", strconv.Itoa(status))
-	w.WriteHeader(status)
-	w.Write(util.StringToBytesWithNoCopy(text))
-}
-
-func WriteTextResponse(resp *pb.Response, err error, textIfSuccess string, w http.ResponseWriter) {
-	if err != nil {
-		WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.Code != pb.Response_SUCCESS {
-		WriteText(http.StatusBadRequest, resp.Message, w)
+func WriteJsonObject(w http.ResponseWriter, obj interface{}) {
+	if obj == nil {
+		w.Header().Add("X-Response-Status", fmt.Sprint(http.StatusOK))
+		w.Header().Set("Content-Type", "text/plain; charset=UTF-8")
+		w.WriteHeader(http.StatusOK)
 		return
 	}
-	WriteText(http.StatusOK, textIfSuccess, w)
-}
 
-func WriteJsonResponse(resp *pb.Response, obj interface{}, err error, w http.ResponseWriter) {
+	objJson, err := json.Marshal(obj)
 	if err != nil {
-		WriteText(http.StatusInternalServerError, err.Error(), w)
+		WriteError(w, error.ErrInternal, err.Error())
 		return
 	}
-	if resp.Code != pb.Response_SUCCESS {
-		WriteText(http.StatusBadRequest, resp.Message, w)
-		return
-	}
-	objJson, err := json.Marshal(obj)
-	if err != nil {
-		WriteText(http.StatusInternalServerError, err.Error(), w)
+	w.Header().Add("X-Response-Status", fmt.Sprint(http.StatusOK))
+	w.Header().Set("Content-Type", "application/json; charset=UTF-8")
+	w.WriteHeader(http.StatusOK)
+	fmt.Fprintln(w, util.BytesToStringWithNoCopy(objJson))
+}
+
+func WriteResponse(w http.ResponseWriter, resp *pb.Response, obj interface{}) {
+	if resp.GetCode() == pb.Response_SUCCESS {
+		WriteJsonObject(w, obj)
 		return
 	}
-	WriteJson(http.StatusOK, objJson, w)
+
+	WriteError(w, resp.GetCode(), resp.GetMessage())
 }
diff --git a/server/rest/controller/v4/governservice_controller.go b/server/rest/controller/v4/governservice_controller.go
index f209a6ad5..4dbed26c9 100644
--- a/server/rest/controller/v4/governservice_controller.go
+++ b/server/rest/controller/v4/governservice_controller.go
@@ -16,11 +16,11 @@ package v4
 import (
 	"net/http"
 
-	"github.com/ServiceComb/service-center/pkg/util"
-
 	"github.com/ServiceComb/service-center/pkg/rest"
+	"github.com/ServiceComb/service-center/pkg/util"
 	"github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/rest/controller"
 	"strings"
 )
@@ -78,7 +78,7 @@ func (governService *GovernService) GetGraph(w http.ResponseWriter, r *http.Requ
 	var graph Graph
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
 	request := &pb.GetServicesRequest{
@@ -87,7 +87,7 @@ func (governService *GovernService) GetGraph(w http.ResponseWriter, r *http.Requ
 	ctx := r.Context()
 	resp, err := core.ServiceAPI.GetServices(ctx, request)
 	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 	services := resp.GetServices()
@@ -107,7 +107,7 @@ func (governService *GovernService) GetGraph(w http.ResponseWriter, r *http.Requ
 		proResp, err := core.ServiceAPI.GetConsumerDependencies(ctx, proRequest)
 		if err != nil {
 			util.Logger().Error("get Dependency failed.", err)
-			controller.WriteText(http.StatusInternalServerError, "get Dependency failed", w)
+			controller.WriteError(w, scerr.ErrInternal, "get Dependency failed")
 			return
 		}
 
@@ -132,7 +132,7 @@ func (governService *GovernService) GetGraph(w http.ResponseWriter, r *http.Requ
 		}
 	}
 	graph.Nodes = nodes
-	controller.WriteJsonObject(http.StatusOK, graph, w)
+	controller.WriteJsonObject(w, graph)
 }
 
 // GetServiceDetail 查询服务详细信息
@@ -140,7 +140,7 @@ func (governService *GovernService) GetServiceDetail(w http.ResponseWriter, r *h
 	serviceID := r.URL.Query().Get(":serviceId")
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
 	request := &pb.GetServiceRequest{
@@ -148,17 +148,17 @@ func (governService *GovernService) GetServiceDetail(w http.ResponseWriter, r *h
 		NoCache:   noCache == "1",
 	}
 	ctx := r.Context()
-	resp, err := core.GovernServiceAPI.GetServiceDetail(ctx, request)
+	resp, _ := core.GovernServiceAPI.GetServiceDetail(ctx, request)
 
 	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonResponse(respInternal, resp, err, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (governService *GovernService) GetAllServicesInfo(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
 	request := &pb.GetServicesInfoRequest{
@@ -167,9 +167,9 @@ func (governService *GovernService) GetAllServicesInfo(w http.ResponseWriter, r
 	ctx := r.Context()
 	optsStr := r.URL.Query().Get("options")
 	request.Options = strings.Split(optsStr, ",")
-	resp, err := core.GovernServiceAPI.GetServicesInfo(ctx, request)
+	resp, _ := core.GovernServiceAPI.GetServicesInfo(ctx, request)
 
 	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonResponse(respInternal, resp, err, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
diff --git a/server/rest/controller/v4/instance_controller.go b/server/rest/controller/v4/instance_controller.go
index bf7f03e67..470c905ba 100644
--- a/server/rest/controller/v4/instance_controller.go
+++ b/server/rest/controller/v4/instance_controller.go
@@ -19,6 +19,7 @@ import (
 	"github.com/ServiceComb/service-center/pkg/util"
 	"github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/rest/controller"
 	"io/ioutil"
 	"net/http"
@@ -46,7 +47,7 @@ func (this *MicroServiceInstanceService) RegisterInstance(w http.ResponseWriter,
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("register instance failed, body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 
@@ -54,7 +55,7 @@ func (this *MicroServiceInstanceService) RegisterInstance(w http.ResponseWriter,
 	err = json.Unmarshal(message, request)
 	if err != nil {
 		util.Logger().Error("register instance failed, Unmarshal error", err)
-		controller.WriteText(http.StatusInternalServerError, "Unmarshal error", w)
+		controller.WriteError(w, scerr.ErrInternal, "Unmarshal error")
 		return
 	}
 	if request.GetInstance() != nil {
@@ -64,7 +65,7 @@ func (this *MicroServiceInstanceService) RegisterInstance(w http.ResponseWriter,
 	resp, err := core.InstanceAPI.Register(r.Context(), request)
 	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonResponse(respInternal, resp, err, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 //TODO 什么样的服务允许更新服务心跳，只能是本服务才可以更新自己，如何屏蔽其他服务伪造的心跳更新？
@@ -73,15 +74,15 @@ func (this *MicroServiceInstanceService) Heartbeat(w http.ResponseWriter, r *htt
 		ServiceId:  r.URL.Query().Get(":serviceId"),
 		InstanceId: r.URL.Query().Get(":instanceId"),
 	}
-	resp, err := core.InstanceAPI.Heartbeat(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	resp, _ := core.InstanceAPI.Heartbeat(r.Context(), request)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceInstanceService) HeartbeatSet(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("register instance failed, body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 
@@ -89,26 +90,18 @@ func (this *MicroServiceInstanceService) HeartbeatSet(w http.ResponseWriter, r *
 	err = json.Unmarshal(message, request)
 	if err != nil {
 		util.Logger().Error("register instance failed, Unmarshal error", err)
-		controller.WriteText(http.StatusInternalServerError, "Unmarshal error", w)
+		controller.WriteError(w, scerr.ErrInternal, "Unmarshal error")
 		return
 	}
 	resp, _ := core.InstanceAPI.HeartbeatSet(r.Context(), request)
 
 	if resp.Response.Code == pb.Response_SUCCESS {
-		controller.WriteText(http.StatusOK, "", w)
-		return
-	}
-	if resp.Instances == nil || len(resp.Instances) == 0 {
-		controller.WriteText(http.StatusBadRequest, resp.Response.Message, w)
+		controller.WriteJsonObject(w, nil)
 		return
 	}
+	respInternal := resp.Response
 	resp.Response = nil
-	objJson, err := json.Marshal(resp)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	controller.WriteJson(http.StatusBadRequest, objJson, w)
+	controller.WriteResponse(w, respInternal, resp)
 	return
 }
 
@@ -117,8 +110,8 @@ func (this *MicroServiceInstanceService) UnregisterInstance(w http.ResponseWrite
 		ServiceId:  r.URL.Query().Get(":serviceId"),
 		InstanceId: r.URL.Query().Get(":instanceId"),
 	}
-	resp, err := core.InstanceAPI.Unregister(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	resp, _ := core.InstanceAPI.Unregister(r.Context(), request)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceInstanceService) FindInstances(w http.ResponseWriter, r *http.Request) {
@@ -129,7 +122,7 @@ func (this *MicroServiceInstanceService) FindInstances(w http.ResponseWriter, r
 	}
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
 	request := &pb.FindInstancesRequest{
@@ -141,17 +134,10 @@ func (this *MicroServiceInstanceService) FindInstances(w http.ResponseWriter, r
 		Tags:              ids,
 		NoCache:           noCache == "1",
 	}
-	resp, err := core.InstanceAPI.Find(r.Context(), request)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.GetResponse().Code != pb.Response_SUCCESS {
-		controller.WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
-		return
-	}
+	resp, _ := core.InstanceAPI.Find(r.Context(), request)
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceInstanceService) GetOneInstance(w http.ResponseWriter, r *http.Request) {
@@ -162,7 +148,7 @@ func (this *MicroServiceInstanceService) GetOneInstance(w http.ResponseWriter, r
 	}
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
 	request := &pb.GetOneInstanceRequest{
@@ -173,17 +159,10 @@ func (this *MicroServiceInstanceService) GetOneInstance(w http.ResponseWriter, r
 		Env:                r.URL.Query().Get("env"),
 		NoCache:            noCache == "1",
 	}
-	resp, err := core.InstanceAPI.GetOneInstance(r.Context(), request)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.GetResponse().Code != pb.Response_SUCCESS {
-		controller.WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
-		return
-	}
+	resp, _ := core.InstanceAPI.GetOneInstance(r.Context(), request)
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceInstanceService) GetInstances(w http.ResponseWriter, r *http.Request) {
@@ -194,7 +173,7 @@ func (this *MicroServiceInstanceService) GetInstances(w http.ResponseWriter, r *
 	}
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
 	request := &pb.GetInstancesRequest{
@@ -204,17 +183,10 @@ func (this *MicroServiceInstanceService) GetInstances(w http.ResponseWriter, r *
 		Env:               r.URL.Query().Get("env"),
 		NoCache:           noCache == "1",
 	}
-	resp, err := core.InstanceAPI.GetInstances(r.Context(), request)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.GetResponse().Code != pb.Response_SUCCESS {
-		controller.WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
-		return
-	}
+	resp, _ := core.InstanceAPI.GetInstances(r.Context(), request)
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceInstanceService) UpdateStatus(w http.ResponseWriter, r *http.Request) {
@@ -224,15 +196,15 @@ func (this *MicroServiceInstanceService) UpdateStatus(w http.ResponseWriter, r *
 		InstanceId: r.URL.Query().Get(":instanceId"),
 		Status:     status,
 	}
-	resp, err := core.InstanceAPI.UpdateStatus(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	resp, _ := core.InstanceAPI.UpdateStatus(r.Context(), request)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceInstanceService) UpdateMetadata(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 	request := &pb.UpdateInstancePropsRequest{
@@ -242,9 +214,9 @@ func (this *MicroServiceInstanceService) UpdateMetadata(w http.ResponseWriter, r
 	err = json.Unmarshal(message, request)
 	if err != nil {
 		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusInternalServerError, "Unmarshal error", w)
+		controller.WriteError(w, scerr.ErrInternal, "Unmarshal error")
 		return
 	}
 	resp, err := core.InstanceAPI.UpdateInstanceProperties(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
diff --git a/server/rest/controller/v4/instance_watcher.go b/server/rest/controller/v4/instance_watcher.go
index e3ec4c036..e98123ea1 100644
--- a/server/rest/controller/v4/instance_watcher.go
+++ b/server/rest/controller/v4/instance_watcher.go
@@ -18,6 +18,7 @@ import (
 	"github.com/ServiceComb/service-center/pkg/util"
 	"github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/rest/controller"
 	"github.com/gorilla/websocket"
 	"net/http"
@@ -46,7 +47,7 @@ func upgrade(w http.ResponseWriter, r *http.Request) (*websocket.Conn, error) {
 	conn, err := upgrader.Upgrade(w, r, nil)
 	if err != nil {
 		util.Logger().Error("upgrade failed.", err)
-		controller.WriteText(http.StatusInternalServerError, "Upgrade error", w)
+		controller.WriteError(w, scerr.ErrInternal, "Upgrade error")
 	}
 	return conn, err
 }
diff --git a/server/rest/controller/v4/main_controller.go b/server/rest/controller/v4/main_controller.go
index 770d40fb4..70166e04e 100644
--- a/server/rest/controller/v4/main_controller.go
+++ b/server/rest/controller/v4/main_controller.go
@@ -18,6 +18,7 @@ import (
 	"github.com/ServiceComb/service-center/pkg/rest"
 	"github.com/ServiceComb/service-center/pkg/util"
 	"github.com/ServiceComb/service-center/server/core"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/rest/controller"
 	"github.com/ServiceComb/service-center/version"
 	"net/http"
@@ -48,13 +49,13 @@ func (this *MainService) ClusterHealth(w http.ResponseWriter, r *http.Request) {
 	resp, err := core.InstanceAPI.ClusterHealth(r.Context())
 	if err != nil {
 		util.Logger().Error("health check failed", err)
-		controller.WriteText(http.StatusInternalServerError, "health check failed", w)
+		controller.WriteError(w, scerr.ErrInternal, "health check failed")
 		return
 	}
 
 	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonResponse(respInternal, resp, err, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MainService) GetVersion(w http.ResponseWriter, r *http.Request) {
diff --git a/server/rest/controller/v4/microservice_controller.go b/server/rest/controller/v4/microservice_controller.go
index 3fbc18b83..67d7b6187 100644
--- a/server/rest/controller/v4/microservice_controller.go
+++ b/server/rest/controller/v4/microservice_controller.go
@@ -19,6 +19,7 @@ import (
 	"github.com/ServiceComb/service-center/pkg/util"
 	"github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/rest/controller"
 	"io/ioutil"
 	"net/http"
@@ -52,7 +53,7 @@ func (this *MicroServiceService) URLPatterns() []rest.Route {
 func (this *MicroServiceService) GetSchemas(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
 	request := &pb.GetSchemaRequest{
@@ -60,20 +61,17 @@ func (this *MicroServiceService) GetSchemas(w http.ResponseWriter, r *http.Reque
 		SchemaId:  r.URL.Query().Get(":schemaId"),
 		NoCache:   noCache == "1",
 	}
-	resp, err := core.ServiceAPI.GetSchemaInfo(r.Context(), request)
-	if len(resp.Schema) != 0 {
-		resp.Response = nil
-		controller.WriteJsonObject(http.StatusOK, resp, w)
-		return
-	}
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	resp, _ := core.ServiceAPI.GetSchemaInfo(r.Context(), request)
+	respInternal := resp.Response
+	resp.Response = nil
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceService) ModifySchema(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 
@@ -81,20 +79,20 @@ func (this *MicroServiceService) ModifySchema(w http.ResponseWriter, r *http.Req
 	err = json.Unmarshal(message, request)
 	if err != nil {
 		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 	request.ServiceId = r.URL.Query().Get(":serviceId")
 	request.SchemaId = r.URL.Query().Get(":schemaId")
 	resp, err := core.ServiceAPI.ModifySchema(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceService) ModifySchemas(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 	serviceId := r.URL.Query().Get(":serviceId")
@@ -102,12 +100,12 @@ func (this *MicroServiceService) ModifySchemas(w http.ResponseWriter, r *http.Re
 	err = json.Unmarshal(message, request)
 	if err != nil {
 		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 	request.ServiceId = serviceId
 	resp, err := core.ServiceAPI.ModifySchemas(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceService) DeleteSchemas(w http.ResponseWriter, r *http.Request) {
@@ -115,42 +113,35 @@ func (this *MicroServiceService) DeleteSchemas(w http.ResponseWriter, r *http.Re
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		SchemaId:  r.URL.Query().Get(":schemaId"),
 	}
-	resp, err := core.ServiceAPI.DeleteSchema(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	resp, _ := core.ServiceAPI.DeleteSchema(r.Context(), request)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceService) Register(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 	var request pb.CreateServiceRequest
 	err = json.Unmarshal(message, &request)
 	if err != nil {
 		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 	resp, err := core.ServiceAPI.Create(r.Context(), &request)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.GetResponse().Code != pb.Response_SUCCESS {
-		controller.WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
-		return
-	}
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceService) Update(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 	request := &pb.UpdateServicePropsRequest{
@@ -159,11 +150,11 @@ func (this *MicroServiceService) Update(w http.ResponseWriter, r *http.Request)
 	err = json.Unmarshal(message, request)
 	if err != nil {
 		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 	resp, err := core.ServiceAPI.UpdateProperties(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceService) Unregister(w http.ResponseWriter, r *http.Request) {
@@ -171,44 +162,37 @@ func (this *MicroServiceService) Unregister(w http.ResponseWriter, r *http.Reque
 	serviceId := r.URL.Query().Get(":serviceId")
 	util.Logger().Warnf(nil, "Service %s unregists, force is %s.", serviceId, force)
 	if force != "0" && force != "1" && strings.TrimSpace(force) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter force must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter force must be 1 or 0")
 		return
 	}
 	request := &pb.DeleteServiceRequest{
 		ServiceId: serviceId,
 		Force:     force == "1",
 	}
-	resp, err := core.ServiceAPI.Delete(r.Context(), request)
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	resp, _ := core.ServiceAPI.Delete(r.Context(), request)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceService) GetServices(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter force must be 1 or 0")
 		return
 	}
 	request := &pb.GetServicesRequest{
 		NoCache: noCache == "1",
 	}
 	util.Logger().Debugf("domain is %s", util.ParseDomain(r.Context()))
-	resp, err := core.ServiceAPI.GetServices(r.Context(), request)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.GetResponse().Code != pb.Response_SUCCESS {
-		controller.WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
-		return
-	}
+	resp, _ := core.ServiceAPI.GetServices(r.Context(), request)
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceService) GetExistence(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter force must be 1 or 0")
 		return
 	}
 	request := &pb.GetExistenceRequest{
@@ -220,133 +204,86 @@ func (this *MicroServiceService) GetExistence(w http.ResponseWriter, r *http.Req
 		SchemaId:    r.URL.Query().Get("schemaId"),
 		NoCache:     noCache == "1",
 	}
-	resp, err := core.ServiceAPI.Exist(r.Context(), request)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.GetResponse().Code != pb.Response_SUCCESS {
-		controller.WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
-		return
-	}
+	resp, _ := core.ServiceAPI.Exist(r.Context(), request)
+	w.Header().Add("X-Schema-Summary", resp.Summary)
+	respInternal := resp.Response
 	resp.Response = nil
-	w.Header().Add("x-schema-summary", resp.Summary)
 	resp.Summary = ""
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceService) GetServiceOne(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter force must be 1 or 0")
 		return
 	}
 	request := &pb.GetServiceRequest{
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		NoCache:   noCache == "1",
 	}
-	resp, err := core.ServiceAPI.GetOne(r.Context(), request)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	if resp.GetResponse().Code != pb.Response_SUCCESS {
-		controller.WriteText(http.StatusBadRequest, resp.GetResponse().Message, w)
-		return
-	}
+	resp, _ := core.ServiceAPI.GetOne(r.Context(), request)
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceService) CreateDependenciesForMicroServices(w http.ResponseWriter, r *http.Request) {
 	requestBody, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 	request := &pb.CreateDependenciesRequest{}
 	err = json.Unmarshal(requestBody, request)
 	if err != nil {
 		util.Logger().Error("Invalid json", err)
-		controller.WriteText(http.StatusInternalServerError, "Unmarshal error", w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
-	//fmt.Println("request is ", request)
-	rsp, err := core.ServiceAPI.CreateDependenciesForMircServices(r.Context(), request)
-	//fmt.Println("rsp is ", rsp)
-	//请求错误
-	if err != nil {
-		util.Logger().Errorf(err, "create dependency failed for service internal reason.")
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	//服务内部错误
-	if rsp.Response.Code == pb.Response_FAIL {
-		util.Logger().Errorf(nil, "create dependency failed for request invalid. %s", rsp.Response.Message)
-		controller.WriteText(http.StatusBadRequest, rsp.Response.Message, w)
-		return
-	}
-	controller.WriteText(http.StatusOK, "add dependency success.", w)
+
+	resp, err := core.ServiceAPI.CreateDependenciesForMircServices(r.Context(), request)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *MicroServiceService) GetConProDependencies(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter force must be 1 or 0")
 		return
 	}
 	request := &pb.GetDependenciesRequest{
 		ServiceId: r.URL.Query().Get(":consumerId"),
 		NoCache:   noCache == "1",
 	}
-	resp, err := core.ServiceAPI.GetConsumerDependencies(r.Context(), request)
-	if err != nil {
-		util.Logger().Error("get Dependency failed.", err)
-		controller.WriteText(http.StatusInternalServerError, "get Dependency failed", w)
-		return
-	}
-	//服务请求错误
-	if resp.Response.Code == pb.Response_FAIL {
-		util.Logger().Errorf(nil, resp.Response.Message)
-		controller.WriteText(http.StatusBadRequest, resp.Response.Message, w)
-		return
-	}
+	resp, _ := core.ServiceAPI.GetConsumerDependencies(r.Context(), request)
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceService) GetProConDependencies(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter force must be 1 or 0")
 		return
 	}
 	request := &pb.GetDependenciesRequest{
 		ServiceId: r.URL.Query().Get(":providerId"),
 		NoCache:   noCache == "1",
 	}
-	resp, err := core.ServiceAPI.GetProviderDependencies(r.Context(), request)
-	if err != nil {
-		util.Logger().Error("get Dependency failed.", err)
-		controller.WriteText(http.StatusInternalServerError, "get Dependency failed", w)
-		return
-	}
-	//服务请求错误
-	if resp.Response.Code == pb.Response_FAIL {
-		util.Logger().Errorf(nil, resp.Response.Message)
-		controller.WriteText(http.StatusBadRequest, resp.Response.Message, w)
-		return
-	}
+	resp, _ := core.ServiceAPI.GetProviderDependencies(r.Context(), request)
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonObject(http.StatusOK, resp, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *MicroServiceService) UnregisterServices(w http.ResponseWriter, r *http.Request) {
 	request_body, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body ,err", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 
@@ -355,26 +292,12 @@ func (this *MicroServiceService) UnregisterServices(w http.ResponseWriter, r *ht
 	err = json.Unmarshal(request_body, request)
 	if err != nil {
 		util.Logger().Error("unmarshal ,err ", err)
-		controller.WriteText(http.StatusBadRequest, err.Error(), w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 
 	resp, err := core.ServiceAPI.DeleteServices(r.Context(), request)
-
-	if resp.Response.Code == pb.Response_SUCCESS {
-		controller.WriteText(http.StatusOK, "", w)
-		return
-	}
-	if resp.Services == nil || len(resp.Services) == 0 {
-		controller.WriteText(http.StatusBadRequest, resp.Response.Message, w)
-		return
-	}
+	respInternal := resp.Response
 	resp.Response = nil
-	objJson, err := json.Marshal(resp)
-	if err != nil {
-		controller.WriteText(http.StatusInternalServerError, err.Error(), w)
-		return
-	}
-	controller.WriteJson(http.StatusBadRequest, objJson, w)
-	return
+	controller.WriteResponse(w, respInternal, resp)
 }
diff --git a/server/rest/controller/v4/query_rule_controller.go b/server/rest/controller/v4/query_rule_controller.go
index a51e7ab1b..b9f742c04 100644
--- a/server/rest/controller/v4/query_rule_controller.go
+++ b/server/rest/controller/v4/query_rule_controller.go
@@ -15,11 +15,11 @@ package v4
 
 import (
 	"encoding/json"
-	"fmt"
 	"github.com/ServiceComb/service-center/pkg/rest"
 	"github.com/ServiceComb/service-center/pkg/util"
 	"github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/rest/controller"
 	"io/ioutil"
 	"net/http"
@@ -42,14 +42,14 @@ func (this *RuleService) AddRule(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("bory err", err)
-		controller.WriteText(http.StatusInternalServerError, fmt.Sprintf("body error %s", err.Error()), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 	rule := map[string][]*pb.AddOrUpdateServiceRule{}
 	err = json.Unmarshal(message, &rule)
 	if err != nil {
-		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusBadRequest, "Unmarshal error", w)
+		util.Logger().Errorf(err, "Unmarshal error")
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 
@@ -57,27 +57,27 @@ func (this *RuleService) AddRule(w http.ResponseWriter, r *http.Request) {
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		Rules:     rule["rules"],
 	})
-	respInter := resp.Response
+	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonResponse(respInter, resp, err, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *RuleService) DeleteRule(w http.ResponseWriter, r *http.Request) {
 	rule_id := r.URL.Query().Get(":rule_id")
 	ids := strings.Split(rule_id, ",")
 
-	resp, err := core.ServiceAPI.DeleteRule(r.Context(), &pb.DeleteServiceRulesRequest{
+	resp, _ := core.ServiceAPI.DeleteRule(r.Context(), &pb.DeleteServiceRulesRequest{
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		RuleIds:   ids,
 	})
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *RuleService) UpdateRule(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusBadRequest, "body error", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 
@@ -85,7 +85,7 @@ func (this *RuleService) UpdateRule(w http.ResponseWriter, r *http.Request) {
 	err = json.Unmarshal(message, &rule)
 	if err != nil {
 		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusBadRequest, "Unmarshal error", w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 	resp, err := core.ServiceAPI.UpdateRule(r.Context(), &pb.UpdateServiceRuleRequest{
@@ -93,23 +93,21 @@ func (this *RuleService) UpdateRule(w http.ResponseWriter, r *http.Request) {
 		RuleId:    r.URL.Query().Get(":rule_id"),
 		Rule:      &rule,
 	})
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *RuleService) GetRules(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
-	// TODO 根据attribute查询
-	// attribute := r.URL.Query().Get("attribute")
 
-	resp, err := core.ServiceAPI.GetRule(r.Context(), &pb.GetServiceRulesRequest{
+	resp, _ := core.ServiceAPI.GetRule(r.Context(), &pb.GetServiceRulesRequest{
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		NoCache:   noCache == "1",
 	})
 	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonResponse(respInternal, resp, err, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
diff --git a/server/rest/controller/v4/tag_controller.go b/server/rest/controller/v4/tag_controller.go
index a08668c34..ef0f8ce17 100644
--- a/server/rest/controller/v4/tag_controller.go
+++ b/server/rest/controller/v4/tag_controller.go
@@ -15,11 +15,11 @@ package v4
 
 import (
 	"encoding/json"
-	"fmt"
 	"github.com/ServiceComb/service-center/pkg/rest"
 	"github.com/ServiceComb/service-center/pkg/util"
 	"github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/rest/controller"
 	"io/ioutil"
 	"net/http"
@@ -43,14 +43,14 @@ func (this *TagService) AddTags(w http.ResponseWriter, r *http.Request) {
 	message, err := ioutil.ReadAll(r.Body)
 	if err != nil {
 		util.Logger().Error("body err", err)
-		controller.WriteText(http.StatusInternalServerError, fmt.Sprintf("body error %s", err.Error()), w)
+		controller.WriteError(w, scerr.ErrInvalidParams, err.Error())
 		return
 	}
 	var tags map[string]map[string]string
 	err = json.Unmarshal(message, &tags)
 	if err != nil {
 		util.Logger().Error("Unmarshal error", err)
-		controller.WriteText(http.StatusBadRequest, "Unmarshal error", w)
+		controller.WriteError(w, scerr.ErrInternal, err.Error())
 		return
 	}
 
@@ -58,40 +58,40 @@ func (this *TagService) AddTags(w http.ResponseWriter, r *http.Request) {
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		Tags:      tags["tags"],
 	})
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *TagService) UpdateTag(w http.ResponseWriter, r *http.Request) {
-	resp, err := core.ServiceAPI.UpdateTag(r.Context(), &pb.UpdateServiceTagRequest{
+	resp, _ := core.ServiceAPI.UpdateTag(r.Context(), &pb.UpdateServiceTagRequest{
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		Key:       r.URL.Query().Get(":key"),
 		Value:     r.URL.Query().Get("value"),
 	})
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
 
 func (this *TagService) GetTags(w http.ResponseWriter, r *http.Request) {
 	noCache := r.URL.Query().Get("noCache")
 	if noCache != "0" && noCache != "1" && strings.TrimSpace(noCache) != "" {
-		controller.WriteText(http.StatusBadRequest, "parameter noCache must be 1 or 0", w)
+		controller.WriteError(w, scerr.ErrInvalidParams, "parameter noCache must be 1 or 0")
 		return
 	}
-	resp, err := core.ServiceAPI.GetTags(r.Context(), &pb.GetServiceTagsRequest{
+	resp, _ := core.ServiceAPI.GetTags(r.Context(), &pb.GetServiceTagsRequest{
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		NoCache:   noCache == "1",
 	})
 	respInternal := resp.Response
 	resp.Response = nil
-	controller.WriteJsonResponse(respInternal, resp, err, w)
+	controller.WriteResponse(w, respInternal, resp)
 }
 
 func (this *TagService) DeleteTags(w http.ResponseWriter, r *http.Request) {
 	keys := r.URL.Query().Get(":key")
 	ids := strings.Split(keys, ",")
 
-	resp, err := core.ServiceAPI.DeleteTags(r.Context(), &pb.DeleteServiceTagsRequest{
+	resp, _ := core.ServiceAPI.DeleteTags(r.Context(), &pb.DeleteServiceTagsRequest{
 		ServiceId: r.URL.Query().Get(":serviceId"),
 		Keys:      ids,
 	})
-	controller.WriteTextResponse(resp.GetResponse(), err, "", w)
+	controller.WriteResponse(w, resp.GetResponse(), nil)
 }
diff --git a/server/service/governservice.go b/server/service/governservice.go
index ef6554c3a..679970d1d 100644
--- a/server/service/governservice.go
+++ b/server/service/governservice.go
@@ -19,6 +19,7 @@ import (
 	pb "github.com/ServiceComb/service-center/server/core/proto"
 	"github.com/ServiceComb/service-center/server/core/registry"
 	"github.com/ServiceComb/service-center/server/core/registry/store"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	serviceUtil "github.com/ServiceComb/service-center/server/service/util"
 	"golang.org/x/net/context"
 	"strings"
@@ -51,7 +52,7 @@ func (governServiceController *GovernServiceController) GetServicesInfo(ctx cont
 		st, err = statistics(ctx, opts...)
 		if err != nil {
 			return &pb.GetServicesInfoResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Statistics failed."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Statistics failed."),
 			}, err
 		}
 		if len(optionMap) == 1 {
@@ -67,7 +68,7 @@ func (governServiceController *GovernServiceController) GetServicesInfo(ctx cont
 	if err != nil {
 		util.Logger().Errorf(err, "Get all services for govern service faild.")
 		return &pb.GetServicesInfoResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get all service failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get all service failed."),
 		}, err
 	}
 
@@ -80,7 +81,7 @@ func (governServiceController *GovernServiceController) GetServicesInfo(ctx cont
 		serviceDetail, err := getServiceDetailUtil(ctx, options, domainProject, service.ServiceId, service, opts...)
 		if err != nil {
 			return &pb.GetServicesInfoResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Get one service detail failed."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Get one service detail failed."),
 			}, err
 		}
 		serviceDetail.MicroSerivce = service
@@ -100,7 +101,7 @@ func (governServiceController *GovernServiceController) GetServiceDetail(ctx con
 
 	if len(in.ServiceId) == 0 {
 		return &pb.GetServiceDetailResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Invalid requtest for getting service detail."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid requtest for getting service detail."),
 		}, nil
 	}
 
@@ -109,12 +110,12 @@ func (governServiceController *GovernServiceController) GetServiceDetail(ctx con
 	service, err := serviceUtil.GetService(ctx, domainProject, in.ServiceId, opts...)
 	if service == nil {
 		return &pb.GetServiceDetailResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 	if err != nil {
 		return &pb.GetServiceDetailResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get service failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get service failed."),
 		}, err
 	}
 
@@ -122,14 +123,14 @@ func (governServiceController *GovernServiceController) GetServiceDetail(ctx con
 	if err != nil {
 		util.Logger().Errorf(err, "Get service all version fialed.")
 		return &pb.GetServiceDetailResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get service detail failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get all versions of the service failed."),
 		}, err
 	}
 
 	serviceInfo, err := getServiceDetailUtil(ctx, options, domainProject, in.ServiceId, service, opts...)
 	if err != nil {
 		return &pb.GetServiceDetailResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get service detail failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get service detail failed."),
 		}, err
 	}
 
diff --git a/server/service/governservice_test.go b/server/service/governservice_test.go
index bacacb80b..c3fb1ee3c 100644
--- a/server/service/governservice_test.go
+++ b/server/service/governservice_test.go
@@ -65,7 +65,7 @@ var _ = Describe("GovernServiceController", func() {
 				})
 
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("服务治理获取单个服务信息", func() {
@@ -128,7 +128,7 @@ var _ = Describe("GovernServiceController", func() {
 					ServiceId: serviceId,
 				})
 
-				Expect(respGetServiceDetail.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respGetServiceDetail.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 		})
 	})
diff --git a/server/service/instances.go b/server/service/instances.go
index 965aa51fb..925a5bd34 100644
--- a/server/service/instances.go
+++ b/server/service/instances.go
@@ -23,7 +23,7 @@ import (
 	apt "github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
 	"github.com/ServiceComb/service-center/server/core/registry"
-	"github.com/ServiceComb/service-center/server/core/registry/store"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/infra/quota"
 	"github.com/ServiceComb/service-center/server/plugin/dynamic"
 	nf "github.com/ServiceComb/service-center/server/service/notification"
@@ -42,7 +42,7 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 	if in == nil || in.Instance == nil {
 		util.Logger().Errorf(nil, "register instance failed: invalid params.")
 		return &pb.RegisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	instance := in.GetInstance()
@@ -56,7 +56,7 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 		util.Logger().Errorf(err, "register instance failed, service %s, operator %s: invalid instance parameters.",
 			instanceFlag, remoteIP)
 		return &pb.RegisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 	//先以domain/project的方式组装
@@ -66,7 +66,7 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 	if !serviceUtil.ServiceExist(ctx, domainProject, instance.ServiceId) {
 		util.Logger().Errorf(nil, "register instance failed, service %s, operator %s: service not exist.", instanceFlag, remoteIP)
 		return &pb.RegisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -82,8 +82,8 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 			if err != nil {
 				util.Logger().Errorf(err, "register instance failed, service %s, operator %s: check endpoints failed.", instanceFlag, remoteIP)
 				return &pb.RegisterInstanceResponse{
-					Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
-				}, nil
+					Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
+				}, err
 			}
 			if oldInstanceId != "" {
 				instanceId = oldInstanceId
@@ -104,13 +104,13 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 			if err != nil {
 				util.Logger().Errorf(err, "register instance failed, service %s, operator %s: check apply quota failed.", instanceFlag, remoteIP)
 				return &pb.RegisterInstanceResponse{
-					Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+					Response: pb.CreateResponse(scerr.ErrUnavailableQuota, err.Error()),
 				}, err
 			}
 			if !ok {
 				util.Logger().Errorf(nil, "register instance failed, service %s, operator %s: no quota apply.", instanceFlag, remoteIP)
 				return &pb.RegisterInstanceResponse{
-					Response: pb.CreateResponse(pb.Response_FAIL, "No quota to create instance."),
+					Response: pb.CreateResponse(scerr.ErrNotEnoughQuota, "No quota to create instance."),
 				}, nil
 			}
 		}
@@ -143,7 +143,7 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 				instance.HealthCheck.Interval*(instance.HealthCheck.Times+1) >= math.MaxInt32 {
 				util.Logger().Errorf(err, "register instance %s(%s) failed for invalid health check settings.", instance.ServiceId, instance.HostName)
 				return &pb.RegisterInstanceResponse{
-					Response: pb.CreateResponse(pb.Response_FAIL, "Invalid health check settings."),
+					Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid health check settings."),
 				}, nil
 			}
 			renewalInterval = instance.HealthCheck.Interval
@@ -159,14 +159,14 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 		util.Logger().Errorf(err, "register instance failed, service %s, instanceId %s, operator %s: json marshal data failed.",
 			instanceFlag, instanceId, remoteIP)
 		return &pb.RegisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Instance file marshal error."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Instance file marshal error."),
 		}, err
 	}
 
 	leaseID, err := grantOrRenewLease(ctx, domainProject, instance.ServiceId, instanceId, ttl)
 	if err != nil {
 		return &pb.RegisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Lease grant or renew failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Lease grant or renew failed."),
 		}, err
 	}
 
@@ -194,7 +194,7 @@ func (s *InstanceController) Register(ctx context.Context, in *pb.RegisterInstan
 		util.Logger().Errorf(err, "register instance failed, service %s, instanceId %s, operator %s: commit data into etcd failed.",
 			instanceFlag, instanceId, remoteIP)
 		return &pb.RegisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."),
 		}, err
 	}
 
@@ -216,7 +216,7 @@ func (s *InstanceController) Unregister(ctx context.Context, in *pb.UnregisterIn
 	if in == nil || len(in.ServiceId) == 0 || len(in.InstanceId) == 0 {
 		util.Logger().Errorf(nil, "unregister instance failed: invalid params.")
 		return &pb.UnregisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -230,13 +230,13 @@ func (s *InstanceController) Unregister(ctx context.Context, in *pb.UnregisterIn
 	if err != nil {
 		util.Logger().Errorf(err, "unregister instance failed, instance %s, operator %s: query instance failed.", instanceFlag, remoteIP)
 		return &pb.UnregisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Query service instance failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Query service instance failed."),
 		}, err
 	}
 	if !isExist {
 		util.Logger().Errorf(nil, "unregister instance failed, instance %s, operator %s: instance not exist.", instanceFlag, remoteIP)
 		return &pb.UnregisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service instance does not exist."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, "Service instance does not exist."),
 		}, nil
 	}
 
@@ -245,11 +245,11 @@ func (s *InstanceController) Unregister(ctx context.Context, in *pb.UnregisterIn
 		util.Logger().Errorf(nil, "unregister instance failed, instance %s, operator %s: revoke instance failed.", instanceFlag, remoteIP)
 		if isInnerErr {
 			return &pb.UnregisterInstanceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Revoke instance failed."),
+				Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Revoke instance failed."),
 			}, err
 		}
 		return &pb.UnregisterInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Revoke instance failed."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, err.Error()),
 		}, nil
 	}
 
@@ -278,7 +278,7 @@ func revokeInstance(ctx context.Context, domainProject string, serviceId string,
 func (s *InstanceController) Heartbeat(ctx context.Context, in *pb.HeartbeatRequest) (*pb.HeartbeatResponse, error) {
 	if in == nil || len(in.ServiceId) == 0 || len(in.InstanceId) == 0 {
 		return &pb.HeartbeatResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	remoteIP := util.GetIPFromContext(ctx)
@@ -291,11 +291,11 @@ func (s *InstanceController) Heartbeat(ctx context.Context, in *pb.HeartbeatRequ
 			instanceFlag, isInnerErr, remoteIP)
 		if isInnerErr {
 			return &pb.HeartbeatResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Service instance does not exist."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Service instance does not exist."),
 			}, err
 		}
 		return &pb.HeartbeatResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service instance does not exist."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, "Service instance does not exist."),
 		}, nil
 	}
 	util.Logger().Infof("heartbeat successful: %s renew ttl to %d. operator: %s", instanceFlag, ttl, remoteIP)
@@ -338,7 +338,7 @@ func (s *InstanceController) HeartbeatSet(ctx context.Context, in *pb.HeartbeatS
 	if in == nil || len(in.Instances) == 0 {
 		util.Logger().Errorf(nil, "heartbeats failed, invalid request. Body not contain Instances or is empty.")
 		return &pb.HeartbeatSetResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	domainProject := util.ParseDomainProject(ctx)
@@ -392,24 +392,18 @@ func (s *InstanceController) HeartbeatSet(ctx context.Context, in *pb.HeartbeatS
 	} else {
 		util.Logger().Errorf(nil, "heartbeatset failed, %v", in.Instances)
 		return &pb.HeartbeatSetResponse{
-			Response:  pb.CreateResponse(pb.Response_FAIL, "Heartbeatset failed."),
+			Response:  pb.CreateResponse(scerr.ErrInstanceNotExists, "Heartbeatset failed."),
 			Instances: instanceHbRstArr,
 		}, nil
 	}
 }
 
 func (s *InstanceController) GetOneInstance(ctx context.Context, in *pb.GetOneInstanceRequest) (*pb.GetOneInstanceResponse, error) {
-	err, isInternalErr := s.getInstancePreCheck(ctx, in)
-	if err != nil {
-		if isInternalErr {
-			util.Logger().Errorf(err, "get instance failed: pre check failed.")
-			return &pb.GetOneInstanceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
-			}, err
-		}
-		util.Logger().Errorf(err, "get instance failed: pre check failed.")
+	checkErr := s.getInstancePreCheck(ctx, in)
+	if checkErr != nil {
+		util.Logger().Errorf(checkErr, "get instance failed: pre check failed.")
 		return &pb.GetOneInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(checkErr.Code, checkErr.Detail),
 		}, nil
 	}
 	conPro := util.StringJoin([]string{in.ConsumerServiceId, in.ProviderServiceId, in.ProviderInstanceId}, "/")
@@ -423,20 +417,20 @@ func (s *InstanceController) GetOneInstance(ctx context.Context, in *pb.GetOneIn
 	if err != nil {
 		util.Logger().Errorf(err, "get instance failed, %s(consumer/provider): get instance failed.", conPro)
 		return &pb.GetOneInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Update service instance properties failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Update service instance properties failed."),
 		}, err
 	}
 	if instance == nil {
 		util.Logger().Errorf(nil, "get instance failed, %s(consumer/provider): instance not exist.", conPro)
 		return &pb.GetOneInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service instance does not exist."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, "Service instance does not exist."),
 		}, nil
 	}
 
 	if len(in.Env) != 0 && in.Env != instance.Environment {
 		util.Logger().Errorf(nil, "get instance failed, %s(consumer/provider): environment not match, can't access.", conPro)
 		return &pb.GetOneInstanceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Environment mismatch, can't access this instance."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Environment mismatch, can't access this instance."),
 		}, nil
 	}
 
@@ -446,10 +440,10 @@ func (s *InstanceController) GetOneInstance(ctx context.Context, in *pb.GetOneIn
 	}, nil
 }
 
-func (s *InstanceController) getInstancePreCheck(ctx context.Context, in interface{}) (err error, IsInnerErr bool) {
-	err = apt.Validate(in)
+func (s *InstanceController) getInstancePreCheck(ctx context.Context, in interface{}) *scerr.Error {
+	err := apt.Validate(in)
 	if err != nil {
-		return err, false
+		return scerr.NewError(scerr.ErrInvalidParams, err.Error())
 	}
 	var providerServiceId, consumerServiceId string
 	var tags []string
@@ -470,18 +464,18 @@ func (s *InstanceController) getInstancePreCheck(ctx context.Context, in interfa
 	}
 
 	if !serviceUtil.ServiceExist(ctx, domainProject, providerServiceId, opts...) {
-		return fmt.Errorf("Service does not exist. Service id is %s", providerServiceId), false
+		return scerr.NewError(scerr.ErrInvalidParams, fmt.Sprintf("Service does not exist. Service id is %s", providerServiceId))
 	}
 
 	// Tag过滤
 	if len(tags) > 0 {
 		tagsFromETCD, err := serviceUtil.GetTagsUtils(ctx, domainProject, providerServiceId, opts...)
 		if err != nil {
-			return err, true
+			return scerr.NewError(scerr.ErrInternal, err.Error())
 		}
 		for _, tag := range tags {
 			if _, ok := tagsFromETCD[tag]; !ok {
-				return fmt.Errorf("Provider's tag not contain %s", tag), false
+				return scerr.NewError(scerr.ErrTagNotExists, fmt.Sprintf("Provider's tag not contain %s", tag))
 			}
 		}
 	}
@@ -490,37 +484,33 @@ func (s *InstanceController) getInstancePreCheck(ctx context.Context, in interfa
 	err = Accessible(ctx, domainProject, consumerServiceId, providerServiceId, opts...)
 	switch err.(type) {
 	case errorsEx.InternalError:
-		return err, true
+		return scerr.NewError(scerr.ErrInternal, err.Error())
 	default:
-		return err, false
+		if err != nil {
+			return scerr.NewError(scerr.ErrPermissionDeny, err.Error())
+		}
+		return nil
 	}
 }
 
 func (s *InstanceController) GetInstances(ctx context.Context, in *pb.GetInstancesRequest) (*pb.GetInstancesResponse, error) {
-	err, isInternalErr := s.getInstancePreCheck(ctx, in)
-	if err != nil {
-		if isInternalErr {
-			util.Logger().Errorf(err, "get instances failed: pre check failed.")
-			return &pb.GetInstancesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
-			}, err
-		}
-		util.Logger().Errorf(err, "get instances failed: pre check failed.")
+	checkErr := s.getInstancePreCheck(ctx, in)
+	if checkErr != nil {
+		util.Logger().Errorf(checkErr, "get instances failed: pre check failed.")
 		return &pb.GetInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(checkErr.Code, checkErr.Detail),
 		}, nil
 	}
 	conPro := util.StringJoin([]string{in.ConsumerServiceId, in.ProviderServiceId}, "/")
 
 	domainProject := util.ParseDomainProject(ctx)
 
-	instances := []*pb.MicroServiceInstance{}
-	instances, err = serviceUtil.GetAllInstancesOfOneService(ctx, domainProject, in.ProviderServiceId, in.Env,
+	instances, err := serviceUtil.GetAllInstancesOfOneService(ctx, domainProject, in.ProviderServiceId, in.Env,
 		serviceUtil.QueryOptions(serviceUtil.WithNoCache(in.NoCache))...)
 	if err != nil {
 		util.Logger().Errorf(err, "get instances failed, %s(consumer/provider): get instances from etcd failed.", conPro)
 		return &pb.GetInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 		}, err
 	}
 	return &pb.GetInstancesResponse{
@@ -534,7 +524,7 @@ func (s *InstanceController) Find(ctx context.Context, in *pb.FindInstancesReque
 	if err != nil {
 		util.Logger().Errorf(err, "find instance failed: invalid parameters.")
 		return &pb.FindInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -547,13 +537,13 @@ func (s *InstanceController) Find(ctx context.Context, in *pb.FindInstancesReque
 	if err != nil {
 		util.Logger().Errorf(err, "find instance failed, %s: get consumer failed.", findFlag)
 		return &pb.FindInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
-		}, nil
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
+		}, err
 	}
 	if service == nil {
 		util.Logger().Errorf(nil, "find instance failed, %s: consumer not exist.", findFlag)
 		return &pb.FindInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Consumer does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Consumer does not exist."),
 		}, nil
 	}
 
@@ -567,13 +557,13 @@ func (s *InstanceController) Find(ctx context.Context, in *pb.FindInstancesReque
 	if err != nil {
 		util.Logger().Errorf(err, "find instance failed, %s: get providers failed.", findFlag)
 		return &pb.FindInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get serviceId failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get serviceId failed."),
 		}, err
 	}
 	if len(ids) == 0 {
 		util.Logger().Errorf(nil, "find instance failed, %s: no provider matched.", findFlag)
 		return &pb.FindInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "No provider matched."),
 		}, nil
 	}
 
@@ -602,7 +592,7 @@ func (s *InstanceController) Find(ctx context.Context, in *pb.FindInstancesReque
 	if providerService == nil {
 		util.Logger().Errorf(nil, "find instance failed, %s: no provider matched.", findFlag)
 		return &pb.FindInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "No provider matched."),
 		}, nil
 	}
 	provider := &pb.MicroServiceKey{
@@ -617,8 +607,8 @@ func (s *InstanceController) Find(ctx context.Context, in *pb.FindInstancesReque
 	if err != nil {
 		util.Logger().Errorf(err, "find instance failed, %s: add service version rule failed.", findFlag)
 		return &pb.FindInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
-		}, nil
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
+		}, err
 	}
 
 	return &pb.FindInstancesResponse{
@@ -631,7 +621,7 @@ func (s *InstanceController) UpdateStatus(ctx context.Context, in *pb.UpdateInst
 	if in == nil || len(in.ServiceId) == 0 || len(in.InstanceId) == 0 {
 		util.Logger().Errorf(nil, "update instance status failed: invalid params.")
 		return &pb.UpdateInstanceStatusResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	domainProject := util.ParseDomainProject(ctx)
@@ -639,7 +629,7 @@ func (s *InstanceController) UpdateStatus(ctx context.Context, in *pb.UpdateInst
 	if err := apt.Validate(in); err != nil {
 		util.Logger().Errorf(nil, "update instance status failed, %s.", updateStatusFlag)
 		return &pb.UpdateInstanceStatusResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -650,13 +640,13 @@ func (s *InstanceController) UpdateStatus(ctx context.Context, in *pb.UpdateInst
 	if err != nil {
 		util.Logger().Errorf(err, "update instance status failed, %s: get instance from etcd failed.", updateStatusFlag)
 		return &pb.UpdateInstanceStatusResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Update service instance properties failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Update service instance properties failed."),
 		}, err
 	}
 	if instance == nil {
 		util.Logger().Errorf(nil, "update instance status failed, %s: instance not exist.", updateStatusFlag)
 		return &pb.UpdateInstanceStatusResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service instance does not exist."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, "Service instance does not exist."),
 		}, nil
 	}
 
@@ -667,11 +657,11 @@ func (s *InstanceController) UpdateStatus(ctx context.Context, in *pb.UpdateInst
 		util.Logger().Errorf(err, "update instance status failed, %s: update instance lease failed.", updateStatusFlag)
 		if isInnerErr {
 			return &pb.UpdateInstanceStatusResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Update instance status failed."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Update instance status failed."),
 			}, err
 		}
 		return &pb.UpdateInstanceStatusResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Update instance status failed."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, "Update instance status failed."),
 		}, nil
 	}
 
@@ -685,7 +675,7 @@ func (s *InstanceController) UpdateInstanceProperties(ctx context.Context, in *p
 	if in == nil || len(in.ServiceId) == 0 || len(in.InstanceId) == 0 || in.Properties == nil {
 		util.Logger().Errorf(nil, "update instance properties failed: invalid params.")
 		return &pb.UpdateInstancePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -699,13 +689,13 @@ func (s *InstanceController) UpdateInstanceProperties(ctx context.Context, in *p
 	if err != nil {
 		util.Logger().Errorf(err, "update instance properties failed, %s: get instance from etcd failed.", instanceFlag)
 		return &pb.UpdateInstancePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Update service instance properties failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Update service instance properties failed."),
 		}, err
 	}
 	if instance == nil {
 		util.Logger().Errorf(nil, "update instance properties failed, %s: instance not exist.", instanceFlag)
 		return &pb.UpdateInstancePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service instance does not exist."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, "Service instance does not exist."),
 		}, nil
 	}
 
@@ -719,11 +709,11 @@ func (s *InstanceController) UpdateInstanceProperties(ctx context.Context, in *p
 		util.Logger().Errorf(err, "update instance properties failed, %s: update instance lease failed.", instanceFlag)
 		if isInnerErr {
 			return &pb.UpdateInstancePropsResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Update instance lease failed."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Update instance lease failed."),
 			}, err
 		}
 		return &pb.UpdateInstancePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Update instance lease failed."),
+			Response: pb.CreateResponse(scerr.ErrInstanceNotExists, "Update instance lease failed."),
 		}, nil
 	}
 
@@ -757,13 +747,6 @@ func updateInstance(ctx context.Context, domainProject string, instance *pb.Micr
 	if err != nil {
 		return err, true
 	}
-
-	_, err = store.Store().KeepAlive(ctx,
-		registry.WithStrKey(apt.GenerateInstanceLeaseKey(domainProject, instance.ServiceId, instance.InstanceId)),
-		registry.WithLease(leaseID))
-	if err != nil {
-		return err, false
-	}
 	return nil, false
 }
 
@@ -823,13 +806,13 @@ func (s *InstanceController) ClusterHealth(ctx context.Context) (*pb.GetInstance
 	if err != nil {
 		util.Logger().Errorf(err, "health check failed: get service center serviceId failed.")
 		return &pb.GetInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service center serviceId failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Service center serviceId failed."),
 		}, err
 	}
 	if len(serviceId) == 0 {
 		util.Logger().Errorf(nil, "health check failed: get service center serviceId not exist.")
 		return &pb.GetInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service center serviceId not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service center serviceId not exist."),
 		}, nil
 	}
 	instances := []*pb.MicroServiceInstance{}
@@ -837,7 +820,7 @@ func (s *InstanceController) ClusterHealth(ctx context.Context) (*pb.GetInstance
 	if err != nil {
 		util.Logger().Errorf(err, "health check failed: get service center instances failed.")
 		return &pb.GetInstancesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service center instances failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Service center instances failed."),
 		}, err
 	}
 	return &pb.GetInstancesResponse{
diff --git a/server/service/instances_test.go b/server/service/instances_test.go
index 127d3f66b..4bc856523 100644
--- a/server/service/instances_test.go
+++ b/server/service/instances_test.go
@@ -17,6 +17,7 @@ import (
 	"fmt"
 	"github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/service"
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -138,7 +139,7 @@ var _ = Describe("InstanceController", func() {
 					Instances: []*pb.HeartbeatSetElement{},
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========实例心跳上报批量接口")
 				resp, err = insResource.HeartbeatSet(getContext(), &pb.HeartbeatSetRequest{
@@ -177,7 +178,7 @@ var _ = Describe("InstanceController", func() {
 						},
 					},
 				})
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("创建实例,参数校验", func() {
@@ -194,7 +195,7 @@ var _ = Describe("InstanceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("health", func() {
@@ -203,7 +204,7 @@ var _ = Describe("InstanceController", func() {
 
 				respCluterhealth, err := insResource.ClusterHealth(getContext())
 				Expect(err).To(BeNil())
-				Expect(respCluterhealth.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCluterhealth.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err := serviceResource.Create(getContext(), core.CreateServiceRequest())
 				Expect(err).To(BeNil())
@@ -238,7 +239,7 @@ var _ = Describe("InstanceController", func() {
 
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respUpdateStatus.GetResponse().Message)
-				Expect(respUpdateStatus.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respUpdateStatus.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respUpdateStatus, err = insResource.UpdateStatus(getContext(), &pb.UpdateInstanceStatusRequest{
 					ServiceId:  "notexistservice",
@@ -248,7 +249,7 @@ var _ = Describe("InstanceController", func() {
 
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respUpdateStatus.GetResponse().Message)
-				Expect(respUpdateStatus.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respUpdateStatus.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respUpdateStatus, err = insResource.UpdateStatus(getContext(), &pb.UpdateInstanceStatusRequest{
 					ServiceId:  consumerId,
@@ -258,7 +259,7 @@ var _ = Describe("InstanceController", func() {
 
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respUpdateStatus.GetResponse().Message)
-				Expect(respUpdateStatus.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respUpdateStatus.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respUpdateStatus, err = insResource.UpdateStatus(getContext(), &pb.UpdateInstanceStatusRequest{
 					ServiceId:  consumerId,
@@ -268,7 +269,7 @@ var _ = Describe("InstanceController", func() {
 
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respUpdateStatus.GetResponse().Message)
-				Expect(respUpdateStatus.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respUpdateStatus.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("修改实例的properties", func() {
@@ -282,7 +283,7 @@ var _ = Describe("InstanceController", func() {
 
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respUpdateProperties.GetResponse().Message)
-				Expect(respUpdateProperties.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respUpdateProperties.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respUpdateProperties, err = insResource.UpdateInstanceProperties(getContext(), &pb.UpdateInstancePropsRequest{
 					ServiceId:  "",
@@ -294,7 +295,7 @@ var _ = Describe("InstanceController", func() {
 
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respUpdateProperties.GetResponse().Message)
-				Expect(respUpdateProperties.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respUpdateProperties.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respUpdateProperties, err = insResource.UpdateInstanceProperties(getContext(), &pb.UpdateInstancePropsRequest{
 					ServiceId:  "notexistservice",
@@ -306,7 +307,7 @@ var _ = Describe("InstanceController", func() {
 
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respUpdateProperties.GetResponse().Message)
-				Expect(respUpdateProperties.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respUpdateProperties.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("创建实例，字段校验", func() {
@@ -347,7 +348,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Register(getContext(), &pb.RegisterInstanceRequest{
 					Instance: &pb.MicroServiceInstance{
@@ -361,7 +362,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Register(getContext(), &pb.RegisterInstanceRequest{
 					Instance: &pb.MicroServiceInstance{
@@ -375,14 +376,14 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Register(getContext(), &pb.RegisterInstanceRequest{
 					Instance: nil,
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("创建实例，字段校验,服务不存在", func() {
@@ -398,7 +399,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("创建实例,含healthcheck", func() {
 				fmt.Println("UT============创建实例，含checkhealth")
@@ -452,7 +453,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Register(getContext(), &pb.RegisterInstanceRequest{
 					Instance: &pb.MicroServiceInstance{
@@ -470,7 +471,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 		})
 	})
@@ -505,7 +506,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respFind.GetResponse().Message)
-				Expect(respFind.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respFind.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respFind, err = insResource.Find(getContext(), &pb.FindInstancesRequest{
 					ConsumerServiceId: "",
@@ -517,7 +518,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respFind.GetResponse().Message)
-				Expect(respFind.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respFind.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respFind, err = insResource.Find(getContext(), &pb.FindInstancesRequest{
 					ConsumerServiceId: consumerIdFind,
@@ -529,7 +530,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respFind.GetResponse().Message)
-				Expect(respFind.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respFind.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respFind, err = insResource.Find(getContext(), &pb.FindInstancesRequest{
 					ConsumerServiceId: consumerIdFind,
@@ -541,7 +542,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respFind.GetResponse().Message)
-				Expect(respFind.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respFind.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respFind, err = insResource.Find(getContext(), &pb.FindInstancesRequest{
 					ConsumerServiceId: consumerIdFind,
@@ -553,7 +554,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + respFind.GetResponse().Message)
-				Expect(respFind.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respFind.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respFind, err = insResource.Find(getContext(), &pb.FindInstancesRequest{
 					ConsumerServiceId: consumerIdFind,
@@ -566,7 +567,7 @@ var _ = Describe("InstanceController", func() {
 				Expect(err).To(BeNil())
 
 				fmt.Println("UT============" + respFind.GetResponse().Message)
-				Expect(respFind.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respFind.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respFind, err = insResource.Find(getContext(), &pb.FindInstancesRequest{
 					ConsumerServiceId: "notExistServiceId",
@@ -579,7 +580,7 @@ var _ = Describe("InstanceController", func() {
 				Expect(err).To(BeNil())
 
 				fmt.Println("UT============" + respFind.GetResponse().Message)
-				Expect(respFind.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respFind.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("find instance, create dependency", func() {
@@ -641,14 +642,14 @@ var _ = Describe("InstanceController", func() {
 
 				resDel, err := serviceResource.Delete(ctx, &pb.DeleteServiceRequest{
 					ServiceId: consumerId,
-					Force: true,
+					Force:     true,
 				})
 				Expect(err).To(BeNil())
 				Expect(resDel.GetResponse().Code).To(Equal(pb.Response_SUCCESS))
 
 				resDel, err = serviceResource.Delete(ctx, &pb.DeleteServiceRequest{
 					ServiceId: providerId,
-					Force: true,
+					Force:     true,
 				})
 				Expect(err).To(BeNil())
 				Expect(resDel.GetResponse().Code).To(Equal(pb.Response_SUCCESS))
@@ -773,7 +774,7 @@ var _ = Describe("InstanceController", func() {
 				Expect(err).To(BeNil())
 				providerOkId := resp.ServiceId
 
-				UTFunc := func(providerId string, code pb.Response_Code) {
+				UTFunc := func(providerId string, code int32) {
 					respFind, err := insResource.GetInstances(getContext(), &pb.GetInstancesRequest{
 						ConsumerServiceId: consumerId,
 						ProviderServiceId: providerId,
@@ -784,7 +785,7 @@ var _ = Describe("InstanceController", func() {
 					Expect(respFind.GetResponse().Code).To(Equal(code))
 				}
 
-				UTFunc(providerFailId, pb.Response_FAIL)
+				UTFunc(providerFailId, scerr.ErrPermissionDeny)
 
 				UTFunc(providerOkId, pb.Response_SUCCESS)
 			})
@@ -806,19 +807,19 @@ var _ = Describe("InstanceController", func() {
 					InstanceId: instanceId,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Heartbeat(getContext(), &pb.HeartbeatRequest{
 					ServiceId:  consumerId,
 					InstanceId: "100000000000",
 				})
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Heartbeat(getContext(), &pb.HeartbeatRequest{
 					ServiceId:  consumerId,
 					InstanceId: "not-exist-ins",
 				})
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("删除微服务,实例存在，不能删除", func() {
@@ -827,7 +828,7 @@ var _ = Describe("InstanceController", func() {
 					Force:     false,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 		})
 	})
@@ -843,7 +844,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========查找实例，参数校验,")
 				resp, err = insResource.GetOneInstance(getContext(), &pb.GetOneInstanceRequest{
@@ -854,7 +855,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.GetOneInstance(getContext(), &pb.GetOneInstanceRequest{
 					ConsumerServiceId:  consumerId,
@@ -864,7 +865,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("查找单个实例,夸app调用", func() {
@@ -891,7 +892,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("查找单个实例", func() {
@@ -914,7 +915,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========查找实例，含有存在的tag")
 				respAddTags, err := serviceResource.AddTags(getContext(), &pb.AddServiceTagsRequest{
@@ -947,7 +948,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.GetInstances(getContext(), &pb.GetInstancesRequest{
 					ConsumerServiceId: "noneservice",
@@ -957,7 +958,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.GetInstances(getContext(), &pb.GetInstancesRequest{
 					ConsumerServiceId: consumerId,
@@ -1000,7 +1001,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Unregister(getContext(), &pb.UnregisterInstanceRequest{
 					ServiceId:  consumerId,
@@ -1008,7 +1009,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = insResource.Unregister(getContext(), &pb.UnregisterInstanceRequest{
 					ServiceId:  consumerId,
@@ -1016,7 +1017,7 @@ var _ = Describe("InstanceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 		})
 	})
diff --git a/server/service/microservices.go b/server/service/microservices.go
index 51b2cfd41..30b0ffd58 100644
--- a/server/service/microservices.go
+++ b/server/service/microservices.go
@@ -23,6 +23,7 @@ import (
 	pb "github.com/ServiceComb/service-center/server/core/proto"
 	"github.com/ServiceComb/service-center/server/core/registry"
 	"github.com/ServiceComb/service-center/server/core/registry/store"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/infra/quota"
 	"github.com/ServiceComb/service-center/server/mux"
 	"github.com/ServiceComb/service-center/server/plugin/dynamic"
@@ -39,7 +40,7 @@ func (s *ServiceController) Create(ctx context.Context, in *pb.CreateServiceRequ
 	if in == nil || in.Service == nil {
 		util.Logger().Errorf(nil, "create microservice failed : param empty.")
 		return &pb.CreateServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "request format invalid"),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "request format invalid"),
 		}, nil
 	}
 
@@ -71,7 +72,7 @@ func (s *ServiceController) CreateServicePri(ctx context.Context, in *pb.CreateS
 		util.Logger().Errorf(err, "create microservice failed, %s: invalid parameters. operator: %s",
 			serviceFlag, remoteIP)
 		return &pb.CreateServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -84,20 +85,20 @@ func (s *ServiceController) CreateServicePri(ctx context.Context, in *pb.CreateS
 		Version:     service.Version,
 		Tenant:      domainProject,
 	}
-	reporter, err := checkBeforeCreate(ctx, domainProject)
+	reporter, err := checkQuota(ctx, domainProject)
 	if reporter != nil {
 		defer reporter.Close()
 	}
 	if err != nil {
 		util.Logger().Errorf(err, "create microservice failed, %s: check service failed before create. operator: %s",
 			serviceFlag, remoteIP)
-		resp := &pb.CreateServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
-		}
+		resp := &pb.CreateServiceResponse{}
 		switch err.(type) {
 		case errorsEx.InternalError:
+			resp.Response = pb.CreateResponse(scerr.ErrUnavailableQuota, err.Error())
 			return resp, err
 		default:
+			resp.Response = pb.CreateResponse(scerr.ErrNotEnoughQuota, err.Error())
 			return resp, nil
 		}
 	}
@@ -116,8 +117,8 @@ func (s *ServiceController) CreateServicePri(ctx context.Context, in *pb.CreateS
 		util.Logger().Errorf(err, "create microservice failed, %s: json marshal service failed. operator: %s",
 			serviceFlag, remoteIP)
 		return &pb.CreateServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Body error "+err.Error()),
-		}, nil
+			Response: pb.CreateResponse(scerr.ErrInternal, "Body error "+err.Error()),
+		}, err
 	}
 	key := apt.GenerateServiceKey(domainProject, serviceId)
 	index := apt.GenerateServiceIndexKey(consumer)
@@ -142,7 +143,7 @@ func (s *ServiceController) CreateServicePri(ctx context.Context, in *pb.CreateS
 		util.Logger().Errorf(err, "create microservice failed, %s: commit data into etcd failed. operator: %s",
 			serviceFlag, remoteIP)
 		return &pb.CreateServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."),
 		}, err
 	}
 	if !resp.Succeeded {
@@ -161,7 +162,7 @@ func (s *ServiceController) CreateServicePri(ctx context.Context, in *pb.CreateS
 			serviceFlag, remoteIP)
 
 		return &pb.CreateServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service already exists."),
+			Response: pb.CreateResponse(scerr.ErrServiceAlreadyExists, "Service already exists."),
 		}, nil
 	}
 
@@ -178,7 +179,7 @@ func (s *ServiceController) CreateServicePri(ctx context.Context, in *pb.CreateS
 	}, nil
 }
 
-func checkBeforeCreate(ctx context.Context, domainProject string) (quota.QuotaReporter, error) {
+func checkQuota(ctx context.Context, domainProject string) (quota.QuotaReporter, error) {
 	if core.ISSCSelf(ctx) {
 		util.Logger().Infof("it is service-center")
 		return nil, nil
@@ -199,12 +200,12 @@ func (s *ServiceController) DeleteServicePri(ctx context.Context, ServiceId stri
 	service, err := serviceUtil.GetService(ctx, domainProject, ServiceId)
 	if err != nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: get service failed.", ServiceId)
-		return pb.CreateResponse(pb.Response_FAIL, err.Error()), err
+		return pb.CreateResponse(scerr.ErrInternal, err.Error()), err
 	}
 
 	if service == nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: service not exist.", ServiceId)
-		return pb.CreateResponse(pb.Response_FAIL, "Service does not exist."), nil
+		return pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."), nil
 	}
 
 	util.Logger().Infof("start delete service %s", ServiceId)
@@ -215,11 +216,11 @@ func (s *ServiceController) DeleteServicePri(ctx context.Context, ServiceId stri
 		services, err := dr.GetDependencyConsumerIds()
 		if err != nil {
 			util.Logger().Errorf(err, "delete microservice failed, serviceId is %s:(unforce) inner err, get service dependency failed.", ServiceId)
-			return pb.CreateResponse(pb.Response_FAIL, "Get dependency info failed."), err
+			return pb.CreateResponse(scerr.ErrInternal, "Get dependency info failed."), err
 		}
 		if len(services) > 1 || (len(services) == 1 && services[0] != ServiceId) {
 			util.Logger().Errorf(nil, "delete microservice failed, serviceId is %s:(unforce) can't delete, other services rely it.", ServiceId)
-			return pb.CreateResponse(pb.Response_FAIL, "Can not delete this service, other service rely it."), err
+			return pb.CreateResponse(scerr.ErrDependedOnConsumer, "Can not delete this service, other service rely it."), err
 		}
 
 		instancesKey := apt.GenerateInstanceKey(domainProject, ServiceId, "")
@@ -229,12 +230,12 @@ func (s *ServiceController) DeleteServicePri(ctx context.Context, ServiceId stri
 			registry.WithCountOnly())
 		if err != nil {
 			util.Logger().Errorf(err, "delete microservice failed, serviceId is %s:(unforce) inner err,get instances failed.", ServiceId)
-			return pb.CreateResponse(pb.Response_FAIL, "Get instance failed."), err
+			return pb.CreateResponse(scerr.ErrInternal, "Get instance failed."), err
 		}
 
 		if rsp.Count > 0 {
 			util.Logger().Errorf(nil, "delete microservice failed, serviceId is %s:(unforce) can't delete, exist instance.", ServiceId)
-			return pb.CreateResponse(pb.Response_FAIL, "Can not delete this service, exist instance."), err
+			return pb.CreateResponse(scerr.ErrDeployedInstance, "Can not delete this service, exist instance."), err
 		}
 	}
 
@@ -250,7 +251,7 @@ func (s *ServiceController) DeleteServicePri(ctx context.Context, ServiceId stri
 	err = serviceUtil.RefreshDependencyCache(ctx, domainProject, ServiceId, service)
 	if err != nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: inner err, refresh service dependency cache failed.", ServiceId)
-		return pb.CreateResponse(pb.Response_FAIL, "Refresh dependency cache failed."), err
+		return pb.CreateResponse(scerr.ErrInternal, "Refresh dependency cache failed."), err
 	}
 
 	opts := []registry.PluginOp{
@@ -265,13 +266,13 @@ func (s *ServiceController) DeleteServicePri(ctx context.Context, ServiceId stri
 	lock, err := mux.Lock(mux.GLOBAL_LOCK)
 	if err != nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: inner err, create lock failed.", ServiceId)
-		return pb.CreateResponse(pb.Response_FAIL, err.Error()), err
+		return pb.CreateResponse(scerr.ErrUnavailableBackend, err.Error()), err
 	}
 	optsTmp, err := serviceUtil.DeleteDependencyForService(ctx, consumer, ServiceId)
 	lock.Unlock()
 	if err != nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: inner err, delete dependency failed.", ServiceId)
-		return pb.CreateResponse(pb.Response_FAIL, err.Error()), err
+		return pb.CreateResponse(scerr.ErrInternal, err.Error()), err
 	}
 	opts = append(opts, optsTmp...)
 
@@ -295,13 +296,13 @@ func (s *ServiceController) DeleteServicePri(ctx context.Context, ServiceId stri
 	err = serviceUtil.DeleteServiceAllInstances(ctx, ServiceId)
 	if err != nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: delete all instances failed.", ServiceId)
-		return pb.CreateResponse(pb.Response_FAIL, "Delete all instances failed for service."), err
+		return pb.CreateResponse(scerr.ErrInternal, "Delete all instances failed for service."), err
 	}
 
 	err = registry.BatchCommit(ctx, opts)
 	if err != nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: commit data into etcd failed.", ServiceId)
-		return pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."), nil
+		return pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."), nil
 	}
 
 	serviceUtil.RemandServiceQuota(ctx)
@@ -314,14 +315,14 @@ func (s *ServiceController) Delete(ctx context.Context, in *pb.DeleteServiceRequ
 	if in == nil || len(in.ServiceId) == 0 || in.ServiceId == apt.Service.ServiceId {
 		util.Logger().Errorf(nil, "delete microservice failed: service empty.")
 		return &pb.DeleteServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	err := apt.Validate(in)
 	if err != nil {
 		util.Logger().Errorf(err, "delete microservice failed, serviceId is %s: invalid parameters.", in.ServiceId)
 		return &pb.DeleteServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -336,7 +337,7 @@ func (s *ServiceController) DeleteServices(ctx context.Context, request *pb.DelS
 	// 合法性检查
 	if request == nil || request.ServiceIds == nil || len(request.ServiceIds) == 0 {
 		return &pb.DelServicesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Invalid request param."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request param."),
 			Services: nil,
 		}, nil
 	}
@@ -393,7 +394,7 @@ func (s *ServiceController) DeleteServices(ctx context.Context, request *pb.DelS
 	for serviceRespItem := range serviceRespChan {
 		count++
 		if len(serviceRespItem.ErrMessage) != 0 {
-			responseCode = pb.Response_FAIL
+			responseCode = scerr.ErrInvalidParams
 		}
 		delServiceRspInfo = append(delServiceRspInfo, serviceRespItem)
 		//结果收集over，关闭通道
@@ -412,7 +413,7 @@ func (s *ServiceController) DeleteServices(ctx context.Context, request *pb.DelS
 func (s *ServiceController) GetOne(ctx context.Context, in *pb.GetServiceRequest) (*pb.GetServiceResponse, error) {
 	if in == nil || len(in.ServiceId) == 0 {
 		return &pb.GetServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	err := apt.Validate(in)
@@ -420,7 +421,7 @@ func (s *ServiceController) GetOne(ctx context.Context, in *pb.GetServiceRequest
 		util.Logger().Errorf(err, "get microservice failed, serviceId is %s: invalid parameters.",
 			in.ServiceId)
 		return &pb.GetServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 	domainProject := util.ParseDomainProject(ctx)
@@ -430,13 +431,13 @@ func (s *ServiceController) GetOne(ctx context.Context, in *pb.GetServiceRequest
 	if err != nil {
 		util.Logger().Errorf(err, "get microservice failed, serviceId is %s: inner err,get service failed.", in.ServiceId)
 		return &pb.GetServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get service file failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get service file failed."),
 		}, err
 	}
 	if service == nil {
 		util.Logger().Errorf(nil, "get microservice failed, serviceId is %s: service not exist.", in.ServiceId)
 		return &pb.GetServiceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 	return &pb.GetServiceResponse{
@@ -449,7 +450,7 @@ func (s *ServiceController) GetServices(ctx context.Context, in *pb.GetServicesR
 	if in == nil {
 		util.Logger().Errorf(nil, "get services failed: invalid params.")
 		return &pb.GetServicesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	services, err := serviceUtil.GetAllServiceUtil(ctx,
@@ -457,7 +458,7 @@ func (s *ServiceController) GetServices(ctx context.Context, in *pb.GetServicesR
 	if err != nil {
 		util.Logger().Errorf(err, "get services failed: inner err.")
 		return &pb.GetServicesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get all service failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 		}, err
 	}
 
@@ -471,14 +472,14 @@ func (s *ServiceController) UpdateProperties(ctx context.Context, in *pb.UpdateS
 	if in == nil || len(in.ServiceId) == 0 || in.Properties == nil {
 		util.Logger().Errorf(nil, "update service properties failed: invalid params.")
 		return &pb.UpdateServicePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	err := apt.Validate(in)
 	if err != nil {
 		util.Logger().Errorf(err, "update service properties failed, serviceId is %s: invalid parameters.", in.ServiceId)
 		return &pb.UpdateServicePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -489,13 +490,13 @@ func (s *ServiceController) UpdateProperties(ctx context.Context, in *pb.UpdateS
 	if err != nil {
 		util.Logger().Errorf(err, "update service properties failed, serviceId is %s: query service failed.", in.ServiceId)
 		return &pb.UpdateServicePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Query service file failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 		}, err
 	}
 	if service == nil {
 		util.Logger().Errorf(nil, "update service properties failed, serviceId is %s: service not exist.", in.ServiceId)
 		return &pb.UpdateServicePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 	service.Properties = make(map[string]string)
@@ -508,7 +509,7 @@ func (s *ServiceController) UpdateProperties(ctx context.Context, in *pb.UpdateS
 	if err != nil {
 		util.Logger().Errorf(err, "update service properties failed, serviceId is %s: json marshal service failed.", in.ServiceId)
 		return &pb.UpdateServicePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service file marshal error."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Service file marshal error."),
 		}, err
 	}
 
@@ -520,7 +521,7 @@ func (s *ServiceController) UpdateProperties(ctx context.Context, in *pb.UpdateS
 	if err != nil {
 		util.Logger().Errorf(err, "update service properties failed, serviceId is %s: commit data into etcd failed.", in.ServiceId)
 		return &pb.UpdateServicePropsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, err.Error()),
 		}, err
 	}
 
@@ -534,7 +535,7 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 	if in == nil {
 		util.Logger().Errorf(nil, "exist failed: invalid params.")
 		return &pb.GetExistenceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -544,7 +545,7 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 		if len(in.AppId) == 0 || len(in.ServiceName) == 0 || len(in.Version) == 0 {
 			util.Logger().Errorf(nil, "microservice exist failed: invalid params.")
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Invalid request."),
+				Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request."),
 			}, nil
 		}
 		err := apt.GetMSExistsReqValidator.Validate(in)
@@ -552,7 +553,7 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 		if err != nil {
 			util.Logger().Errorf(err, "microservice exist failed, service %s: invalid params.", serviceFlag)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 			}, nil
 		}
 
@@ -566,13 +567,13 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 		if err != nil {
 			util.Logger().Errorf(err, "microservice exist failed, service %s: find serviceIds failed.", serviceFlag)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Get service file failed."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Get service file failed."),
 			}, err
 		}
 		if len(ids) <= 0 {
 			util.Logger().Infof("microservice exist failed, service %s: service not exist.", serviceFlag)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+				Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 			}, nil
 		}
 		return &pb.GetExistenceResponse{
@@ -583,7 +584,7 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 		if len(in.SchemaId) == 0 || len(in.ServiceId) == 0 {
 			util.Logger().Errorf(nil, "schema exist failed, serviceId %s, schemaId %s: invalid params.", in.ServiceId, in.SchemaId)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Invalid request."),
+				Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request."),
 			}, nil
 		}
 
@@ -591,7 +592,7 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 		if err != nil {
 			util.Logger().Errorf(err, "schema exist failed, serviceId %s, schemaId %s: invalid params.", in.ServiceId, in.SchemaId)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 			}, nil
 		}
 
@@ -600,7 +601,7 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 		if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId, opts...) {
 			util.Logger().Warnf(nil, "schema exist failed, serviceId %s, schemaId %s: service not exist.", in.ServiceId, in.SchemaId)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+				Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 			}, nil
 		}
 
@@ -609,20 +610,20 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 		if err != nil {
 			util.Logger().Errorf(err, "schema exist failed, serviceId %s, schemaId %s: get schema failed.", in.ServiceId, in.SchemaId)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 		if !exist {
 			util.Logger().Infof("schema exist failed, serviceId %s, schemaId %s: schema not exist.", in.ServiceId, in.SchemaId)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Schema does not exist."),
+				Response: pb.CreateResponse(scerr.ErrSchemaNotExists, "Schema does not exist."),
 			}, nil
 		}
 		schemaSummary, err := getSchemaSummary(ctx, domainProject, in.ServiceId, in.SchemaId)
 		if err != nil {
 			util.Logger().Errorf(err, "schema exist failed, serviceId %s, schemaId %s: get schema summary failed.", in.ServiceId, in.SchemaId)
 			return &pb.GetExistenceResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 		return &pb.GetExistenceResponse{
@@ -633,7 +634,7 @@ func (s *ServiceController) Exist(ctx context.Context, in *pb.GetExistenceReques
 	default:
 		util.Logger().Warnf(nil, "unexpected type '%s' for query.", in.Type)
 		return &pb.GetExistenceResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Only microservice and schema can be used as type."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Only microservice and schema can be used as type."),
 		}, nil
 	}
 }
@@ -721,7 +722,7 @@ func (s *ServiceController) CreateServiceEx(ctx context.Context, in *pb.CreateSe
 	}
 
 	if len(errMessages) != 0 {
-		result.Response.Code = pb.Response_FAIL
+		result.Response.Code = scerr.ErrInvalidParams
 		errMessage, err := json.Marshal(errMessages)
 		if err != nil {
 			result.Response.Message = "marshal errMessages error"
diff --git a/server/service/microservices_test.go b/server/service/microservices_test.go
index 74c6bef42..59557d650 100644
--- a/server/service/microservices_test.go
+++ b/server/service/microservices_test.go
@@ -35,7 +35,7 @@ var _ = Describe("ServiceController", func() {
 						Service: nil,
 					})
 					Expect(err).To(BeNil())
-					Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+					Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				})
 			})
@@ -140,7 +140,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Create(getContext(), &pb.CreateServiceRequest{
 					Service: &pb.MicroService{
@@ -157,7 +157,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Create(getContext(), &pb.CreateServiceRequest{
 					Service: &pb.MicroService{
@@ -175,7 +175,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("微服务是否存在,参数校验", func() {
@@ -186,7 +186,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Exist(getContext(), &pb.GetExistenceRequest{
 					Type:      "schema",
@@ -195,7 +195,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Exist(getContext(), &pb.GetExistenceRequest{
 					Type:      "nonetype",
@@ -204,7 +204,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Exist(getContext(), &pb.GetExistenceRequest{
 					Type:      "schema",
@@ -213,7 +213,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				//Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Exist(getContext(), &pb.GetExistenceRequest{
 					Type:        "microservice",
@@ -224,7 +224,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("exist schema", func() {
@@ -328,7 +328,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				Expect(err).To(BeNil())
 				fmt.Println("UT=============" + resp.String())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("创建微服务2", func() {
@@ -385,7 +385,7 @@ var _ = Describe("ServiceController", func() {
 				resp, err := serviceResource.Create(getContext(), r)
 				Expect(err).To(BeNil())
 				fmt.Println("UT=========" + resp.ServiceId)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				r = &pb.CreateServiceRequest{
 					Service: &pb.MicroService{
@@ -398,7 +398,7 @@ var _ = Describe("ServiceController", func() {
 				resp, err = serviceResource.Create(getContext(), r)
 				Expect(err).To(BeNil())
 				fmt.Println("UT=========" + resp.ServiceId)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				r = &pb.CreateServiceRequest{
 					Service: &pb.MicroService{
@@ -411,7 +411,7 @@ var _ = Describe("ServiceController", func() {
 				resp, err = serviceResource.Create(getContext(), r)
 				Expect(err).To(BeNil())
 				fmt.Println("UT=========" + resp.ServiceId)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				r = &pb.CreateServiceRequest{
 					Service: &pb.MicroService{
@@ -425,7 +425,7 @@ var _ = Describe("ServiceController", func() {
 				resp, err = serviceResource.Create(getContext(), r)
 				Expect(err).To(BeNil())
 				fmt.Println("UT=========" + resp.ServiceId)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				r = &pb.CreateServiceRequest{
 					Service: &pb.MicroService{
@@ -438,7 +438,7 @@ var _ = Describe("ServiceController", func() {
 				resp, err = serviceResource.Create(getContext(), r)
 				Expect(err).To(BeNil())
 				fmt.Println("UT=========" + resp.ServiceId)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("create service, schema param check", func() {
@@ -457,7 +457,7 @@ var _ = Describe("ServiceController", func() {
 						Status:      "UP",
 					},
 				})
-				Expect(respServiceForSchema.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respServiceForSchema.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("创建微服务5,参数校验", func() {
@@ -467,7 +467,7 @@ var _ = Describe("ServiceController", func() {
 				}
 				resp, err := serviceResource.Create(getContext(), r)
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT=========" + "Alias 非法")
 				r = &pb.CreateServiceRequest{
@@ -482,7 +482,7 @@ var _ = Describe("ServiceController", func() {
 				}
 				resp, err = serviceResource.Create(getContext(), r)
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT=========" + "Alias 合法")
 				r = &pb.CreateServiceRequest{
@@ -504,7 +504,7 @@ var _ = Describe("ServiceController", func() {
 				resp, err := serviceResource.GetServices(getContext(), nil)
 				Expect(err).To(BeNil())
 				fmt.Println(fmt.Sprintf("UT=============%s", resp.Services))
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("查询所有服务", func() {
@@ -519,19 +519,19 @@ var _ = Describe("ServiceController", func() {
 					ServiceId: "",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.GetOne(getContext(), &pb.GetServiceRequest{
 					ServiceId: "notexistservice",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.GetOne(getContext(), &pb.GetServiceRequest{
 					ServiceId: TOO_LONG_SERVICEID,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("更新微服务1props", func() {
 				r := &pb.UpdateServicePropsRequest{
@@ -571,7 +571,7 @@ var _ = Describe("ServiceController", func() {
 				}
 				Expect(err).To(BeNil())
 				fmt.Println(fmt.Sprintf("UT=============%s", resp.Response.Code))
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("更新微服务3props，空结构更新", func() {
 				r := &pb.UpdateServicePropsRequest{
@@ -584,7 +584,7 @@ var _ = Describe("ServiceController", func() {
 				}
 				Expect(err).To(BeNil())
 				fmt.Println(fmt.Sprintf("UT=============%s", resp.Response.Code))
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				r = &pb.UpdateServicePropsRequest{
 					ServiceId:  "",
@@ -593,7 +593,7 @@ var _ = Describe("ServiceController", func() {
 				resp, err = serviceResource.UpdateProperties(getContext(), r)
 				Expect(err).To(BeNil())
 				fmt.Println(fmt.Sprintf("UT=============%s", resp.Response.Code))
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("更新微服务3props, 参数校验", func() {
@@ -602,7 +602,7 @@ var _ = Describe("ServiceController", func() {
 					Properties: map[string]string{},
 				}
 				resp, _ := serviceResource.UpdateProperties(getContext(), r)
-				Expect(resp.Response.Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.Response.Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("创建微服务1实例", func() {
@@ -659,7 +659,7 @@ var _ = Describe("ServiceController", func() {
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp2.GetResponse().Message)
 				fmt.Println(fmt.Sprintf("UT============%s"), resp2.Instances)
-				Expect(resp2.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp2.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 				Expect(len(resp2.Instances)).To((Equal(0)))
 			})
 			It("添加白名单 尝试访问", func() {
@@ -738,7 +738,7 @@ var _ = Describe("ServiceController", func() {
 				Expect(err).To(BeNil())
 				fmt.Println("UT============" + resp2.GetResponse().Message)
 				fmt.Println(fmt.Sprintf("UT============%s"), resp2.Instances)
-				Expect(resp2.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp2.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 				Expect(len(resp2.Instances)).To((Equal(0)))
 			})
 		})
@@ -752,21 +752,21 @@ var _ = Describe("ServiceController", func() {
 					Force:     true,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Delete(getContext(), &pb.DeleteServiceRequest{
 					ServiceId: TOO_LONG_SERVICEID,
 					Force:     true,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Delete(getContext(), &pb.DeleteServiceRequest{
 					ServiceId: "notexistservice",
 					Force:     true,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("删除微服务1", func() {
@@ -810,7 +810,7 @@ var _ = Describe("ServiceController", func() {
 				})
 				fmt.Println("UT============" + resp.GetResponse().Message)
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 		})
 	})
@@ -823,14 +823,14 @@ var _ = Describe("ServiceController", func() {
 					Force:      false,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.DeleteServices(getContext(), &pb.DelServicesRequest{
 					ServiceIds: []string{"@#$44332_non-invalid_serviceId"},
 					Force:      false,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 		})
@@ -958,7 +958,7 @@ var _ = Describe("ServiceController", func() {
 				Expect(err).To(BeNil())
 				//期待结果失败
 				fmt.Println("UT============" + resp.GetResponse().Message)
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("删除服务6的实例，删除服务5和服务6", func() {
diff --git a/server/service/rule.go b/server/service/rule.go
index 12f662ed4..6c209a0e3 100644
--- a/server/service/rule.go
+++ b/server/service/rule.go
@@ -21,6 +21,7 @@ import (
 	apt "github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
 	"github.com/ServiceComb/service-center/server/core/registry"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/infra/quota"
 	"github.com/ServiceComb/service-center/server/plugin/dynamic"
 	serviceUtil "github.com/ServiceComb/service-center/server/service/util"
@@ -107,7 +108,7 @@ func (s *ServiceController) AddRule(ctx context.Context, in *pb.AddServiceRulesR
 	if in == nil || len(in.ServiceId) == 0 || len(in.GetRules()) == 0 {
 		util.Logger().Errorf(nil, "add rule failed: invalid parameters.")
 		return &pb.AddServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -117,20 +118,20 @@ func (s *ServiceController) AddRule(ctx context.Context, in *pb.AddServiceRulesR
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId) {
 		util.Logger().Errorf(nil, "add rule failed, serviceId is %s: service not exist.", in.ServiceId)
 		return &pb.AddServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Service does not exist."),
 		}, nil
 	}
 	_, ok, err := quota.QuotaPlugins[quota.QuataType]().Apply4Quotas(ctx, quota.RULEQuotaType, domainProject, in.ServiceId, int16(len(in.Rules)))
 	if err != nil {
 		util.Logger().Errorf(err, "check can apply resource failed.%s", in.ServiceId)
 		return &pb.AddServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrUnavailableQuota, err.Error()),
 		}, err
 	}
 	if !ok {
 		util.Logger().Errorf(err, "no size to add tag, max size is 100 for one servivce.%s", in.ServiceId)
 		return &pb.AddServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "no size to add tag, max size is 100 for one servivce"),
+			Response: pb.CreateResponse(scerr.ErrNotEnoughQuota, "no size to add tag, max size is 100 for one servivce"),
 		}, nil
 	}
 
@@ -139,8 +140,8 @@ func (s *ServiceController) AddRule(ctx context.Context, in *pb.AddServiceRulesR
 	util.Logger().Debugf("ruleType is %s", ruleType)
 	if err != nil {
 		return &pb.AddServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
-		}, nil
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
+		}, err
 	}
 	ruleIds := []string{}
 	for _, rule := range in.Rules {
@@ -148,7 +149,7 @@ func (s *ServiceController) AddRule(ctx context.Context, in *pb.AddServiceRulesR
 		if err != nil {
 			util.Logger().Errorf(err, "add rule failed, serviceId is %s: invalid rule.", in.ServiceId)
 			return &pb.AddServiceRulesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 			}, nil
 		}
 		//黑白名单只能存在一种，黑名单 or 白名单
@@ -158,7 +159,7 @@ func (s *ServiceController) AddRule(ctx context.Context, in *pb.AddServiceRulesR
 			if ruleType != rule.RuleType {
 				util.Logger().Errorf(nil, "add rule failed, serviceId is %s:can only exist one type, BLACK or WHITE.", in.ServiceId)
 				return &pb.AddServiceRulesResponse{
-					Response: pb.CreateResponse(pb.Response_FAIL, "Service can only contain one rule type, BLACK or WHITE."),
+					Response: pb.CreateResponse(scerr.ErrBlackAndWhiteRule, "Service can only contain one rule type, BLACK or WHITE."),
 				}, nil
 			}
 		}
@@ -191,7 +192,7 @@ func (s *ServiceController) AddRule(ctx context.Context, in *pb.AddServiceRulesR
 		if err != nil {
 			util.Logger().Errorf(err, "add rule failed, serviceId is %s: marshal rule failed.", in.ServiceId)
 			return &pb.AddServiceRulesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Service rule file marshal error."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Service rule file marshal error."),
 			}, err
 		}
 
@@ -208,7 +209,7 @@ func (s *ServiceController) AddRule(ctx context.Context, in *pb.AddServiceRulesR
 	if err != nil {
 		util.Logger().Errorf(err, "add rule failed, serviceId is %s:commit date into etcd failed.", in.ServiceId)
 		return &pb.AddServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."),
 		}, err
 	}
 
@@ -223,7 +224,7 @@ func (s *ServiceController) UpdateRule(ctx context.Context, in *pb.UpdateService
 	if in == nil || in.GetRule() == nil || len(in.ServiceId) == 0 || len(in.RuleId) == 0 {
 		util.Logger().Errorf(nil, "update rule failed: invalid parameters.")
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -233,14 +234,14 @@ func (s *ServiceController) UpdateRule(ctx context.Context, in *pb.UpdateService
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId) {
 		util.Logger().Errorf(nil, "update rule failed, serviceId is %s, ruleId is %s: service not exist.", in.ServiceId, in.RuleId)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 	err := apt.Validate(in.Rule)
 	if err != nil {
 		util.Logger().Errorf(err, "update rule failed, serviceId is %s, ruleId is %s: invalid service rule.", in.ServiceId, in.RuleId)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -249,13 +250,13 @@ func (s *ServiceController) UpdateRule(ctx context.Context, in *pb.UpdateService
 	if err != nil {
 		util.Logger().Errorf(err, "update rule failed, serviceId is %s, ruleId is %s: get rule type failed.", in.ServiceId, in.RuleId)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 		}, err
 	}
 	if ruleNum >= 1 && ruleType != in.Rule.RuleType {
 		util.Logger().Errorf(err, "update rule failed, serviceId is %s, ruleId is %s: rule type can exist one type, BLACK or WHITE.rule type is %s", in.ServiceId, in.RuleId, in.Rule.RuleType)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Exist multiple rules,can not change rule type. Rule type is "+ruleType),
+			Response: pb.CreateResponse(scerr.ErrModifyRuleNotAllow, "Exist multiple rules,can not change rule type. Rule type is "+ruleType),
 		}, nil
 	}
 
@@ -263,13 +264,13 @@ func (s *ServiceController) UpdateRule(ctx context.Context, in *pb.UpdateService
 	if err != nil {
 		util.Logger().Errorf(err, "update rule failed, serviceId is %s, ruleId is %s: query service rule failed.", in.ServiceId, in.RuleId)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get service rule file failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get service rule file failed."),
 		}, err
 	}
 	if rule == nil {
 		util.Logger().Errorf(err, "update rule failed, serviceId is %s, ruleId is %s:this rule does not exist,can't update.", in.ServiceId, in.RuleId)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "This rule does not exist."),
+			Response: pb.CreateResponse(scerr.ErrRuleNotExists, "This rule does not exist."),
 		}, nil
 	}
 
@@ -294,7 +295,7 @@ func (s *ServiceController) UpdateRule(ctx context.Context, in *pb.UpdateService
 	if err != nil {
 		util.Logger().Errorf(err, "update rule failed, serviceId is %s, ruleId is %s: marshal service rule failed.", in.ServiceId, in.RuleId)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service rule file marshal error."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Service rule file marshal error."),
 		}, err
 	}
 	opts := []registry.PluginOp{}
@@ -312,7 +313,7 @@ func (s *ServiceController) UpdateRule(ctx context.Context, in *pb.UpdateService
 	if err != nil {
 		util.Logger().Errorf(err, "update rule failed, serviceId is %s, ruleId is %s: commit date into etcd failed.", in.ServiceId, in.RuleId)
 		return &pb.UpdateServiceRuleResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."),
 		}, err
 	}
 
@@ -326,7 +327,7 @@ func (s *ServiceController) GetRule(ctx context.Context, in *pb.GetServiceRulesR
 	if in == nil || len(in.ServiceId) == 0 {
 		util.Logger().Errorf(nil, "get service rule failed, serviceId is %s: invalid params.", in.ServiceId)
 		return &pb.GetServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -338,16 +339,16 @@ func (s *ServiceController) GetRule(ctx context.Context, in *pb.GetServiceRulesR
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId, opts...) {
 		util.Logger().Errorf(nil, "get service rule failed, serviceId is %s: service not exist.", in.ServiceId)
 		return &pb.GetServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
 	rules, err := serviceUtil.GetRulesUtil(ctx, domainProject, in.ServiceId, opts...)
 	if err != nil {
-		util.Logger().Errorf(nil, "get service rule failed, serviceId is %s: get rule failed.", in.ServiceId)
+		util.Logger().Errorf(err, "get service rule failed, serviceId is %s: get rule failed.", in.ServiceId)
 		return &pb.GetServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get service rules failed."),
-		}, nil
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get service rules failed."),
+		}, err
 	}
 
 	return &pb.GetServiceRulesResponse{
@@ -360,7 +361,7 @@ func (s *ServiceController) DeleteRule(ctx context.Context, in *pb.DeleteService
 	if in == nil || len(in.ServiceId) == 0 {
 		util.Logger().Errorf(nil, "delete service rule failed: invalid parameters.")
 		return &pb.DeleteServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -369,7 +370,7 @@ func (s *ServiceController) DeleteRule(ctx context.Context, in *pb.DeleteService
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId) {
 		util.Logger().Errorf(nil, "delete service rule failed, serviceId is %s, rule is %v: service not exist.", in.ServiceId, in.RuleIds)
 		return &pb.DeleteServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -383,13 +384,13 @@ func (s *ServiceController) DeleteRule(ctx context.Context, in *pb.DeleteService
 		if err != nil {
 			util.Logger().Errorf(err, "delete service rule failed, serviceId is %s, rule is %v: get rule of ruleId %s failed.", in.ServiceId, in.RuleIds, ruleId)
 			return &pb.DeleteServiceRulesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 		if data == nil {
 			util.Logger().Errorf(nil, "delete service rule failed, serviceId is %s, rule is %v: ruleId %s not exist.", in.ServiceId, in.RuleIds, ruleId)
 			return &pb.DeleteServiceRulesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "This rule does not exist."),
+				Response: pb.CreateResponse(scerr.ErrRuleNotExists, "This rule does not exist."),
 			}, nil
 		}
 		indexKey = apt.GenerateRuleIndexKey(domainProject, in.ServiceId, data.Attribute, data.Pattern)
@@ -400,14 +401,14 @@ func (s *ServiceController) DeleteRule(ctx context.Context, in *pb.DeleteService
 	if len(opts) <= 0 {
 		util.Logger().Errorf(nil, "delete service rule failed, serviceId is %s, rule is %v: rule has been deleted.", in.ServiceId, in.RuleIds)
 		return &pb.DeleteServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "No service rule has been deleted."),
+			Response: pb.CreateResponse(scerr.ErrRuleNotExists, "No service rule has been deleted."),
 		}, nil
 	}
 	_, err := registry.GetRegisterCenter().Txn(ctx, opts)
 	if err != nil {
 		util.Logger().Errorf(err, "delete service rule failed, serviceId is %s, rule is %v: commit data into etcd failed.", in.ServiceId, in.RuleIds)
 		return &pb.DeleteServiceRulesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."),
 		}, err
 	}
 
diff --git a/server/service/rule_test.go b/server/service/rule_test.go
index 45f01b7b0..bcf3a622d 100644
--- a/server/service/rule_test.go
+++ b/server/service/rule_test.go
@@ -39,7 +39,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
 					ServiceId: serviceId,
@@ -53,7 +53,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
 					ServiceId: "notexistservice",
@@ -67,7 +67,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
 					ServiceId: "",
@@ -81,7 +81,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			ruleId := ""
 			It("创建rule", func() {
@@ -160,7 +160,7 @@ var _ = Describe("ServiceController", func() {
 						},
 					})
 					if i == size-1 {
-						Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+						Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 						return
 					}
 					Expect(resp.GetResponse().Code).To(Equal(pb.Response_SUCCESS))
@@ -172,13 +172,13 @@ var _ = Describe("ServiceController", func() {
 					ServiceId: "",
 				})
 				Expect(err).To(BeNil())
-				Expect(respGetRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respGetRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respGetRule, err = serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
 					ServiceId: "notexist",
 				})
 				Expect(err).To(BeNil())
-				Expect(respGetRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respGetRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("获取rule", func() {
 				respAddRule, err := serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
@@ -193,7 +193,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				//只能有一种ruleType
 				respAddRule, err = serviceResource.AddRule(getContext(), &pb.AddServiceRulesRequest{
@@ -208,7 +208,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========获取rule")
 				respGetRule, err := serviceResource.GetRule(getContext(), &pb.GetServiceRulesRequest{
@@ -230,7 +230,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
 					ServiceId: "notexistservice",
@@ -243,7 +243,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
 					ServiceId: serviceId,
@@ -256,7 +256,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
 					ServiceId: serviceId,
@@ -269,7 +269,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("修改rule", func() {
 				fmt.Println("UT===========修改rule")
@@ -309,7 +309,7 @@ var _ = Describe("ServiceController", func() {
 						Description: "test white update",
 					},
 				})
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.UpdateRule(getContext(), &pb.UpdateServiceRuleRequest{
 					ServiceId: serviceId,
@@ -321,7 +321,7 @@ var _ = Describe("ServiceController", func() {
 						Description: "test white update",
 					},
 				})
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("删除rule,参数校验", func() {
@@ -331,14 +331,14 @@ var _ = Describe("ServiceController", func() {
 					RuleIds:   []string{"1000000"},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddRule, err = serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
 					ServiceId: serviceId,
 					RuleIds:   []string{},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			})
 
@@ -365,7 +365,7 @@ var _ = Describe("ServiceController", func() {
 					RuleIds:   []string{ruleId},
 				})
 				//Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========删除serviceId不存在rule")
 				respAddRule, _ = serviceResource.DeleteRule(getContext(), &pb.DeleteServiceRulesRequest{
@@ -373,7 +373,7 @@ var _ = Describe("ServiceController", func() {
 					RuleIds:   []string{ruleId},
 				})
 				//Expect(err).To(BeNil())
-				Expect(respAddRule.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddRule.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 		})
 	})
diff --git a/server/service/schema.go b/server/service/schema.go
index 0c1e68f58..ac1544c36 100644
--- a/server/service/schema.go
+++ b/server/service/schema.go
@@ -21,6 +21,7 @@ import (
 	pb "github.com/ServiceComb/service-center/server/core/proto"
 	"github.com/ServiceComb/service-center/server/core/registry"
 	"github.com/ServiceComb/service-center/server/core/registry/store"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/infra/quota"
 	serviceUtil "github.com/ServiceComb/service-center/server/service/util"
 	"github.com/ServiceComb/service-center/version"
@@ -32,7 +33,7 @@ func (s *ServiceController) GetSchemaInfo(ctx context.Context, in *pb.GetSchemaR
 	if in == nil || len(in.ServiceId) == 0 || len(in.SchemaId) == 0 {
 		util.Logger().Errorf(nil, "get schema failed: invalid params.")
 		return &pb.GetSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Invalid request path."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request path."),
 		}, nil
 	}
 
@@ -40,7 +41,7 @@ func (s *ServiceController) GetSchemaInfo(ctx context.Context, in *pb.GetSchemaR
 	if err != nil {
 		util.Logger().Errorf(nil, "get schema failed, serviceId %s, schemaId %s: invalid params.", in.ServiceId, in.SchemaId)
 		return &pb.GetSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -51,7 +52,7 @@ func (s *ServiceController) GetSchemaInfo(ctx context.Context, in *pb.GetSchemaR
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId, opts...) {
 		util.Logger().Errorf(nil, "get schema failed, serviceId %s, schemaId %s: service not exist.", in.ServiceId, in.SchemaId)
 		return &pb.GetSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -61,13 +62,13 @@ func (s *ServiceController) GetSchemaInfo(ctx context.Context, in *pb.GetSchemaR
 	if errDo != nil {
 		util.Logger().Errorf(errDo, "get schema failed, serviceId %s, schemaId %s: get schema info failed.", in.ServiceId, in.SchemaId)
 		return &pb.GetSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get schema info failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get schema info failed."),
 		}, errDo
 	}
 	if resp.Count == 0 {
 		util.Logger().Errorf(errDo, "get schema failed, serviceId %s, schemaId %s: schema not exists.", in.ServiceId, in.SchemaId)
 		return &pb.GetSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Do not have this schema info."),
+			Response: pb.CreateResponse(scerr.ErrSchemaNotExists, "Do not have this schema info."),
 		}, nil
 	}
 	return &pb.GetSchemaResponse{
@@ -80,14 +81,14 @@ func (s *ServiceController) DeleteSchema(ctx context.Context, request *pb.Delete
 	if request == nil || len(request.ServiceId) == 0 || len(request.SchemaId) == 0 {
 		util.Logger().Errorf(nil, "delete schema failded: invalid params.")
 		return &pb.DeleteSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Invalid request path."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request path."),
 		}, nil
 	}
 	err := apt.Validate(request)
 	if err != nil {
 		util.Logger().Errorf(err, "delete schema failded, serviceId %s, schemaId %s: invalid params.", request.ServiceId, request.SchemaId)
 		return &pb.DeleteSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 	domainProject := util.ParseDomainProject(ctx)
@@ -95,7 +96,7 @@ func (s *ServiceController) DeleteSchema(ctx context.Context, request *pb.Delete
 	if !serviceUtil.ServiceExist(ctx, domainProject, request.ServiceId) {
 		util.Logger().Errorf(nil, "delete schema failded, serviceId %s, schemaId %s: service not exist.", request.ServiceId, request.SchemaId)
 		return &pb.DeleteSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -104,20 +105,20 @@ func (s *ServiceController) DeleteSchema(ctx context.Context, request *pb.Delete
 	if err != nil {
 		util.Logger().Errorf(err, "delete schema failded, serviceId %s, schemaId %s: get schema failed.", request.ServiceId, request.SchemaId)
 		return &pb.DeleteSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Schema info does not exist."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Schema info does not exist."),
 		}, err
 	}
 	if !exist {
 		util.Logger().Errorf(nil, "delete schema failded, serviceId %s, schemaId %s: schema not exist.", request.ServiceId, request.SchemaId)
 		return &pb.DeleteSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Schema info does not exist."),
+			Response: pb.CreateResponse(scerr.ErrSchemaNotExists, "Schema info does not exist."),
 		}, nil
 	}
 	_, errDo := registry.GetRegisterCenter().Do(ctx, registry.DEL, registry.WithStrKey(key))
 	if errDo != nil {
 		util.Logger().Errorf(errDo, "delete schema failded, serviceId %s, schemaId %s: delete schema from etcd faild.", request.ServiceId, request.SchemaId)
 		return &pb.DeleteSchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Delete schema info failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Delete schema info failed."),
 		}, errDo
 	}
 	util.Logger().Infof("delete schema info successfully.%s", request.SchemaId)
@@ -131,7 +132,7 @@ func (s *ServiceController) ModifySchemas(ctx context.Context, request *pb.Modif
 	if err != nil {
 		util.Logger().Errorf(err, "modify schemas failded: invalid params.")
 		return &pb.ModifySchemasResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Invalid request."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Invalid request."),
 		}, nil
 	}
 	serviceId := request.ServiceId
@@ -142,13 +143,13 @@ func (s *ServiceController) ModifySchemas(ctx context.Context, request *pb.Modif
 	if err != nil {
 		util.Logger().Errorf(err, "modify schemas failded: get service failed. %s", serviceId)
 		return &pb.ModifySchemasResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Invalid request."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Invalid request."),
 		}, err
 	}
 	if service == nil {
-		util.Logger().Errorf(nil, "modify schemas failded: service not exist. %s", serviceId)
+		util.Logger().Errorf(nil, "modify schemas failded: service does not exist. %s", serviceId)
 		return &pb.ModifySchemasResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -156,11 +157,11 @@ func (s *ServiceController) ModifySchemas(ctx context.Context, request *pb.Modif
 	if err != nil {
 		if isInnErr {
 			return &pb.ModifySchemasResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 		return &pb.ModifySchemasResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrModifySchemaNotAllow, err.Error()),
 		}, nil
 	}
 
@@ -380,11 +381,11 @@ func (s *ServiceController) ModifySchema(ctx context.Context, request *pb.Modify
 	if err != nil {
 		if !rst {
 			return &pb.ModifySchemaResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrModifySchemaNotAllow, err.Error()),
 			}, nil
 		}
 		return &pb.ModifySchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Modify schema info failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Modify schema info failed."),
 		}, err
 	}
 	serviceId := request.ServiceId
@@ -400,11 +401,11 @@ func (s *ServiceController) ModifySchema(ctx context.Context, request *pb.Modify
 		util.Logger().Errorf(err, "modify service schema failed")
 		if isInnerErr {
 			return &pb.ModifySchemaResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Modify schema info failed."),
+				Response: pb.CreateResponse(scerr.ErrInternal, "Modify schema info failed."),
 			}, err
 		}
 		return &pb.ModifySchemaResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Modify schema info failed."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Modify schema info failed."),
 		}, nil
 	}
 
diff --git a/server/service/schema_test.go b/server/service/schema_test.go
index 63cee6291..cc4c1d3db 100644
--- a/server/service/schema_test.go
+++ b/server/service/schema_test.go
@@ -63,7 +63,7 @@ var _ = Describe("ServiceController", func() {
 					Schema:    "create schema",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.ModifySchema(getContext(), &pb.ModifySchemaRequest{
 					ServiceId: serviceId,
@@ -71,7 +71,7 @@ var _ = Describe("ServiceController", func() {
 					Schema:    "create schema",
 				})
 				//Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.ModifySchema(getContext(), &pb.ModifySchemaRequest{
 					ServiceId: "notExistService",
@@ -79,7 +79,7 @@ var _ = Describe("ServiceController", func() {
 					Schema:    "create schema",
 				})
 				//Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("schema是否存在,参数校验", func() {
@@ -89,7 +89,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "com.huawei.test",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Exist(getContext(), &pb.GetExistenceRequest{
 					Type:      "schema",
@@ -97,11 +97,11 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "noneschema",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.Exist(getContext(), nil)
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respExist, err := serviceResource.Exist(getContext(), &pb.GetExistenceRequest{
 					Type:        "microservice",
@@ -110,7 +110,7 @@ var _ = Describe("ServiceController", func() {
 					Version:     "3.0.0",
 				})
 				Expect(err).To(BeNil())
-				Expect(respExist.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respExist.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("schema是否存在", func() {
@@ -143,7 +143,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "com.huawei.test",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("查询schema", func() {
@@ -164,7 +164,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "com.huawei.test",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========查询schema")
 				resp, err = serviceResource.GetSchemaInfo(getContext(), &pb.GetSchemaRequest{
@@ -172,7 +172,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "com.huawei.test",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========查询schema")
 				resp, err = serviceResource.GetSchemaInfo(getContext(), &pb.GetSchemaRequest{
@@ -180,7 +180,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "nonexistschema",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========查询schema")
 				resp, err = serviceResource.GetSchemaInfo(getContext(), &pb.GetSchemaRequest{
@@ -188,7 +188,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  invalidSchemaId,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("修改schema,参数校验", func() {
@@ -207,7 +207,7 @@ var _ = Describe("ServiceController", func() {
 					Schema:    "change schema",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("修改schema", func() {
@@ -227,7 +227,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "noneschema",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========删除schema")
 				resp, err = serviceResource.DeleteSchema(getContext(), &pb.DeleteSchemaRequest{
@@ -252,7 +252,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "com.huawei.test",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========删除schema，")
 				resp, err = serviceResource.DeleteSchema(getContext(), &pb.DeleteSchemaRequest{
@@ -260,7 +260,7 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "com.huawei.test",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========删除schema，")
 				resp, err = serviceResource.DeleteSchema(getContext(), &pb.DeleteSchemaRequest{
@@ -268,19 +268,19 @@ var _ = Describe("ServiceController", func() {
 					SchemaId:  "com.huawei.test",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.DeleteSchema(getContext(), &pb.DeleteSchemaRequest{
 					ServiceId: serviceId,
 					SchemaId:  invalidSchemaId,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 		})
 	})
 	Describe("schemas", func() {
-		var serviceId , serviceId2 string
+		var serviceId, serviceId2 string
 		It("create service", func() {
 			respCreateService, err := serviceResource.Create(getContext(), &pb.CreateServiceRequest{
 				Service: &pb.MicroService{
@@ -300,14 +300,13 @@ var _ = Describe("ServiceController", func() {
 			serviceId = respCreateService.ServiceId
 			Expect(respCreateService.GetResponse().Code).To(Equal(pb.Response_SUCCESS))
 
-
 			respCreateService, err = serviceResource.Create(getContext(), &pb.CreateServiceRequest{
 				Service: &pb.MicroService{
 					ServiceName: "service_name_no_schemaId",
 					AppId:       "service_group_no_schema",
 					Version:     "1.0.0",
 					Level:       "FRONT",
-					Status: "UP",
+					Status:      "UP",
 				},
 			})
 			Expect(err).To(BeNil())
@@ -321,14 +320,14 @@ var _ = Describe("ServiceController", func() {
 				Schemas:   nil,
 			})
 			Expect(err).To(BeNil())
-			Expect(respCreateService.GetResponse().Code).To(Equal(pb.Response_FAIL))
+			Expect(respCreateService.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			respCreateService, err = serviceResource.ModifySchemas(getContext(), &pb.ModifySchemasRequest{
 				ServiceId: "not_exist_serviceId",
 				Schemas:   []*pb.Schema{},
 			})
 			Expect(err).To(BeNil())
-			Expect(respCreateService.GetResponse().Code).To(Equal(pb.Response_FAIL))
+			Expect(respCreateService.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			respCreateService, err = serviceResource.ModifySchemas(getContext(), &pb.ModifySchemasRequest{
 				ServiceId: "not_exist_serviceId",
@@ -339,20 +338,20 @@ var _ = Describe("ServiceController", func() {
 				},
 			})
 			Expect(err).To(BeNil())
-			Expect(respCreateService.GetResponse().Code).To(Equal(pb.Response_FAIL))
+			Expect(respCreateService.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			respCreateService, err = serviceResource.ModifySchemas(getContext(), &pb.ModifySchemasRequest{
 				ServiceId: "",
 			})
 			Expect(err).To(BeNil())
-			Expect(respCreateService.GetResponse().Code).To(Equal(pb.Response_FAIL))
+			Expect(respCreateService.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			respCreateService, err = serviceResource.ModifySchemas(getContext(), &pb.ModifySchemasRequest{
 				ServiceId: "not_exist_serviceId",
 				Schemas:   []*pb.Schema{},
 			})
 			Expect(err).To(BeNil())
-			Expect(respCreateService.GetResponse().Code).To(Equal(pb.Response_FAIL))
+			Expect(respCreateService.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			respCreateService, err = serviceResource.ModifySchemas(getContext(), &pb.ModifySchemasRequest{
 				ServiceId: serviceId,
@@ -466,7 +465,6 @@ var _ = Describe("ServiceController", func() {
 			Expect(respSchemaExist.GetResponse().Code).To(Equal(pb.Response_SUCCESS))
 			Expect(respSchemaExist.Summary).To(Equal("third_summary"))
 
-
 			schemas = []*pb.Schema{
 				&pb.Schema{
 					SchemaId: "first_schemaId",
@@ -486,7 +484,7 @@ var _ = Describe("ServiceController", func() {
 				Schemas:   schemas,
 			})
 			Expect(err).To(BeNil())
-			Expect(respModifySchemas.GetResponse().Code).To(Equal(pb.Response_FAIL))
+			Expect(respModifySchemas.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			schemas = []*pb.Schema{
 				&pb.Schema{
diff --git a/server/service/service_dependency_test.go b/server/service/service_dependency_test.go
index 7107abd0f..e92e1c505 100644
--- a/server/service/service_dependency_test.go
+++ b/server/service/service_dependency_test.go
@@ -48,7 +48,7 @@ var _ = Describe("ServiceController", func() {
 					Dependencies: nil,
 				})
 				Expect(err).To(BeNil())
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respCreateDependency, err = serviceResource.CreateDependenciesForMircServices(getContext(), &pb.CreateDependenciesRequest{
 					Dependencies: []*pb.MircroServiceDependency{
@@ -62,7 +62,7 @@ var _ = Describe("ServiceController", func() {
 						},
 					},
 				})
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respCreateDependency, err = serviceResource.CreateDependenciesForMircServices(getContext(), &pb.CreateDependenciesRequest{
 					Dependencies: []*pb.MircroServiceDependency{
@@ -88,7 +88,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respCreateDependency, err = serviceResource.CreateDependenciesForMircServices(getContext(), &pb.CreateDependenciesRequest{
 					Dependencies: []*pb.MircroServiceDependency{
@@ -130,7 +130,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respCreateDependency, err = serviceResource.CreateDependenciesForMircServices(getContext(), &pb.CreateDependenciesRequest{
 					Dependencies: []*pb.MircroServiceDependency{
@@ -151,7 +151,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respCreateDependency, err = serviceResource.CreateDependenciesForMircServices(getContext(), &pb.CreateDependenciesRequest{
 					Dependencies: []*pb.MircroServiceDependency{
@@ -172,7 +172,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respCreateDependency, err = serviceResource.CreateDependenciesForMircServices(getContext(), &pb.CreateDependenciesRequest{
 					Dependencies: []*pb.MircroServiceDependency{
@@ -193,7 +193,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respCreateDependency, err = serviceResource.CreateDependenciesForMircServices(getContext(), &pb.CreateDependenciesRequest{
 					Dependencies: []*pb.MircroServiceDependency{
@@ -214,7 +214,7 @@ var _ = Describe("ServiceController", func() {
 					},
 				})
 				Expect(err).To(BeNil())
-				Expect(respCreateDependency.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respCreateDependency.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("创建Dependency", func() {
 				fmt.Println("UT===========创建Dependency")
@@ -390,7 +390,7 @@ var _ = Describe("ServiceController", func() {
 					Force:     false,
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("查询provider对应的所有consumer,参数校验", func() {
@@ -399,13 +399,13 @@ var _ = Describe("ServiceController", func() {
 					ServiceId: "",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.GetProviderDependencies(getContext(), &pb.GetDependenciesRequest{
 					ServiceId: "noneservice",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("查询provider对应的所有consumer", func() {
@@ -423,13 +423,13 @@ var _ = Describe("ServiceController", func() {
 					ServiceId: "",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.GetConsumerDependencies(getContext(), &pb.GetDependenciesRequest{
 					ServiceId: "noneservice",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("查询consumer对应的所有provider", func() {
@@ -782,7 +782,7 @@ var _ = Describe("ServiceController", func() {
 					}
 				}
 				Expect(flag).To(Equal(true))
-			} )
+			})
 
 			It("clean", func() {
 				respDelete, err := serviceResource.Delete(getContext(), &pb.DeleteServiceRequest{
@@ -815,7 +815,6 @@ var _ = Describe("ServiceController", func() {
 			})
 		})
 
-
 		It("删除微服务,作为provider，有consumer", func() {
 			var consumerId, providerId string
 			resp, err := serviceResource.Create(getContext(), &pb.CreateServiceRequest{
@@ -876,8 +875,7 @@ var _ = Describe("ServiceController", func() {
 				Force:     false,
 			})
 			Expect(err).To(BeNil())
-			Expect(respDelete.GetResponse().Code).To(Equal(pb.Response_FAIL))
-
+			Expect(respDelete.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 			respDelete, err = serviceResource.Delete(getContext(), &pb.DeleteServiceRequest{
 				ServiceId: consumerId,
diff --git a/server/service/services_dependency.go b/server/service/services_dependency.go
index c39e315f9..f5d584ff0 100644
--- a/server/service/services_dependency.go
+++ b/server/service/services_dependency.go
@@ -17,6 +17,7 @@ import (
 	"github.com/ServiceComb/service-center/pkg/util"
 	apt "github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/mux"
 	serviceUtil "github.com/ServiceComb/service-center/server/service/util"
 	"golang.org/x/net/context"
@@ -53,13 +54,13 @@ func (s *ServiceController) CreateDependenciesForMircServices(ctx context.Contex
 		if err != nil {
 			util.Logger().Errorf(err, "create dependency failed, consumer %s: get consumer failed.", consumerFlag)
 			return &pb.CreateDependenciesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 		if len(consumerId) == 0 {
 			util.Logger().Errorf(nil, "create dependency failed, consumer %s: consumer not exist.", consumerFlag)
 			return &pb.CreateDependenciesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Get consumer's serviceId is empty."),
+				Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Get consumer's serviceId is empty."),
 			}, nil
 		}
 
@@ -69,7 +70,7 @@ func (s *ServiceController) CreateDependenciesForMircServices(ctx context.Contex
 		if err != nil {
 			util.Logger().Errorf(err, "create dependency failed, consumer %s: Update service failed.", consumerFlag)
 			return &pb.CreateDependenciesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 
@@ -78,7 +79,7 @@ func (s *ServiceController) CreateDependenciesForMircServices(ctx context.Contex
 		if err != nil {
 			util.Logger().Errorf(err, "create dependency failed, consumer %s: create lock failed.", consumerFlag)
 			return &pb.CreateDependenciesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 
@@ -88,7 +89,7 @@ func (s *ServiceController) CreateDependenciesForMircServices(ctx context.Contex
 		if err != nil {
 			util.Logger().Errorf(err, "create dependency rule failed: consumer %s", consumerFlag)
 			return &pb.CreateDependenciesResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+				Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 			}, err
 		}
 		util.Logger().Infof("Create dependency success: consumer %s, %s  from remote %s", consumerFlag, consumerId, util.GetIPFromContext(ctx))
@@ -103,7 +104,7 @@ func (s *ServiceController) GetProviderDependencies(ctx context.Context, in *pb.
 	if err != nil {
 		util.Logger().Errorf(err, "GetProviderDependencies failed for validating parameters failed.")
 		return &pb.GetProDependenciesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 	domainProject := util.ParseDomainProject(ctx)
@@ -115,9 +116,9 @@ func (s *ServiceController) GetProviderDependencies(ctx context.Context, in *pb.
 		return nil, err
 	}
 	if provider == nil {
-		util.Logger().Errorf(err, "GetProviderDependencies failed for provider not exist, %s.", providerServiceId)
+		util.Logger().Errorf(err, "GetProviderDependencies failed for provider does not exist, %s.", providerServiceId)
 		return &pb.GetProDependenciesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Provider not exist"),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Provider does not exist"),
 		}, nil
 	}
 
@@ -127,7 +128,7 @@ func (s *ServiceController) GetProviderDependencies(ctx context.Context, in *pb.
 	if err != nil {
 		util.Logger().Errorf(err, "GetProviderDependencies failed.")
 		return &pb.GetProDependenciesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 		}, err
 	}
 	util.Logger().Infof("GetProviderDependencies successfully, providerId is %s.", in.ServiceId)
@@ -142,7 +143,7 @@ func (s *ServiceController) GetConsumerDependencies(ctx context.Context, in *pb.
 	if err != nil {
 		util.Logger().Errorf(err, "GetConsumerDependencies failed for validating parameters failed.")
 		return &pb.GetConDependenciesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 	consumerId := in.ServiceId
@@ -152,13 +153,13 @@ func (s *ServiceController) GetConsumerDependencies(ctx context.Context, in *pb.
 	if err != nil {
 		util.Logger().Errorf(err, "GetConsumerDependencies failed for get consumer failed.")
 		return &pb.GetConDependenciesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 		}, err
 	}
 	if consumer == nil {
-		util.Logger().Errorf(err, "GetConsumerDependencies failed for consumer not exist, %s.", consumerId)
+		util.Logger().Errorf(err, "GetConsumerDependencies failed for consumer does not exist, %s.", consumerId)
 		return &pb.GetConDependenciesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Consumer not exist"),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Consumer does not exist"),
 		}, nil
 	}
 
@@ -168,7 +169,7 @@ func (s *ServiceController) GetConsumerDependencies(ctx context.Context, in *pb.
 	if err != nil {
 		util.Logger().Errorf(err, "GetConsumerDependencies failed for get providers failed.")
 		return &pb.GetConDependenciesResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInternal, err.Error()),
 		}, err
 	}
 
diff --git a/server/service/tag.go b/server/service/tag.go
index baf69a718..13ae1ba3b 100644
--- a/server/service/tag.go
+++ b/server/service/tag.go
@@ -19,6 +19,7 @@ import (
 	apt "github.com/ServiceComb/service-center/server/core"
 	pb "github.com/ServiceComb/service-center/server/core/proto"
 	"github.com/ServiceComb/service-center/server/core/registry"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/infra/quota"
 	serviceUtil "github.com/ServiceComb/service-center/server/service/util"
 	"golang.org/x/net/context"
@@ -28,7 +29,7 @@ func (s *ServiceController) AddTags(ctx context.Context, in *pb.AddServiceTagsRe
 	if in == nil || len(in.ServiceId) == 0 || len(in.GetTags()) == 0 {
 		util.Logger().Errorf(nil, "add service tags failed: invalid parameters.")
 		return &pb.AddServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 
@@ -36,7 +37,7 @@ func (s *ServiceController) AddTags(ctx context.Context, in *pb.AddServiceTagsRe
 	if err != nil {
 		util.Logger().Errorf(err, "add service tags failed, serviceId %s, tags %v: invalid parameters.", in.ServiceId, in.Tags)
 		return &pb.AddServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -45,7 +46,7 @@ func (s *ServiceController) AddTags(ctx context.Context, in *pb.AddServiceTagsRe
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId) {
 		util.Logger().Errorf(nil, "add service tags failed, serviceId %s, tags %v: service not exist.", in.ServiceId, in.Tags)
 		return &pb.AddServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -54,13 +55,13 @@ func (s *ServiceController) AddTags(ctx context.Context, in *pb.AddServiceTagsRe
 	if err != nil {
 		util.Logger().Errorf(err, "add tag info failed, check resource num failed, %s", in.ServiceId)
 		return &pb.AddServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Modify schema info failed, check resource num failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableQuota, "Modify schema info failed, check resource num failed."),
 		}, err
 	}
 	if !ok {
 		util.Logger().Errorf(err, "add tag info failed, reach the max size of tag, %s", in.ServiceId)
 		return &pb.AddServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "reach the max size of tag."),
+			Response: pb.CreateResponse(scerr.ErrNotEnoughQuota, "reach the max size of tag."),
 		}, nil
 	}
 
@@ -68,7 +69,7 @@ func (s *ServiceController) AddTags(ctx context.Context, in *pb.AddServiceTagsRe
 	if err != nil {
 		util.Logger().Errorf(err, "add service tags failed, serviceId %s, tags %v: get existed tag failed.", in.ServiceId, in.Tags)
 		return &pb.AddServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get tags failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get tags failed."),
 		}, err
 	}
 	if len(dataTags) > 0 {
@@ -83,7 +84,7 @@ func (s *ServiceController) AddTags(ctx context.Context, in *pb.AddServiceTagsRe
 	if err != nil {
 		util.Logger().Errorf(err, "add service tags failed, serviceId %s, tags %v: commit tag data into etcd failed.", in.ServiceId, in.Tags)
 		return &pb.AddServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Commit operations failed."),
 		}, err
 	}
 
@@ -97,7 +98,7 @@ func (s *ServiceController) UpdateTag(ctx context.Context, in *pb.UpdateServiceT
 	if in == nil || len(in.ServiceId) == 0 || len(in.Key) == 0 || len(in.Value) == 0 {
 		util.Logger().Errorf(nil, "update service tag failed: invalid parameters.")
 		return &pb.UpdateServiceTagResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	tagFlag := util.StringJoin([]string{in.Key, in.Value}, "/")
@@ -105,7 +106,7 @@ func (s *ServiceController) UpdateTag(ctx context.Context, in *pb.UpdateServiceT
 	if err != nil {
 		util.Logger().Errorf(err, "update service tag failed, serviceId %s, tag %s: invalid params.", in.ServiceId, tagFlag)
 		return &pb.UpdateServiceTagResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -114,7 +115,7 @@ func (s *ServiceController) UpdateTag(ctx context.Context, in *pb.UpdateServiceT
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId) {
 		util.Logger().Errorf(err, "update service tag failed, serviceId %s, tag %s: service not exist.", in.ServiceId, tagFlag)
 		return &pb.UpdateServiceTagResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -122,15 +123,15 @@ func (s *ServiceController) UpdateTag(ctx context.Context, in *pb.UpdateServiceT
 	if err != nil {
 		util.Logger().Errorf(err, "update service tag failed, serviceId %s, tag %s: get tag failed.", in.ServiceId, tagFlag)
 		return &pb.UpdateServiceTagResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get tags for service failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get tags for service failed."),
 		}, err
 	}
 	//check tag 是否存在
 	if _, ok := tags[in.Key]; !ok {
 		util.Logger().Errorf(nil, "update service tag failed, serviceId %s, tag %s: tag not exist,please add first.", in.ServiceId, tagFlag)
 		return &pb.UpdateServiceTagResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Update tag for service failed for update tags not exist, please add first."),
-		}, err
+			Response: pb.CreateResponse(scerr.ErrTagNotExists, "Update tag for service failed for update tags not exist, please add first."),
+		}, nil
 	}
 	tags[in.Key] = in.Value
 
@@ -139,7 +140,7 @@ func (s *ServiceController) UpdateTag(ctx context.Context, in *pb.UpdateServiceT
 	if err != nil {
 		util.Logger().Errorf(err, "update service tag failed, serviceId %s, tag %s: adding service tags failed.", in.ServiceId, tagFlag)
 		return &pb.UpdateServiceTagResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit into etcd failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Commit into etcd failed."),
 		}, err
 	}
 
@@ -153,14 +154,14 @@ func (s *ServiceController) DeleteTags(ctx context.Context, in *pb.DeleteService
 	if in == nil || len(in.ServiceId) == 0 || len(in.Keys) == 0 {
 		util.Logger().Errorf(nil, "delete service tags failed: invalid parameters.")
 		return &pb.DeleteServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	err := apt.Validate(in)
 	if err != nil {
 		util.Logger().Errorf(err, "delete service tags failed, serviceId %s, tags %v: invalid params.", in.ServiceId, in.Keys)
 		return &pb.DeleteServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -169,7 +170,7 @@ func (s *ServiceController) DeleteTags(ctx context.Context, in *pb.DeleteService
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId) {
 		util.Logger().Errorf(nil, "delete service tags failed, serviceId %s, tags %v: service not exist.", in.ServiceId, in.Keys)
 		return &pb.DeleteServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -177,14 +178,14 @@ func (s *ServiceController) DeleteTags(ctx context.Context, in *pb.DeleteService
 	if err != nil {
 		util.Logger().Errorf(err, "delete service tags failed, serviceId %s, tags %v: query service failed.", in.ServiceId, in.Keys)
 		return &pb.DeleteServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get service tags file failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get service tags file failed."),
 		}, err
 	}
 	for _, key := range in.Keys {
 		if _, ok := tags[key]; !ok {
 			util.Logger().Errorf(nil, "delete service tags failed, serviceId %s, tags %v: tag %s not exist.", in.ServiceId, in.Keys, key)
 			return &pb.DeleteServiceTagsResponse{
-				Response: pb.CreateResponse(pb.Response_FAIL, "Delete tags failed for this key "+key+" does not exist."),
+				Response: pb.CreateResponse(scerr.ErrTagNotExists, "Delete tags failed for this key "+key+" does not exist."),
 			}, nil
 		}
 		delete(tags, key)
@@ -195,7 +196,7 @@ func (s *ServiceController) DeleteTags(ctx context.Context, in *pb.DeleteService
 	if err != nil {
 		util.Logger().Errorf(err, "delete service tags failed, serviceId %s, tags %v: marshall service tag failed.", in.ServiceId, in.Keys)
 		return &pb.DeleteServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Marshal service tags file failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Marshal service tags file failed."),
 		}, err
 	}
 
@@ -209,7 +210,7 @@ func (s *ServiceController) DeleteTags(ctx context.Context, in *pb.DeleteService
 	if err != nil {
 		util.Logger().Errorf(err, "delete service tags failed, serviceId %s, tags %v: commit tag data into etcd failed.", in.ServiceId, in.Keys)
 		return &pb.DeleteServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Commit operations failed."),
+			Response: pb.CreateResponse(scerr.ErrUnavailableBackend, "Commit operations failed."),
 		}, err
 	}
 
@@ -223,14 +224,14 @@ func (s *ServiceController) GetTags(ctx context.Context, in *pb.GetServiceTagsRe
 	if in == nil || len(in.ServiceId) == 0 {
 		util.Logger().Errorf(nil, "get service tags failed: invalid params.")
 		return &pb.GetServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Request format invalid."),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, "Request format invalid."),
 		}, nil
 	}
 	err := apt.Validate(in)
 	if err != nil {
 		util.Logger().Errorf(err, "get service tags failed, serviceId %s: invalid parameters.", in.ServiceId)
 		return &pb.GetServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, err.Error()),
+			Response: pb.CreateResponse(scerr.ErrInvalidParams, err.Error()),
 		}, nil
 	}
 
@@ -241,7 +242,7 @@ func (s *ServiceController) GetTags(ctx context.Context, in *pb.GetServiceTagsRe
 	if !serviceUtil.ServiceExist(ctx, domainProject, in.ServiceId, opts...) {
 		util.Logger().Errorf(err, "get service tags failed, serviceId %s: service not exist.", in.ServiceId)
 		return &pb.GetServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Service does not exist."),
+			Response: pb.CreateResponse(scerr.ErrServiceNotExists, "Service does not exist."),
 		}, nil
 	}
 
@@ -249,7 +250,7 @@ func (s *ServiceController) GetTags(ctx context.Context, in *pb.GetServiceTagsRe
 	if err != nil {
 		util.Logger().Errorf(err, "get service tags failed, serviceId %s: get tag failed.", in.ServiceId)
 		return &pb.GetServiceTagsResponse{
-			Response: pb.CreateResponse(pb.Response_FAIL, "Get tags for service failed."),
+			Response: pb.CreateResponse(scerr.ErrInternal, "Get tags for service failed."),
 		}, err
 	}
 
diff --git a/server/service/tag_test.go b/server/service/tag_test.go
index 2c0be473f..eedff08b3 100644
--- a/server/service/tag_test.go
+++ b/server/service/tag_test.go
@@ -91,7 +91,7 @@ var _ = Describe("ServiceController", func() {
 						"a": "test",
 					},
 				})
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddTags, _ = serviceResource.AddTags(getContext(), &pb.AddServiceTagsRequest{
 					ServiceId: "noServiceTest",
@@ -99,13 +99,13 @@ var _ = Describe("ServiceController", func() {
 						"a": "test",
 					},
 				})
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddTags, _ = serviceResource.AddTags(getContext(), &pb.AddServiceTagsRequest{
 					ServiceId: serviceId,
 					Tags:      map[string]string{},
 				})
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddTags, _ = serviceResource.AddTags(getContext(), &pb.AddServiceTagsRequest{
 					ServiceId: TOO_LONG_SERVICEID,
@@ -113,7 +113,7 @@ var _ = Describe("ServiceController", func() {
 						"a": "b",
 					},
 				})
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddTags, _ = serviceResource.AddTags(getContext(), &pb.AddServiceTagsRequest{
 					ServiceId: serviceId,
@@ -121,7 +121,7 @@ var _ = Describe("ServiceController", func() {
 						"": "value",
 					},
 				})
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("size of tags checker for one service", func() {
 				size := buildin.TAG_MAX_NUM_FOR_ONESERVICE + 2
@@ -133,23 +133,23 @@ var _ = Describe("ServiceController", func() {
 					ServiceId: serviceId,
 					Tags:      tags,
 				})
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 			It("获取tag，参数校验", func() {
 				resp, _ := serviceResource.GetTags(getContext(), &pb.GetServiceTagsRequest{
 					ServiceId: "noThisService",
 				})
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, _ = serviceResource.GetTags(getContext(), &pb.GetServiceTagsRequest{
 					ServiceId: "",
 				})
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, _ = serviceResource.GetTags(getContext(), &pb.GetServiceTagsRequest{
 					ServiceId: TOO_LONG_SERVICEID,
 				})
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("获取tag", func() {
@@ -168,7 +168,7 @@ var _ = Describe("ServiceController", func() {
 					Value:     "update",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.UpdateTag(getContext(), &pb.UpdateServiceTagRequest{
 					ServiceId: "noneservice",
@@ -176,7 +176,7 @@ var _ = Describe("ServiceController", func() {
 					Value:     "update",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.UpdateTag(getContext(), &pb.UpdateServiceTagRequest{
 					ServiceId: TOO_LONG_SERVICEID,
@@ -184,7 +184,7 @@ var _ = Describe("ServiceController", func() {
 					Value:     "update",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("修改tag", func() {
@@ -203,7 +203,7 @@ var _ = Describe("ServiceController", func() {
 					Value:     "update",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				resp, err = serviceResource.UpdateTag(getContext(), &pb.UpdateServiceTagRequest{
 					ServiceId: TOO_LONG_SERVICEID,
@@ -211,7 +211,7 @@ var _ = Describe("ServiceController", func() {
 					Value:     "update",
 				})
 				Expect(err).To(BeNil())
-				Expect(resp.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(resp.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("删除tag,参数校验", func() {
@@ -221,7 +221,7 @@ var _ = Describe("ServiceController", func() {
 					Keys:      []string{"a", "b"},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				fmt.Println("UT===========删除tag,参数校验，serviceId为空")
 				respAddTags, err = serviceResource.DeleteTags(getContext(), &pb.DeleteServiceTagsRequest{
@@ -229,28 +229,28 @@ var _ = Describe("ServiceController", func() {
 					Keys:      []string{"a", "b"},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddTags, err = serviceResource.DeleteTags(getContext(), &pb.DeleteServiceTagsRequest{
 					ServiceId: serviceId2,
 					Keys:      []string{"a", "b"},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddTags, err = serviceResource.DeleteTags(getContext(), &pb.DeleteServiceTagsRequest{
 					ServiceId: serviceId,
 					Keys:      []string{"c"},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 
 				respAddTags, err = serviceResource.DeleteTags(getContext(), &pb.DeleteServiceTagsRequest{
 					ServiceId: TOO_LONG_SERVICEID,
 					Keys:      []string{""},
 				})
 				Expect(err).To(BeNil())
-				Expect(respAddTags.GetResponse().Code).To(Equal(pb.Response_FAIL))
+				Expect(respAddTags.GetResponse().Code).ToNot(Equal(pb.Response_SUCCESS))
 			})
 
 			It("删除tag", func() {
diff --git a/server/service/util/dependency.go b/server/service/util/dependency.go
index 5c420e5ec..220c766fe 100644
--- a/server/service/util/dependency.go
+++ b/server/service/util/dependency.go
@@ -23,6 +23,7 @@ import (
 	pb "github.com/ServiceComb/service-center/server/core/proto"
 	"github.com/ServiceComb/service-center/server/core/registry"
 	"github.com/ServiceComb/service-center/server/core/registry/store"
+	scerr "github.com/ServiceComb/service-center/server/error"
 	"github.com/ServiceComb/service-center/server/mux"
 	"golang.org/x/net/context"
 	"strings"
@@ -543,7 +544,7 @@ func BadParamsResponse(detailErr string) *pb.CreateDependenciesResponse {
 		detailErr = "Request params is invalid."
 	}
 	return &pb.CreateDependenciesResponse{
-		Response: pb.CreateResponse(pb.Response_FAIL, detailErr),
+		Response: pb.CreateResponse(scerr.ErrInvalidParams, detailErr),
 	}
 }
 
diff --git a/server/service/util/dependency_test.go b/server/service/util/dependency_test.go
index 082fd8fce..5a5d1e51b 100644
--- a/server/service/util/dependency_test.go
+++ b/server/service/util/dependency_test.go
@@ -181,7 +181,7 @@ func TestBadParamsResponse(t *testing.T) {
 
 func TestParamsChecker(t *testing.T) {
 	p := ParamsChecker(nil, nil)
-	if p == nil || p.Response.Code != proto.Response_FAIL {
+	if p == nil || p.Response.Code == proto.Response_SUCCESS {
 		fmt.Printf(`ParamsChecker invalid failed`)
 		t.FailNow()
 	}
@@ -191,7 +191,7 @@ func TestParamsChecker(t *testing.T) {
 		ServiceName: "b",
 		Version:     "1.0.0",
 	}, nil)
-	if p == nil || p.Response.Code != proto.Response_FAIL {
+	if p == nil || p.Response.Code == proto.Response_SUCCESS {
 		fmt.Printf(`ParamsChecker invalid failed`)
 		t.FailNow()
 	}