dataplane-sdk 0.1.1

A Rust SDK for building data planes that interface with Dataspace Protocol Control Planes via the Data Plane Signaling API
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

//  Copyright (c) 2026 Metaform Systems, Inc
//
//  This program and the accompanying materials are made available under the
//  terms of the Apache License, Version 2.0 which is available at
//  https://www.apache.org/licenses/LICENSE-2.0
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Contributors:
//         Metaform Systems, Inc. - initial API and implementation

use std::{ops::Deref, sync::Arc};

use crate::core::{
    db::{control_plane::ControlPlaneRepo, data_flow::DataFlowRepo, tx::TransactionalContext},
    handler::DataFlowHandler,
};

pub mod internal;

pub struct DataPlaneSdk<C: TransactionalContext>(Arc<internal::DataPlaneSdkInternal<C>>);

impl<C> Clone for DataPlaneSdk<C>
where
    C: TransactionalContext,
{
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
}

impl<C> DataPlaneSdk<C>
where
    C: TransactionalContext,
{
    pub fn builder(ctx: C) -> DataPlaneSdkBuilder<C> {
        DataPlaneSdkBuilder::new(ctx)
    }

    pub(crate) fn new(
        ctx: C,
        repo: Box<dyn DataFlowRepo<Transaction = C::Transaction>>,
        control_plane_repo: Box<dyn ControlPlaneRepo<Transaction = C::Transaction>>,
        handler: Box<dyn DataFlowHandler<Transaction = C::Transaction>>,
        client: reqwest::Client,
    ) -> Self {
        Self(Arc::new(internal::DataPlaneSdkInternal {
            ctx,
            repo,
            control_plane_repo,
            handler,
            client,
        }))
    }
}

impl<C> Deref for DataPlaneSdk<C>
where
    C: TransactionalContext,
{
    type Target = internal::DataPlaneSdkInternal<C>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

pub struct DataPlaneSdkBuilder<C>
where
    C: TransactionalContext,
{
    ctx: C,
    repo: Option<Box<dyn DataFlowRepo<Transaction = C::Transaction>>>,
    control_plane_repo: Option<Box<dyn ControlPlaneRepo<Transaction = C::Transaction>>>,
    handler: Option<Box<dyn DataFlowHandler<Transaction = C::Transaction>>>,
    client: Option<reqwest::Client>,
}

impl<C> DataPlaneSdkBuilder<C>
where
    C: TransactionalContext,
{
    pub(crate) fn new(ctx: C) -> Self {
        Self {
            ctx,
            repo: None,
            control_plane_repo: None,
            handler: None,
            client: None,
        }
    }

    pub fn with_repo(
        mut self,
        repo: impl DataFlowRepo<Transaction = C::Transaction> + 'static,
    ) -> Self {
        self.repo = Some(Box::new(repo));
        self
    }

    pub fn with_control_plane_repo(
        mut self,
        control_plane_repo: impl ControlPlaneRepo<Transaction = C::Transaction> + 'static,
    ) -> Self {
        self.control_plane_repo = Some(Box::new(control_plane_repo));
        self
    }

    pub fn with_handler(
        mut self,
        handler: impl DataFlowHandler<Transaction = C::Transaction> + 'static,
    ) -> Self {
        self.handler = Some(Box::new(handler));
        self
    }

    /// Overrides the `reqwest::Client` used to send control plane notifications.
    /// Defaults to `reqwest::Client::new()` when not set.
    pub fn with_client(mut self, client: reqwest::Client) -> Self {
        self.client = Some(client);
        self
    }

    pub fn build(self) -> Result<DataPlaneSdk<C>, String> {
        let repo = self.repo.ok_or("DataFlowRepo is not set")?;

        let control_plane_repo = self
            .control_plane_repo
            .ok_or("ControlPlaneRepo is not set")?;

        let handler = self.handler.ok_or("DataFlowHandler is not set")?;

        let client = self.client.unwrap_or_default();

        Ok(DataPlaneSdk::new(
            self.ctx,
            repo,
            control_plane_repo,
            handler,
            client,
        ))
    }
}