SCToolBox/app
1
0
Fork 0
mirror of https://ghfast.top/https://github.com/StarCitizenToolBox/app.git synced 2025-06-28 09:04:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

update RSHttp

Browse Source
This commit is contained in:
xkeyC
2024-02-07 19:32:36 +08:00
parent 7e1352c0be
commit 5fa62351f2
19 changed files with 1202 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
rust/Cargo.toml
View File

@ -13,6 +13,7 @@ tokio = { version = "1", features = ["full"] }
url = "2.5.0"
uuid = { version = "1.7.0", features = ["v4", "fast-rng", "macro-diagnostics"] }
async-std = "1.12.0"
hyper = { version = "0.14.28"}
once_cell = "1.19.0"
reqwest = { version = "0.11", features = ["rustls-tls-native-roots", "cookies", "gzip", "brotli", "deflate", "multipart", "trust-dns", "json"] }
serde_json = { version = "1.0.1", features = [] }
reqwest = { version = "0.11", features = ["rustls-tls-native-roots", "cookies", "gzip", "brotli", "deflate", "multipart", "trust-dns", "json","stream"] }
hickory-resolver = {version = "0.24.0", features = [ "dns-over-https-rustls","dns-over-rustls","native-certs"]}

66
rust/src/api/http_api.rs
View File

