Struct DiscoveryLimiter 

struct DiscoveryLimiter {
    restart_imminent_lock: Arc<RwLock<bool>>,
    restart_imminent_cached: OnceCell<()>,
}

Encapsulates the handling of running just one discovery process per server

Fields

restart_imminent_lock: Arc<RwLock<bool>>

Lock that makes sure only one discovery task is running at the same time.

The protected value is true when restart due to a changed constellation is imminent.

restart_imminent_cached: OnceCell<()>

Set when contents of restart_imminent_lock lock was observed to be true, reducing the load on this lock.

Implementations

impl DiscoveryLimiter

fn new() -> Self

async fn request_discovery<S: Server>( &self, app: Rc<S::AppT>, ) -> Result<DiscoveryRunResp>

This functions contains the discovery logic that’s shared between servers.

Discovery can be invoked for two reasons:

1. This server has just been restarted and is not aware of the current constellation. Perhaps part of our configuration has changed that makes the current constellation obsolete.

2. The .ph/discovery/run endpoint was triggered. This should happen when another server detects that our constellation is out-of-date, but since the .ph/discovery/run endpoint is unprotected, anyone can invoke it at any time.

   The non-PHC servers check during their discovery whether the constellation PHC advertises is up-to-date with respect to their own configuration. If it isn’t, the non-PHC server triggers PHC to run discovery.

   PHC checks during its discovery (after it obtained recent details from each of the other servers) whether the constellations of the other servers are up-to-date, and will trigger their discovery routine when these aren’t.

Thus the procedure for discovery is as follows.

Non-PHC:

1. Obtain constellation from PHC. Return if it coincides with the constellation that we already got - if we already got one.
2. Check the constellation against our own configuration. If it’s up-to-date, restart this server but with the new constellation.
3. Invoke discovery on PHC, and return a retryable error - effectively go back to step 1.

PHC:

1. Obtain discovery info from ourselves - i.e. check whether phc_url is configured correctly.
2. Retrieve discovery info from the other servers and construct a constellation from it.
3. If the constellation has changed, restart to update it.
4. Invoke discovery on those servers that have no or outdated constellations, and return a retryable error - effectively go back to step 1.

async fn obtain_lock(&self) -> Option<RwLockWriteGuard<'_, bool>>

Obtains write lock to self.restart_imminent_lock when restart is not imminent.

Trait Implementations

impl Clone for DiscoveryLimiter

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.