rocketmq-remoting/src/protocol/command_custom_header.rs (2)

74-79: Document the purpose of the default decode_fast implementation

The default implementation of decode_fast in the CommandCustomHeader trait returns Ok(()) without performing any actions. Consider adding documentation to clarify that this default method should be overridden by implementing types that require custom decoding logic.

---

90-120: Improve error handling in get_and_check_not_none method

The method get_and_check_not_none can be simplified using the cloned and ok_or_else methods for clearer error handling.

Apply this diff to enhance readability and efficiency:

- fn get_and_check_not_none(
-     &self,
-     map: &HashMap<CheetahString, CheetahString>,
-     field: &CheetahString,
- ) -> crate::Result<CheetahString> {
-     match map.get(field) {
-         Some(value) => Ok(value.clone()),
-         None => Err(crate::remoting_error::RemotingError::RemotingCommandError(
-             format!("The field {} is required.", field),
-         )),
-     }
- }
+ fn get_and_check_not_none(
+     &self,
+     map: &HashMap<CheetahString, CheetahString>,
+     field: &CheetahString,
+ ) -> crate::Result<CheetahString> {
+     map.get(field)
+         .cloned()
+         .ok_or_else(|| crate::remoting_error::RemotingError::RemotingCommandError(
+             format!("The field {} is required.", field),
+         ))
+ }

rocketmq-remoting/src/protocol/header/message_operation_header/send_message_request_header_v2.rs (2)

28-28: Remove unused import if unnecessary

The import of RemotingError::RemotingCommandError is added but may not be required in this file. Ensure that this import is needed; otherwise, consider removing it to clean up the code.

---

Line range hint 149-206: Handle parsing errors to prevent panics in decode_fast

The decode_fast method uses parse().unwrap() when parsing fields, which can cause the application to panic if parsing fails. Replace unwrap() with proper error handling to ensure robustness.

Apply this diff to handle parsing errors safely:

- self.j = Some(v.parse().unwrap());
+ self.j = Some(v.parse().map_err(|_| RemotingCommandError("Parse field j error".to_string()))?);

- self.k = Some(
-     v.parse()
-         .map_err(|_| RemotingCommandError("Parse field k error".to_string()))?,
- );

- self.l = Some(
-     v.parse()
-         .map_err(|_| RemotingCommandError("Parse field l error".to_string()))?,
- );

- self.m = Some(
-     v.parse()
-         .map_err(|_| RemotingCommandError("Parse field m error".to_string()))?,
- );

This change ensures that any parsing errors are properly propagated as Err values.

rocketmq-remoting/src/protocol/header/pull_message_response_header.rs (1)

Line range hint 137-174: Safely handle parsing in decode_fast to avoid panics

In the decode_fast method, using parse().unwrap() can lead to panics if the data cannot be parsed. Replace unwrap() with map_err to return meaningful errors and prevent the application from crashing.

Apply this diff to improve error handling:

if let Some(offset_delta) = fields.get(&CheetahString::from_static_str(Self::SUGGEST_WHICH_BROKER_ID)) {
-    self.suggest_which_broker_id = Some(offset_delta.parse().unwrap());
+    self.suggest_which_broker_id = Some(offset_delta.parse().map_err(|_| RemotingCommandError("Parse field suggestWhichBrokerId error".to_string()))?);
}

Repeat similar changes for the other fields (next_begin_offset, min_offset, etc.) to handle parsing errors appropriately.

rocketmq-remoting/src/protocol/header/pull_message_request_header.rs (1)

Line range hint 214-319: Prevent application panics by handling errors in decode_fast

The use of str.parse::<i64>().unwrap() and similar statements can cause panics if parsing fails. Modify the code to handle parsing errors using map_err and return them as part of the Result.

Apply this diff to handle parsing errors safely:

- self.queue_offset = str.parse::<i64>().unwrap();
+ self.queue_offset = str.parse::<i64>().map_err(|_| RemotingCommandError("Parse field queueOffset error".to_string()))?;

- self.max_msg_nums = str.parse::<i32>().unwrap();
+ self.max_msg_nums = str.parse::<i32>().map_err(|_| RemotingCommandError("Parse field maxMsgNums error".to_string()))?;

- self.sys_flag = str.parse::<i32>().unwrap();
+ self.sys_flag = str.parse::<i32>().map_err(|_| RemotingCommandError("Parse field sysFlag error".to_string()))?;

- self.commit_offset = str.parse::<i64>().unwrap();
+ self.commit_offset = str.parse::<i64>().map_err(|_| RemotingCommandError("Parse field commitOffset error".to_string()))?;

- self.suspend_timeout_millis = str.parse::<u64>().unwrap();
+ self.suspend_timeout_millis = str.parse::<u64>().map_err(|_| RemotingCommandError("Parse field suspendTimeoutMillis error".to_string()))?;

- self.sub_version = str.parse::<i64>().unwrap();
+ self.sub_version = str.parse::<i64>().map_err(|_| RemotingCommandError("Parse field subVersion error".to_string()))?;

By handling errors, you ensure that the application remains stable even when encountering invalid input.

Configuration used: .coderabbit.yaml
Review profile: CHILL