sendry 0.2.0

Official Rust crate for the Sendry email 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
144
145
146
147
148
149
150
151
152
153

//! Dedicated IP addresses.

use reqwest::Method;
use serde::{Deserialize, Serialize};

use crate::{client::Sendry, error::Error, DeleteResponse, Page, PaginationParams};

/// Dedicated IPs resource handle.
#[derive(Debug, Clone)]
pub struct DedicatedIps {
    client: Sendry,
}

impl DedicatedIps {
    pub(crate) fn new(client: Sendry) -> Self {
        Self { client }
    }

    /// Provision a new dedicated IP.
    pub async fn provision(&self, params: ProvisionDedicatedIp) -> Result<DedicatedIp, Error> {
        self.client
            .request(
                self.client
                    .build(Method::POST, "/v1/ips", &[], Some(&params)),
            )
            .await
    }

    /// List dedicated IPs.
    pub async fn list(&self, params: PaginationParams) -> Result<Page<DedicatedIp>, Error> {
        let q = params.to_query();
        self.client
            .request(self.client.build::<()>(Method::GET, "/v1/ips", &q, None))
            .await
    }

    /// Retrieve a specific IP.
    pub async fn get(&self, id: &str) -> Result<DedicatedIp, Error> {
        self.client
            .request(self.client.build::<()>(
                Method::GET,
                &format!("/v1/ips/{id}"),
                &[],
                None,
            ))
            .await
    }

    /// Assign an IP to a domain.
    pub async fn assign(&self, ip_id: &str, params: AssignIp) -> Result<IpAssignment, Error> {
        self.client
            .request(self.client.build(
                Method::POST,
                &format!("/v1/ips/{ip_id}/assign"),
                &[],
                Some(&params),
            ))
            .await
    }

    /// Remove an IP assignment.
    pub async fn remove_assignment(
        &self,
        ip_id: &str,
        assignment_id: &str,
    ) -> Result<DeleteResponse, Error> {
        self.client
            .request(self.client.build::<()>(
                Method::DELETE,
                &format!("/v1/ips/{ip_id}/assign/{assignment_id}"),
                &[],
                None,
            ))
            .await
    }

    /// Release a dedicated IP.
    pub async fn release(&self, id: &str) -> Result<DeleteResponse, Error> {
        self.client
            .request(self.client.build::<()>(
                Method::DELETE,
                &format!("/v1/ips/{id}"),
                &[],
                None,
            ))
            .await
    }
}

/// One IP assignment record (embedded in [`DedicatedIp`]).
#[derive(Debug, Clone, Deserialize)]
pub struct DedicatedIpAssignment {
    /// Assignment id.
    pub id: String,
    /// Domain id.
    pub domain_id: String,
    /// Domain name.
    pub domain_name: String,
    /// Creation timestamp.
    pub created_at: String,
}

/// Dedicated IP record.
#[derive(Debug, Clone, Deserialize)]
pub struct DedicatedIp {
    /// IP id.
    pub id: String,
    /// IPv4 / IPv6 address.
    pub ip_address: String,
    /// `ses` or `mailgun`.
    pub provider: String,
    /// `provisioning`, `warming`, `active`, or `inactive`.
    pub status: String,
    /// Warmup day (0-indexed).
    pub warmup_day: u32,
    /// Warmup progress percentage 0–100.
    pub warmup_progress: f64,
    /// Pool name.
    pub pool_name: Option<String>,
    /// Current assignments.
    #[serde(default)]
    pub assignments: Vec<DedicatedIpAssignment>,
    /// Creation timestamp.
    pub created_at: String,
}

/// Parameters for [`DedicatedIps::provision`].
#[derive(Debug, Clone, Serialize, Default)]
pub struct ProvisionDedicatedIp {
    /// `ses` (default) or `mailgun`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
}

/// Parameters for [`DedicatedIps::assign`].
#[derive(Debug, Clone, Serialize)]
pub struct AssignIp {
    /// Domain id.
    pub domain_id: String,
}

/// Assignment record returned by [`DedicatedIps::assign`].
#[derive(Debug, Clone, Deserialize)]
pub struct IpAssignment {
    /// Assignment id.
    pub id: String,
    /// IP id.
    pub ip_id: String,
    /// Domain id.
    pub domain_id: String,
    /// Creation timestamp.
    pub created_at: String,
}