MCPcopy Create free account
hub / github.com/atomicdotdev/atomic / update_turn

Function update_turn

atomic-cli/src/commands/agent/provenance_rpc.rs:950–1011  ·  view source on GitHub ↗

The lifecycle transitions: GetTurn first (a lookup never grants a generation — the request's expected_generation is the turn's own current one), then one UpdateTurn. An unknown turn is `Ok(None)`, exactly like the legacy owner's TurnLifecycle{turn: None}.

(
    sink: &ProvenanceRpcSink,
    session_id: &str,
    turn_number: u32,
    action: pb::TurnAction,
    cause: Option<pb::StopCause>,
    resumable: Option<bool>,
    observed_at: i64,
)

Source from the content-addressed store, hash-verified

948/// current one), then one UpdateTurn. An unknown turn is `Ok(None)`,
949/// exactly like the legacy owner's TurnLifecycle{turn: None}.
950fn update_turn(
951 sink: &ProvenanceRpcSink,
952 session_id: &str,
953 turn_number: u32,
954 action: pb::TurnAction,
955 cause: Option<pb::StopCause>,
956 resumable: Option<bool>,
957 observed_at: i64,
958) -> Result<Option<JournalTurnStatus>, String> {
959 let reference = sink.reference.clone();
960 let session_id = session_id.to_string();
961 run_outside_async_runtime(move || {
962 current_thread_runtime()?.block_on(async {
963 let stored = request_with_reconnect("turn lookup", |client| {
964 let session_id = session_id.clone();
965 let reference = reference.clone();
966 async move {
967 provenance_client(client)
968 .get_turn(pb::GetTurnRequest {
969 repository: Some(reference.clone()),
970 session_id,
971 turn_number,
972 })
973 .await
974 .map(|response| response.into_inner())
975 }
976 })
977 .await?;
978 let Some(turn) = stored.turn else {
979 return Ok(None);
980 };
981 let response = request_with_reconnect("update turn", |client| {
982 let reference = reference.clone();
983 let turn = turn.clone();
984 async move {
985 provenance_client(client)
986 .update_turn(pb::UpdateTurnRequest {
987 repository: Some(reference),
988 meta: request_meta(observed_at),
989 session_id: turn.session_id.clone(),
990 turn_number,
991 action: action as i32,
992 cause: cause.map(|cause| cause as i32),
993 resumable,
994 // The looked-up turn's own current generation —
995 // a lookup never grants one, so this is exactly
996 // what the legacy owner used internally.
997 expected_generation: turn.generation,
998 })
999 .await
1000 .map(|response| response.into_inner())
1001 }
1002 })
1003 .await?;
1004 match response.turn {
1005 None => Ok(None),
1006 Some(turn) => Ok(Some(journal_turn_status(&turn)?)),
1007 }

Callers 3

stop_turnMethod · 0.85
resume_turnMethod · 0.85
abandon_turnMethod · 0.85

Calls 10

current_thread_runtimeFunction · 0.85
request_with_reconnectFunction · 0.85
provenance_clientFunction · 0.85
journal_turn_statusFunction · 0.85
get_turnMethod · 0.80
update_turnMethod · 0.80
request_metaFunction · 0.70
cloneMethod · 0.45
into_innerMethod · 0.45

Tested by

no test coverage detected