Function handle_expose_service

crates/openshell-server/src/grpc/service.rs:24–125

(
    state: &Arc<ServerState>,
    request: Request<ExposeServiceRequest>,
)

const MAX_SANDBOX_NAME_LEN: usize = 28;

pub(super) async fn handle_expose_service(
    state: &Arc<ServerState>,
    request: Request<ExposeServiceRequest>,
) -> Result<Response<ServiceEndpointResponse>, Status> {
    let req = request.into_inner();
    validate_endpoint_name("sandbox", &req.sandbox, MAX_SANDBOX_NAME_LEN)?;
    validate_optional_endpoint_name("service", &req.service, MAX_SERVICE_NAME_LEN)?;
    if req.target_port == 0 || req.target_port > u32::from(u16::MAX) {
        return Err(Status::invalid_argument("target_port must be in 1..=65535"));
    }

    let sandbox = state
        .store
        .get_message_by_name::<Sandbox>(&req.sandbox)
        .await
        .map_err(|e| Status::internal(format!("fetch sandbox failed: {e}")))?
        .ok_or_else(|| Status::not_found("sandbox not found"))?;

    let now = crate::persistence::current_time_ms();
    let key = service_routing::endpoint_key(&req.sandbox, &req.service);

    // Fetch existing endpoint to determine create vs. update path
    let existing = state
        .store
        .get_message_by_name::<ServiceEndpoint>(&key)
        .await
        .map_err(|e| Status::internal(format!("fetch endpoint failed: {e}")))?;

    let (id, created_at_ms, condition, created) = if let Some(existing) = existing {
        // Update path: preserve id and created_at, use CAS to prevent conflicts
        let resource_version = existing
            .metadata
            .as_ref()
            .map_or(0, |metadata| metadata.resource_version);
        (
            existing.object_id().to_string(),
            existing
                .metadata
                .as_ref()
                .map_or(now, |metadata| metadata.created_at_ms),
            WriteCondition::MatchResourceVersion(resource_version),
            false,
        )
    } else {
        // Create path: new id and created_at, use MustCreate to prevent races
        (
            Uuid::new_v4().to_string(),
            now,
            WriteCondition::MustCreate,
            true,
        )
    };

    let labels_json = serde_json::to_string(&HashMap::from([(
        "sandbox".to_string(),
        req.sandbox.clone(),
    )]))
    .map_err(|e| Status::internal(format!("serialize labels failed: {e}")))?;