@ -1,40 +1,42 @@
use std::collections::HashMap;
use std::time::Duration;
use once_cell::sync::Lazy;
use reqwest;
use reqwest::header::{HeaderMap, HeaderValue};
use reqwest::RequestBuilder;
static HTTP_CLIENT: Lazy<reqwest::Client> = Lazy::new(|| {
let mut header_map = HeaderMap::new();
header_map.insert("User-Agent", HeaderValue::from_static("SCToolBox/2.10.x lib_rust_http"));
reqwest::Client::builder()
.use_rustls_tls()
.connect_timeout(Duration::from_secs(10))
.timeout(Duration::from_secs(10))
.default_headers(header_map).build().unwrap()
});
use hyper::Method;
use crate::http_package;
use crate::http_package::RustHttpResponse;
#[tokio::main]
pub async fn get_string(url: String, headers: Option<HashMap<String, String>>) -> String {
let mut req = _append_header(HTTP_CLIENT.get(url), headers);
req.send().await.unwrap().text().await.unwrap()
pub enum MyMethod {
Options,
Gets,
Post,
Put,
Delete,
Head,
Trace,
Connect,
Patch,
}
pub async fn post_json_string(url: String, headers: Option<HashMap<String, String>>, json_data: Option<String>) -> String {
let mut req = _append_header(HTTP_CLIENT.post(url), headers);
if json_data.is_some() {
req = req.body(json_data.unwrap()).header(reqwest::header::CONTENT_TYPE, "application/json");
}
req.send().await.unwrap().text().await.unwrap()
fn _my_method_to_hyper_method(m: MyMethod) -> Method {
return match m {
MyMethod::Options => { Method::OPTIONS }
MyMethod::Gets => { Method::GET }
MyMethod::Post => { Method::POST }
MyMethod::Put => { Method::PUT }
MyMethod::Delete => { Method::DELETE }
MyMethod::Head => { Method::HEAD }
MyMethod::Trace => { Method::TRACE }
MyMethod::Connect => { Method::CONNECT }
MyMethod::Patch => { Method::PATCH }
};
}
fn _append_header(mut req: RequestBuilder, headers: Option<HashMap<String, String>>) -> RequestBuilder {
if headers.is_some() {
for x in headers.unwrap() {
req = req.header(x.0, x.1);
}
}
req
pub fn set_default_header(headers: HashMap<String, String>) {
http_package::set_default_header(headers)
}
pub async fn fetch(method: MyMethod,
url: String,
headers: Option<HashMap<String, String>>,
input_data: Option<Vec<u8>>) -> RustHttpResponse {
http_package::fetch(_my_method_to_hyper_method(method), url, headers, input_data).await.unwrap()
}

15
rust/src/frb_generated.io.rs
View File

@ -4,6 +4,7 @@
// Section: imports
use super::*;
use crate::api::http_api::*;
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
use flutter_rust_bridge::for_generated::transform_result_dco;
use flutter_rust_bridge::{Handler, IntoIntoDart};
@ -11,3 +12,17 @@ use flutter_rust_bridge::{Handler, IntoIntoDart};
// Section: boilerplate
flutter_rust_bridge::frb_generated_boilerplate_io!();
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest :: Version>>::increment_strong_count(ptr as _);
}
#[no_mangle]
pub extern "C" fn frbgen_starcitizen_doctor_rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest :: Version>>::decrement_strong_count(ptr as _);
}

348
rust/src/frb_generated.rs
View File

@ -19,6 +19,7 @@
// Section: imports
use crate::api::http_api::*;
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
use flutter_rust_bridge::for_generated::transform_result_dco;
use flutter_rust_bridge::{Handler, IntoIntoDart};
@ -120,41 +121,7 @@ fn wire_start_download_impl(
},
)
}
fn wire_get_string_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
rust_vec_len_: i32,
data_len_: i32,
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::SseCodec, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "get_string",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let message = unsafe {
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
ptr_,
rust_vec_len_,
data_len_,
)
};
let mut deserializer =
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
let api_url = <String>::sse_decode(&mut deserializer);
let api_headers =
<Option<std::collections::HashMap<String, String>>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| {
transform_result_sse((move || {
Result::<_, ()>::Ok(crate::api::http_api::get_string(api_url, api_headers))
})())
}
},
)
}
fn wire_post_json_string_impl(
fn wire_fetch_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
rust_vec_len_: i32,
@ -162,7 +129,7 @@ fn wire_post_json_string_impl(
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "post_json_string",
debug_name: "fetch",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
@ -176,19 +143,21 @@ fn wire_post_json_string_impl(
};
let mut deserializer =
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
let api_method = <crate::api::http_api::MyMethod>::sse_decode(&mut deserializer);
let api_url = <String>::sse_decode(&mut deserializer);
let api_headers =
<Option<std::collections::HashMap<String, String>>>::sse_decode(&mut deserializer);
let api_json_data = <Option<String>>::sse_decode(&mut deserializer);
let api_input_data = <Option<Vec<u8>>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| async move {
transform_result_sse(
(move || async move {
Result::<_, ()>::Ok(
crate::api::http_api::post_json_string(
crate::api::http_api::fetch(
api_method,
api_url,
api_headers,
api_json_data,
api_input_data,
)
.await,
)
@ -199,9 +168,58 @@ fn wire_post_json_string_impl(
},
)
}
fn wire_set_default_header_impl(
port_: flutter_rust_bridge::for_generated::MessagePort,
ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
rust_vec_len_: i32,
data_len_: i32,
) {
FLUTTER_RUST_BRIDGE_HANDLER.wrap_normal::<flutter_rust_bridge::for_generated::SseCodec, _, _>(
flutter_rust_bridge::for_generated::TaskInfo {
debug_name: "set_default_header",
port: Some(port_),
mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
},
move || {
let message = unsafe {
flutter_rust_bridge::for_generated::Dart2RustMessageSse::from_wire(
ptr_,
rust_vec_len_,
data_len_,
)
};
let mut deserializer =
flutter_rust_bridge::for_generated::SseDeserializer::new(message);
let api_headers =
<std::collections::HashMap<String, String>>::sse_decode(&mut deserializer);
deserializer.end();
move |context| {
transform_result_sse((move || {
Result::<_, ()>::Ok(crate::api::http_api::set_default_header(api_headers))
})())
}
},
)
}
// Section: related_funcs
flutter_rust_bridge::frb_generated_moi_arc_impl_value!(
flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest::Version>
);
// Section: dart2rust
impl SseDecode for reqwest::Version {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut inner = <RustOpaqueMoi<
flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest::Version>,
>>::sse_decode(deserializer);
return inner.rust_auto_opaque_decode_owned();
}
}
impl SseDecode for std::collections::HashMap<String, String> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@ -210,6 +228,16 @@ impl SseDecode for std::collections::HashMap<String, String> {
}
}
impl SseDecode
for RustOpaqueMoi<flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest::Version>>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut inner = <usize>::sse_decode(deserializer);
return decode_rust_opaque_moi(inner);
}
}
impl SseDecode for String {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@ -297,6 +325,25 @@ impl SseDecode for crate::downloader::MyDownloaderStatus {
}
}
impl SseDecode for crate::api::http_api::MyMethod {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut inner = <i32>::sse_decode(deserializer);
return match inner {
0 => crate::api::http_api::MyMethod::Options,
1 => crate::api::http_api::MyMethod::Gets,
2 => crate::api::http_api::MyMethod::Post,
3 => crate::api::http_api::MyMethod::Put,
4 => crate::api::http_api::MyMethod::Delete,
5 => crate::api::http_api::MyMethod::Head,
6 => crate::api::http_api::MyMethod::Trace,
7 => crate::api::http_api::MyMethod::Connect,
8 => crate::api::http_api::MyMethod::Patch,
_ => unreachable!("Invalid variant for MyMethod: {}", inner),
};
}
}
impl SseDecode for crate::downloader::MyNetworkItemPendingType {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@ -324,11 +371,22 @@ impl SseDecode for Option<std::collections::HashMap<String, String>> {
}
}
impl SseDecode for Option<String> {
impl SseDecode for Option<u64> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<String>::sse_decode(deserializer));
return Some(<u64>::sse_decode(deserializer));
} else {
return None;
}
}
}
impl SseDecode for Option<Vec<u8>> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
if (<bool>::sse_decode(deserializer)) {
return Some(<Vec<u8>>::sse_decode(deserializer));
} else {
return None;
}
@ -344,6 +402,35 @@ impl SseDecode for (String, String) {
}
}
impl SseDecode for crate::http_package::RustHttpResponse {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
let mut var_statusCode = <u16>::sse_decode(deserializer);
let mut var_headers = <std::collections::HashMap<String, String>>::sse_decode(deserializer);
let mut var_url = <String>::sse_decode(deserializer);
let mut var_contentLength = <Option<u64>>::sse_decode(deserializer);
let mut var_version = <reqwest::Version>::sse_decode(deserializer);
let mut var_remoteAddr = <String>::sse_decode(deserializer);
let mut var_data = <Option<Vec<u8>>>::sse_decode(deserializer);
return crate::http_package::RustHttpResponse {
status_code: var_statusCode,
headers: var_headers,
url: var_url,
content_length: var_contentLength,
version: var_version,
remote_addr: var_remoteAddr,
data: var_data,
};
}
}
impl SseDecode for u16 {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
deserializer.cursor.read_u16::<NativeEndian>().unwrap()
}
}
impl SseDecode for u64 {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@ -363,6 +450,13 @@ impl SseDecode for () {
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {}
}
impl SseDecode for usize {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
deserializer.cursor.read_u64::<NativeEndian>().unwrap() as _
}
}
impl SseDecode for bool {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_decode(deserializer: &mut flutter_rust_bridge::for_generated::SseDeserializer) -> Self {
@ -381,8 +475,8 @@ fn pde_ffi_dispatcher_primary_impl(
match func_id {
2 => wire_cancel_download_impl(port, ptr, rust_vec_len, data_len),
1 => wire_start_download_impl(port, ptr, rust_vec_len, data_len),
3 => wire_get_string_impl(port, ptr, rust_vec_len, data_len),
4 => wire_post_json_string_impl(port, ptr, rust_vec_len, data_len),
4 => wire_fetch_impl(port, ptr, rust_vec_len, data_len),
3 => wire_set_default_header_impl(port, ptr, rust_vec_len, data_len),
_ => unreachable!(),
}
}
@ -401,6 +495,36 @@ fn pde_ffi_dispatcher_sync_impl(
// Section: rust2dart
pub struct Local_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion(
reqwest::Version,
);
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart
for Local_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion
{
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self.0)
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for Local_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion
{
}
impl
flutter_rust_bridge::IntoIntoDart<
Local_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion,
> for reqwest::Version
{
fn into_into_dart(
self,
) -> Local_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion
{
Local_Auto_Owned_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion(
self,
)
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::downloader::DownloadCallbackData {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
@ -453,6 +577,33 @@ impl flutter_rust_bridge::IntoIntoDart<crate::downloader::MyDownloaderStatus>
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::api::http_api::MyMethod {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self {
Self::Options => 0.into_dart(),
Self::Gets => 1.into_dart(),
Self::Post => 2.into_dart(),
Self::Put => 3.into_dart(),
Self::Delete => 4.into_dart(),
Self::Head => 5.into_dart(),
Self::Trace => 6.into_dart(),
Self::Connect => 7.into_dart(),
Self::Patch => 8.into_dart(),
}
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::api::http_api::MyMethod
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::api::http_api::MyMethod>
for crate::api::http_api::MyMethod
{
fn into_into_dart(self) -> crate::api::http_api::MyMethod {
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::downloader::MyNetworkItemPendingType {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
match self {
@ -474,6 +625,39 @@ impl flutter_rust_bridge::IntoIntoDart<crate::downloader::MyNetworkItemPendingTy
self
}
}
// Codec=Dco (DartCObject based), see doc to use other codecs
impl flutter_rust_bridge::IntoDart for crate::http_package::RustHttpResponse {
fn into_dart(self) -> flutter_rust_bridge::for_generated::DartAbi {
[
self.status_code.into_into_dart().into_dart(),
self.headers.into_into_dart().into_dart(),
self.url.into_into_dart().into_dart(),
self.content_length.into_into_dart().into_dart(),
self.version.into_into_dart().into_dart(),
self.remote_addr.into_into_dart().into_dart(),
self.data.into_into_dart().into_dart(),
]
.into_dart()
}
}
impl flutter_rust_bridge::for_generated::IntoDartExceptPrimitive
for crate::http_package::RustHttpResponse
{
}
impl flutter_rust_bridge::IntoIntoDart<crate::http_package::RustHttpResponse>
for crate::http_package::RustHttpResponse
{
fn into_into_dart(self) -> crate::http_package::RustHttpResponse {
self
}
}
impl SseEncode for reqwest::Version {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<RustOpaqueMoi<flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest :: Version>>>::sse_encode(flutter_rust_bridge::for_generated::rust_auto_opaque_encode::<_, MoiArc<_>>(self), serializer);
}
}
impl SseEncode for std::collections::HashMap<String, String> {
// Codec=Sse (Serialization based), see doc to use other codecs
@ -482,6 +666,17 @@ impl SseEncode for std::collections::HashMap<String, String> {
}
}
impl SseEncode
for RustOpaqueMoi<flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest::Version>>
{
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
let (ptr, size) = self.sse_encode_raw();
<usize>::sse_encode(ptr, serializer);
<i32>::sse_encode(size, serializer);
}
}
impl SseEncode for String {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
@ -552,6 +747,29 @@ impl SseEncode for crate::downloader::MyDownloaderStatus {
}
}
impl SseEncode for crate::api::http_api::MyMethod {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<i32>::sse_encode(
match self {
crate::api::http_api::MyMethod::Options => 0,
crate::api::http_api::MyMethod::Gets => 1,
crate::api::http_api::MyMethod::Post => 2,
crate::api::http_api::MyMethod::Put => 3,
crate::api::http_api::MyMethod::Delete => 4,
crate::api::http_api::MyMethod::Head => 5,
crate::api::http_api::MyMethod::Trace => 6,
crate::api::http_api::MyMethod::Connect => 7,
crate::api::http_api::MyMethod::Patch => 8,
_ => {
unimplemented!("");
}
},
serializer,
);
}
}
impl SseEncode for crate::downloader::MyNetworkItemPendingType {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
@ -580,12 +798,22 @@ impl SseEncode for Option<std::collections::HashMap<String, String>> {
}
}
impl SseEncode for Option<String> {
impl SseEncode for Option<u64> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<String>::sse_encode(value, serializer);
<u64>::sse_encode(value, serializer);
}
}
}
impl SseEncode for Option<Vec<u8>> {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<bool>::sse_encode(self.is_some(), serializer);
if let Some(value) = self {
<Vec<u8>>::sse_encode(value, serializer);
}
}
}
@ -598,6 +826,26 @@ impl SseEncode for (String, String) {
}
}
impl SseEncode for crate::http_package::RustHttpResponse {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
<u16>::sse_encode(self.status_code, serializer);
<std::collections::HashMap<String, String>>::sse_encode(self.headers, serializer);
<String>::sse_encode(self.url, serializer);
<Option<u64>>::sse_encode(self.content_length, serializer);
<reqwest::Version>::sse_encode(self.version, serializer);
<String>::sse_encode(self.remote_addr, serializer);
<Option<Vec<u8>>>::sse_encode(self.data, serializer);
}
}
impl SseEncode for u16 {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
serializer.cursor.write_u16::<NativeEndian>(self).unwrap();
}
}
impl SseEncode for u64 {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
@ -617,6 +865,16 @@ impl SseEncode for () {
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {}
}
impl SseEncode for usize {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {
serializer
.cursor
.write_u64::<NativeEndian>(self as _)
.unwrap();
}
}
impl SseEncode for bool {
// Codec=Sse (Serialization based), see doc to use other codecs
fn sse_encode(self, serializer: &mut flutter_rust_bridge::for_generated::SseSerializer) {

15
rust/src/frb_generated.web.rs
View File

@ -4,6 +4,7 @@
// Section: imports
use super::*;
use crate::api::http_api::*;
use flutter_rust_bridge::for_generated::byteorder::{NativeEndian, ReadBytesExt, WriteBytesExt};
use flutter_rust_bridge::for_generated::transform_result_dco;
use flutter_rust_bridge::for_generated::wasm_bindgen;
@ -13,3 +14,17 @@ use flutter_rust_bridge::{Handler, IntoIntoDart};
// Section: boilerplate
flutter_rust_bridge::frb_generated_boilerplate_web!();
#[wasm_bindgen]
pub fn rust_arc_increment_strong_count_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest :: Version>>::increment_strong_count(ptr as _);
}
#[wasm_bindgen]
pub fn rust_arc_decrement_strong_count_RustOpaque_flutter_rust_bridgefor_generatedrust_asyncRwLockreqwestVersion(
ptr: *const std::ffi::c_void,
) {
MoiArc::<flutter_rust_bridge::for_generated::rust_async::RwLock<reqwest :: Version>>::decrement_strong_count(ptr as _);
}

58
rust/src/http_package/dns.rs Normal file
View File

@ -0,0 +1,58 @@
use hickory_resolver::config::{NameServerConfigGroup, ResolverConfig, ResolverOpts};
use hickory_resolver::{lookup_ip::LookupIpIntoIter, TokioAsyncResolver};
use hyper::client::connect::dns::Name;
use once_cell::sync::OnceCell;
use reqwest::dns::{Addrs, Resolve, Resolving};
use std::io;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::sync::Arc;
/// Wrapper around an `AsyncResolver`, which implements the `Resolve` trait.
#[derive(Debug, Default, Clone)]
pub(crate) struct MyHickoryDnsResolver {
/// Since we might not have been called in the context of a
/// Tokio Runtime in initialization, so we must delay the actual
/// construction of the resolver.
state: Arc<OnceCell<TokioAsyncResolver>>,
}
struct SocketAddrs {
iter: LookupIpIntoIter,
}
impl Resolve for MyHickoryDnsResolver {
fn resolve(&self, name: Name) -> Resolving {
let resolver = self.clone();
Box::pin(async move {
let resolver = resolver.state.get_or_try_init(new_resolver)?;
let lookup = resolver.lookup_ip(name.as_str()).await?;
let addrs: Addrs = Box::new(SocketAddrs {
iter: lookup.into_iter(),
});
Ok(addrs)
})
}
}
impl Iterator for SocketAddrs {
type Item = SocketAddr;
fn next(&mut self) -> Option<Self::Item> {
self.iter.next().map(|ip_addr| SocketAddr::new(ip_addr, 0))
}
}
fn new_resolver() -> io::Result<TokioAsyncResolver> {
let ali_ips: &[IpAddr] = &[
IpAddr::V4(Ipv4Addr::new(223, 5, 5, 5)),
IpAddr::V4(Ipv4Addr::new(223, 6, 6, 6)),
IpAddr::V6("2400:3200::1".parse::<Ipv6Addr>().unwrap()),
IpAddr::V6("2400:3200:baba::1".parse::<Ipv6Addr>().unwrap()),
];
let group =
NameServerConfigGroup::from_ips_https(ali_ips, 443, "dns.alidns.com".to_string(), true);
let cfg = ResolverConfig::from_parts(None, vec![], group);
Ok(TokioAsyncResolver::tokio(cfg, ResolverOpts::default()))
}

109
rust/src/http_package/mod.rs Normal file
View File

@ -0,0 +1,109 @@
pub mod dns;
use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
use reqwest::{Method, RequestBuilder};
use std::collections::HashMap;
use std::str::FromStr;
use std::sync::{Arc, RwLock};
use std::time::Duration;
use flutter_rust_bridge::for_generated::lazy_static;
#[derive(Debug)]
pub struct RustHttpResponse {
pub status_code: u16,
pub headers: HashMap<String, String>,
pub url: String,
pub content_length: Option<u64>,
pub version: reqwest::Version,
pub remote_addr: String,
pub data: Option<Vec<u8>>,
}
lazy_static! {
static ref DEFAULT_HEADER: RwLock<HeaderMap> = RwLock::from(HeaderMap::new());
static ref HTTP_CLIENT: reqwest::Client = {
reqwest::Client::builder()
.use_rustls_tls()
.connect_timeout(Duration::from_secs(10))
.timeout(Duration::from_secs(10))
.dns_resolver(Arc::from(dns::MyHickoryDnsResolver::default()))
.build()
.unwrap()
};
}
pub fn set_default_header(headers: HashMap<String, String>) {
let mut dh = DEFAULT_HEADER.write().unwrap();
dh.clear();
for ele in headers {
dh.append(
HeaderName::from_str(ele.0.as_str()).unwrap(),
HeaderValue::from_str(ele.1.as_str()).unwrap(),
);
}
}
pub async fn fetch(
method: Method,
url: String,
headers: Option<HashMap<String, String>>,
input_data: Option<Vec<u8>>,
) -> reqwest::Result<RustHttpResponse> {
let mut req = _mix_header(HTTP_CLIENT.request(method, url), headers);
if input_data.is_some() {
req = req.body(input_data.unwrap());
}
let resp = req.send().await?;
let url = resp.url().to_string();
let status_code = resp.status().as_u16();
let resp_headers = _reade_resp_header(resp.headers());
let content_length = resp.content_length();
let version = resp.version();
let mut remote_addr = "".to_string();
if resp.remote_addr().is_some() {
remote_addr = resp.remote_addr().unwrap().to_string();
}
let mut data: Option<Vec<u8>> = None;
let bytes = resp.bytes().await;
if bytes.is_ok() {
data = Some(bytes.unwrap().to_vec());
}
let resp = RustHttpResponse {
status_code,
headers: resp_headers,
url,
content_length,
version,
remote_addr,
data,
};
Ok(resp)
}
fn _reade_resp_header(r_header: &HeaderMap) -> HashMap<String, String> {
let mut resp_headers = HashMap::new();
for ele in r_header {
resp_headers.insert(
ele.0.as_str().to_string(),
ele.1.to_str().unwrap().to_string(),
);
}
resp_headers
}
fn _mix_header(
mut req: RequestBuilder,
headers: Option<HashMap<String, String>>,
) -> RequestBuilder {
if headers.is_some() {
for x in headers.unwrap() {
req = req.header(x.0, x.1);
}
}
let dh = DEFAULT_HEADER.read().unwrap();
req = req.headers(dh.clone());
req
}

1
rust/src/lib.rs
View File

@ -1,3 +1,4 @@
mod frb_generated;
mod api;
mod downloader;
mod http_package;