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
154
|
//! The HTTP module which provides functions for performing requests to
//! endpoints in Discord's API.
//!
//! An important function of the REST API is ratelimiting. Requests to endpoints
//! are ratelimited to prevent spam, and once ratelimited Discord will stop
//! performing requests. The library implements protection to pre-emptively
//! ratelimit, to ensure that no wasted requests are made.
//!
//! The HTTP module comprises of two types of requests:
//!
//! - REST API requests, which require an authorization token;
//! - Other requests, which do not require an authorization token.
//!
//! The former require a [`Client`] to have logged in, while the latter may be
//! made regardless of any other usage of the library.
//!
//! If a request spuriously fails, it will be retried once.
//!
//! Note that you may want to perform requests through a [model]s'
//! instance methods where possible, as they each offer different
//! levels of a high-level interface to the HTTP module.
//!
//! [`Client`]: ../client/struct.Client.html
//! [model]: ../model/index.html
pub mod ratelimiting;
pub mod raw;
pub mod request;
pub mod routing;
mod error;
pub use hyper::status::{StatusClass, StatusCode};
pub use self::error::Error as HttpError;
pub use self::raw::*;
use hyper::{
client::Client as HyperClient,
method::Method,
net::HttpsConnector,
};
use hyper_native_tls::NativeTlsClient;
use model::prelude::*;
use parking_lot::Mutex;
use self::{request::Request};
use std::{
default::Default,
fs::File,
path::{Path, PathBuf},
sync::Arc
};
lazy_static! {
static ref CLIENT: HyperClient = {
let tc = NativeTlsClient::new().expect("Unable to make http client");
let connector = HttpsConnector::new(tc);
HyperClient::with_connector(connector)
};
}
/// An method used for ratelimiting special routes.
///
/// This is needed because `hyper`'s `Method` enum does not derive Copy.
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
pub enum LightMethod {
/// Indicates that a route is for the `DELETE` method only.
Delete,
/// Indicates that a route is for the `GET` method only.
Get,
/// Indicates that a route is for the `PATCH` method only.
Patch,
/// Indicates that a route is for the `POST` method only.
Post,
/// Indicates that a route is for the `PUT` method only.
Put,
}
impl LightMethod {
pub fn hyper_method(&self) -> Method {
match *self {
LightMethod::Delete => Method::Delete,
LightMethod::Get => Method::Get,
LightMethod::Patch => Method::Patch,
LightMethod::Post => Method::Post,
LightMethod::Put => Method::Put,
}
}
}
lazy_static! {
static ref TOKEN: Arc<Mutex<String>> = Arc::new(Mutex::new(String::default()));
}
/// Enum that allows a user to pass a `Path` or a `File` type to `send_files`
pub enum AttachmentType<'a> {
/// Indicates that the `AttachmentType` is a byte slice with a filename.
Bytes((&'a [u8], &'a str)),
/// Indicates that the `AttachmentType` is a `File`
File((&'a File, &'a str)),
/// Indicates that the `AttachmentType` is a `Path`
Path(&'a Path),
}
impl<'a> From<(&'a [u8], &'a str)> for AttachmentType<'a> {
fn from(params: (&'a [u8], &'a str)) -> AttachmentType { AttachmentType::Bytes(params) }
}
impl<'a> From<&'a str> for AttachmentType<'a> {
fn from(s: &'a str) -> AttachmentType { AttachmentType::Path(Path::new(s)) }
}
impl<'a> From<&'a Path> for AttachmentType<'a> {
fn from(path: &'a Path) -> AttachmentType {
AttachmentType::Path(path)
}
}
impl<'a> From<&'a PathBuf> for AttachmentType<'a> {
fn from(pathbuf: &'a PathBuf) -> AttachmentType { AttachmentType::Path(pathbuf.as_path()) }
}
impl<'a> From<(&'a File, &'a str)> for AttachmentType<'a> {
fn from(f: (&'a File, &'a str)) -> AttachmentType<'a> { AttachmentType::File((f.0, f.1)) }
}
/// Representation of the method of a query to send for the [`get_guilds`]
/// function.
///
/// [`get_guilds`]: fn.get_guilds.html
pub enum GuildPagination {
/// The Id to get the guilds after.
After(GuildId),
/// The Id to get the guilds before.
Before(GuildId),
}
#[cfg(test)]
mod test {
use super::AttachmentType;
use std::path::Path;
#[test]
fn test_attachment_type() {
assert!(match AttachmentType::from(Path::new("./dogs/corgis/kona.png")) {
AttachmentType::Path(_) => true,
_ => false,
});
assert!(match AttachmentType::from("./cats/copycat.png") {
AttachmentType::Path(_) => true,
_ => false,
});
}
}
|