`3042f28`

Respect default_session config in greeter

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: 3042f28fdae4800913bc654d2e2a2e3d0ed6a325
Parents: e3e3eea
Tree: 9bb19e6

4 changed files

Status	File	+	-
M	`gardm-greeter/src/main.rs`	5	5
M	`gardm-greeter/src/widgets/session_selector.rs`	8	3
M	`gardm-ipc/src/lib.rs`	6	1
M	`gardmd/src/main.rs`	10	5

gardm-greeter/src/main.rsmodified

      tracing::info!("Connected to gardmd");
      // Fetch available sessions
--    let sessions = match client.request(&Request::ListSessions).await? {
++    let (sessions, default_session) = match client.request(&Request::ListSessions).await? {
--        Response::Sessions { sessions } => sessions,
++        Response::Sessions { sessions, default_session } => (sessions, default_session),
--        _ => Vec::new(),
++        _ => (Vec::new(), None),
      };
--    tracing::debug!(?sessions, "Available sessions");
++    tracing::debug!(?sessions, ?default_session, "Available sessions");
      // Fetch available users
      let users = match client.request(&Request::ListUsers).await? {
      let selector_width = 200.0;
      let selector_x = center_x - selector_width / 2.0;
      let selector_y = center_y + 180.0; // Below the login form
--    let mut session_selector = SessionSelector::new(sessions, selector_x, selector_y, selector_width);
++    let mut session_selector = SessionSelector::new(sessions, selector_x, selector_y, selector_width, default_session.as_deref());
      // Create power buttons (bottom-right corner of primary monitor)
      let mut power_buttons = PowerButtons::new(

gardm-greeter/src/widgets/session_selector.rsmodified

+ }
  impl SessionSelector {
--    /// Create a new session selector
++    /// Create a new session selector with optional default session
--    pub fn new(sessions: Vec<SessionInfo>, x: f64, y: f64, width: f64) -> Self {
++    pub fn new(sessions: Vec<SessionInfo>, x: f64, y: f64, width: f64, default_session: Option<&str>) -> Self {
++        // Find index of default session, or fall back to 0
++        let selected_index = default_session
++            .and_then(|default| sessions.iter().position(|s| s.id == default))
++            .unwrap_or(0);
++
          Self {
              sessions,
--            selected_index: 0,
++            selected_index,
              expanded: false,
              hovered_index: None,
              x,

gardm-ipc/src/lib.rsmodified

      Error { message: String },
      /// List of available sessions
--    Sessions { sessions: Vec<SessionInfo> },
++    Sessions {
++        sessions: Vec<SessionInfo>,
++        /// Default session ID from daemon config
++        #[serde(default)]
++        default_session: Option<String>,
++    },
      /// List of available users
      Users { users: Vec<UserInfo> },

gardmd/src/main.rsmodified

          // Handle greeter authentication
          let session_result = tokio::select! {
--            result = handle_greeter_session(&server, &x_display) => result,
++            result = handle_greeter_session(&server, &x_display, &config.general.default_session) => result,
              _ = sigterm.recv() => {
                  tracing::info!("Received SIGTERM during greeter");
                  break;
  async fn handle_greeter_session(
      server: &ipc::Server,
      _display: &str,
++    default_session: &str,
  ) -> Result<Option<SessionStartInfo>> {
      let mut conn = server.accept().await?;
      let mut auth = AuthSession::new();
              None => return Ok(None), // Greeter disconnected
          };
--        let (response, session_info) = handle_greeter_request(request, &mut auth).await;
++        let (response, session_info) = handle_greeter_request(request, &mut auth, default_session).await;
          tracing::debug!(?response, has_session_info = session_info.is_some(), "Sending response to greeter");
          conn.send(&response).await?;
  async fn handle_greeter_request(
      request: Request,
      auth: &mut AuthSession,
++    default_session: &str,
  ) -> (Response, Option<SessionStartInfo>) {
      use gardmd::auth::AuthResponse;
          Request::ListSessions => {
              let sessions = gardmd::list_sessions();
--            (Response::Sessions { sessions }, None)
++            (Response::Sessions {
++                sessions,
++                default_session: Some(default_session.to_string()),
++            }, None)
          }
          Request::ListUsers => {
  }
  /// Handle a test mode client (same as before, for backwards compatibility)
--async fn handle_test_client(mut conn: ipc::ClientConnection, _config: Config) {
++async fn handle_test_client(mut conn: ipc::ClientConnection, config: Config) {
      let mut auth = AuthSession::new();
      loop {
          match conn.recv().await {
              Ok(Some(request)) => {
--                let (response, _) = handle_greeter_request(request, &mut auth).await;
++                let (response, _) = handle_greeter_request(request, &mut auth, &config.general.default_session).await;
                  if let Err(e) = conn.send(&response).await {
                      tracing::error!("Failed to send response: {}", e);
                      break;