`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? {
 -        Response::Sessions { sessions } => sessions,
 -        _ => Vec::new(),
 +    let (sessions, default_session) = match client.request(&Request::ListSessions).await? {
 +        Response::Sessions { sessions, default_session } => (sessions, default_session),
 +        _ => (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
 -    pub fn new(sessions: Vec<SessionInfo>, x: f64, y: f64, width: f64) -> Self {
 +    /// Create a new session selector with optional default session
 +    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;