oxirs-fuseki 0.2.4

SPARQL 1.1/1.2 HTTP protocol server with Fuseki-compatible configuration
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! IDS Connector Core Implementation
//!
//! Main IDS Connector implementing IDSA Reference Architecture

use super::catalog::ResourceCatalog;
use super::contract::{ContractManager, InMemoryNegotiator};
use super::identity::IdentityProvider;
use super::lineage::ProvenanceGraph;
use super::policy::PolicyEngine;
use super::residency::ResidencyEnforcer;
use super::types::{IdsResult, IdsUri, Party, SecurityProfile, TransferProtocol};
use std::sync::Arc;

/// IDS Connector Configuration
#[derive(Debug, Clone)]
pub struct IdsConnectorConfig {
    /// Connector ID
    pub connector_id: IdsUri,

    /// Connector title
    pub title: String,

    /// Connector description
    pub description: String,

    /// Curator (responsible party)
    pub curator: IdsUri,

    /// Maintainer
    pub maintainer: IdsUri,

    /// Security profile
    pub security_profile: SecurityProfile,

    /// DAPS URL
    pub daps_url: String,

    /// IDS Broker URLs
    pub broker_urls: Vec<String>,

    /// Gaia-X registry URL
    pub gaiax_registry_url: Option<String>,

    /// Supported transfer protocols
    pub supported_protocols: Vec<TransferProtocol>,
}

impl Default for IdsConnectorConfig {
    fn default() -> Self {
        Self {
            connector_id: IdsUri::new("urn:ids:connector:oxirs")
                .expect("default connector URI should be valid"),
            title: "OxiRS IDS Connector".to_string(),
            description: "Semantic Web Data Space Connector".to_string(),
            curator: IdsUri::new("https://oxirs.io").expect("default curator URI should be valid"),
            maintainer: IdsUri::new("https://oxirs.io")
                .expect("default maintainer URI should be valid"),
            security_profile: SecurityProfile::TrustSecurityProfile,
            daps_url: super::DEFAULT_DAPS_URL.to_string(),
            broker_urls: vec![super::DEFAULT_IDS_BROKER.to_string()],
            gaiax_registry_url: None,
            supported_protocols: vec![TransferProtocol::Https, TransferProtocol::MultipartFormData],
        }
    }
}

/// IDS Connector
pub struct IdsConnector {
    config: IdsConnectorConfig,
    identity: Arc<IdentityProvider>,
    catalog: Arc<ResourceCatalog>,
    contract_manager: Arc<ContractManager>,
    policy_engine: Arc<PolicyEngine>,
    lineage_tracker: Arc<ProvenanceGraph>,
    residency_enforcer: Arc<ResidencyEnforcer>,
}

impl IdsConnector {
    /// Create a new IDS Connector
    pub fn new(config: IdsConnectorConfig) -> Self {
        let identity = Arc::new(IdentityProvider::new(config.daps_url.clone()));
        let catalog = Arc::new(ResourceCatalog::new());
        let policy_engine = Arc::new(PolicyEngine::new());
        let lineage_tracker = Arc::new(ProvenanceGraph::default());
        let residency_enforcer = Arc::new(ResidencyEnforcer::new());

        let negotiator = Arc::new(InMemoryNegotiator::new());
        let contract_manager = Arc::new(ContractManager::new(negotiator));

        Self {
            config,
            identity,
            catalog,
            contract_manager,
            policy_engine,
            lineage_tracker,
            residency_enforcer,
        }
    }

    /// Get connector ID
    pub fn connector_id(&self) -> &IdsUri {
        &self.config.connector_id
    }

    /// Get catalog
    pub fn catalog(&self) -> Arc<ResourceCatalog> {
        Arc::clone(&self.catalog)
    }

    /// Get contract manager
    pub fn contract_manager(&self) -> Arc<ContractManager> {
        Arc::clone(&self.contract_manager)
    }

    /// Get policy engine
    pub fn policy_engine(&self) -> Arc<PolicyEngine> {
        Arc::clone(&self.policy_engine)
    }

    /// Get lineage tracker
    pub fn lineage_tracker(&self) -> Arc<ProvenanceGraph> {
        Arc::clone(&self.lineage_tracker)
    }

    /// Get residency enforcer
    pub fn residency_enforcer(&self) -> Arc<ResidencyEnforcer> {
        Arc::clone(&self.residency_enforcer)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_connector_creation() {
        let config = IdsConnectorConfig::default();
        let connector = IdsConnector::new(config);

        assert_eq!(connector.connector_id().as_str(), "urn:ids:connector:oxirs");
    }
}