ossify 0.4.0

A modern, easy-to-use, and reqwest-powered Rust SDK for Alibaba Cloud Object Storage Service (OSS)
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

//! ListLiveChannel: list LiveChannels under a bucket.
//!
//! Official document: <https://www.alibabacloud.com/help/en/oss/developer-reference/listlivechannel>

use std::future::Future;

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

use crate::body::NoneBody;
use crate::error::Result;
use crate::ops::common::LiveChannelSummary;
use crate::response::BodyResponseProcessor;
use crate::ser::OnlyKeyField;
use crate::{Client, Ops, Prepared, Request};

/// ListLiveChannel query parameters.
#[derive(Debug, Clone, Default, Serialize)]
#[serde(rename_all = "kebab-case")]
pub struct ListLiveChannelParams {
    pub(crate) live: OnlyKeyField,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub marker: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_keys: Option<String>,
}

impl ListLiveChannelParams {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn prefix(mut self, v: impl Into<String>) -> Self {
        self.prefix = Some(v.into());
        self
    }

    pub fn marker(mut self, v: impl Into<String>) -> Self {
        self.marker = Some(v.into());
        self
    }

    pub fn max_keys(mut self, v: impl Into<String>) -> Self {
        self.max_keys = Some(v.into());
        self
    }
}

/// ListLiveChannel response body `<ListLiveChannelResult>`.
#[derive(Debug, Clone, Deserialize)]
#[serde(rename = "ListLiveChannelResult", rename_all = "PascalCase")]
pub struct ListLiveChannelResponse {
    pub prefix: Option<String>,
    pub marker: Option<String>,
    pub max_keys: Option<String>,
    pub is_truncated: bool,
    pub next_marker: Option<String>,
    #[serde(rename = "LiveChannel", default)]
    pub live_channels: Vec<LiveChannelSummary>,
}

pub struct ListLiveChannel {
    pub params: ListLiveChannelParams,
}

impl Ops for ListLiveChannel {
    type Response = BodyResponseProcessor<ListLiveChannelResponse>;
    type Body = NoneBody;
    type Query = ListLiveChannelParams;

    fn prepare(self) -> Result<Prepared<ListLiveChannelParams>> {
        Ok(Prepared {
            method: Method::GET,
            query: Some(self.params),
            ..Default::default()
        })
    }
}

/// Trait for ListLiveChannel operations.
pub trait ListLiveChannelOperations {
    fn list_live_channel(
        &self,
        params: Option<ListLiveChannelParams>,
    ) -> impl Future<Output = Result<ListLiveChannelResponse>>;
}

impl ListLiveChannelOperations for Client {
    async fn list_live_channel(
        &self,
        params: Option<ListLiveChannelParams>,
    ) -> Result<ListLiveChannelResponse> {
        let ops = ListLiveChannel {
            params: params.unwrap_or_default(),
        };
        self.request(ops).await
    }
}

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

    #[test]
    fn test_serialize_params_full() {
        let p = ListLiveChannelParams::new()
            .prefix("abc")
            .marker("m")
            .max_keys("50");
        let q = crate::ser::to_string(&p).unwrap();
        assert_eq!(q, "live&marker=m&max-keys=50&prefix=abc");
    }

    #[test]
    fn test_serialize_params_default() {
        let q = crate::ser::to_string(&ListLiveChannelParams::default()).unwrap();
        assert_eq!(q, "live");
    }

    #[test]
    fn test_deserialize_response() {
        let xml = r#"<ListLiveChannelResult>
  <Prefix></Prefix>
  <Marker></Marker>
  <MaxKeys>100</MaxKeys>
  <IsTruncated>false</IsTruncated>
  <LiveChannel>
    <Name>abc</Name>
    <Description>d</Description>
    <Status>enabled</Status>
    <LastModified>2024-01-01T00:00:00Z</LastModified>
    <PublishUrls><Url>rtmp://x/abc</Url></PublishUrls>
    <PlayUrls><Url>http://x/abc.m3u8</Url></PlayUrls>
  </LiveChannel>
</ListLiveChannelResult>"#;
        let resp: ListLiveChannelResponse = quick_xml::de::from_str(xml).unwrap();
        assert!(!resp.is_truncated);
        assert_eq!(resp.live_channels.len(), 1);
        assert_eq!(resp.live_channels[0].name, "abc");
    }
}