You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@iggy.apache.org by hg...@apache.org on 2026/10/18 15:34:20 UTC
(iggy) 02/23: feat(metadata): populate permissioner from replicated user ops
This is an automated email from the ASF dual-hosted git repository.
hubcio pushed a commit to branch http-listener
in repository https://gitbox.apache.org/repos/asf/iggy.git
commit 855ce303ab6340296127fb11964aef4cb3ca6909
Author: Hubert Gruszecki <h....@gmail.com>
AuthorDate: Thu Jul 2 11:07:46 2026 +0200
feat(metadata): populate permissioner from replicated user ops
The permissioner rule fns and index maps existed but were dead:
nothing populated them, so every check would deny. Its snapshot
also iterated AHash containers, which would serialize in
per-replica-random order the moment the maps held data.
Wire the index into the replicated user ops: create-user,
update-permissions and delete-user applies maintain it from the
just-stored user so it cannot drift from User.permissions; the
root user inherits via ensure_root_user's ordinary CreateUser
path. Snapshots now serialize intentionally-empty vecs (kept for
positional-msgpack layout compat) and restore rebuilds the index
from User.permissions, making snapshot bytes deterministic.
Add the get_snapshot rule missing from the port (same
read_servers/manage_servers semantics as its system siblings).
---
.../src/permissioner/permissioner_rules/system.rs | 4 +
core/metadata/src/stm/user.rs | 349 +++++++++++++++++----
2 files changed, 285 insertions(+), 68 deletions(-)
diff --git a/core/metadata/src/permissioner/permissioner_rules/system.rs b/core/metadata/src/permissioner/permissioner_rules/system.rs
index 720067afb..4a11c8c96 100644
--- a/core/metadata/src/permissioner/permissioner_rules/system.rs
+++ b/core/metadata/src/permissioner/permissioner_rules/system.rs
@@ -32,6 +32,10 @@ impl Permissioner {
self.get_server_info(user_id)
}
+ pub fn get_snapshot(&self, user_id: u32) -> Result<(), IggyError> {
+ self.get_server_info(user_id)
+ }
+
fn get_server_info(&self, user_id: u32) -> Result<(), IggyError> {
if let Some(global_permissions) = self.users_permissions.get(&user_id)
&& (global_permissions.manage_servers || global_permissions.read_servers)
diff --git a/core/metadata/src/stm/user.rs b/core/metadata/src/stm/user.rs
index cda74d0b1..51e51e60c 100644
--- a/core/metadata/src/stm/user.rs
+++ b/core/metadata/src/stm/user.rs
@@ -360,6 +360,16 @@ impl StateHandler for CreateUserRequest {
.personal_access_tokens
.insert(id as UserId, AHashMap::default());
+ // The permissioner is a denormalized index of `User.permissions`;
+ // derive it from the just-stored user so the two never drift.
+ let user_permissions = state
+ .items
+ .get(id)
+ .and_then(|user| user.permissions.as_deref().cloned());
+ state
+ .permissioner
+ .init_permissions_for_user(id as UserId, user_permissions);
+
// Reply body: the SDK `create_user` decodes a `UserDetailsResponse`.
// Serialization local to this state machine.
ApplyReply::ok(
@@ -435,6 +445,9 @@ impl StateHandler for DeleteUserRequest {
}
}
}
+ state
+ .permissioner
+ .delete_permissions_for_user(user_id as UserId);
}
ApplyReply::ok(Bytes::new())
}
@@ -456,6 +469,7 @@ impl StateHandler for ChangePasswordRequest {
impl StateHandler for UpdatePermissionsRequest {
type State = UsersInner;
+ #[allow(clippy::cast_possible_truncation)]
fn apply(&self, state: &mut UsersInner, _timestamp: IggyTimestamp) -> ApplyReply {
let Some(user_id) = state.resolve_user_id(&self.user_id) else {
return ApplyReply::err(UpdatePermissionsResult::UserNotFound);
@@ -467,6 +481,13 @@ impl StateHandler for UpdatePermissionsRequest {
.as_ref()
.map(|p| Arc::new(Permissions::from(p.clone())));
}
+ let user_permissions = state
+ .items
+ .get(user_id)
+ .and_then(|user| user.permissions.as_deref().cloned());
+ state
+ .permissioner
+ .update_permissions_for_user(user_id as UserId, user_permissions);
ApplyReply::ok(Bytes::new())
}
}
@@ -650,43 +671,18 @@ impl Snapshotable for Users {
})
.collect();
+ // The permissioner is a denormalized index of `User.permissions`.
+ // Its `AHashMap`/`AHashSet` fields iterate in a per-replica-random
+ // order, so serializing them would make the snapshot bytes differ
+ // across replicas. Persist empty vecs (kept only for the positional
+ // msgpack layout) and rebuild the index from the users on restore.
let permissioner = PermissionerSnapshot {
- users_permissions: inner
- .permissioner
- .users_permissions
- .iter()
- .map(|(&k, v)| (k, v.clone()))
- .collect(),
- users_streams_permissions: inner
- .permissioner
- .users_streams_permissions
- .iter()
- .map(|(&k, v)| (k, v.clone()))
- .collect(),
- users_that_can_poll_messages_from_all_streams: inner
- .permissioner
- .users_that_can_poll_messages_from_all_streams
- .iter()
- .copied()
- .collect(),
- users_that_can_send_messages_to_all_streams: inner
- .permissioner
- .users_that_can_send_messages_to_all_streams
- .iter()
- .copied()
- .collect(),
- users_that_can_poll_messages_from_specific_streams: inner
- .permissioner
- .users_that_can_poll_messages_from_specific_streams
- .iter()
- .copied()
- .collect(),
- users_that_can_send_messages_to_specific_streams: inner
- .permissioner
- .users_that_can_send_messages_to_specific_streams
- .iter()
- .copied()
- .collect(),
+ users_permissions: Vec::new(),
+ users_streams_permissions: Vec::new(),
+ users_that_can_poll_messages_from_all_streams: Vec::new(),
+ users_that_can_send_messages_to_all_streams: Vec::new(),
+ users_that_can_poll_messages_from_specific_streams: Vec::new(),
+ users_that_can_send_messages_to_specific_streams: Vec::new(),
};
UsersSnapshot {
@@ -751,38 +747,14 @@ impl Snapshotable for Users {
personal_access_tokens.insert(user_id, token_map);
}
- let permissioner = Permissioner {
- users_permissions: snapshot
- .permissioner
- .users_permissions
- .into_iter()
- .collect(),
- users_streams_permissions: snapshot
- .permissioner
- .users_streams_permissions
- .into_iter()
- .collect(),
- users_that_can_poll_messages_from_all_streams: snapshot
- .permissioner
- .users_that_can_poll_messages_from_all_streams
- .into_iter()
- .collect(),
- users_that_can_send_messages_to_all_streams: snapshot
- .permissioner
- .users_that_can_send_messages_to_all_streams
- .into_iter()
- .collect(),
- users_that_can_poll_messages_from_specific_streams: snapshot
- .permissioner
- .users_that_can_poll_messages_from_specific_streams
- .into_iter()
- .collect(),
- users_that_can_send_messages_to_specific_streams: snapshot
- .permissioner
- .users_that_can_send_messages_to_specific_streams
- .into_iter()
- .collect(),
- };
+ // Rebuild the permissioner from the restored users rather than the
+ // snapshot vecs, which are intentionally empty (see `to_snapshot`).
+ // Slab iteration is ascending by key, so the build is deterministic.
+ let mut permissioner = Permissioner::new();
+ for (user_id, user) in &items {
+ permissioner
+ .init_permissions_for_user(user_id as UserId, user.permissions.as_deref().cloned());
+ }
let inner = UsersInner {
index,
@@ -802,6 +774,8 @@ impl_fill_restore!(Users, users);
#[cfg(test)]
mod tests {
use super::*;
+ use iggy_binary_protocol::primitives::permissions::WireStreamPermissions;
+ use iggy_common::IggyError;
#[test]
fn create_pat_request_roundtrip_preserves_user_id() {
@@ -989,4 +963,243 @@ mod tests {
let apply = StateHandler::apply(&request, &mut users, IggyTimestamp::now());
assert_eq!(apply.code, u32::from(DeleteUserResult::UserNotFound));
}
+
+ fn empty_global() -> WireGlobalPermissions {
+ WireGlobalPermissions {
+ manage_servers: false,
+ read_servers: false,
+ manage_users: false,
+ read_users: false,
+ manage_streams: false,
+ read_streams: false,
+ manage_topics: false,
+ read_topics: false,
+ poll_messages: false,
+ send_messages: false,
+ }
+ }
+
+ fn create_user_with(
+ users: &mut UsersInner,
+ username: &str,
+ permissions: Option<WirePermissions>,
+ ) -> UserId {
+ let request = CreateUserRequest {
+ username: WireName::new(username).unwrap(),
+ password: "hash".to_owned(),
+ status: 1,
+ permissions,
+ };
+ let reply = StateHandler::apply(&request, users, IggyTimestamp::now());
+ assert_eq!(reply.code, 0);
+ *users.index.get(username).expect("user created")
+ }
+
+ #[test]
+ fn given_global_poll_grant_when_apply_create_user_should_allow_poll_from_any_stream() {
+ let mut users = UsersInner::new();
+ let mut global = empty_global();
+ global.poll_messages = true;
+ let uid = create_user_with(
+ &mut users,
+ "poller",
+ Some(WirePermissions {
+ global,
+ streams: Vec::new(),
+ }),
+ );
+
+ // The global poll bit denormalizes into the can-poll-all set, so the
+ // user may poll any stream/topic without a stream-specific grant.
+ assert!(users.permissioner.poll_messages(uid, 7, 3).is_ok());
+ assert!(
+ users
+ .permissioner
+ .users_that_can_poll_messages_from_all_streams
+ .contains(&uid)
+ );
+ }
+
+ #[test]
+ fn given_poll_grant_when_apply_update_permissions_removes_it_should_return_unauthorized() {
+ let mut users = UsersInner::new();
+ let mut global = empty_global();
+ global.poll_messages = true;
+ let uid = create_user_with(
+ &mut users,
+ "poller",
+ Some(WirePermissions {
+ global,
+ streams: Vec::new(),
+ }),
+ );
+ assert!(users.permissioner.poll_messages(uid, 1, 1).is_ok());
+
+ let update = UpdatePermissionsRequest {
+ user_id: WireIdentifier::numeric(uid),
+ permissions: None,
+ };
+ let reply = StateHandler::apply(&update, &mut users, IggyTimestamp::now());
+ assert_eq!(reply.code, 0);
+
+ assert!(matches!(
+ users.permissioner.poll_messages(uid, 1, 1),
+ Err(IggyError::Unauthorized)
+ ));
+ assert!(
+ !users
+ .permissioner
+ .users_that_can_poll_messages_from_all_streams
+ .contains(&uid)
+ );
+ }
+
+ #[test]
+ fn given_permissioned_user_when_apply_delete_user_should_clear_all_indexes() {
+ let mut users = UsersInner::new();
+ let mut global = empty_global();
+ global.poll_messages = true;
+ global.send_messages = true;
+ let stream = WireStreamPermissions {
+ stream_id: 4,
+ manage_stream: false,
+ read_stream: false,
+ manage_topics: false,
+ read_topics: false,
+ poll_messages: true,
+ send_messages: true,
+ topics: Vec::new(),
+ };
+ let uid = create_user_with(
+ &mut users,
+ "victim",
+ Some(WirePermissions {
+ global,
+ streams: vec![stream],
+ }),
+ );
+ assert!(!users.permissioner.users_permissions.is_empty());
+
+ let delete = DeleteUserRequest {
+ user_id: WireIdentifier::numeric(uid),
+ };
+ let reply = StateHandler::apply(&delete, &mut users, IggyTimestamp::now());
+ assert_eq!(reply.code, 0);
+
+ let permissioner = &users.permissioner;
+ assert!(permissioner.users_permissions.is_empty());
+ assert!(permissioner.users_streams_permissions.is_empty());
+ assert!(
+ permissioner
+ .users_that_can_poll_messages_from_all_streams
+ .is_empty()
+ );
+ assert!(
+ permissioner
+ .users_that_can_send_messages_to_all_streams
+ .is_empty()
+ );
+ assert!(
+ permissioner
+ .users_that_can_poll_messages_from_specific_streams
+ .is_empty()
+ );
+ assert!(
+ permissioner
+ .users_that_can_send_messages_to_specific_streams
+ .is_empty()
+ );
+ }
+
+ #[test]
+ fn given_populated_permissions_when_snapshot_round_trip_should_rebuild_index_and_persist_empty_vecs()
+ {
+ let mut inner = UsersInner::new();
+ let mut global = empty_global();
+ global.poll_messages = true;
+ global.send_messages = true;
+ let stream = WireStreamPermissions {
+ stream_id: 2,
+ manage_stream: false,
+ read_stream: false,
+ manage_topics: false,
+ read_topics: false,
+ poll_messages: true,
+ send_messages: true,
+ topics: Vec::new(),
+ };
+ let uid = create_user_with(
+ &mut inner,
+ "alice",
+ Some(WirePermissions {
+ global,
+ streams: vec![stream],
+ }),
+ );
+ let pre_poll = inner.permissioner.poll_messages(uid, 9, 9).is_ok();
+ let pre_send = inner.permissioner.append_messages(uid, 2, 0).is_ok();
+
+ let users: Users = inner.into();
+ let snapshot = users.to_snapshot();
+
+ // The derived index is not serialized: every permissioner vec is empty.
+ let snap = &snapshot.permissioner;
+ assert!(snap.users_permissions.is_empty());
+ assert!(snap.users_streams_permissions.is_empty());
+ assert!(
+ snap.users_that_can_poll_messages_from_all_streams
+ .is_empty()
+ );
+ assert!(snap.users_that_can_send_messages_to_all_streams.is_empty());
+ assert!(
+ snap.users_that_can_poll_messages_from_specific_streams
+ .is_empty()
+ );
+ assert!(
+ snap.users_that_can_send_messages_to_specific_streams
+ .is_empty()
+ );
+
+ let restored = Users::from_snapshot(snapshot).expect("snapshot restore");
+ let (poll_ok, send_ok, in_poll_all, in_send_specific) = restored.read(|inner| {
+ let permissioner = &inner.permissioner;
+ (
+ permissioner.poll_messages(uid, 9, 9).is_ok(),
+ permissioner.append_messages(uid, 2, 0).is_ok(),
+ permissioner
+ .users_that_can_poll_messages_from_all_streams
+ .contains(&uid),
+ permissioner
+ .users_that_can_send_messages_to_specific_streams
+ .contains(&(uid, 2)),
+ )
+ });
+
+ // Rule results survive the round-trip...
+ assert_eq!(poll_ok, pre_poll);
+ assert_eq!(send_ok, pre_send);
+ // ...because the index was rebuilt from the restored user: the global
+ // poll bit repopulated the can-poll-all set and the stream send bit
+ // repopulated the specific set.
+ assert!(in_poll_all);
+ assert!(in_send_specific);
+ }
+
+ #[test]
+ fn given_root_user_when_ensure_root_after_bootstrap_should_have_root_grants() {
+ let users = Users::default();
+ users.ensure_root_user("iggy", "hash");
+ // Root carries `Permissions::root()`: full grants across every rule.
+ let (can_create_stream, can_get_stats, can_poll) = users.read(|inner| {
+ let root = *inner.index.get("iggy").expect("root user created");
+ (
+ inner.permissioner.create_stream(root).is_ok(),
+ inner.permissioner.get_stats(root).is_ok(),
+ inner.permissioner.poll_messages(root, 1, 1).is_ok(),
+ )
+ });
+ assert!(can_create_stream);
+ assert!(can_get_stats);
+ assert!(can_poll);
+ }
}