[ISSUE #1458]🔥Refactor rocketmq-client crate error handle🚨

rocketmq-broker/src/broker_error.rs

@@ -32,7 +32,7 @@ pub enum BrokerError {
     IllegalArgumentError(String),
 
     #[error("Client error: {0}")]
-    ClientError(#[from] rocketmq_client_rust::error::MQClientError),
+    ClientError(#[from] rocketmq_client_rust::client_error::MQClientError),
 }
 
 #[cfg(test)]

rocketmq-client/src/base/validators.rs

@@ -24,7 +24,8 @@
 use rocketmq_common::common::topic::TopicValidator;
 use rocketmq_remoting::code::response_code::ResponseCode;
 
-use crate::error::MQClientError::MQClientErr;
+use crate::client_error::ClientErr;
+use crate::client_error::MQClientError::MQClientErr;
 use crate::producer::default_mq_producer::ProducerConfig;
 use crate::Result;
 
@@ -36,25 +37,21 @@
 
     pub fn check_group(group: &str) -> Result<()> {
         if group.trim().is_empty() {
-            return Err(MQClientErr(-1, "the specified group is blank".to_string()));
+            return Err(MQClientErr(ClientErr::new("the specified group is blank")));
         }
 
         if group.len() > Self::CHARACTER_MAX_LENGTH {
-            return Err(MQClientErr(
-                -1,
-                "the specified group is longer than group max length 255.".to_string(),
-            ));
+            return Err(MQClientErr(ClientErr::new(
+                "the specified group is longer than group max length 255.",
+            )));
         }
 
         if TopicValidator::is_topic_or_group_illegal(group) {
-            return Err(MQClientErr(
-                -1,
-                format!(
-                    "the specified group[{}] contains illegal characters, allowing only \
-                     ^[%|a-zA-Z0-9_-]+$",
-                    group
-                ),
-            ));
+            return Err(MQClientErr(ClientErr::new(format!(
+                "the specified group[{}] contains illegal characters, allowing only \
+                 ^[%|a-zA-Z0-9_-]+$",
+                group
+            ))));
         }
         Ok(())
     }
@@ -64,53 +61,53 @@
         M: MessageTrait,
     {
         if msg.is_none() {
-            return Err(MQClientErr(
+            return Err(MQClientErr(ClientErr::new_with_code(
                 ResponseCode::MessageIllegal as i32,
                 "the message is null".to_string(),
-            ));
+            )));
         }
         let msg = msg.unwrap();
         Self::check_topic(msg.get_topic())?;
         Self::is_not_allowed_send_topic(msg.get_topic())?;
 
         if msg.get_body().is_none() {
-            return Err(MQClientErr(
+            return Err(MQClientErr(ClientErr::new_with_code(
                 ResponseCode::MessageIllegal as i32,
                 "the message body is null".to_string(),
-            ));
+            )));
         }
 
         let length = msg.get_body().unwrap().len();
         if length == 0 {
-            return Err(MQClientErr(
+            return Err(MQClientErr(ClientErr::new_with_code(
                 ResponseCode::MessageIllegal as i32,
                 "the message body length is zero".to_string(),
-            ));
+            )));
         }
 
         if length > producer_config.max_message_size() as usize {
-            return Err(MQClientErr(
+            return Err(MQClientErr(ClientErr::new_with_code(
                 ResponseCode::MessageIllegal as i32,
                 format!(
                     "the message body size over max value, MAX: {}",
                     producer_config.max_message_size()
                 ),
-            ));
+            )));
         }
 
         let lmq_path = msg.get_user_property(&CheetahString::from_static_str(
             MessageConst::PROPERTY_INNER_MULTI_DISPATCH,
         ));
         if let Some(value) = lmq_path {
             if value.contains(std::path::MAIN_SEPARATOR) {
-                return Err(MQClientErr(
+                return Err(MQClientErr(ClientErr::new_with_code(
                     ResponseCode::MessageIllegal as i32,
                     format!(
                         "INNER_MULTI_DISPATCH {} can not contains {} character",
                         value,
                         std::path::MAIN_SEPARATOR
                     ),
-                ));
+                )));
             }
         }
 
@@ -119,60 +116,54 @@
 
     pub fn check_topic(topic: &str) -> Result<()> {
         if topic.trim().is_empty() {
-            return Err(MQClientErr(-1, "The specified topic is blank".to_string()));
+            return Err(MQClientErr(ClientErr::new("The specified topic is blank")));
         }
 
         if topic.len() > Self::TOPIC_MAX_LENGTH {
-            return Err(MQClientErr(
-                -1,
-                format!(
-                    "The specified topic is longer than topic max length {}.",
-                    Self::TOPIC_MAX_LENGTH
-                ),
-            ));
+            return Err(MQClientErr(ClientErr::new(format!(
+                "The specified topic is longer than topic max length {}.",
+                Self::TOPIC_MAX_LENGTH
+            ))));
         }
 
         if TopicValidator::is_topic_or_group_illegal(topic) {
-            return Err(MQClientErr(
-                -1,
-                format!(
-                    "The specified topic[{}] contains illegal characters, allowing only \
-                     ^[%|a-zA-Z0-9_-]+$",
-                    topic
-                ),
-            ));
+            return Err(MQClientErr(ClientErr::new(format!(
+                "The specified topic[{}] contains illegal characters, allowing only \
+                 ^[%|a-zA-Z0-9_-]+$",
+                topic
+            ))));
         }
 
         Ok(())
     }
 
     pub fn is_system_topic(topic: &str) -> Result<()> {
         if TopicValidator::is_system_topic(topic) {
-            return Err(MQClientErr(
-                -1,
-                format!("The topic[{}] is conflict with system topic.", topic),
-            ));
+            return Err(MQClientErr(ClientErr::new(format!(
+                "The topic[{}] is conflict with system topic.",
+                topic
+            ))));
         }
         Ok(())
     }
 
     pub fn is_not_allowed_send_topic(topic: &str) -> Result<()> {
         if TopicValidator::is_not_allowed_send_topic(topic) {
-            return Err(MQClientErr(
-                -1,
-                format!("Sending message to topic[{}] is forbidden.", topic),
-            ));
+            return Err(MQClientErr(ClientErr::new(format!(
+                "Sending message to topic[{}] is forbidden.",
+                topic
+            ))));
         }
 
         Ok(())
     }
 
     pub fn check_topic_config(topic_config: &TopicConfig) -> Result<()> {
         if !PermName::is_valid(topic_config.perm) {
-            return Err(MQClientErr(
+            return Err(MQClientErr(ClientErr::new_with_code(
                 ResponseCode::NoPermission as i32,
                 format!("topicPermission value: {} is invalid.", topic_config.perm),
-            ));
+            )));
         }
 
         Ok(())
@@ -181,10 +172,10 @@
     pub fn check_broker_config(broker_config: &HashMap<String, String>) -> Result<()> {
         if let Some(broker_permission) = broker_config.get("brokerPermission") {
             if !PermName::is_valid(broker_permission.parse().unwrap()) {
-                return Err(MQClientErr(
-                    -1,
-                    format!("brokerPermission value: {} is invalid.", broker_permission),
-                ));
+                return Err(MQClientErr(ClientErr::new(format!(
+                    "brokerPermission value: {} is invalid.",
+                    broker_permission
+                ))));
             }
         }