Struct location_manager::LocationManager

pub struct LocationManager {
    pub location_map: HashMap<ObjectId, HostId>,
    pub move_handles: Arc<MoveHandleMap>,
    pub(crate) async_rt_manager: Arc<AsyncRuntimeManager>,
    pub(crate) config: Config,
    pub(crate) object_tracker: Arc<ObjectTracker>,
    pub(crate) data_request_client: Arc<DataRequestClient>,
    pub(crate) data_exchange_client: Arc<DataExchangeClient>,
}

Fields

location_map: HashMap<ObjectId, HostId>

move_handles: Arc<MoveHandleMap>

async_rt_manager: Arc<AsyncRuntimeManager>

config: Config

object_tracker: Arc<ObjectTracker>

data_request_client: Arc<DataRequestClient>

data_exchange_client: Arc<DataExchangeClient>

Implementations

impl LocationManager

pub fn new( config: Config, async_rt_manager: Arc<AsyncRuntimeManager>, object_tracker: Arc<ObjectTracker> ) -> Self

pub fn get_current_host_id(&self) -> HostId

pub async fn init_server(&self) -> Result<(), InternalError>

pub async fn move_object_to( &self, object_id: ObjectId, target_host: HostId ) -> Result<(), Error>

pub async fn move_object( &self, object_id: ObjectId, source_host_id: u16, target_host_id: u16 ) -> Result<(), Error>

pub async fn wait_for_object(&self, object_id: ObjectId)

pub async fn wait_for_object_or_update(&self, object_id: ObjectId) -> Option<()>

Unconditionally waits for an in-flight object without first checking for residency.

It is up to the caller of this function to ensure that the right wait semantics are enforced.

pub fn get_object_tracker(&self) -> Arc<ObjectTracker>

pub async fn calculate_signature(&self, object_id: ObjectId) -> Vec<u8>

pub async fn insert_move_handle(&self, object_id: ObjectId)

pub async fn trigger_move( &self, object_id: ObjectId, foreign_signature: &Vec<u8>, target_host_id: String )