seuss 0.3.1

A batteries-included framework for implementing Redfish-compliant services.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::str::FromStr;

use axum::{
    extract::{OriginalUri, State},
    http::StatusCode,
    response::Response,
    Extension, Json, Router,
};
use redfish_axum::{session::Session, session_collection::SessionCollection};
use redfish_codegen::models::{
    odata_v4, resource, session::v1_6_0::Session as SessionModel,
    session_collection::SessionCollection as SessionCollectionModel,
    session_service::v1_1_8::SessionService as SessionServiceModel,
};
use redfish_core::auth::AuthenticateRequest;

use crate::{auth::SessionManagement, middleware::ResourceLocator};

#[derive(Clone)]
pub struct SessionService<M, A>
where
    M: Clone + SessionManagement,
    A: Clone + AuthenticateRequest + 'static,
{
    session_manager: M,
    auth_handler: A,
}

impl<M, A> AsRef<dyn AuthenticateRequest> for SessionService<M, A>
where
    M: Clone + SessionManagement,
    A: Clone + AuthenticateRequest + 'static,
{
    fn as_ref(&self) -> &(dyn AuthenticateRequest + 'static) {
        &self.auth_handler
    }
}

impl<M, A> SessionService<M, A>
where
    M: Clone + SessionManagement + Send + Sync + 'static,
    <M as SessionManagement>::Id: FromStr + Clone + Send + Sync,
    A: Clone + AuthenticateRequest + Send + Sync + 'static,
{
    pub fn new(session_manager: M, auth_handler: A) -> Self {
        Self {
            auth_handler,
            session_manager,
        }
    }

    pub fn into_router<S>(self) -> Router<S> {
        redfish_axum::session_service::SessionService::default()
        .get(|OriginalUri(uri): OriginalUri| async move {
            crate::Response(SessionServiceModel {
                id: resource::Id("sessions".to_string()),
                name: resource::Name("SessionService".to_string()),
                odata_id: odata_v4::Id(uri.path().to_string()),
                sessions: Some(odata_v4::IdRef {
                    odata_id: Some(odata_v4::Id(uri.path().to_string() + "/Sessions")),
                }),
                ..Default::default()
            })
        })
        .sessions(
            SessionCollection::default()
                .get(
                    |OriginalUri(uri): OriginalUri, State(state): State<Self>| async move {
                        match state.session_manager.sessions() {
                            Ok(members) => Ok(crate::Response(SessionCollectionModel {
                                name: resource::Name("SessionCollection".to_string()),
                                odata_id: odata_v4::Id(uri.path().to_string()),
                                members_odata_count: odata_v4::Count(members.len().try_into().unwrap()),
                                members,
                                ..Default::default()
                            })),
                            Err(error) => Err(crate::Response(error)),
                        }
                    },
                )
                .post(
                    |State(mut state): State<Self>, OriginalUri(uri): OriginalUri, Json(session): Json<SessionModel>| async move {
                        match state.session_manager.create_session(session, uri.path().to_string()) {
                            Ok(session) => Ok((
                                StatusCode::CREATED,
                                [
                                    ("X-Auth-Token", session.token.clone().unwrap()),
                                    ("Location", session.odata_id.0.clone()),
                                ],
                                crate::Response(session),
                            )),
                            Err(error) => Err(crate::Response(error)),
                        }
                    },
                )
                .session(
                    Session::default()
                        .get(|Extension(id): Extension<M::Id>, State(state): State<Self>| async move {
                            match state.session_manager.get_session(id) {
                                Ok(session) => Ok(crate::Response(session)),
                                Err(error) => Err(crate::Response(error)),
                            }
                        })
                        .delete(|Extension(id): Extension<M::Id>, State(mut state): State<Self>| async move {
                            match state.session_manager.delete_session(id) {
                                Ok(()) => Ok(StatusCode::NO_CONTENT),
                                Err(error) => Err(crate::Response(error)),
                            }
                        })
                        .into_router()
                        .route_layer(ResourceLocator::new(
                            "session_id".to_string(),
                            |id: M::Id| async move { Ok::<_, Response>(id) }
                        ))
                )
                .into_router()
        )
        .into_router()
        .with_state(self)
    }
}