Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
117 changes: 61 additions & 56 deletions rocketmq-broker/src/processor/send_message_processor.rs
Original file line number Diff line number Diff line change
Expand Up @@ -127,17 +127,16 @@ pub struct SendMessageProcessor<MS: BrokerWriteStore, TS> {
after_hooks: Arc<Mutex<HashMap<RequestId, SendMessageContext>>>,
}

struct SendCompletionFacts {
struct SendHookMetadata {
policy: Arc<SendMessagePolicy>,
opaque: i32,
body_len: i32,
owner: Option<CheetahString>,
auth_type: Option<CheetahString>,
owner_parent: Option<CheetahString>,
owner_self: Option<CheetahString>,
}

impl SendCompletionFacts {
impl SendHookMetadata {
fn capture(request: &RemotingCommand, policy: Arc<SendMessagePolicy>) -> Self {
// One walk over the header: a send header is otherwise never turned into a field map.
// As in that map, the last occurrence of a repeated field wins.
Expand All @@ -158,8 +157,7 @@ impl SendCompletionFacts {
});
Self {
policy,
opaque: request.opaque(),
body_len: request.body().as_ref().map_or(0, |body| body.len() as i32),
body_len: request.body().map_or(0, |body| body.len() as i32),
owner: owner.map(CheetahString::from),
auth_type: auth_type.map(CheetahString::from),
owner_parent: owner_parent.map(CheetahString::from),
Expand Down Expand Up @@ -652,7 +650,9 @@ where
if !self.inner.check_broker_permission(&policy, &mut response) {
return BrokerResponseParts::from_command(response)?.into_response_action();
}
let completion_facts = SendCompletionFacts::capture(request, policy);
let hook_metadata = self
.has_send_message_hook()
.then(|| SendHookMetadata::capture(request, policy));
if transactional {
let mut store = TransactionalMessageAppender::new(self.inner.transactional_message_service.as_ref());
let result = match await_store(StoreAwaitControl::Request(control), store.append_message(message_ext))
Expand All @@ -674,7 +674,7 @@ where
let completion = self.handle_put_message_result(
store_append_receipt(result, max_phy_offset, flushed_where),
&mut response,
completion_facts,
hook_metadata,
topic.as_str(),
transaction_id,
recall_handle,
Expand All @@ -701,7 +701,7 @@ where
let completion = processor.handle_put_message_result(
receipt,
&mut response,
completion_facts,
hook_metadata,
topic.as_str(),
transaction_id,
recall_handle,
Expand Down Expand Up @@ -852,7 +852,9 @@ where
if !self.inner.check_broker_permission(&policy, &mut response) {
return BrokerResponseParts::from_command(response)?.into_response_action();
}
let completion_facts = SendCompletionFacts::capture(request, policy);
let hook_metadata = self
.has_send_message_hook()
.then(|| SendHookMetadata::capture(request, policy));
let processor = self;
let reply = if is_inner_batch {
let mut store = self.inner.context.store.clone();
Expand All @@ -865,7 +867,7 @@ where
let completion = processor.handle_put_message_result(
receipt,
&mut response,
completion_facts,
hook_metadata,
topic.as_str(),
transaction_id,
None,
Expand Down Expand Up @@ -903,7 +905,7 @@ where
let completion = processor.handle_put_message_result(
receipt,
&mut response,
completion_facts,
hook_metadata,
topic.as_str(),
transaction_id,
None,
Expand Down Expand Up @@ -1128,17 +1130,13 @@ where
/// Update send message context for hooks
fn update_send_context_on_success(
&self,
policy: &SendMessagePolicy,
metadata: SendHookMetadata,
send_message_context: &mut SendMessageContext,
response_header: &SendMessageResponseHeader,
append_receipt: &StoreAppendReceipt,
owner: Option<CheetahString>,
auth_type: Option<CheetahString>,
owner_parent: Option<CheetahString>,
owner_self: Option<CheetahString>,
) {
let commercial_size_per_msg = policy.commercial_size_per_msg;
let commercial_base_count = policy.commercial_base_count;
let commercial_size_per_msg = metadata.policy.commercial_size_per_msg;
let commercial_base_count = metadata.policy.commercial_base_count;

send_message_context.msg_id = response_header.msg_id().clone();
send_message_context.queue_id = Some(response_header.queue_id());
Expand All @@ -1154,30 +1152,26 @@ where
send_message_context.commercial_send_stats = StatsType::SendSuccess;
send_message_context.commercial_send_times = inc_value;
send_message_context.commercial_send_size = append_result.wrote_bytes;
send_message_context.commercial_owner = owner.unwrap_or_default();
send_message_context.commercial_owner = metadata.owner.unwrap_or_default();

send_message_context.send_stat = StatsType::SendSuccess;
send_message_context.commercial_send_msg_num = commercial_msg_num;
send_message_context.account_auth_type = auth_type.unwrap_or_default();
send_message_context.account_owner_parent = owner_parent.unwrap_or_default();
send_message_context.account_owner_self = owner_self.unwrap_or_default();
send_message_context.account_auth_type = metadata.auth_type.unwrap_or_default();
send_message_context.account_owner_parent = metadata.owner_parent.unwrap_or_default();
send_message_context.account_owner_self = metadata.owner_self.unwrap_or_default();
send_message_context.send_msg_size = append_result.wrote_bytes;
send_message_context.send_msg_num = append_result.msg_num;
}

/// Update send message context for failure case
fn update_send_context_on_failure(
&self,
policy: &SendMessagePolicy,
metadata: SendHookMetadata,
send_message_context: &mut SendMessageContext,
append_receipt: &StoreAppendReceipt,
request_body_len: i32,
owner: Option<CheetahString>,
auth_type: Option<CheetahString>,
owner_parent: Option<CheetahString>,
owner_self: Option<CheetahString>,
) {
let commercial_size_per_msg = policy.commercial_size_per_msg;
let commercial_size_per_msg = metadata.policy.commercial_size_per_msg;
let request_body_len = metadata.body_len;

let msg_num = append_receipt
.result()
Expand All @@ -1189,13 +1183,13 @@ where
send_message_context.commercial_send_stats = StatsType::SendFailure;
send_message_context.commercial_send_times = commercial_msg_num;
send_message_context.commercial_send_size = request_body_len;
send_message_context.commercial_owner = owner.unwrap_or_default();
send_message_context.commercial_owner = metadata.owner.unwrap_or_default();

send_message_context.send_stat = StatsType::SendFailure;
send_message_context.commercial_send_msg_num = commercial_msg_num;
send_message_context.account_auth_type = auth_type.unwrap_or_default();
send_message_context.account_owner_parent = owner_parent.unwrap_or_default();
send_message_context.account_owner_self = owner_self.unwrap_or_default();
send_message_context.account_auth_type = metadata.auth_type.unwrap_or_default();
send_message_context.account_owner_parent = metadata.owner_parent.unwrap_or_default();
send_message_context.account_owner_self = metadata.owner_self.unwrap_or_default();
send_message_context.send_msg_size = request_body_len;
send_message_context.send_msg_num = msg_num;
}
Expand All @@ -1208,7 +1202,7 @@ where
&self,
append_receipt: StoreAppendReceipt,
response: &mut RemotingCommand,
completion_facts: SendCompletionFacts,
hook_metadata: Option<SendHookMetadata>,
topic: &str,
transaction_id: Option<CheetahString>,
recall_handle: Option<CheetahString>,
Expand All @@ -1228,8 +1222,6 @@ where
);
}

let has_send_message_hook = self.has_send_message_hook();

if send_ok {
response.set_command_custom_header_ref(SendMessageResponseHeader::default());
self.update_broker_stats_on_success(
Expand All @@ -1249,8 +1241,8 @@ where
response_header,
&append_receipt,
queue_id_int,
transaction_id.clone(),
recall_handle.clone(),
transaction_id,
recall_handle,
);

let rewrite_result = rewrite_response_for_static_topic(
Expand All @@ -1262,34 +1254,20 @@ where
return (rewrite_result, false);
}

if has_send_message_hook {
if let Some(metadata) = hook_metadata {
self.update_send_context_on_success(
&completion_facts.policy,
metadata,
send_message_context,
response_header,
&append_receipt,
completion_facts.owner,
completion_facts.auth_type,
completion_facts.owner_parent,
completion_facts.owner_self,
);
}
}

response.set_opaque_mut(completion_facts.opaque);
(None, true)
} else {
if has_send_message_hook {
self.update_send_context_on_failure(
&completion_facts.policy,
send_message_context,
&append_receipt,
completion_facts.body_len,
completion_facts.owner,
completion_facts.auth_type,
completion_facts.owner_parent,
completion_facts.owner_self,
);
if let Some(metadata) = hook_metadata {
self.update_send_context_on_failure(metadata, send_message_context, &append_receipt);
}
(None, false)
}
Expand Down Expand Up @@ -2468,6 +2446,33 @@ mod tests {
assert!(has_registered_send_message_hooks(&hooks));
}

#[test]
fn send_hook_metadata_keeps_the_last_account_field_and_request_body_length() {
let header = concat!(
r#"{"code":10,"language":"RUST","version":0,"opaque":17,"flag":0,"extFields":{"#,
r#""Owner":"old","AUTH_TYPE":"signed","OWNER_PARENT":"parent","OWNER_SELF":"self","Owner":"new"}}"#,
);
let mut encoded = bytes::BytesMut::from(header);
let request = RemotingCommand::header_decode(&mut encoded, header.len(), SerializeType::JSON)
.unwrap()
.unwrap()
.set_body(bytes::Bytes::from_static(b"payload"));
let broker = BrokerConfig::default();
let policy = super::SendMessagePolicy::from_configs(
&broker,
&rocketmq_store::MessageStoreConfig::default(),
([127, 0, 0, 1], 10911).into(),
crate::broker::broker_runtime_config_state::BrokerPermissionState::new(broker.broker_permission),
);
let metadata = super::SendHookMetadata::capture(&request, Arc::new(policy));

assert_eq!(metadata.owner.as_deref(), Some("new"));
assert_eq!(metadata.auth_type.as_deref(), Some("signed"));
assert_eq!(metadata.owner_parent.as_deref(), Some("parent"));
assert_eq!(metadata.owner_self.as_deref(), Some("self"));
assert_eq!(metadata.body_len, 7);
}

#[test]
fn priority_message_maps_to_bounded_priority_queue() {
let mut topic = rocketmq_model::common::config::TopicConfig::with_queues("priority-topic", 8, 8);
Expand Down
44 changes: 41 additions & 3 deletions rocketmq-broker/tests/broker_runtime/send_policy.rs
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,11 @@ use std::sync::Barrier;
use parking_lot::Mutex;
use rocketmq_model::common::message::message_single::Message;
use rocketmq_protocol::protocol::header::message_operation_header::send_message_request_header_v2::SendMessageRequestHeaderV2;
use rocketmq_transport::api::EmbeddedResponseBody;
use rocketmq_transport::api::RemotingRequest;
use rocketmq_transport::api::RemotingResponse;
use rocketmq_transport::api::RequestProcessor;
use rocketmq_transport::api::ResponseAction;

use super::*;
use crate::mqtrace::send_message_context::SendMessageContext;
Expand Down Expand Up @@ -252,6 +257,25 @@ async fn send_policy_generation_survives_configuration_update_through_store_and_
}
}

#[derive(Clone)]
struct ObserveSendOpaque {
processor: DefaultServerProcessor,
opaque: Arc<Mutex<Option<i32>>>,
}

impl RequestProcessor for ObserveSendOpaque {
async fn process(&mut self, request: &mut RemotingRequest) -> crate::broker_error::BrokerResult<ResponseAction> {
let ResponseAction::Reply(reply) = self.processor.process(request).await? else {
panic!("Send must produce an immediate reply")
};
let (head, body) = reply.into_embedded_response().into_parts();
assert!(matches!(body, EmbeddedResponseBody::Empty));
// The transport binds this response to the original request after this point.
*self.opaque.lock() = Some(head.opaque());
Ok(ResponseAction::Reply(RemotingResponse::command(head).unwrap()))
}
}

#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn send_without_hooks_still_stores_broker_owned_properties() {
for code in [RequestCode::SendMessage, RequestCode::SendBatchMessage] {
Expand All @@ -262,10 +286,24 @@ async fn send_without_hooks_still_stores_broker_owned_properties() {
config.broker_identity.broker_cluster_name = "hookless-cluster".into();
config.async_topic_create_persist_enable = false;
runtime.composition.state.set_broker_config(config).unwrap();
let (processor, _) = runtime.init_processor_checked().unwrap();

let response = process_broker_request(&processor, &mut request(code, "HooklessTopic", false)).await;
let (mut processor, _) = runtime.init_processor_checked().unwrap();
processor.set_auth_disabled_by_validated_config();
let opaque = Arc::new(Mutex::new(None));
let (mut client, server) = crate::processor::processor_test_support::start_processor_server(
"hookless-send",
ObserveSendOpaque {
processor: processor.clone(),
opaque: Arc::clone(&opaque),
},
Arc::new(AdmissionController::new(AdmissionLimits::default())),
)
.await;
let command = request(code, "HooklessTopic", false).set_opaque(-947);
let expected_opaque = command.opaque();
client.send_command(command).await.unwrap();
let response = server.receive_one_then_finish_and_collect(client).await.remove(0);
assert_eq!(ResponseCode::from(response.code()), ResponseCode::Success);
assert_eq!(*opaque.lock(), Some(expected_opaque));
let ext_fields = response.ext_fields().unwrap();
assert_eq!(
ext_fields.get(MessageConst::PROPERTY_MSG_REGION).unwrap(),
Expand Down
Loading