use infinity_agent_core::ThreadId;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use infinity_protocol::{ClientMessage, DaemonMessage, RemoteName, ThreadRef};
use tokio::sync::mpsc::UnboundedSender;
use crate::rap_servers::{MigrationServer, boot_migration_servers, migration_server_ports};
use crate::remote::{RemoteDaemons, SshPortForward};
use crate::session::SharedSessionManager;
type BoxError = Box<dyn std::error::Error + Send + Sync>;
pub async fn orchestrate_migration(
root_thread_id: ThreadRef,
to: Option<RemoteName>,
dest_cwd: PathBuf,
session_manager: SharedSessionManager,
daemon_tx: UnboundedSender<DaemonMessage>,
) {
let _ = daemon_tx.send(DaemonMessage::MigrateStarted {
root_thread_id: root_thread_id.clone(),
});
let new_root_thread_id = ThreadRef {
remote: to.clone(),
id: root_thread_id.id.clone(),
};
match run_migration(&root_thread_id, to.as_ref(), &dest_cwd, &session_manager).await {
Ok(()) => {
let _ = daemon_tx.send(DaemonMessage::MigrateComplete {
root_thread_id,
new_root_thread_id,
});
}
Err(e) => {
let _ = daemon_tx.send(DaemonMessage::MigrateError {
root_thread_id,
error: e.to_string(),
});
}
}
}
async fn run_migration(
session_ref: &ThreadRef,
to: Option<&RemoteName>,
dest_cwd: &Path,
session_manager: &SharedSessionManager,
) -> Result<(), BoxError> {
let source_is_local = session_ref.remote.is_none();
let source_remote = session_ref.remote.clone();
let real_session_id = session_ref.id.clone();
let dest_is_local = to.is_none();
let source_cwd = if source_is_local {
let mgr = session_manager.lock().await;
let cwd = mgr
.session_store
.lock()
.await
.get_cwd(&real_session_id)
.clone();
mgr.cleanup_session(&real_session_id).await;
Some(cwd)
} else {
None
};
let (dest_rap_urls, dest_spawned, _tunnel_guards) =
boot_dest_and_tunnel(to, dest_cwd, &source_remote, session_manager).await?;
if source_is_local && !dest_rap_urls.is_empty() {
let (migration_servers, _spawned) = boot_source_rap_servers(
source_cwd.as_deref().expect("bug: source local but no cwd"),
&dest_rap_urls,
)
.await?;
let notifier = rap_client::notifier::RapNotifier::new(
migration_servers
.iter()
.map(|(_, url)| url.clone())
.collect(),
rap_client::http::SimpleHttpClient::new(),
);
if let Err(errors) = notifier
.request_migration(&real_session_id, &migration_servers, &dest_rap_urls)
.await
{
return Err(format!("RAP migration failed: {}", errors.join("; ")).into());
}
}
let session_data = if source_is_local {
let mgr = session_manager.lock().await;
mgr.conversation_store().serialize_session(&real_session_id)
} else {
let rd = {
let mgr = session_manager.lock().await;
mgr.remote_daemons.clone()
};
let rd = rd.ok_or("no remote daemons configured")?;
emigrate_from_remote(
&rd,
source_remote
.as_ref()
.expect("bug: source remote but no name"),
&real_session_id,
dest_rap_urls,
)
.await?
};
drop(dest_spawned);
if dest_is_local {
let mgr = session_manager.lock().await;
mgr.conversation_store()
.import_session(&session_data)
.map_err(|e| format!("import failed: {e}"))?;
let mut store = mgr.session_store.lock().await;
store.create(&real_session_id, dest_cwd.to_path_buf());
store.mark_shut_down(&real_session_id);
store.save()?;
} else {
let rd = {
let mgr = session_manager.lock().await;
mgr.remote_daemons.clone()
};
let rd = rd.ok_or("no remote daemons configured")?;
immigrate_to_remote(
&rd,
to.expect("bug: dest is remote"),
&real_session_id,
dest_cwd,
&session_data,
)
.await?;
}
if source_is_local {
let mgr = session_manager.lock().await;
let mut store = mgr.session_store.lock().await;
store.mark_archived(&real_session_id);
store.save()?;
} else {
let rd = {
let mgr = session_manager.lock().await;
mgr.remote_daemons.clone()
};
if let Some(rd) = rd {
send_emigrate_done(
&rd,
source_remote
.as_ref()
.expect("bug: source remote but no name"),
&real_session_id,
)
.await?;
}
}
Ok(())
}
async fn boot_source_rap_servers(
cwd: &Path,
dest_rap_urls: &HashMap<String, String>,
) -> Result<(Vec<(String, String)>, Vec<MigrationServer>), BoxError> {
let user_rap = crate::config::user_config_path().ok();
let servers = boot_migration_servers(cwd, user_rap.as_deref()).await?;
let migration_servers: Vec<(String, String)> = servers
.iter()
.filter_map(|s| {
let id = s.config_id.as_ref()?;
dest_rap_urls
.contains_key(id)
.then(|| (id.clone(), s.url.clone()))
})
.collect();
Ok((migration_servers, servers))
}
pub async fn handle_emigrate(
session_id: &ThreadId<str>,
dest_rap_urls: HashMap<String, String>,
session_manager: &SharedSessionManager,
) -> Result<String, BoxError> {
let cwd = {
let mgr = session_manager.lock().await;
mgr.session_store.lock().await.get_cwd(session_id).clone()
};
{
let mgr = session_manager.lock().await;
mgr.cleanup_session(session_id).await;
}
let (migration_servers, _spawned) = boot_source_rap_servers(&cwd, &dest_rap_urls).await?;
if !migration_servers.is_empty() {
let notifier = rap_client::notifier::RapNotifier::new(
migration_servers
.iter()
.map(|(_, url)| url.clone())
.collect(),
rap_client::http::SimpleHttpClient::new(),
);
if let Err(errors) = notifier
.request_migration(session_id, &migration_servers, &dest_rap_urls)
.await
{
return Err(format!("RAP migration failed: {}", errors.join("; ")).into());
}
}
let mgr = session_manager.lock().await;
Ok(mgr.conversation_store().serialize_session(session_id))
}
pub enum LocalOrRemoteSpawned {
Local(Vec<MigrationServer>),
Remote(UnboundedSender<ClientMessage>),
}
async fn boot_dest_and_tunnel(
to: Option<&RemoteName>,
dest_cwd: &Path,
source_remote: &Option<RemoteName>,
session_manager: &SharedSessionManager,
) -> Result<
(
HashMap<String, String>,
LocalOrRemoteSpawned,
Vec<SshPortForward>,
),
BoxError,
> {
let dest_is_local = to.is_none();
let (dest_server_ports, dest_spawned) = if dest_is_local {
let user_rap = crate::config::user_config_path().ok();
let servers = boot_migration_servers(dest_cwd, user_rap.as_deref()).await?;
let ports = migration_server_ports(&servers);
(ports, LocalOrRemoteSpawned::Local(servers))
} else {
tracing::info!("Launching RAP servers on remote destination to receive migration");
let rd = {
let mgr = session_manager.lock().await;
mgr.remote_daemons.clone()
};
let rd = rd.ok_or("no remote daemons configured")?;
let (tx, mut rx) = rd
.open_raw_connection(to.expect("bug: dest is remote"))
.await?;
tx.send(ClientMessage::BootRapServers {
cwd: dest_cwd.to_path_buf(),
})?;
let ports = match rx.recv().await {
Some(DaemonMessage::RapServersBooted { server_ports }) => server_ports,
Some(msg) => return Err(format!("remote sent unxpected response {:?}", msg).into()),
None => return Err("remote closed without sending EmigrateResult".into()),
};
(ports, LocalOrRemoteSpawned::Remote(tx))
};
let mut dest_rap_urls = HashMap::new();
let source_is_local = source_remote.is_none();
let mut tunnel_guards = Vec::new();
if dest_is_local && source_is_local {
for (id, port) in &dest_server_ports {
dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{port}"));
}
} else if dest_is_local {
let rd = {
let mgr = session_manager.lock().await;
mgr.remote_daemons.clone()
};
let rd = rd.ok_or("no remote daemons configured")?;
let source_remote_name = source_remote
.as_ref()
.expect("bug: source remote but no name");
let ssh_args = rd
.get_ssh_args(source_remote_name)
.ok_or("unknown source remote")?;
for (id, local_port) in &dest_server_ports {
let (remote_port, guard) =
crate::remote::ssh_reverse_forward_port(&ssh_args, *local_port).await?;
dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{remote_port}"));
tunnel_guards.push(guard);
}
} else if source_is_local {
let rd = {
let mgr = session_manager.lock().await;
mgr.remote_daemons.clone()
};
let rd = rd.ok_or("no remote daemons configured")?;
let ssh_args = rd
.get_ssh_args(to.expect("bug: dest is remote"))
.ok_or("unknown remote")?;
for (id, remote_port) in &dest_server_ports {
let (local_port, guard) =
crate::remote::ssh_forward_port(&ssh_args, *remote_port).await?;
dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{local_port}"));
tunnel_guards.push(guard);
}
} else {
let rd = {
let mgr = session_manager.lock().await;
mgr.remote_daemons.clone()
};
let rd = rd.ok_or("no remote daemons configured")?;
let dest_ssh_args = rd
.get_ssh_args(to.expect("bug: dest is remote"))
.ok_or("unknown dest remote")?;
let source_remote_name = source_remote
.as_ref()
.expect("bug: source remote but no name");
let source_ssh_args = rd
.get_ssh_args(source_remote_name)
.ok_or("unknown source remote")?;
for (id, dest_port) in &dest_server_ports {
let (local_port, guard1) =
crate::remote::ssh_forward_port(&dest_ssh_args, *dest_port).await?;
let (source_port, guard2) =
crate::remote::ssh_reverse_forward_port(&source_ssh_args, local_port).await?;
dest_rap_urls.insert(id.clone(), format!("http://127.0.0.1:{source_port}"));
tunnel_guards.push(guard1);
tunnel_guards.push(guard2);
}
}
Ok((dest_rap_urls, dest_spawned, tunnel_guards))
}
async fn emigrate_from_remote(
rd: &RemoteDaemons,
remote_name: &RemoteName,
session_id: &ThreadId<str>,
dest_rap_urls: HashMap<String, String>,
) -> Result<String, BoxError> {
let (tx, mut rx) = rd.open_raw_connection(remote_name).await?;
tx.send(ClientMessage::Emigrate {
root_thread_id: session_id.to_owned(),
dest_rap_urls,
})?;
match rx.recv().await {
Some(DaemonMessage::EmigrateResult { session_data, .. }) => Ok(session_data),
Some(msg) => Err(format!("remote sent unxpected response {:?}", msg).into()),
None => Err("remote closed without sending EmigrateResult".into()),
}
}
async fn immigrate_to_remote(
rd: &RemoteDaemons,
remote_name: &RemoteName,
session_id: &ThreadId<str>,
dest_cwd: &Path,
session_data: &str,
) -> Result<(), BoxError> {
let (tx, mut rx) = rd.open_raw_connection(remote_name).await?;
tx.send(ClientMessage::ImportSession {
root_thread_id: session_id.to_owned(),
cwd: dest_cwd.to_path_buf(),
session_data: session_data.to_owned(),
})?;
match rx.recv().await {
Some(DaemonMessage::ImportComplete { .. }) => Ok(()),
Some(msg) => Err(format!("remote sent unxpected response {:?}", msg).into()),
None => Err("remote closed without sending EmigrateResult".into()),
}
}
async fn send_emigrate_done(
rd: &RemoteDaemons,
remote_name: &RemoteName,
session_id: &ThreadId<str>,
) -> Result<(), BoxError> {
let (tx, _rx) = rd.open_raw_connection(remote_name).await?;
tx.send(ClientMessage::EmigrateDone {
root_thread_id: session_id.to_owned(),
})
.map_err(|e| e.into())
}