dyer/component/request.rs
1//! This module contains structs related to HTTP requests, notably the Request type itself as well
2//! as a builder to create requests. Typically you’ll import the http::Request type rather than
3//! reaching into this module itself.
4//!
5use crate::component::client::Client;
6use crate::component::couple::Couple;
7#[cfg(feature = "proxy")]
8use crate::component::proxy::Proxy;
9use crate::task::InnerTask;
10use crate::task::MetaTask;
11use crate::{
12 component::{body::Body, info::Info},
13 plugin::deser::*,
14};
15use http::{
16 header::{HeaderMap, HeaderName, HeaderValue},
17 Extensions, Method, Uri, Version,
18};
19use serde::{Deserialize, Serialize};
20use std::{convert::TryFrom, fmt, io};
21
22/// An Wrapper of [http::Request]
23///
24/// An HTTP request consists of a head and a potentially optional body. The body component is
25/// generic, enabling arbitrary types to represent the HTTP body. For example, the body could be
26/// Vec<u8>, a Stream of byte chunks, or a value that has been deserialized.
27/// Generally, `Affix` and `Task` roughly add up to a `Request`,
28#[derive(Serialize, Default, fmt::Debug, Deserialize)]
29pub struct Request {
30 pub inner: InnerRequest,
31 pub body: Body,
32 pub metar: MetaRequest,
33 #[cfg(feature = "proxy")]
34 proxy: Option<Proxy>,
35}
36
37/// An Wrapper of [http::request::Parts]
38///
39/// Component parts of an HTTP `Request`
40///
41/// The HTTP request head consists of a method, uri, version, and a set of
42/// header fields.
43#[derive(Deserialize, Default, fmt::Debug, Serialize)]
44pub struct InnerRequest {
45 #[serde(with = "serde_uri")]
46 pub uri: Uri,
47 /// request's vesoin
48 #[serde(with = "serde_version")]
49 pub version: Version,
50 #[serde(with = "serde_method")]
51 pub method: Method,
52 /// additional headers if necessary
53 #[serde(with = "serde_headermap")]
54 pub headers: HeaderMap<HeaderValue>,
55 /// additional arguments for extensive application
56 #[serde(skip)]
57 pub extensions: Exts,
58}
59
60/// An Wrapper of [http::Extensions]
61///
62/// A type map of protocol extensions.
63///
64/// Extensions` can be used by `Request` and `Response` to store
65/// extra data derived from the underlying protocol.
66#[derive(fmt::Debug, Default)]
67pub struct Exts(
68 pub Extensions,
69 pub Extensions,
70 pub Extensions,
71 pub Extensions,
72);
73
74impl Exts {
75 pub fn as_mut(&mut self, index: usize) -> &mut Extensions {
76 match index {
77 0 | 1 => unreachable!("cannot mutate the extension data for Safety!"),
78 2 => &mut self.2,
79 3 => &mut self.3,
80 _ => unreachable!("out of range, no more than 3"),
81 }
82 }
83
84 pub fn as_ref(&self, index: usize) -> &Extensions {
85 match index {
86 0 => &self.0,
87 1 => &self.1,
88 2 => &self.2,
89 3 => &self.3,
90 _ => unreachable!("out of range, no more than 3"),
91 }
92 }
93}
94
95/// Meta Data of the Request
96///
97/// `MetaRequest` can be used to carry infomation about the worlflow and beyond
98#[derive(Deserialize, Serialize)]
99pub struct MetaRequest {
100 /// identifier of the entity
101 pub info: Info,
102 /// parsing the `Response` when it's done
103 #[serde(serialize_with = "serde_fn::serfn")]
104 #[serde(deserialize_with = "serde_fn::defn")]
105 pub(crate) parser: *const (),
106 /// parsing the `Response` when it failed
107 #[serde(serialize_with = "serde_fn::serfn_op")]
108 #[serde(deserialize_with = "serde_fn::defn_op")]
109 pub(crate) err_parser: Option<*const ()>,
110 /// convert the `Body`s from `Task` and `Affix` to make a new `Body`
111 #[serde(serialize_with = "serde_fn::serfn_op")]
112 #[serde(deserialize_with = "serde_fn::defn_op")]
113 pub body_fn: Option<*const ()>,
114 /// additional arguments for extensive application
115 #[serde(skip)]
116 pub exts: Exts,
117}
118
119// Safety: since *const () is a static function pointer(a usize that indicating hardware address)
120// which is `Copy` so it owns the data, and no one else has it, the data can be safely transfered
121// to another thread
122unsafe impl Send for MetaRequest {}
123unsafe impl Sync for MetaRequest {}
124
125impl From<MetaTask> for MetaRequest {
126 fn from(mut m: MetaTask) -> Self {
127 m.info.used += 1;
128 Self {
129 info: m.info,
130 parser: m.parser,
131 err_parser: m.err_parser,
132 body_fn: None,
133 exts: Exts(
134 m.exts,
135 Extensions::new(),
136 Extensions::new(),
137 Extensions::new(),
138 ),
139 }
140 }
141}
142
143impl From<InnerTask> for InnerRequest {
144 fn from(task: InnerTask) -> Self {
145 Self {
146 uri: task.uri,
147 headers: task.headers,
148 method: task.method,
149 version: task.version,
150 extensions: Exts(
151 task.extensions,
152 Extensions::new(),
153 Extensions::new(),
154 Extensions::new(),
155 ),
156 }
157 }
158}
159
160impl Default for MetaRequest {
161 fn default() -> Self {
162 Self {
163 info: Info::default(),
164 parser: 0 as *const (),
165 body_fn: None,
166 err_parser: None,
167 exts: Exts::default(),
168 }
169 }
170}
171
172impl fmt::Debug for MetaRequest {
173 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
174 let mut parser = "Unknow";
175 let mut err_parser = None;
176 if let Some((n, _)) = serde_fn::query(None, Some(self.parser)) {
177 parser = n;
178 }
179 if self.err_parser.is_some() {
180 if let Some((n, _)) = serde_fn::query(None, self.err_parser) {
181 err_parser = Some(n);
182 }
183 }
184 f.debug_struct("MetaRequest")
185 .field("info", &self.info)
186 .field("parser", &parser)
187 .field("err_parser", &err_parser)
188 .field("exts", &self.exts)
189 .finish()
190 }
191}
192
193impl Request {
194 /// Create an instance of `RequestBuilder` that used to build a `Request`
195 ///
196 /// # Examples
197 ///
198 /// ```rust
199 /// # use dyer::request::*;
200 /// let request = Request::default();
201 /// .body(());
202 /// ```
203 pub fn builder() -> RequestBuilder {
204 RequestBuilder {
205 inner: InnerRequest::default(),
206 meta: MetaRequest::default(),
207 #[cfg(feature = "proxy")]
208 proxy: None,
209 }
210 }
211
212 // /// get shared reference to header of `RequestBuilder`
213 // ///
214 // /// # Examples
215 // ///
216 // /// ```rust
217 // /// # use dyer::request::*;
218 // /// let request = Request::default();
219 // /// assert!(request.task().is_none());
220 // /// ```
221 // pub fn task(&self) -> &Task {
222 // &self.inner.task
223 // }
224
225 // /// get mutable reference to header of `RequestBuilder`
226 // ///
227 // /// # Examples
228 // ///
229 // /// ```rust
230 // /// # use dyer::request::*;
231 // /// let request = Request::default();
232 // /// request.task_mut().unwrap().body = 3;
233 // /// assert_eq!(request.task().unwrap().body, 3);
234 // /// ```
235 // pub fn task_mut(&mut self) -> &mut Task {
236 // self.inner.task
237 // }
238
239 // /// get shared reference to affix of `RequestBuilder`
240 // ///
241 // /// # Examples
242 // ///
243 // /// ```rust
244 // /// # use dyer::request::*;
245 // /// let request = Request::default();
246 // /// assert!(request.affix().is_none());
247 // /// ```
248 // pub fn affix(&self) -> Option<&Affix> {
249 // if self.inner.affix.is_none() {
250 // return None;
251 // }
252 // self.inner.affix.as_ref()
253 // }
254
255 // /// get mutable reference to affix of `RequestBuilder`
256 // ///
257 // /// # Examples
258 // ///
259 // /// ```rust
260 // /// # use dyer::request::*;
261 // /// let request = Request::default();
262 // /// request.affix_mut().body = Some(3);
263 // /// assert_eq!(request.affix().body, Some(3));
264 // /// ```
265 // pub fn affix_mut(&mut self) -> Option<&mut Affix> {
266 // if self.inner.affix.is_none() {
267 // return None;
268 // }
269 // self.inner.affix.as_mut()
270 // }
271
272 /// get shared reference to body of `RequestBuilder`
273 ///
274 /// # Examples
275 ///
276 /// ```rust
277 /// # use dyer::request::*;
278 /// let request = Request::default();
279 /// assert!(request.body().is_none());
280 /// ```
281 pub fn body(&self) -> &Body {
282 &self.body
283 }
284
285 /// get mutable reference to body of `RequestBuilder`
286 ///
287 /// # Examples
288 ///
289 /// ```rust
290 /// # use dyer::request::*;
291 /// let request = Request::default();
292 /// request.body_mut() = 3;
293 /// assert!(request.body_mut().is_none());
294 /// ```
295 pub fn body_mut(&mut self) -> &mut Body {
296 &mut self.body
297 }
298
299 /// get shared reference to extensions of `RequestBuilder`
300 ///
301 /// # Examples
302 ///
303 /// ```rust
304 /// # use dyer::request::*;
305 /// # use http::*;
306 /// struct S {}
307 /// let request = Request::default();
308 /// .body(());
309 /// let s = S {};
310 /// request.extensions_mut.insert(s);
311 /// assert_eq!(request.extensions().get::<S>(), &s);
312 /// ```
313 pub fn extensions(&self) -> &Extensions {
314 &self.inner.extensions.2
315 }
316
317 /// get mutable reference to extensions of `RequestBuilder`
318 ///
319 /// # Examples
320 ///
321 /// ```rust
322 /// # use dyer::Request::*;
323 /// # use http::*;
324 /// let request = Request::default();
325 /// .body(());
326 /// request.extensions_mut().insert(vec![1,2,3]);
327 /// assert_eq!(request.extensions().get::<Vec<_>>(), &vec![1,2,3]);
328 /// ```
329 pub fn extensions_mut(&mut self) -> &mut Extensions {
330 &mut self.inner.extensions.2
331 }
332
333 /// get shared reference to exts of `RequestBuilder`
334 ///
335 /// # Examples
336 ///
337 /// ```rust
338 /// # use dyer::request::*;
339 /// # use http::*;
340 /// struct S {}
341 /// let request = Request::default();
342 /// .body(());
343 /// let s = S {};
344 /// request.exts_mut.insert(s);
345 /// assert_eq!(request.exts().get::<S>(), &s);
346 /// ```
347 pub fn exts(&self) -> &Extensions {
348 &self.metar.exts.2
349 }
350
351 /// get mutable reference to exts of `RequestBuilder`
352 ///
353 /// # Examples
354 ///
355 /// ```rust
356 /// # use dyer::Request::*;
357 /// # use http::*;
358 /// let request = Request::default();
359 /// .body(());
360 /// request.exts_mut().insert(vec![1,2,3]);
361 /// assert_eq!(request.exts().get::<Vec<_>>(), &vec![1,2,3]);
362 /// ```
363 pub fn exts_mut(&mut self) -> &mut Extensions {
364 &mut self.metar.exts.2
365 }
366
367 /// get shared reference to body_fn of `Request`
368 ///
369 /// # Examples
370 ///
371 /// ```rust
372 /// # use dyer::request::*;
373 /// # fn body_fn(t: T, p: P) -> Body { todo!() }
374 /// let reqeust = Request::default();
375 /// .body_fn(body_fn)
376 /// .body(());
377 /// assert_eq!(*reqeust.body_fn(), body_fn);
378 /// ```
379 pub fn body_fn(&self) -> Option<fn(Body) -> Body> {
380 if self.metar.body_fn.is_none() {
381 return None;
382 }
383 let f = unsafe {
384 std::mem::transmute::<*const (), fn(Body) -> Body>(self.metar.body_fn.unwrap())
385 };
386 Some(f)
387 }
388
389 /// set the body_fn of `Request`,
390 ///
391 /// # Examples
392 ///
393 /// ```rust
394 /// # use dyer::Request::*;
395 /// # use http::*;
396 /// # fn body_fn(_: Body) -> Body { todo!() }
397 /// let req = Request::default();
398 /// .as_mut()
399 /// .body_fn_mut(body_fn);
400 /// assert_eq!(*Request.body_fn(), body_fn);
401 /// ```
402 pub fn body_fn_mut(&mut self, body_fn: fn(Body) -> Body) {
403 let body_fn = body_fn as *const ();
404 self.metar.body_fn = Some(body_fn);
405 }
406
407 /// get shared reference to info of `Request`
408 ///
409 /// # Examples
410 ///
411 /// ```rust
412 /// # use dyer::request::*;
413 /// let request = request::default();
414 /// assert_eq!(request.info().used, 0);
415 /// ```
416 pub fn info(&self) -> &Info {
417 &self.metar.info
418 }
419
420 /// get mutable reference to info of `Request`
421 ///
422 /// # Examples
423 ///
424 /// ```rust
425 /// # use dyer::request::*;
426 /// let request = request::default();
427 /// request.info_mut().unique = false;
428 /// assert_eq!(*request.info_ref().unique, false);
429 /// ```
430 pub fn info_mut(&mut self) -> &mut Info {
431 &mut self.metar.info
432 }
433
434 /// Consume the request and obtain the body
435 ///
436 /// # Examples
437 ///
438 /// ```rust
439 /// # use dyer::request::*;
440 /// let request = request::default();
441 /// assert!(request.into_body().is_empty());
442 /// ```
443 pub fn into_body(self) -> Body {
444 self.body
445 }
446
447 /// Convert the body of the `request` with function
448 ///
449 /// # Examples
450 ///
451 /// ```rust
452 /// # use dyer::request::*;
453 /// let request = request::default();
454 /// let new= request.map(|v| v + 1 );
455 /// assert_eq!(new.body, vec![2,3,4]);
456 /// ```
457 pub fn map<F>(self, f: F) -> Request
458 where
459 F: FnOnce(Body) -> Body,
460 {
461 Request {
462 body: f(self.body),
463 metar: self.metar,
464 inner: self.inner,
465 #[cfg(feature = "proxy")]
466 proxy: self.proxy,
467 }
468 }
469
470 /// Create new `Request` directly with body, inner data (require feature `proxy` enabled)
471 ///
472 /// # Examples
473 ///
474 /// ```rust
475 /// # use dyer::request::*;
476 /// let request = request::default();
477 /// let ( mut inner, body, meta ) = request.into_parts();
478 /// let _ = request::from_parts(inner, body, meta);
479 /// ```
480 pub fn from_parts(
481 inner: InnerRequest,
482 body: Body,
483 metar: MetaRequest,
484 #[cfg(feature = "proxy")] proxy: Option<Proxy>,
485 ) -> Self {
486 Self {
487 inner,
488 body,
489 metar,
490 #[cfg(feature = "proxy")]
491 proxy,
492 }
493 }
494
495 /// split `request` into body, inner data, (require feature `proxy` enabled)
496 ///
497 /// # Examples
498 ///
499 /// ```rust
500 /// # use dyer::request::*;
501 /// let request = request::default();
502 /// let (_inner, _body, _meta ) = request.into_parts();
503 /// ```
504 #[cfg(feature = "proxy")]
505 pub fn into_parts(self) -> (InnerRequest, Body, MetaRequest, Option<Proxy>) {
506 (self.inner, self.body, self.metar, self.proxy)
507 }
508 #[cfg(not(feature = "proxy"))]
509 pub fn into_parts(self) -> (InnerRequest, Body, MetaRequest) {
510 (self.inner, self.body, self.metar)
511 }
512
513 /// Create new `Request` directly with Task and Affix(Optional)
514 ///
515 /// # Examples
516 ///
517 /// ```rust
518 /// # use dyer::request::*;
519 /// let request = request::default();
520 /// let ( mut inner, body, meta ) = request.into_parts();
521 /// let _ = request::from_parts(inner, body, meta);
522 /// ```
523 pub fn from_couple(
524 couple: &Couple,
525 f: Option<&Box<dyn for<'c, 'd> Fn(&'c Body, Option<&'d Body>) -> Body + Send>>,
526 exts_t_fn: Option<
527 &Box<
528 dyn for<'c, 'd> Fn(&'c Extensions, &'d Extensions) -> (Extensions, Extensions)
529 + Send,
530 >,
531 >,
532 exts_p_fn: Option<
533 &Box<
534 dyn for<'c, 'd> Fn(&'c Extensions, &'d Extensions) -> (Extensions, Extensions)
535 + Send,
536 >,
537 >,
538 ) -> Self {
539 match couple.affix {
540 Some(ref affix) => {
541 let item = Some(&affix.body);
542 let body = match f {
543 Some(ff) => ff(&couple.task.body, item),
544 None => Body::get_merged(&couple.task.body, item),
545 };
546 let (inner_t, exts_t) = match exts_t_fn {
547 None => (Extensions::new(), Extensions::new()),
548 Some(ff) => ff(&couple.task.inner.extensions, &couple.task.metat.exts),
549 };
550 let (inner_p, exts_p) = match exts_p_fn {
551 None => (Extensions::new(), Extensions::new()),
552 Some(ff) => ff(&affix.inner.extensions, &affix.metap.exts),
553 };
554 let mut headers = couple.task.inner.headers.clone();
555 couple
556 .affix
557 .as_ref()
558 .and_then(|item| {
559 headers.extend(item.inner.headers.clone());
560 Some(0)
561 })
562 .unwrap();
563 let inner = InnerRequest {
564 uri: couple.task.inner.uri.clone(),
565 method: couple.task.inner.method.clone(),
566 version: couple.task.inner.version.clone(),
567 headers,
568 extensions: Exts(inner_t, inner_p, Extensions::new(), Extensions::new()),
569 };
570 let mut info = couple.task.metat.info.clone();
571 info.able = f64::max(info.able, affix.metap.info.able);
572 info.id = couple.id;
573 let metar = MetaRequest {
574 info: info,
575 parser: couple.task.metat.parser.clone(),
576 err_parser: couple.task.metat.err_parser.clone(),
577 body_fn: None,
578 exts: Exts(exts_t, exts_p, Extensions::new(), Extensions::new()),
579 };
580 #[cfg(feature = "proxy")]
581 let proxy = match affix.proxy {
582 Some(ref prox) => Some(prox.clone()),
583 None => match couple.task.proxy {
584 Some(ref prx) => Some(prx.clone()),
585 None => None,
586 },
587 };
588 Self {
589 inner,
590 body,
591 metar,
592 #[cfg(feature = "proxy")]
593 proxy,
594 }
595 }
596
597 None => {
598 let body = match f {
599 // concat the body with the function
600 Some(ff) => ff(&couple.task.body, None),
601 // concat the body directly, the layout:
602 // - task body + affix body
603 None => Body::get_merged(&couple.task.body, None),
604 };
605 let (inner_t, exts_t) = match exts_t_fn {
606 None => (Extensions::new(), Extensions::new()),
607 Some(ff) => ff(&couple.task.inner.extensions, &couple.task.metat.exts),
608 };
609 let inner = InnerRequest {
610 uri: couple.task.inner.uri.clone(),
611 method: couple.task.inner.method.clone(),
612 version: couple.task.inner.version,
613 headers: couple.task.inner.headers.clone(),
614 extensions: Exts(
615 inner_t,
616 Extensions::new(),
617 Extensions::new(),
618 Extensions::new(),
619 ),
620 };
621 let mut info = couple.task.metat.info.clone();
622 info.id = couple.id;
623 let metar = MetaRequest {
624 info: info,
625 parser: couple.task.metat.parser,
626 err_parser: couple.task.metat.err_parser,
627 body_fn: None,
628 exts: Exts(
629 exts_t,
630 Extensions::new(),
631 Extensions::new(),
632 Extensions::new(),
633 ),
634 };
635 #[cfg(feature = "proxy")]
636 let proxy = match couple.task.proxy {
637 Some(ref prx) => Some(prx.clone()),
638 None => None,
639 };
640 Self {
641 inner,
642 body,
643 metar,
644 #[cfg(feature = "proxy")]
645 proxy,
646 }
647 }
648 }
649 }
650}
651
652impl Request {
653 #[cfg_attr(docsrs, doc(cfg(feature = "proxy")))]
654 /// get the unique client id that will execute the request
655 pub fn get_id(&self) -> u64 {
656 #[cfg(feature = "proxy")]
657 match self.proxy {
658 None => 0,
659 Some(ref prx) => crate::utils::hash(prx),
660 }
661 #[cfg(not(feature = "proxy"))]
662 0u64
663 }
664
665 #[cfg_attr(docsrs, doc(cfg(feature = "proxy")))]
666 /// get the client to execute the request
667 pub fn get_client(&mut self) -> &'static Client {
668 use crate::client::CLIENTPOOL;
669 let id = self.get_id();
670 unsafe {
671 match CLIENTPOOL.as_ref().and_then(|pool| pool.get(&id)) {
672 Some(ref downloader) => {
673 #[cfg(feature = "proxy")]
674 if let Some(ref prx) = self.proxy {
675 if let Some("http") = self.inner.uri.scheme_str() {
676 prx.auth
677 .as_ref()
678 .and_then(|au| Some(au.encode()))
679 .and_then(|token| {
680 let val = HeaderValue::from_str(&token).unwrap();
681 self.inner.headers.insert("Authorization", val.clone());
682 self.inner.headers.insert("Proxy-Authorization", val);
683 Some(())
684 });
685 }
686 }
687 downloader
688 }
689 None => {
690 #[cfg(feature = "proxy")]
691 match self.proxy {
692 None => {
693 // non proxy client
694 Client::new_plain()
695 }
696 Some(ref prx) => {
697 let client = prx.build();
698 if let Some("http") = self.inner.uri.scheme_str() {
699 prx.auth.as_ref().and_then(|au| Some(au.encode())).and_then(
700 |token| {
701 let val = HeaderValue::from_str(&token).unwrap();
702 self.inner.headers.insert("Authorization", val.clone());
703 self.inner.headers.insert("Proxy-Authorization", val);
704 Some(())
705 },
706 );
707 }
708 client
709 }
710 }
711 #[cfg(not(feature = "proxy"))]
712 Client::new_plain()
713 }
714 }
715 }
716 }
717}
718
719#[cfg(feature = "proxy")]
720#[test]
721fn test_get_client() {
722 use super::*;
723 use crate::component::client::CLIENTPOOL;
724 fn parse(_: Response) -> Parsed<()> {
725 todo!()
726 }
727
728 let task = Task::get("https://example.com")
729 .proxy("http://127.0.0.1:1088")
730 .parser(parse)
731 .body(Body::empty(), "marker")
732 .unwrap();
733 let cp = Couple::new(task, None);
734 let req = Request::from_couple(&cp, None, None, None);
735 let id = req.get_client().id;
736 unsafe {
737 assert_eq!(CLIENTPOOL.as_ref().unwrap().len(), 1);
738 }
739 let task = Task::get("https://example.com")
740 .parser(parse)
741 .body(Body::empty(), "marker")
742 .unwrap();
743 let cp = Couple::new(task, None);
744 let req2 = Request::from_couple(&cp, None, None, None);
745 let id2 = req2.get_client().id;
746 unsafe {
747 assert_eq!(CLIENTPOOL.as_ref().unwrap().len(), 2);
748 assert_eq!(id2, 0);
749 }
750 let task = Task::get("https://example.com")
751 .parser(parse)
752 .proxy("http://127.0.0.1:1088")
753 .body(Body::empty(), "marker")
754 .unwrap();
755 let cp = Couple::new(task, None);
756 let req3 = Request::from_couple(&cp, None, None, None);
757 let id3 = req3.get_client().id;
758 unsafe {
759 assert_eq!(CLIENTPOOL.as_ref().unwrap().len(), 2);
760 }
761 assert_eq!(id, id3);
762 assert!(id2 != id3);
763 let task = Task::get("https://example.com")
764 .parser(parse)
765 .proxy("http://127.0.0.1:1080")
766 .body(Body::empty(), "marker")
767 .unwrap();
768 let cp = Couple::new(task, None);
769 let req4 = Request::from_couple(&cp, None, None, None);
770 let _ = req4.get_client().id;
771 unsafe {
772 assert_eq!(CLIENTPOOL.as_ref().unwrap().len(), 3);
773 }
774}
775
776impl
777 Into<(
778 MetaRequest,
779 hyper::Request<hyper::Body>,
780 Extensions,
781 Extensions,
782 )> for Request
783{
784 /// transform a `Request` into `hyper::Request`
785 fn into(
786 self,
787 ) -> (
788 MetaRequest,
789 hyper::Request<hyper::Body>,
790 Extensions,
791 Extensions,
792 ) {
793 let (ext_t, ext_p) = (self.inner.extensions.0, self.inner.extensions.1);
794 let stream = futures_util::stream::iter(
795 self.body
796 .inner
797 .into_iter()
798 .map(|chunk| Ok::<_, io::Error>(chunk.inner())),
799 );
800 let mut r = hyper::Request::builder()
801 .uri(self.inner.uri)
802 .method(self.inner.method)
803 //.header(self.inner.headers)
804 .version(self.inner.version)
805 .extension(self.inner.extensions.2)
806 .body(hyper::body::Body::wrap_stream(stream))
807 .unwrap();
808 *r.headers_mut() = self.inner.headers;
809 (self.metar, r, ext_t, ext_p)
810 }
811}
812
813/// An Wrapper of [http::request::Builder]
814///
815/// An HTTP request builder
816///
817/// This type can be used to construct an instance or `Request`
818/// through a builder-like pattern.
819pub struct RequestBuilder {
820 inner: InnerRequest,
821 meta: MetaRequest,
822 #[cfg(feature = "proxy")]
823 proxy: Option<Proxy>,
824}
825
826impl RequestBuilder {
827 /// Create an instance of `RequestBuilder` that used to build a `Request`
828 /// Same as `Request::builder()`
829 ///
830 /// # Examples
831 ///
832 /// ```rust
833 /// # use dyer::request::*;
834 /// let request = RequestBuilder::new()
835 /// .body(());
836 /// ```
837 pub fn new() -> Self {
838 Self {
839 inner: InnerRequest::default(),
840 meta: MetaRequest::default(),
841 #[cfg(feature = "proxy")]
842 proxy: None,
843 }
844 }
845
846 /// set the uri of `request`, if not called, the default value is "/"
847 ///
848 /// # Examples
849 ///
850 /// ```rust
851 /// # use dyer::request::*;
852 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
853 /// let request = RequestBuilder::new()
854 /// .uri("https://example.com")
855 /// .parser(parser_fn)
856 /// .body(());
857 /// ```
858 pub fn uri<S>(mut self, uri: S) -> Self
859 where
860 Uri: TryFrom<S>,
861 <Uri as TryFrom<S>>::Error: Into<http::Error>,
862 {
863 self.inner.uri = TryFrom::try_from(uri)
864 .map_err(Into::into)
865 .expect("Set Uri Failed");
866 self
867 }
868
869 /// get shared reference to uri of `RequestBuilder`
870 /// Same as `request.uri(...)`
871 ///
872 /// # Examples
873 ///
874 /// ```rust
875 /// # use dyer::request::*;
876 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
877 /// let uri = "https://example.com";
878 /// let request = RequestBuilder::new()
879 /// .uri(uri)
880 /// .parser(parser_fn)
881 /// .body(());
882 /// assert_eq!(task.uri_ref(), uri);
883 /// ```
884 pub fn uri_ref(&self) -> &Uri {
885 &self.inner.uri
886 }
887
888 /// set the method of `Request`
889 ///
890 /// # Examples
891 ///
892 /// ```rust
893 /// # use dyer::request::*;
894 /// # use http::*;
895 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
896 /// let method = Method::POST;
897 /// let request = RequestBuilder::new()
898 /// .method(method)
899 /// .parser(parser_fn)
900 /// .body(());
901 /// assert_eq!(request.method_ref(), method);
902 /// ```
903 pub fn method<S>(mut self, method: S) -> Self
904 where
905 Method: TryFrom<S>,
906 <Method as TryFrom<S>>::Error: Into<http::Error>,
907 {
908 self.inner.method = TryFrom::try_from(method)
909 .map_err(Into::into)
910 .expect("Set Method Failed");
911 self
912 }
913
914 /// get shared reference to method of `RequestBuilder`
915 /// Same as `request.method(...)`
916 ///
917 /// # Examples
918 ///
919 /// ```rust
920 /// # use dyer::request::*;
921 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
922 /// let method = Method::POST;
923 /// let request = RequestBuilder::new()
924 /// .method(method)
925 /// .parser(parser_fn)
926 /// .body(());
927 /// assert_eq!(request.method_ref(), method);
928 /// ```
929 pub fn method_ref(&self) -> &Method {
930 &self.inner.method
931 }
932
933 /// get shared reference to header of `RequestBuilder`
934 /// Same as `Request::headers(...)`
935 ///
936 /// # Examples
937 ///
938 /// ```rust
939 /// # use dyer::request::*;
940 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
941 /// let request = RequestBuilder::new()
942 /// .header("accept", "*/*")
943 /// .parser(parser_fn)
944 /// .body(());
945 /// assert_eq!(task.header_ref()["accept"], "*/*");
946 /// ```
947 pub fn header_ref(&self) -> &HeaderMap<HeaderValue> {
948 &self.inner.headers
949 }
950
951 /// get mutable reference to header of `RequestBuilder`
952 ///
953 /// # Examples
954 ///
955 /// ```rust
956 /// # use dyer::request::*;
957 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
958 /// let request = RequestBuilder::new()
959 /// .header("accept", "*/*")
960 /// .parser(parser_fn)
961 /// .body(());
962 /// task.header_mut().insert("accept", "text/html");
963 /// assert_eq!(task.header_ref()["accept"], "text/html");
964 /// ```
965 pub fn header_mut(&mut self) -> &mut HeaderMap<HeaderValue> {
966 &mut self.inner.headers
967 }
968
969 /// set the headers of `Request`
970 ///
971 /// # Examples
972 ///
973 /// ```rust
974 /// # use dyer::request::*;
975 /// # use http::*;
976 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
977 /// let request = RequestBuilder::new()
978 /// .header("accept", "*/*")
979 /// .parser(parser_fn)
980 /// .body(());
981 /// assert_eq!(task.header_ref()["accept"], "*/*");
982 /// ```
983 pub fn header<K, V>(mut self, key: K, value: V) -> Self
984 where
985 HeaderName: TryFrom<K>,
986 <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
987 HeaderValue: TryFrom<V>,
988 <HeaderValue as TryFrom<V>>::Error: Into<http::Error>,
989 {
990 let k: HeaderName = TryFrom::try_from(key)
991 .map_err(Into::into)
992 .expect("Invalid Key When Setting Header");
993 let v: HeaderValue = TryFrom::try_from(value)
994 .map_err(Into::into)
995 .expect("Invalid Value When Setting Header");
996 self.inner.headers.append(k, v);
997 self
998 }
999
1000 /// set the version of `Request`
1001 ///
1002 /// # Examples
1003 ///
1004 /// ```rust
1005 /// # use dyer::request::*;
1006 /// # use http::*;
1007 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
1008 /// let request = RequestBuilder::new()
1009 /// .version(Version::HTTP_10)
1010 /// .parser(parser_fn)
1011 /// .body(());
1012 /// assert_eq!(task.version_ref(), Version::HTTP_10);
1013 /// ```
1014 pub fn version(mut self, version: Version) -> Self {
1015 self.inner.version = version;
1016 self
1017 }
1018
1019 /// get shared reference to version of `RequestBuilder`
1020 /// Same as `Request::version(...)`
1021 ///
1022 /// # Examples
1023 ///
1024 /// ```rust
1025 /// # use dyer::request::*;
1026 /// # use http::Version;
1027 /// # fn parser_fn(_: Response ) -> Parsed<E,> { todo!() }
1028 /// let version = Version::HTTP_10;
1029 /// let request = RequestBuilder::new()
1030 /// .version(version)
1031 /// .parser(parser_fn)
1032 /// .body(());
1033 /// assert_eq!(task.version_ref(), version);
1034 /// ```
1035 pub fn version_ref(&self) -> &Version {
1036 &self.inner.version
1037 }
1038
1039 /// Take this `RequestBuilder` and combine the body to create a `Request`
1040 ///
1041 /// # Examples
1042 ///
1043 /// ```rust
1044 /// # use dyer::request::*;
1045 /// let _ = RequestBuilder::new()
1046 /// .body(());
1047 /// ```
1048 pub fn body<'r, R>(self, body: Body) -> http::Result<Request> {
1049 Ok(Request {
1050 inner: self.inner,
1051 metar: self.meta,
1052 body,
1053 #[cfg(feature = "proxy")]
1054 proxy: self.proxy,
1055 })
1056 }
1057
1058 /// get shared reference to extensions of `RequestBuilder`
1059 /// Same as `Request::extensions(...)`
1060 ///
1061 /// # Examples
1062 ///
1063 /// ```rust
1064 /// # use dyer::request::*;
1065 /// # use http::*;
1066 /// struct S {}
1067 /// let request = RequestBuilder::new()
1068 /// .body(());
1069 /// let s = S {};
1070 /// request.extensions_mut.insert(s);
1071 /// assert_eq!(request.extensions_ref().get::<S>(), &s);
1072 /// ```
1073 pub fn extensions_ref(&self) -> &Extensions {
1074 &self.inner.extensions.2
1075 }
1076
1077 /// get mutable reference to extensions of `RequestBuilder`
1078 ///
1079 /// # Examples
1080 ///
1081 /// ```rust
1082 /// # use dyer::Request::*;
1083 /// # use http::*;
1084 /// let request = RequestBuilder::new()
1085 /// .body(());
1086 /// request.extensions_mut().insert(vec![1,2,3]);
1087 /// assert_eq!(request.extensions_ref().get::<Vec<_>>(), &vec![1,2,3]);
1088 /// ```
1089 pub fn extensions_mut(&mut self) -> &mut Extensions {
1090 &mut self.inner.extensions.2
1091 }
1092
1093 /// set the exts of `Request`
1094 ///
1095 /// # Examples
1096 ///
1097 /// ```rust
1098 /// # use dyer::Request::*;
1099 /// let Request = RequestBuilder::new()
1100 /// .extensions(vec![1,2,3])
1101 /// .body(());
1102 /// assert_eq!(Request.extensions_ref(), &vec![1,2,3]);
1103 /// ```
1104 pub fn extensions<S>(mut self, extensions: S) -> Self
1105 where
1106 S: std::any::Any + Send + Sync + 'static,
1107 {
1108 self.inner.extensions.2.insert(extensions);
1109 self
1110 }
1111
1112 /// get shared reference to exts of `RequestBuilder`
1113 /// Same as `Request::exts(...)`
1114 ///
1115 /// # Examples
1116 ///
1117 /// ```rust
1118 /// # use dyer::request::*;
1119 /// # use http::*;
1120 /// struct S {}
1121 /// let request = RequestBuilder::new()
1122 /// .body(());
1123 /// let s = S {};
1124 /// request.exts_mut.insert(s);
1125 /// assert_eq!(request.exts_ref().get::<S>(), &s);
1126 /// ```
1127 pub fn exts_ref(&self) -> &Extensions {
1128 &self.meta.exts.2
1129 }
1130
1131 /// get mutable reference to exts of `RequestBuilder`
1132 ///
1133 /// # Examples
1134 ///
1135 /// ```rust
1136 /// # use dyer::Request::*;
1137 /// # use http::*;
1138 /// let request = RequestBuilder::new()
1139 /// .body(());
1140 /// request.exts_mut().insert(vec![1,2,3]);
1141 /// assert_eq!(request.exts_ref().get::<Vec<_>>(), &vec![1,2,3]);
1142 /// ```
1143 pub fn exts_mut(&mut self) -> &mut Extensions {
1144 &mut self.meta.exts.2
1145 }
1146
1147 /// set the exts of `Request`
1148 ///
1149 /// # Examples
1150 ///
1151 /// ```rust
1152 /// # use dyer::Request::*;
1153 /// let Request = RequestBuilder::new()
1154 /// .exts(vec![1,2,3])
1155 /// .body(());
1156 /// assert_eq!(Request.exts_ref(), &vec![1,2,3]);
1157 /// ```
1158 pub fn exts<S>(mut self, exts: S) -> Self
1159 where
1160 S: std::any::Any + Send + Sync + 'static,
1161 {
1162 self.meta.exts.2.insert(exts);
1163 self
1164 }
1165
1166 /// set the body_fn of `Request`,
1167 ///
1168 /// # Examples
1169 ///
1170 /// ```rust
1171 /// # use dyer::Request::*;
1172 /// # use http::*;
1173 /// # fn body_fn(_: Body) -> Body { todo!() }
1174 /// let request = RequestBuilder::new()
1175 /// .body_fn(body_fn)
1176 /// .body(());
1177 /// assert_eq!(Request.body_fn_ref(), body_fn);
1178 /// ```
1179 pub fn body_fn(mut self, body_fn: fn(Body) -> Body) -> Self {
1180 let body_fn = body_fn as *const ();
1181 self.meta.body_fn = Some(body_fn);
1182 self
1183 }
1184
1185 /// get the the body_fn of `Request`,
1186 ///
1187 /// # Examples
1188 ///
1189 /// ```rust
1190 /// # use dyer::Request::*;
1191 /// # use http::*;
1192 /// # fn body_fn(_: Body) -> Body { todo!() }
1193 /// let request = RequestBuilder::new()
1194 /// .body_fn(body_fn)
1195 /// .body(());
1196 /// assert_eq!(Request.body_fn_ref(), body_fn);
1197 /// ```
1198 pub fn body_fn_ref(&self) -> fn(Body) -> Body {
1199 let ptr = self.meta.body_fn.unwrap();
1200 unsafe { std::mem::transmute::<*const (), fn(Body) -> Body>(ptr) }
1201 }
1202
1203 /// change the the body_fn of `Request`,
1204 ///
1205 /// # Examples
1206 ///
1207 /// ```rust
1208 /// # use dyer::Request::*;
1209 /// # use http::*;
1210 /// # fn body_fn(_: Body) -> Body { todo!() }
1211 /// let request = RequestBuilder::new()
1212 /// .body_fn(body_fn)
1213 /// .body(());
1214 /// assert_eq!(Request.body_fn_ref(), body_fn);
1215 /// ```
1216 pub fn body_fn_mut(&mut self, body_fn: fn(Body) -> Body) {
1217 let body_fn = body_fn as *const ();
1218 self.meta.body_fn = Some(body_fn);
1219 }
1220}