mod builder;
#[macro_use]
mod macros;
mod network;
mod plan;
mod spec;
pub use builder::ManifestBuilder;
pub use network::{NetworkPolicySpec, NetworkProfileSpec, NetworkSegmentSpec, NetworkSpec};
pub use plan::{
ApplyReport, Change, CreatedServiceAccount, ManagementPlan, Outcome, PlannedAction, Target,
};
pub use spec::{
GrantSpec, GroupSpec, ManagementManifest, PermissionSpec, ResourceSpec, RoleBinding, RoleSpec,
ScopeSpec, ServiceAccountSpec, UserSpec,
};
use std::collections::HashMap;
use uuid::Uuid;
use crate::AxiamError;
use crate::client::AxiamClient;
use crate::management::models;
use crate::management::page::PageRequest;
use plan::{Resolved, topological_order, validate};
const PLAN_PAGE: u64 = 200;
#[derive(Clone, Copy)]
pub struct Manifest<'c> {
client: &'c AxiamClient,
}
impl std::fmt::Debug for Manifest<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str("Manifest")
}
}
impl AxiamClient {
#[must_use]
pub fn manifest(&self) -> Manifest<'_> {
Manifest { client: self }
}
}
struct Snapshot {
resources: Vec<models::Resource>,
scopes: HashMap<Uuid, Vec<models::Scope>>,
permissions: Vec<models::Permission>,
roles: Vec<models::Role>,
groups: Vec<models::Group>,
users: Vec<models::UserResponse>,
service_accounts: Vec<models::ServiceAccountResponse>,
role_grants: HashMap<Uuid, Vec<Uuid>>,
role_users: HashMap<Uuid, Vec<Held>>,
role_groups: HashMap<Uuid, Vec<Held>>,
role_service_accounts: HashMap<Uuid, Vec<Held>>,
group_members: HashMap<Uuid, Vec<Uuid>>,
network: network::NetworkSnapshot,
}
#[derive(Debug, Clone)]
struct Held {
subject: Uuid,
resource_id: Option<Uuid>,
inherit: bool,
tenant_scope: Option<Vec<Uuid>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Subject {
Group,
User,
ServiceAccount,
}
impl Subject {
fn target(self) -> Target {
match self {
Subject::Group => Target::GroupRole,
Subject::User => Target::UserRole,
Subject::ServiceAccount => Target::ServiceAccountRole,
}
}
fn noun(self) -> &'static str {
match self {
Subject::Group => "group",
Subject::User => "user",
Subject::ServiceAccount => "service account",
}
}
fn resolved(self, resolved: &Resolved) -> &HashMap<String, Uuid> {
match self {
Subject::Group => &resolved.groups,
Subject::User => &resolved.users,
Subject::ServiceAccount => &resolved.service_accounts,
}
}
}
impl<'c> Manifest<'c> {
pub async fn plan(&self, manifest: &ManagementManifest) -> Result<ManagementPlan, AxiamError> {
validate(manifest)?;
let snapshot = self.read(manifest).await?;
let (plan, _, _) = self.compute(manifest, &snapshot)?;
Ok(plan)
}
pub async fn apply(&self, manifest: &ManagementManifest) -> Result<ApplyReport, AxiamError> {
validate(manifest)?;
let snapshot = self.read(manifest).await?;
let (plan, mut resolved, steps) = self.compute(manifest, &snapshot)?;
self.execute(plan, steps, &mut resolved).await
}
async fn read(&self, manifest: &ManagementManifest) -> Result<Snapshot, AxiamError> {
let c = self.client;
let start = || PageRequest::first(PLAN_PAGE);
let resources = c.resources().list_all(start()).await?;
let permissions = c.permissions().list_all(start()).await?;
let roles = c.roles().list_all(start()).await?;
let groups = c.groups().list_all(start()).await?;
let users = c.users().list_all(start()).await?;
let mut scopes = HashMap::new();
let wanted: Vec<&models::Resource> = resources
.iter()
.filter(|r| manifest.resources.iter().any(|s| s.name == r.name))
.collect();
for resource in wanted {
scopes.insert(resource.id, c.scopes().list(resource.id).await?);
}
let with_accounts = !manifest.service_accounts.is_empty();
let service_accounts = if with_accounts {
c.service_accounts().list_all(start()).await?
} else {
Vec::new()
};
let mut role_grants = HashMap::new();
let mut role_users = HashMap::new();
let mut role_groups = HashMap::new();
let mut role_service_accounts = HashMap::new();
for role in roles
.iter()
.filter(|r| manifest.roles.iter().any(|s| s.name == r.name))
{
role_grants.insert(
role.id,
c.roles()
.list_permissions(role.id)
.await?
.into_iter()
.map(|g| g.permission.id)
.collect::<Vec<_>>(),
);
role_users.insert(
role.id,
c.roles()
.list_users(role.id)
.await?
.into_iter()
.map(|a| Held {
subject: a.user.id,
resource_id: a.resource_id,
inherit: a.inherit,
tenant_scope: a.tenant_scope,
})
.collect::<Vec<_>>(),
);
role_groups.insert(
role.id,
c.roles()
.list_groups(role.id)
.await?
.into_iter()
.map(|a| Held {
subject: a.group.id,
resource_id: a.resource_id,
inherit: a.inherit,
tenant_scope: a.tenant_scope,
})
.collect::<Vec<_>>(),
);
if with_accounts {
role_service_accounts.insert(
role.id,
c.roles()
.list_service_accounts(role.id)
.await?
.into_iter()
.map(|a| Held {
subject: a.service_account.id,
resource_id: a.resource_id,
inherit: a.inherit,
tenant_scope: a.tenant_scope,
})
.collect::<Vec<_>>(),
);
}
}
let mut group_members = HashMap::new();
for group in groups
.iter()
.filter(|g| manifest.groups.iter().any(|s| s.name == g.name))
{
group_members.insert(
group.id,
c.groups()
.list_members_all(group.id, start())
.await?
.into_iter()
.map(|u| u.id)
.collect::<Vec<_>>(),
);
}
let network = if manifest.network.is_empty() {
network::NetworkSnapshot::default()
} else {
self.read_network(&manifest.network).await?
};
Ok(Snapshot {
resources,
scopes,
permissions,
roles,
groups,
users,
service_accounts,
role_grants,
role_users,
role_groups,
role_service_accounts,
group_members,
network,
})
}
}
#[derive(Debug, Clone)]
enum Step {
Noop,
CreateResource {
key: String,
name: String,
resource_type: String,
parent: Option<String>,
metadata: Option<serde_json::Value>,
},
UpdateResource {
key: String,
resource_type: Option<String>,
metadata: Option<serde_json::Value>,
},
CreateScope {
resource: String,
key: String,
name: String,
description: String,
},
CreatePermission {
key: String,
action: String,
description: String,
},
UpdatePermission {
key: String,
description: String,
},
CreateRole {
key: String,
name: String,
description: String,
is_global: bool,
},
UpdateRole {
key: String,
description: String,
is_global: bool,
},
GrantPermission {
role: String,
permission: String,
effect: Option<crate::management::models::PermissionEffect>,
scopes: Vec<String>,
},
CreateGroup {
key: String,
name: String,
description: String,
},
UpdateGroup {
key: String,
description: String,
},
AssignRole {
subject_kind: Subject,
subject: String,
role: String,
resource: Option<String>,
inherit: bool,
},
RebindRole {
subject_kind: Subject,
subject: String,
role: String,
resource: Option<String>,
inherit: bool,
previous: Held,
},
CreateServiceAccount {
key: String,
name: String,
description: Option<String>,
},
UpdateServiceAccount {
key: String,
description: String,
},
CreateUser {
key: String,
username: String,
email: String,
password: crate::Sensitive<String>,
},
UpdateUser {
key: String,
email: String,
},
AddGroupMember {
group: String,
user: String,
},
Network(network::NetStep),
}
impl<'c> Manifest<'c> {
#[allow(clippy::too_many_lines)]
fn compute(
&self,
manifest: &ManagementManifest,
snapshot: &Snapshot,
) -> Result<(ManagementPlan, Resolved, Vec<Step>), AxiamError> {
let mut resolved = Resolved::default();
let mut steps: Vec<(PlannedAction, Step)> = Vec::new();
let specs: HashMap<&str, &ResourceSpec> = manifest
.resources
.iter()
.map(|r| (r.key.as_str(), r))
.collect();
let order = topological_order(manifest).map_err(AxiamError::network)?;
for key in &order {
let spec = specs[key.as_str()];
let parent_id = spec
.parent
.as_ref()
.map(|p| resolved.resources.get(p).copied());
let parent_pending = matches!(parent_id, Some(None));
let parent_id = parent_id.flatten();
let existing = if parent_pending {
None
} else {
snapshot
.resources
.iter()
.find(|r| r.name == spec.name && r.parent_id == parent_id)
};
match existing {
Some(found) => {
resolved.resources.insert(spec.key.clone(), found.id);
let type_drifted = found.resource_type != spec.resource_type;
let metadata_drifted = spec
.metadata
.as_ref()
.is_some_and(|stated| *stated != found.metadata);
let drifted = type_drifted || metadata_drifted;
steps.push((
action(
if drifted {
Change::Update
} else {
Change::NoChange
},
Target::Resource,
&spec.key,
format!("resource {:?} ({})", spec.name, spec.resource_type),
),
if drifted {
Step::UpdateResource {
key: spec.key.clone(),
resource_type: type_drifted.then(|| spec.resource_type.clone()),
metadata: if metadata_drifted {
spec.metadata.clone()
} else {
None
},
}
} else {
Step::Noop
},
));
}
None => steps.push((
action(
Change::Create,
Target::Resource,
&spec.key,
format!("resource {:?} ({})", spec.name, spec.resource_type),
),
Step::CreateResource {
key: spec.key.clone(),
name: spec.name.clone(),
resource_type: spec.resource_type.clone(),
parent: spec.parent.clone(),
metadata: spec.metadata.clone(),
},
)),
}
}
for key in &order {
let spec = specs[key.as_str()];
let resource_id = resolved.resources.get(&spec.key).copied();
let empty = Vec::new();
let existing_scopes = resource_id
.and_then(|id| snapshot.scopes.get(&id))
.unwrap_or(&empty);
for scope in &spec.scopes {
match existing_scopes.iter().find(|s| s.name == scope.name) {
Some(found) => {
resolved.scopes.insert(scope.key.clone(), found.id);
steps.push((
action(
Change::NoChange,
Target::Scope,
&scope.key,
format!("scope {:?} on {:?}", scope.name, spec.name),
),
Step::Noop,
));
}
None => steps.push((
action(
Change::Create,
Target::Scope,
&scope.key,
format!("scope {:?} on {:?}", scope.name, spec.name),
),
Step::CreateScope {
resource: spec.key.clone(),
key: scope.key.clone(),
name: scope.name.clone(),
description: scope.description.clone(),
},
)),
}
}
}
for spec in &manifest.permissions {
match snapshot
.permissions
.iter()
.find(|p| p.action == spec.action)
{
Some(found) => {
resolved.permissions.insert(spec.key.clone(), found.id);
let drifted = found.description != spec.description;
steps.push((
action(
if drifted {
Change::Update
} else {
Change::NoChange
},
Target::Permission,
&spec.key,
format!("permission {:?}", spec.action),
),
if drifted {
Step::UpdatePermission {
key: spec.key.clone(),
description: spec.description.clone(),
}
} else {
Step::Noop
},
));
}
None => steps.push((
action(
Change::Create,
Target::Permission,
&spec.key,
format!("permission {:?}", spec.action),
),
Step::CreatePermission {
key: spec.key.clone(),
action: spec.action.clone(),
description: spec.description.clone(),
},
)),
}
}
for spec in &manifest.roles {
match snapshot.roles.iter().find(|r| r.name == spec.name) {
Some(found) => {
resolved.roles.insert(spec.key.clone(), found.id);
let drifted =
found.description != spec.description || found.is_global != spec.is_global;
steps.push((
action(
if drifted {
Change::Update
} else {
Change::NoChange
},
Target::Role,
&spec.key,
format!("role {:?}", spec.name),
),
if drifted {
Step::UpdateRole {
key: spec.key.clone(),
description: spec.description.clone(),
is_global: spec.is_global,
}
} else {
Step::Noop
},
));
}
None => steps.push((
action(
Change::Create,
Target::Role,
&spec.key,
format!("role {:?}", spec.name),
),
Step::CreateRole {
key: spec.key.clone(),
name: spec.name.clone(),
description: spec.description.clone(),
is_global: spec.is_global,
},
)),
}
}
for spec in &manifest.roles {
let held = resolved
.roles
.get(&spec.key)
.and_then(|id| snapshot.role_grants.get(id));
for grant in &spec.grants {
let permission_id = resolved.permissions.get(&grant.permission).copied();
let present =
matches!((held, permission_id), (Some(list), Some(pid)) if list.contains(&pid));
steps.push((
action(
if present {
Change::NoChange
} else {
Change::Create
},
Target::RoleGrant,
&spec.key,
format!("role {:?} grants {:?}", spec.name, grant.permission),
),
if present {
Step::Noop
} else {
Step::GrantPermission {
role: spec.key.clone(),
permission: grant.permission.clone(),
effect: grant.effect.clone(),
scopes: grant.scopes.clone(),
}
},
));
}
}
for spec in &manifest.groups {
match snapshot.groups.iter().find(|g| g.name == spec.name) {
Some(found) => {
resolved.groups.insert(spec.key.clone(), found.id);
let drifted = found.description != spec.description;
steps.push((
action(
if drifted {
Change::Update
} else {
Change::NoChange
},
Target::Group,
&spec.key,
format!("group {:?}", spec.name),
),
if drifted {
Step::UpdateGroup {
key: spec.key.clone(),
description: spec.description.clone(),
}
} else {
Step::Noop
},
));
}
None => steps.push((
action(
Change::Create,
Target::Group,
&spec.key,
format!("group {:?}", spec.name),
),
Step::CreateGroup {
key: spec.key.clone(),
name: spec.name.clone(),
description: spec.description.clone(),
},
)),
}
}
for spec in &manifest.groups {
for binding in &spec.roles {
steps.push(plan_binding(
Subject::Group,
&spec.key,
&spec.name,
binding,
&snapshot.role_groups,
&resolved,
));
}
}
for spec in &manifest.users {
match snapshot.users.iter().find(|u| u.username == spec.username) {
Some(found) => {
resolved.users.insert(spec.key.clone(), found.id);
let drifted = found.email != spec.email;
steps.push((
action(
if drifted {
Change::Update
} else {
Change::NoChange
},
Target::User,
&spec.key,
format!("user {:?}", spec.username),
),
if drifted {
Step::UpdateUser {
key: spec.key.clone(),
email: spec.email.clone(),
}
} else {
Step::Noop
},
));
}
None => {
let password = spec.initial_password.clone().ok_or_else(|| {
AxiamError::network(format!(
"user {:?} does not exist and would be created, but the spec carries \
no initial_password",
spec.username
))
})?;
steps.push((
action(
Change::Create,
Target::User,
&spec.key,
format!("user {:?}", spec.username),
),
Step::CreateUser {
key: spec.key.clone(),
username: spec.username.clone(),
email: spec.email.clone(),
password,
},
));
}
}
}
for spec in &manifest.users {
let user_id = resolved.users.get(&spec.key).copied();
for binding in &spec.roles {
steps.push(plan_binding(
Subject::User,
&spec.key,
&spec.username,
binding,
&snapshot.role_users,
&resolved,
));
}
for group_key in &spec.groups {
let group_id = resolved.groups.get(group_key).copied();
let present = matches!(
(group_id, user_id),
(Some(gid), Some(uid))
if snapshot.group_members.get(&gid).is_some_and(|l| l.contains(&uid))
);
steps.push((
action(
if present {
Change::NoChange
} else {
Change::Create
},
Target::GroupMember,
&spec.key,
format!("user {:?} is in group {group_key:?}", spec.username),
),
if present {
Step::Noop
} else {
Step::AddGroupMember {
group: group_key.clone(),
user: spec.key.clone(),
}
},
));
}
}
for spec in &manifest.service_accounts {
let mut matching = snapshot
.service_accounts
.iter()
.filter(|a| a.name == spec.name);
let found = matching.next();
if found.is_some() && matching.next().is_some() {
return Err(AxiamError::network(format!(
"service account {:?} is ambiguous: more than one existing account is named \
{:?}, and a service account's name is not unique on the server — rename one, \
or remove it from the manifest",
spec.key, spec.name
)));
}
let summary = format!("service account {:?}", spec.name);
match found {
Some(found) => {
resolved.service_accounts.insert(spec.key.clone(), found.id);
let drifted = spec
.description
.as_ref()
.is_some_and(|d| found.description.as_ref() != Some(d));
steps.push((
action(
if drifted {
Change::Update
} else {
Change::NoChange
},
Target::ServiceAccount,
&spec.key,
summary,
),
match (&spec.description, drifted) {
(Some(description), true) => Step::UpdateServiceAccount {
key: spec.key.clone(),
description: description.clone(),
},
_ => Step::Noop,
},
));
}
None => steps.push((
action(Change::Create, Target::ServiceAccount, &spec.key, summary),
Step::CreateServiceAccount {
key: spec.key.clone(),
name: spec.name.clone(),
description: spec.description.clone(),
},
)),
}
}
for spec in &manifest.service_accounts {
for binding in &spec.roles {
steps.push(plan_binding(
Subject::ServiceAccount,
&spec.key,
&spec.name,
binding,
&snapshot.role_service_accounts,
&resolved,
));
}
}
network::plan(
&manifest.network,
&snapshot.network,
&mut resolved,
&mut steps,
)?;
let (actions, pending): (Vec<_>, Vec<_>) = steps.into_iter().unzip();
Ok((ManagementPlan { actions }, resolved, pending))
}
}
fn plan_binding(
kind: Subject,
subject_key: &str,
subject_label: &str,
binding: &RoleBinding,
held: &HashMap<Uuid, Vec<Held>>,
resolved: &Resolved,
) -> (PlannedAction, Step) {
let role_key = binding.role();
let subject_id = kind.resolved(resolved).get(subject_key).copied();
let role_id = resolved.roles.get(role_key).copied();
let existing = match (role_id, subject_id) {
(Some(role), Some(subject)) => held
.get(&role)
.and_then(|list| list.iter().find(|h| h.subject == subject)),
_ => None,
};
let wanted_resource: Option<Option<Uuid>> = match binding.resource() {
None => Some(None),
Some(key) => resolved.resources.get(key).map(|id| Some(*id)),
};
let mut summary = format!("{} {subject_label:?} holds role {role_key:?}", kind.noun());
if let Some(resource) = binding.resource() {
summary.push_str(&format!(" at {resource:?}"));
if !binding.inherit() {
summary.push_str(" (here only)");
}
}
let change = match existing {
None => Change::Create,
Some(h) if wanted_resource == Some(h.resource_id) && h.inherit == binding.inherit() => {
Change::NoChange
}
Some(_) => Change::Update,
};
let step = match (change, existing) {
(Change::NoChange, _) => Step::Noop,
(Change::Update, Some(previous)) => Step::RebindRole {
subject_kind: kind,
subject: subject_key.to_string(),
role: role_key.to_string(),
resource: binding.resource().map(str::to_string),
inherit: binding.inherit(),
previous: previous.clone(),
},
_ => Step::AssignRole {
subject_kind: kind,
subject: subject_key.to_string(),
role: role_key.to_string(),
resource: binding.resource().map(str::to_string),
inherit: binding.inherit(),
},
};
(action(change, kind.target(), subject_key, summary), step)
}
fn action(change: Change, target: Target, key: &str, summary: String) -> PlannedAction {
PlannedAction {
change,
target,
key: key.to_string(),
summary,
}
}
impl<'c> Manifest<'c> {
async fn execute(
&self,
plan: ManagementPlan,
steps: Vec<Step>,
resolved: &mut Resolved,
) -> Result<ApplyReport, AxiamError> {
let mut out: Vec<(PlannedAction, Outcome)> = Vec::with_capacity(plan.actions.len());
let mut stopped = false;
for (action, step) in plan.actions.into_iter().zip(steps) {
if stopped {
out.push((action, Outcome::NotAttempted));
continue;
}
if matches!(step, Step::Noop) {
out.push((action, Outcome::Unchanged));
continue;
}
let created = matches!(action.change, Change::Create);
match self.run(step, resolved).await {
Ok(Done::Plain) => out.push((
action,
if created {
Outcome::Created
} else {
Outcome::Updated
},
)),
Ok(Done::ServiceAccount(response)) => out.push((
action,
Outcome::CreatedServiceAccount(CreatedServiceAccount(response)),
)),
Err(StepError::Plain(e)) if action.target.is_network() && e.is_conflict() => {
stopped = true;
out.push((
action,
Outcome::Conflict {
message: e.to_string(),
reason_code: e.reason_code().map(str::to_string),
},
));
}
Err(StepError::Plain(e)) => {
stopped = true;
out.push((action, Outcome::Failed(e.to_string())));
}
Err(StepError::Rebind(failure)) => {
let RebindFailure { error, restore } = *failure;
stopped = true;
out.push((
action,
Outcome::BindingUpdateFailed {
error: error.to_string(),
restore: restore.map_err(|e| e.to_string()),
},
));
}
}
}
Ok(ApplyReport { steps: out })
}
#[allow(clippy::too_many_lines)]
async fn run(&self, step: Step, resolved: &mut Resolved) -> Result<Done, StepError> {
let c = self.client;
match step {
Step::Noop => {}
Step::CreateResource {
key,
name,
resource_type,
parent,
metadata,
} => {
let parent_id = match parent {
Some(p) => Some(lookup(&resolved.resources, &p, "resource")?),
None => None,
};
let created = c
.resources()
.create(&models::CreateResourceRequest {
name,
resource_type,
parent_id,
metadata,
})
.await?;
resolved.resources.insert(key, created.id);
}
Step::UpdateResource {
key,
resource_type,
metadata,
} => {
let id = lookup(&resolved.resources, &key, "resource")?;
c.resources()
.update(
id,
&models::UpdateResourceRequest {
resource_type,
metadata,
..Default::default()
},
)
.await?;
}
Step::CreateScope {
resource,
key,
name,
description,
} => {
let resource_id = lookup(&resolved.resources, &resource, "resource")?;
let created = c
.scopes()
.create(
resource_id,
&models::CreateScopeRequest { name, description },
)
.await?;
resolved.scopes.insert(key, created.id);
}
Step::CreatePermission {
key,
action,
description,
} => {
let created = c
.permissions()
.create(&models::CreatePermissionRequest {
action,
description,
})
.await?;
resolved.permissions.insert(key, created.id);
}
Step::UpdatePermission { key, description } => {
let id = lookup(&resolved.permissions, &key, "permission")?;
c.permissions()
.update(
id,
&models::UpdatePermissionRequest {
description: Some(description),
..Default::default()
},
)
.await?;
}
Step::CreateRole {
key,
name,
description,
is_global,
} => {
let created = c
.roles()
.create(&models::CreateRoleRequest {
name,
description,
is_global,
})
.await?;
resolved.roles.insert(key, created.id);
}
Step::UpdateRole {
key,
description,
is_global,
} => {
let id = lookup(&resolved.roles, &key, "role")?;
c.roles()
.update(
id,
&models::UpdateRole {
description: Some(description),
is_global: Some(is_global),
..Default::default()
},
)
.await?;
}
Step::GrantPermission {
role,
permission,
effect,
scopes,
} => {
let role_id = lookup(&resolved.roles, &role, "role")?;
let permission_id = lookup(&resolved.permissions, &permission, "permission")?;
let scope_ids = scopes
.iter()
.map(|s| lookup(&resolved.scopes, s, "scope"))
.collect::<Result<Vec<_>, _>>()?;
c.roles()
.grant_permission(
role_id,
&models::GrantPermissionRequest {
permission_id,
effect,
scope_ids: if scope_ids.is_empty() {
None
} else {
Some(scope_ids)
},
},
)
.await?;
}
Step::CreateGroup {
key,
name,
description,
} => {
let created = c
.groups()
.create(&models::CreateGroupRequest {
name,
description,
metadata: None,
})
.await?;
resolved.groups.insert(key, created.id);
}
Step::UpdateGroup { key, description } => {
let id = lookup(&resolved.groups, &key, "group")?;
c.groups()
.update(
id,
&models::UpdateGroup {
description: Some(description),
..Default::default()
},
)
.await?;
}
Step::CreateUser {
key,
username,
email,
password,
} => {
let created = c
.users()
.create(&models::CreateUserRequest {
username,
email,
password,
metadata: None,
opaque: None,
})
.await?;
resolved.users.insert(key, created.id);
}
Step::UpdateUser { key, email } => {
let id = lookup(&resolved.users, &key, "user")?;
c.users()
.update(
id,
&models::UpdateUserRequest {
email: Some(email),
..Default::default()
},
)
.await?;
}
Step::AssignRole {
subject_kind,
subject,
role,
resource,
inherit,
} => {
let role_id = lookup(&resolved.roles, &role, "role")?;
let subject_id = lookup(
subject_kind.resolved(resolved),
&subject,
subject_kind.noun(),
)?;
let resource_id = resource
.as_deref()
.map(|r| lookup(&resolved.resources, r, "resource"))
.transpose()?;
self.assign(
subject_kind,
role_id,
subject_id,
resource_id,
inherit,
None,
)
.await?;
}
Step::RebindRole {
subject_kind,
subject,
role,
resource,
inherit,
previous,
} => {
let role_id = lookup(&resolved.roles, &role, "role")?;
let subject_id = lookup(
subject_kind.resolved(resolved),
&subject,
subject_kind.noun(),
)?;
let resource_id = resource
.as_deref()
.map(|r| lookup(&resolved.resources, r, "resource"))
.transpose()?;
self.unassign(subject_kind, role_id, subject_id, previous.resource_id)
.await?;
if let Err(error) = self
.assign(
subject_kind,
role_id,
subject_id,
resource_id,
inherit,
previous.tenant_scope.clone(),
)
.await
{
let restore = self
.assign(
subject_kind,
role_id,
subject_id,
previous.resource_id,
previous.inherit,
previous.tenant_scope,
)
.await;
return Err(StepError::Rebind(Box::new(RebindFailure {
error,
restore,
})));
}
}
Step::CreateServiceAccount {
key,
name,
description,
} => {
let created = c
.service_accounts()
.create(&models::CreateServiceAccountRequest { name, description })
.await?;
resolved.service_accounts.insert(key, created.id);
return Ok(Done::ServiceAccount(Box::new(created)));
}
Step::UpdateServiceAccount { key, description } => {
let id = lookup(&resolved.service_accounts, &key, "service account")?;
c.service_accounts()
.update(
id,
&models::UpdateServiceAccount {
description: Some(description),
..Default::default()
},
)
.await?;
}
Step::AddGroupMember { group, user } => {
let group_id = lookup(&resolved.groups, &group, "group")?;
let user_id = lookup(&resolved.users, &user, "user")?;
c.groups()
.add_member(group_id, &models::AddMemberRequest { user_id })
.await?;
}
Step::Network(step) => return self.run_network(step, resolved).await,
}
Ok(Done::Plain)
}
async fn assign(
&self,
kind: Subject,
role_id: Uuid,
subject_id: Uuid,
resource_id: Option<Uuid>,
inherit: bool,
tenant_scope: Option<Vec<Uuid>>,
) -> Result<(), AxiamError> {
let roles = self.client.roles();
let inherit = if inherit { None } else { Some(false) };
match kind {
Subject::Group => {
roles
.assign_to_group(
role_id,
&models::AssignRoleToGroupRequest {
group_id: subject_id,
inherit,
resource_id,
tenant_scope,
},
)
.await
}
Subject::User => {
roles
.assign_to_user(
role_id,
&models::AssignRoleToUserRequest {
user_id: subject_id,
inherit,
resource_id,
tenant_scope,
},
)
.await
}
Subject::ServiceAccount => {
roles
.assign_to_service_account(
role_id,
&models::AssignRoleToServiceAccountRequest {
service_account_id: subject_id,
inherit,
resource_id,
tenant_scope,
},
)
.await
}
}
}
async fn unassign(
&self,
kind: Subject,
role_id: Uuid,
subject_id: Uuid,
resource_id: Option<Uuid>,
) -> Result<(), AxiamError> {
let roles = self.client.roles();
let resource = resource_id.map(|r| r.to_string());
let resource = resource.as_deref();
match kind {
Subject::Group => {
roles
.unassign_from_group(role_id, subject_id, resource)
.await
}
Subject::User => {
roles
.unassign_from_user(role_id, subject_id, resource)
.await
}
Subject::ServiceAccount => {
roles
.unassign_from_service_account(role_id, subject_id, resource)
.await
}
}
}
}
enum Done {
Plain,
ServiceAccount(Box<models::ServiceAccountCreatedResponse>),
}
enum StepError {
Plain(AxiamError),
Rebind(Box<RebindFailure>),
}
struct RebindFailure {
error: AxiamError,
restore: Result<(), AxiamError>,
}
impl From<AxiamError> for StepError {
fn from(error: AxiamError) -> Self {
StepError::Plain(error)
}
}
fn lookup(map: &HashMap<String, Uuid>, key: &str, kind: &str) -> Result<Uuid, AxiamError> {
map.get(key).copied().ok_or_else(|| {
AxiamError::network(format!(
"internal: {kind} key {key:?} was consumed before the step that creates it ran"
))
})
}