reasonerconn/
lib.rs

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
122
123
124
125
126
127
use std::fmt;

use audit_logger::{ConnectorWithContext, ReasonerConnectorAuditLogger, SessionedConnectorAuditLogger};
use policy::Policy;
use serde::{Deserialize, Serialize};
use state_resolver::State;
use workflow::spec::Workflow;

#[derive(Debug)]
pub struct ReasonerConnError {
    err: String,
}

impl fmt::Display for ReasonerConnError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { self.err.fmt(f) }
}

impl ReasonerConnError {
    pub fn new<T: Into<String>>(t: T) -> Self { Self { err: t.into() } }

    pub fn from<T: std::error::Error>(t: T) -> Self { Self { err: format!("{}", t) } }
}

impl std::error::Error for ReasonerConnError {
    fn description(&self) -> &str { &self.err }
}

#[derive(Serialize, Deserialize)]
pub struct ReasonerResponse {
    pub success: bool,
    pub errors:  Vec<String>,
}

impl ReasonerResponse {
    pub fn new(success: bool, errors: Vec<String>) -> Self { ReasonerResponse { success, errors } }
}

#[async_trait::async_trait]
pub trait ReasonerConnector<L: ReasonerConnectorAuditLogger>: ConnectorWithContext {
    async fn execute_task(
        &self,
        logger: SessionedConnectorAuditLogger<L>,
        policy: Policy,
        state: State,
        workflow: Workflow,
        task: String,
    ) -> Result<ReasonerResponse, ReasonerConnError>;
    async fn access_data_request(
        &self,
        logger: SessionedConnectorAuditLogger<L>,
        policy: Policy,
        state: State,
        workflow: Workflow,
        data: String,
        task: Option<String>,
    ) -> Result<ReasonerResponse, ReasonerConnError>;
    async fn workflow_validation_request(
        &self,
        logger: SessionedConnectorAuditLogger<L>,
        policy: Policy,
        state: State,
        workflow: Workflow,
    ) -> Result<ReasonerResponse, ReasonerConnError>;
}

// #[async_trait::async_trait]
// pub trait LoggingReasonerConnector: ReasonerConnector + ReasonerConnectorAuditLogger {
//     fn reference(&self) -> String;
//     async fn log_raw_result(&self, raw_result: &str) -> Result<(), ReasonerConnError> {
//         self.log_reasoner_response(&self.reference(), raw_result).await.map_err(|err| ReasonerConnError { err: "test".into() })
//     }
//     fn new_session(&self, session_id: String) -> Self;
// }

// pub struct DefaultLoggingReasonerConnector<Connector: ReasonerConnector, Logger: ReasonerConnectorAuditLogger> {
//     session:   Option<String>,
//     connector: Arc<Connector>,
//     logger:    Arc<Logger>,
// }

// impl<Connector: ReasonerConnector, Logger: ReasonerConnectorAuditLogger> DefaultLoggingReasonerConnector<Connector, Logger> {
//     fn new(connector: Connector, logger: Logger) -> Self { Self { session: None, connector: Arc::new(connector), logger: Arc::new(logger) } }
// }

// #[async_trait::async_trait]
// impl<Connector: ReasonerConnector + Send + Sync, Logger: ReasonerConnectorAuditLogger + Send + Sync> LoggingReasonerConnector
//     for DefaultLoggingReasonerConnector<Connector, Logger>
// {
//     fn reference(&self) -> String { return self.session.clone().unwrap() }

//     fn new_session(&self, session_id: String) -> Self {
//         Self { session: Some(session_id), connector: self.connector.clone(), logger: self.logger.clone() }
//     }
// }

// #[async_trait::async_trait]
// impl<Connector: ReasonerConnector + Send + Sync, Logger: ReasonerConnectorAuditLogger + Send + Sync> ReasonerConnectorAuditLogger
//     for DefaultLoggingReasonerConnector<Connector, Logger>
// {
//     async fn log_reasoner_response(&self, reference: &str, response: &str) -> Result<(), AuditLoggerError> {
//         self.logger.log_reasoner_response(reference, response).await
//     }
// }

// #[async_trait::async_trait]
// impl<Connector: ReasonerConnector + Send + Sync, Logger: ReasonerConnectorAuditLogger + Send + Sync> ReasonerConnector
//     for DefaultLoggingReasonerConnector<Connector, Logger>
// {
//     async fn execute_task(&self, policy: Policy, state: State, workflow: Workflow, task: String) -> Result<ReasonerResponse, ReasonerConnError> {
//         self.connector.execute_task(policy, state, workflow, task).await
//     }

//     async fn access_data_request(
//         &self,
//         policy: Policy,
//         state: State,
//         workflow: Workflow,
//         data: String,
//         task: Option<String>,
//     ) -> Result<ReasonerResponse, ReasonerConnError> {
//         self.connector.access_data_request(policy, state, workflow, data, task).await
//     }

//     async fn workflow_validation_request(&self, policy: Policy, state: State, workflow: Workflow) -> Result<ReasonerResponse, ReasonerConnError> {
//         self.connector.workflow_validation_request(policy, state, workflow).await
//     }
// }