655 lines
20 KiB
Rust
655 lines
20 KiB
Rust
use std::collections::{HashMap, HashSet};
|
|
|
|
use garage_db as db;
|
|
|
|
use garage_util::crdt::*;
|
|
use garage_util::data::*;
|
|
use garage_util::error::{Error as GarageError, OkOrMessage};
|
|
use garage_util::time::*;
|
|
|
|
use garage_table::util::*;
|
|
|
|
use crate::bucket_alias_table::*;
|
|
use crate::garage::Garage;
|
|
use crate::helper::bucket::BucketHelper;
|
|
use crate::helper::error::*;
|
|
use crate::helper::key::KeyHelper;
|
|
use crate::key_table::*;
|
|
use crate::permission::BucketKeyPerm;
|
|
|
|
/// A LockedHelper is the mandatory struct to hold when doing operations
|
|
/// that modify access keys or bucket aliases. This structure takes
|
|
/// a lock to a unit value that is in the globally-shared Garage struct.
|
|
///
|
|
/// This avoid several concurrent requests to modify the list of buckets
|
|
/// and aliases at the same time, ending up in inconsistent states.
|
|
/// This DOES NOT FIX THE FUNDAMENTAL ISSUE as CreateBucket requests handled
|
|
/// by different API nodes can still break the cluster, but it is a first
|
|
/// fix that allows consistency to be maintained if all such requests are
|
|
/// directed to a single node, which is doable for many deployments.
|
|
///
|
|
/// See issues: #649, #723
|
|
pub struct LockedHelper<'a>(
|
|
pub(crate) &'a Garage,
|
|
pub(crate) Option<tokio::sync::MutexGuard<'a, ()>>,
|
|
);
|
|
|
|
impl<'a> Drop for LockedHelper<'a> {
|
|
fn drop(&mut self) {
|
|
// make it explicit that the mutexguard lives until here
|
|
drop(self.1.take())
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::ptr_arg)]
|
|
impl<'a> LockedHelper<'a> {
|
|
pub fn bucket(&self) -> BucketHelper<'a> {
|
|
BucketHelper(self.0)
|
|
}
|
|
|
|
pub fn key(&self) -> KeyHelper<'a> {
|
|
KeyHelper(self.0)
|
|
}
|
|
|
|
// ================================================
|
|
// global bucket aliases
|
|
// ================================================
|
|
|
|
/// Sets a new alias for a bucket in global namespace.
|
|
/// This function fails if:
|
|
/// - alias name is not valid according to S3 spec
|
|
/// - bucket does not exist or is deleted
|
|
/// - alias already exists and points to another bucket
|
|
pub async fn set_global_bucket_alias(
|
|
&self,
|
|
bucket_id: Uuid,
|
|
alias_name: &String,
|
|
) -> Result<(), Error> {
|
|
if !is_valid_bucket_name(alias_name) {
|
|
return Err(Error::InvalidBucketName(alias_name.to_string()));
|
|
}
|
|
|
|
let mut bucket = self.bucket().get_existing_bucket(bucket_id).await?;
|
|
|
|
let alias = self.0.bucket_alias_table.get(&EmptyKey, alias_name).await?;
|
|
|
|
if let Some(existing_alias) = alias.as_ref() {
|
|
if let Some(p_bucket) = existing_alias.state.get() {
|
|
if *p_bucket != bucket_id {
|
|
return Err(Error::BadRequest(format!(
|
|
"Alias {} already exists and points to different bucket: {:?}",
|
|
alias_name, p_bucket
|
|
)));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Checks ok, add alias
|
|
let bucket_p = bucket.state.as_option_mut().unwrap();
|
|
|
|
let alias_ts = increment_logical_clock_2(
|
|
bucket_p.aliases.get_timestamp(alias_name),
|
|
alias.as_ref().map(|a| a.state.timestamp()).unwrap_or(0),
|
|
);
|
|
|
|
// ---- timestamp-ensured causality barrier ----
|
|
// writes are now done and all writes use timestamp alias_ts
|
|
|
|
let alias = match alias {
|
|
None => BucketAlias::new(alias_name.clone(), alias_ts, Some(bucket_id))
|
|
.ok_or_else(|| Error::InvalidBucketName(alias_name.clone()))?,
|
|
Some(mut a) => {
|
|
a.state = Lww::raw(alias_ts, Some(bucket_id));
|
|
a
|
|
}
|
|
};
|
|
self.0.bucket_alias_table.insert(&alias).await?;
|
|
|
|
bucket_p.aliases = LwwMap::raw_item(alias_name.clone(), alias_ts, true);
|
|
self.0.bucket_table.insert(&bucket).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Unsets an alias for a bucket in global namespace.
|
|
/// This function fails if:
|
|
/// - bucket does not exist or is deleted
|
|
/// - alias does not exist or maps to another bucket (-> internal error)
|
|
/// - bucket has no other aliases (global or local)
|
|
pub async fn unset_global_bucket_alias(
|
|
&self,
|
|
bucket_id: Uuid,
|
|
alias_name: &String,
|
|
) -> Result<(), Error> {
|
|
let mut bucket = self.bucket().get_existing_bucket(bucket_id).await?;
|
|
let bucket_state = bucket.state.as_option_mut().unwrap();
|
|
|
|
let mut alias = self
|
|
.0
|
|
.bucket_alias_table
|
|
.get(&EmptyKey, alias_name)
|
|
.await?
|
|
.filter(|a| a.state.get().map(|x| x == bucket_id).unwrap_or(false))
|
|
.ok_or_message(format!(
|
|
"Internal error: alias not found or does not point to bucket {:?}",
|
|
bucket_id
|
|
))?;
|
|
|
|
let has_other_global_aliases = bucket_state
|
|
.aliases
|
|
.items()
|
|
.iter()
|
|
.any(|(name, _, active)| name != alias_name && *active);
|
|
let has_other_local_aliases = bucket_state
|
|
.local_aliases
|
|
.items()
|
|
.iter()
|
|
.any(|(_, _, active)| *active);
|
|
if !has_other_global_aliases && !has_other_local_aliases {
|
|
return Err(Error::BadRequest(format!("Bucket {} doesn't have other aliases, please delete it instead of just unaliasing.", alias_name)));
|
|
}
|
|
|
|
// Checks ok, remove alias
|
|
let alias_ts = increment_logical_clock_2(
|
|
alias.state.timestamp(),
|
|
bucket_state.aliases.get_timestamp(alias_name),
|
|
);
|
|
|
|
// ---- timestamp-ensured causality barrier ----
|
|
// writes are now done and all writes use timestamp alias_ts
|
|
|
|
alias.state = Lww::raw(alias_ts, None);
|
|
self.0.bucket_alias_table.insert(&alias).await?;
|
|
|
|
bucket_state.aliases = LwwMap::raw_item(alias_name.clone(), alias_ts, false);
|
|
self.0.bucket_table.insert(&bucket).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Ensures a bucket does not have a certain global alias.
|
|
/// Contrarily to unset_global_bucket_alias, this does not
|
|
/// fail on any condition other than:
|
|
/// - bucket cannot be found (its fine if it is in deleted state)
|
|
/// - alias cannot be found (its fine if it points to nothing or
|
|
/// to another bucket)
|
|
pub async fn purge_global_bucket_alias(
|
|
&self,
|
|
bucket_id: Uuid,
|
|
alias_name: &String,
|
|
) -> Result<(), Error> {
|
|
let mut bucket = self.bucket().get_internal_bucket(bucket_id).await?;
|
|
|
|
let mut alias = self
|
|
.0
|
|
.bucket_alias_table
|
|
.get(&EmptyKey, alias_name)
|
|
.await?
|
|
.ok_or_else(|| Error::NoSuchBucket(alias_name.to_string()))?;
|
|
|
|
// Checks ok, remove alias
|
|
let alias_ts = increment_logical_clock_2(
|
|
alias.state.timestamp(),
|
|
bucket
|
|
.state
|
|
.as_option()
|
|
.map(|p| p.aliases.get_timestamp(alias_name))
|
|
.unwrap_or(0),
|
|
);
|
|
|
|
// ---- timestamp-ensured causality barrier ----
|
|
// writes are now done and all writes use timestamp alias_ts
|
|
|
|
if alias.state.get() == &Some(bucket_id) {
|
|
alias.state = Lww::raw(alias_ts, None);
|
|
self.0.bucket_alias_table.insert(&alias).await?;
|
|
}
|
|
|
|
if let Some(bucket_state) = bucket.state.as_option_mut() {
|
|
bucket_state.aliases = LwwMap::raw_item(alias_name.clone(), alias_ts, false);
|
|
self.0.bucket_table.insert(&bucket).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ================================================
|
|
// local bucket aliases
|
|
// ================================================
|
|
|
|
/// Sets a new alias for a bucket in the local namespace of a key.
|
|
/// This function fails if:
|
|
/// - alias name is not valid according to S3 spec
|
|
/// - bucket does not exist or is deleted
|
|
/// - key does not exist or is deleted
|
|
/// - alias already exists and points to another bucket
|
|
pub async fn set_local_bucket_alias(
|
|
&self,
|
|
bucket_id: Uuid,
|
|
key_id: &String,
|
|
alias_name: &String,
|
|
) -> Result<(), Error> {
|
|
if !is_valid_bucket_name(alias_name) {
|
|
return Err(Error::InvalidBucketName(alias_name.to_string()));
|
|
}
|
|
|
|
let mut bucket = self.bucket().get_existing_bucket(bucket_id).await?;
|
|
let mut key = self.key().get_existing_key(key_id).await?;
|
|
|
|
let key_param = key.state.as_option_mut().unwrap();
|
|
|
|
if let Some(Some(existing_alias)) = key_param.local_aliases.get(alias_name) {
|
|
if *existing_alias != bucket_id {
|
|
return Err(Error::BadRequest(format!("Alias {} already exists in namespace of key {} and points to different bucket: {:?}", alias_name, key.key_id, existing_alias)));
|
|
}
|
|
}
|
|
|
|
// Checks ok, add alias
|
|
let bucket_p = bucket.state.as_option_mut().unwrap();
|
|
let bucket_p_local_alias_key = (key.key_id.clone(), alias_name.clone());
|
|
|
|
// Calculate the timestamp to assign to this aliasing in the two local_aliases maps
|
|
// (the one from key to bucket, and the reverse one stored in the bucket itself)
|
|
// so that merges on both maps in case of a concurrent operation resolve
|
|
// to the same alias being set
|
|
let alias_ts = increment_logical_clock_2(
|
|
key_param.local_aliases.get_timestamp(alias_name),
|
|
bucket_p
|
|
.local_aliases
|
|
.get_timestamp(&bucket_p_local_alias_key),
|
|
);
|
|
|
|
// ---- timestamp-ensured causality barrier ----
|
|
// writes are now done and all writes use timestamp alias_ts
|
|
|
|
key_param.local_aliases = LwwMap::raw_item(alias_name.clone(), alias_ts, Some(bucket_id));
|
|
self.0.key_table.insert(&key).await?;
|
|
|
|
bucket_p.local_aliases = LwwMap::raw_item(bucket_p_local_alias_key, alias_ts, true);
|
|
self.0.bucket_table.insert(&bucket).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Unsets an alias for a bucket in the local namespace of a key.
|
|
/// This function fails if:
|
|
/// - bucket does not exist or is deleted
|
|
/// - key does not exist or is deleted
|
|
/// - alias does not exist or maps to another bucket (-> internal error)
|
|
/// - bucket has no other aliases (global or local)
|
|
pub async fn unset_local_bucket_alias(
|
|
&self,
|
|
bucket_id: Uuid,
|
|
key_id: &String,
|
|
alias_name: &String,
|
|
) -> Result<(), Error> {
|
|
let mut bucket = self.bucket().get_existing_bucket(bucket_id).await?;
|
|
let mut key = self.key().get_existing_key(key_id).await?;
|
|
|
|
let key_p = key.state.as_option().unwrap();
|
|
let bucket_p = bucket.state.as_option_mut().unwrap();
|
|
|
|
if key_p.local_aliases.get(alias_name).cloned().flatten() != Some(bucket_id) {
|
|
return Err(GarageError::Message(format!(
|
|
"Bucket {:?} does not have alias {} in namespace of key {}",
|
|
bucket_id, alias_name, key_id
|
|
))
|
|
.into());
|
|
}
|
|
|
|
let has_other_global_aliases = bucket_p
|
|
.aliases
|
|
.items()
|
|
.iter()
|
|
.any(|(_, _, active)| *active);
|
|
let has_other_local_aliases = bucket_p
|
|
.local_aliases
|
|
.items()
|
|
.iter()
|
|
.any(|((k, n), _, active)| (*k != key.key_id || n != alias_name) && *active);
|
|
|
|
if !has_other_global_aliases && !has_other_local_aliases {
|
|
return Err(Error::BadRequest(format!("Bucket {} doesn't have other aliases, please delete it instead of just unaliasing.", alias_name)));
|
|
}
|
|
|
|
// Checks ok, remove alias
|
|
let bucket_p_local_alias_key = (key.key_id.clone(), alias_name.clone());
|
|
|
|
let alias_ts = increment_logical_clock_2(
|
|
key_p.local_aliases.get_timestamp(alias_name),
|
|
bucket_p
|
|
.local_aliases
|
|
.get_timestamp(&bucket_p_local_alias_key),
|
|
);
|
|
|
|
// ---- timestamp-ensured causality barrier ----
|
|
// writes are now done and all writes use timestamp alias_ts
|
|
|
|
key.state.as_option_mut().unwrap().local_aliases =
|
|
LwwMap::raw_item(alias_name.clone(), alias_ts, None);
|
|
self.0.key_table.insert(&key).await?;
|
|
|
|
bucket_p.local_aliases = LwwMap::raw_item(bucket_p_local_alias_key, alias_ts, false);
|
|
self.0.bucket_table.insert(&bucket).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Ensures a bucket does not have a certain local alias.
|
|
/// Contrarily to unset_local_bucket_alias, this does not
|
|
/// fail on any condition other than:
|
|
/// - bucket cannot be found (its fine if it is in deleted state)
|
|
/// - key cannot be found (its fine if alias in key points to nothing
|
|
/// or to another bucket)
|
|
pub async fn purge_local_bucket_alias(
|
|
&self,
|
|
bucket_id: Uuid,
|
|
key_id: &String,
|
|
alias_name: &String,
|
|
) -> Result<(), Error> {
|
|
let mut bucket = self.bucket().get_internal_bucket(bucket_id).await?;
|
|
let mut key = self.key().get_internal_key(key_id).await?;
|
|
|
|
let bucket_p_local_alias_key = (key.key_id.clone(), alias_name.clone());
|
|
|
|
let alias_ts = increment_logical_clock_2(
|
|
key.state
|
|
.as_option()
|
|
.map(|p| p.local_aliases.get_timestamp(alias_name))
|
|
.unwrap_or(0),
|
|
bucket
|
|
.state
|
|
.as_option()
|
|
.map(|p| p.local_aliases.get_timestamp(&bucket_p_local_alias_key))
|
|
.unwrap_or(0),
|
|
);
|
|
|
|
// ---- timestamp-ensured causality barrier ----
|
|
// writes are now done and all writes use timestamp alias_ts
|
|
|
|
if let Some(kp) = key.state.as_option_mut() {
|
|
kp.local_aliases = LwwMap::raw_item(alias_name.clone(), alias_ts, None);
|
|
self.0.key_table.insert(&key).await?;
|
|
}
|
|
|
|
if let Some(bp) = bucket.state.as_option_mut() {
|
|
bp.local_aliases = LwwMap::raw_item(bucket_p_local_alias_key, alias_ts, false);
|
|
self.0.bucket_table.insert(&bucket).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ================================================
|
|
// permissions
|
|
// ================================================
|
|
|
|
/// Sets permissions for a key on a bucket.
|
|
/// This function fails if:
|
|
/// - bucket or key cannot be found at all (its ok if they are in deleted state)
|
|
/// - bucket or key is in deleted state and we are trying to set
|
|
/// permissions other than "deny all"
|
|
pub async fn set_bucket_key_permissions(
|
|
&self,
|
|
bucket_id: Uuid,
|
|
key_id: &String,
|
|
mut perm: BucketKeyPerm,
|
|
) -> Result<(), Error> {
|
|
let mut bucket = self.bucket().get_internal_bucket(bucket_id).await?;
|
|
let mut key = self.key().get_internal_key(key_id).await?;
|
|
|
|
if let Some(bstate) = bucket.state.as_option() {
|
|
if let Some(kp) = bstate.authorized_keys.get(key_id) {
|
|
perm.timestamp = increment_logical_clock_2(perm.timestamp, kp.timestamp);
|
|
}
|
|
} else if perm.is_any() {
|
|
return Err(Error::BadRequest(
|
|
"Trying to give permissions on a deleted bucket".into(),
|
|
));
|
|
}
|
|
|
|
if let Some(kstate) = key.state.as_option() {
|
|
if let Some(bp) = kstate.authorized_buckets.get(&bucket_id) {
|
|
perm.timestamp = increment_logical_clock_2(perm.timestamp, bp.timestamp);
|
|
}
|
|
} else if perm.is_any() {
|
|
return Err(Error::BadRequest(
|
|
"Trying to give permissions to a deleted key".into(),
|
|
));
|
|
}
|
|
|
|
// ---- timestamp-ensured causality barrier ----
|
|
|
|
if let Some(bstate) = bucket.state.as_option_mut() {
|
|
bstate.authorized_keys = Map::put_mutator(key_id.clone(), perm);
|
|
self.0.bucket_table.insert(&bucket).await?;
|
|
}
|
|
|
|
if let Some(kstate) = key.state.as_option_mut() {
|
|
kstate.authorized_buckets = Map::put_mutator(bucket_id, perm);
|
|
self.0.key_table.insert(&key).await?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ================================================
|
|
// keys
|
|
// ================================================
|
|
|
|
/// Deletes an API access key
|
|
pub async fn delete_key(&self, key: &mut Key) -> Result<(), Error> {
|
|
let state = key.state.as_option_mut().unwrap();
|
|
|
|
// --- done checking, now commit ---
|
|
|
|
// 1. Delete local aliases
|
|
for (alias, _, to) in state.local_aliases.items().iter() {
|
|
if let Some(bucket_id) = to {
|
|
self.purge_local_bucket_alias(*bucket_id, &key.key_id, alias)
|
|
.await?;
|
|
}
|
|
}
|
|
|
|
// 2. Remove permissions on all authorized buckets
|
|
for (ab_id, _auth) in state.authorized_buckets.items().iter() {
|
|
self.set_bucket_key_permissions(*ab_id, &key.key_id, BucketKeyPerm::NO_PERMISSIONS)
|
|
.await?;
|
|
}
|
|
|
|
// 3. Actually delete key
|
|
key.state = Deletable::delete();
|
|
self.0.key_table.insert(key).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// ================================================
|
|
// repair procedure
|
|
// ================================================
|
|
|
|
pub async fn repair_aliases(&self) -> Result<(), GarageError> {
|
|
self.0.db.transaction(|tx| {
|
|
info!("--- begin repair_aliases transaction ----");
|
|
|
|
// 1. List all non-deleted buckets, so that we can fix bad aliases
|
|
let mut all_buckets: HashSet<Uuid> = HashSet::new();
|
|
|
|
for item in tx.range::<&[u8], _>(&self.0.bucket_table.data.store, ..)? {
|
|
let bucket = self
|
|
.0
|
|
.bucket_table
|
|
.data
|
|
.decode_entry(&(item?.1))
|
|
.map_err(db::TxError::Abort)?;
|
|
if !bucket.is_deleted() {
|
|
all_buckets.insert(bucket.id);
|
|
}
|
|
}
|
|
|
|
info!("number of buckets: {}", all_buckets.len());
|
|
|
|
// 2. List all aliases declared in bucket_alias_table and key_table
|
|
// Take note of aliases that point to non-existing buckets
|
|
let mut global_aliases: HashMap<String, Uuid> = HashMap::new();
|
|
|
|
{
|
|
let mut delete_global = vec![];
|
|
for item in tx.range::<&[u8], _>(&self.0.bucket_alias_table.data.store, ..)? {
|
|
let mut alias = self
|
|
.0
|
|
.bucket_alias_table
|
|
.data
|
|
.decode_entry(&(item?.1))
|
|
.map_err(db::TxError::Abort)?;
|
|
if let Some(id) = alias.state.get() {
|
|
if all_buckets.contains(id) {
|
|
// keep aliases
|
|
global_aliases.insert(alias.name().to_string(), *id);
|
|
} else {
|
|
// delete alias
|
|
warn!(
|
|
"global alias: remove {} -> {:?} (bucket is deleted)",
|
|
alias.name(),
|
|
id
|
|
);
|
|
alias.state.update(None);
|
|
delete_global.push(alias);
|
|
}
|
|
}
|
|
}
|
|
|
|
info!("number of global aliases: {}", global_aliases.len());
|
|
|
|
info!("global alias table: {} entries fixed", delete_global.len());
|
|
for ga in delete_global {
|
|
debug!("Enqueue update to global alias table: {:?}", ga);
|
|
self.0.bucket_alias_table.queue_insert(tx, &ga)?;
|
|
}
|
|
}
|
|
|
|
let mut local_aliases: HashMap<(String, String), Uuid> = HashMap::new();
|
|
|
|
{
|
|
let mut delete_local = vec![];
|
|
|
|
for item in tx.range::<&[u8], _>(&self.0.key_table.data.store, ..)? {
|
|
let mut key = self
|
|
.0
|
|
.key_table
|
|
.data
|
|
.decode_entry(&(item?.1))
|
|
.map_err(db::TxError::Abort)?;
|
|
let Some(p) = key.state.as_option_mut() else {
|
|
continue;
|
|
};
|
|
let mut has_changes = false;
|
|
for (name, _, to) in p.local_aliases.items().to_vec() {
|
|
if let Some(id) = to {
|
|
if all_buckets.contains(&id) {
|
|
local_aliases.insert((key.key_id.clone(), name), id);
|
|
} else {
|
|
warn!(
|
|
"local alias: remove ({}, {}) -> {:?} (bucket is deleted)",
|
|
key.key_id, name, id
|
|
);
|
|
p.local_aliases.update_in_place(name, None);
|
|
has_changes = true;
|
|
}
|
|
}
|
|
}
|
|
if has_changes {
|
|
delete_local.push(key);
|
|
}
|
|
}
|
|
|
|
info!("number of local aliases: {}", local_aliases.len());
|
|
|
|
info!("key table: {} entries fixed", delete_local.len());
|
|
for la in delete_local {
|
|
debug!("Enqueue update to key table: {:?}", la);
|
|
self.0.key_table.queue_insert(tx, &la)?;
|
|
}
|
|
}
|
|
|
|
// 4. Reverse the alias maps to determine the aliases per-bucket
|
|
let mut bucket_global: HashMap<Uuid, Vec<String>> = HashMap::new();
|
|
let mut bucket_local: HashMap<Uuid, Vec<(String, String)>> = HashMap::new();
|
|
|
|
for (name, bucket) in global_aliases {
|
|
bucket_global.entry(bucket).or_default().push(name);
|
|
}
|
|
for ((key, name), bucket) in local_aliases {
|
|
bucket_local.entry(bucket).or_default().push((key, name));
|
|
}
|
|
|
|
// 5. Fix the bucket table to ensure consistency
|
|
let mut bucket_updates = vec![];
|
|
|
|
for item in tx.range::<&[u8], _>(&self.0.bucket_table.data.store, ..)? {
|
|
let bucket = self
|
|
.0
|
|
.bucket_table
|
|
.data
|
|
.decode_entry(&(item?.1))
|
|
.map_err(db::TxError::Abort)?;
|
|
let mut bucket2 = bucket.clone();
|
|
let Some(param) = bucket2.state.as_option_mut() else {
|
|
continue;
|
|
};
|
|
|
|
// fix global aliases
|
|
{
|
|
let ga = bucket_global.remove(&bucket.id).unwrap_or_default();
|
|
for (name, _, active) in param.aliases.items().to_vec() {
|
|
if active && !ga.contains(&name) {
|
|
warn!("bucket {:?}: remove global alias {}", bucket.id, name);
|
|
param.aliases.update_in_place(name, false);
|
|
}
|
|
}
|
|
for name in ga {
|
|
if param.aliases.get(&name).copied().unwrap_or(false) == false {
|
|
warn!("bucket {:?}: add global alias {}", bucket.id, name);
|
|
param.aliases.update_in_place(name, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
// fix local aliases
|
|
{
|
|
let la = bucket_local.remove(&bucket.id).unwrap_or_default();
|
|
for (pair, _, active) in param.local_aliases.items().to_vec() {
|
|
if active && !la.contains(&pair) {
|
|
warn!("bucket {:?}: remove local alias {:?}", bucket.id, pair);
|
|
param.local_aliases.update_in_place(pair, false);
|
|
}
|
|
}
|
|
for pair in la {
|
|
if param.local_aliases.get(&pair).copied().unwrap_or(false) == false {
|
|
warn!("bucket {:?}: add local alias {:?}", bucket.id, pair);
|
|
param.local_aliases.update_in_place(pair, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if bucket2 != bucket {
|
|
bucket_updates.push(bucket2);
|
|
}
|
|
}
|
|
|
|
info!("bucket table: {} entries fixed", bucket_updates.len());
|
|
for b in bucket_updates {
|
|
debug!("Enqueue update to bucket table: {:?}", b);
|
|
self.0.bucket_table.queue_insert(tx, &b)?;
|
|
}
|
|
|
|
info!("--- end repair_aliases transaction ----");
|
|
|
|
Ok(())
|
|
})?;
|
|
|
|
info!("repair_aliases is done");
|
|
|
|
Ok(())
|
|
}
|
|
}
|