1use crate::FieldMap;
2use crate::p3::bindings::clocks::monotonic_clock::Duration;
3use crate::p3::bindings::http::types::{
4 ErrorCode, FieldName, FieldValue, Fields, HeaderError, Headers, Host, HostFields, HostRequest,
5 HostRequestOptions, HostRequestWithStore, HostResponse, HostResponseWithStore, Method, Request,
6 RequestOptions, RequestOptionsError, Response, Scheme, StatusCode, Trailers,
7};
8use crate::p3::body::Body;
9use crate::p3::{HeaderResult, HttpError, RequestOptionsResult};
10use crate::{WasiHttp, WasiHttpCtxView};
11use std::sync::Arc;
12use wasmtime::AsContextMut;
13use wasmtime::component::{Access, FutureReader, Resource, ResourceTable, StreamReader};
14use wasmtime::error::Context as _;
15
16fn get_fields<'a>(
17 table: &'a ResourceTable,
18 fields: &Resource<Fields>,
19) -> wasmtime::Result<&'a Fields> {
20 table
21 .get(&fields)
22 .context("failed to get fields from table")
23}
24
25fn get_fields_mut<'a>(
26 table: &'a mut ResourceTable,
27 fields: &Resource<Fields>,
28) -> HeaderResult<&'a mut Fields> {
29 table
30 .get_mut(&fields)
31 .context("failed to get fields from table")
32 .map_err(crate::p3::HeaderError::trap)
33}
34
35fn push_fields(table: &mut ResourceTable, fields: Fields) -> wasmtime::Result<Resource<Fields>> {
36 table.push(fields).context("failed to push fields to table")
37}
38
39fn delete_fields(table: &mut ResourceTable, fields: Resource<Fields>) -> wasmtime::Result<Fields> {
40 let mut fields = table
41 .delete(fields)
42 .context("failed to delete fields from table")?;
43 fields.set_immutable();
48 Ok(fields)
49}
50
51fn get_request<'a>(
52 table: &'a ResourceTable,
53 req: &Resource<Request>,
54) -> wasmtime::Result<&'a Request> {
55 table.get(req).context("failed to get request from table")
56}
57
58fn get_request_mut<'a>(
59 table: &'a mut ResourceTable,
60 req: &Resource<Request>,
61) -> wasmtime::Result<&'a mut Request> {
62 table
63 .get_mut(req)
64 .context("failed to get request from table")
65}
66
67fn get_response<'a>(
68 table: &'a ResourceTable,
69 res: &Resource<Response>,
70) -> wasmtime::Result<&'a Response> {
71 table.get(res).context("failed to get response from table")
72}
73
74fn get_response_mut<'a>(
75 table: &'a mut ResourceTable,
76 res: &Resource<Response>,
77) -> wasmtime::Result<&'a mut Response> {
78 table
79 .get_mut(res)
80 .context("failed to get response from table")
81}
82
83fn get_request_options<'a>(
84 table: &'a ResourceTable,
85 opts: &Resource<RequestOptions>,
86) -> wasmtime::Result<&'a RequestOptions> {
87 table
88 .get(opts)
89 .context("failed to get request options from table")
90}
91
92fn get_request_options_mut<'a>(
93 table: &'a mut ResourceTable,
94 opts: &Resource<RequestOptions>,
95) -> RequestOptionsResult<&'a mut RequestOptions> {
96 table
97 .get_mut(opts)
98 .context("failed to get request options from table")
99 .map_err(crate::p3::RequestOptionsError::trap)
100}
101
102fn push_request_options(
103 table: &mut ResourceTable,
104 opts: RequestOptions,
105) -> wasmtime::Result<Resource<RequestOptions>> {
106 table
107 .push(opts)
108 .context("failed to push request options to table")
109}
110
111fn delete_request_options(
112 table: &mut ResourceTable,
113 opts: Resource<RequestOptions>,
114) -> wasmtime::Result<RequestOptions> {
115 table
116 .delete(opts)
117 .context("failed to delete request options from table")
118}
119
120impl HostFields for WasiHttpCtxView<'_> {
121 fn new(&mut self) -> wasmtime::Result<Resource<Fields>> {
122 push_fields(self.table, FieldMap::new_mutable(self.ctx.field_size_limit))
123 }
124
125 fn from_list(
126 &mut self,
127 entries: Vec<(FieldName, FieldValue)>,
128 ) -> HeaderResult<Resource<Fields>> {
129 let mut fields = FieldMap::new_mutable(self.ctx.field_size_limit);
130 for (name, value) in entries {
131 fields.append(self.hooks, name, value)?;
132 }
133 let fields = push_fields(self.table, fields).map_err(crate::p3::HeaderError::trap)?;
134 Ok(fields)
135 }
136
137 fn get(
138 &mut self,
139 fields: Resource<Fields>,
140 name: FieldName,
141 ) -> wasmtime::Result<Vec<FieldValue>> {
142 let fields = get_fields(self.table, &fields)?;
143 Ok(fields
144 .get_all(name)
145 .into_iter()
146 .map(|val| val.as_bytes().into())
147 .collect())
148 }
149
150 fn has(&mut self, fields: Resource<Fields>, name: FieldName) -> wasmtime::Result<bool> {
151 let fields = get_fields(self.table, &fields)?;
152 Ok(fields.contains_key(name))
153 }
154
155 fn set(
156 &mut self,
157 fields: Resource<Fields>,
158 name: FieldName,
159 values: Vec<FieldValue>,
160 ) -> HeaderResult<()> {
161 get_fields_mut(self.table, &fields)?.set(self.hooks, name, values)?;
162 Ok(())
163 }
164
165 fn delete(&mut self, fields: Resource<Fields>, name: FieldName) -> HeaderResult<()> {
166 get_fields_mut(self.table, &fields)?.remove_all(self.hooks, name)?;
167 Ok(())
168 }
169
170 fn get_and_delete(
171 &mut self,
172 fields: Resource<Fields>,
173 name: FieldName,
174 ) -> HeaderResult<Vec<FieldValue>> {
175 let name = name.parse().or(Err(HeaderError::InvalidSyntax))?;
176 let values = get_fields_mut(self.table, &fields)?
177 .remove_all(self.hooks, name)?
178 .into_iter();
179 Ok(values.map(|value| value.as_bytes().into()).collect())
180 }
181
182 fn append(
183 &mut self,
184 fields: Resource<Fields>,
185 name: FieldName,
186 value: FieldValue,
187 ) -> HeaderResult<()> {
188 get_fields_mut(self.table, &fields)?.append(self.hooks, name, value)?;
189 Ok(())
190 }
191
192 fn copy_all(
193 &mut self,
194 fields: Resource<Fields>,
195 ) -> wasmtime::Result<Vec<(FieldName, FieldValue)>> {
196 let fields = get_fields(self.table, &fields)?;
197 let fields = fields
198 .iter()
199 .map(|(name, value)| (name.as_str().into(), value.as_bytes().into()))
200 .collect();
201 Ok(fields)
202 }
203
204 fn clone(&mut self, fields: Resource<Fields>) -> wasmtime::Result<Resource<Fields>> {
205 let mut fields = get_fields(self.table, &fields)?.clone();
206 fields.set_mutable(self.ctx.field_size_limit);
207 push_fields(self.table, fields)
208 }
209
210 fn drop(&mut self, fields: Resource<Fields>) -> wasmtime::Result<()> {
211 delete_fields(self.table, fields)?;
212 Ok(())
213 }
214}
215
216fn new_request<S>(
217 mut store: S,
218 mut getter: impl FnMut(&mut S::Data) -> WasiHttpCtxView<'_> + Copy + Send + 'static,
219 headers: Resource<Headers>,
220 contents: Option<StreamReader<u8>>,
221 trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
222 options: Option<Resource<RequestOptions>>,
223) -> wasmtime::Result<(Resource<Request>, FutureReader<Result<(), ErrorCode>>)>
224where
225 S: AsContextMut,
226{
227 let mut store = store.as_context_mut();
228 let (body, body_result) = Body::new_guest(&mut store, getter, contents, trailers)?;
229 let cx = getter(store.data_mut());
230 let headers = delete_fields(cx.table, headers)?;
231 let options = options
232 .map(|options| delete_request_options(cx.table, options))
233 .transpose()?;
234 let req = Request {
235 method: http::Method::GET,
236 scheme: None,
237 authority: None,
238 path_with_query: None,
239 headers,
240 options: options.map(Into::into),
241 extensions: http::Extensions::new(),
242 body,
243 };
244 let req = cx
245 .table
246 .push(req)
247 .context("failed to push request to table")?;
248 Ok((req, body_result))
249}
250
251impl<T> HostRequestWithStore<T> for WasiHttp {
252 fn new(
253 store: Access<T, Self>,
254 headers: Resource<Headers>,
255 contents: Option<StreamReader<u8>>,
256 trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
257 options: Option<Resource<RequestOptions>>,
258 ) -> wasmtime::Result<(Resource<Request>, FutureReader<Result<(), ErrorCode>>)> {
259 let getter = store.getter();
260 new_request(store, getter, headers, contents, trailers, options)
261 }
262
263 fn consume_body(
264 mut store: Access<T, Self>,
265 req: Resource<Request>,
266 fut: FutureReader<Result<(), ErrorCode>>,
267 ) -> wasmtime::Result<(
268 StreamReader<u8>,
269 FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
270 )> {
271 let getter = store.getter();
272 let Request { body, .. } = store.get().table.delete(req)?;
273 body.consume(store, fut, getter)
274 }
275
276 fn drop(mut store: Access<'_, T, Self>, req: Resource<Request>) -> wasmtime::Result<()> {
277 let Request { body, .. } = store.get().table.delete(req)?;
278 body.drop(store)?;
279 Ok(())
280 }
281}
282
283impl HostRequest for WasiHttpCtxView<'_> {
284 fn get_method(&mut self, req: Resource<Request>) -> wasmtime::Result<Method> {
285 let Request { method, .. } = get_request(self.table, &req)?;
286 Ok(method.into())
287 }
288
289 fn set_method(
290 &mut self,
291 req: Resource<Request>,
292 method: Method,
293 ) -> wasmtime::Result<Result<(), ()>> {
294 let req = get_request_mut(self.table, &req)?;
295 let Ok(method) = method.try_into() else {
296 return Ok(Err(()));
297 };
298 req.method = method;
299 Ok(Ok(()))
300 }
301
302 fn get_path_with_query(&mut self, req: Resource<Request>) -> wasmtime::Result<Option<String>> {
303 let Request {
304 path_with_query, ..
305 } = get_request(self.table, &req)?;
306 Ok(path_with_query.as_ref().map(|pq| pq.as_str().into()))
307 }
308
309 fn set_path_with_query(
310 &mut self,
311 req: Resource<Request>,
312 path_with_query: Option<String>,
313 ) -> wasmtime::Result<Result<(), ()>> {
314 let req = get_request_mut(self.table, &req)?;
315
316 let Some(path_with_query) = path_with_query else {
317 req.path_with_query = None;
318 return Ok(Ok(()));
319 };
320 let Some(path_with_query) = crate::parse_path_with_query(&path_with_query) else {
321 return Ok(Err(()));
322 };
323 req.path_with_query = Some(path_with_query);
324 Ok(Ok(()))
325 }
326
327 fn get_scheme(&mut self, req: Resource<Request>) -> wasmtime::Result<Option<Scheme>> {
328 let Request { scheme, .. } = get_request(self.table, &req)?;
329 Ok(scheme.as_ref().map(Into::into))
330 }
331
332 fn set_scheme(
333 &mut self,
334 req: Resource<Request>,
335 scheme: Option<Scheme>,
336 ) -> wasmtime::Result<Result<(), ()>> {
337 let req = get_request_mut(self.table, &req)?;
338 let Some(scheme) = scheme else {
339 req.scheme = None;
340 return Ok(Ok(()));
341 };
342 let Ok(scheme) = scheme.try_into() else {
343 return Ok(Err(()));
344 };
345 req.scheme = Some(scheme);
346 Ok(Ok(()))
347 }
348
349 fn get_authority(&mut self, req: Resource<Request>) -> wasmtime::Result<Option<String>> {
350 let Request { authority, .. } = get_request(self.table, &req)?;
351 Ok(authority.as_ref().map(|auth| auth.as_str().into()))
352 }
353
354 fn set_authority(
355 &mut self,
356 req: Resource<Request>,
357 authority: Option<String>,
358 ) -> wasmtime::Result<Result<(), ()>> {
359 let req = get_request_mut(self.table, &req)?;
360 let Some(authority) = authority else {
361 req.authority = None;
362 return Ok(Ok(()));
363 };
364 let Ok(authority) = crate::parse_authority(authority) else {
365 return Ok(Err(()));
366 };
367 req.authority = Some(authority);
368 Ok(Ok(()))
369 }
370
371 fn get_options(
372 &mut self,
373 req: Resource<Request>,
374 ) -> wasmtime::Result<Option<Resource<RequestOptions>>> {
375 let Request { options, .. } = get_request(self.table, &req)?;
376 if let Some(options) = options {
377 let options = push_request_options(
378 self.table,
379 RequestOptions::new_immutable(Arc::clone(options)),
380 )?;
381 Ok(Some(options))
382 } else {
383 Ok(None)
384 }
385 }
386
387 fn get_headers(&mut self, req: Resource<Request>) -> wasmtime::Result<Resource<Headers>> {
388 let Request { headers, .. } = get_request(self.table, &req)?;
389 let mut headers = headers.clone();
391 headers.set_immutable();
392 push_fields(self.table, headers)
393 }
394}
395
396impl HostRequestOptions for WasiHttpCtxView<'_> {
397 fn new(&mut self) -> wasmtime::Result<Resource<RequestOptions>> {
398 push_request_options(self.table, RequestOptions::new_mutable_default())
399 }
400
401 fn get_connect_timeout(
402 &mut self,
403 opts: Resource<RequestOptions>,
404 ) -> wasmtime::Result<Option<Duration>> {
405 let opts = get_request_options(self.table, &opts)?;
406 let Some(connect_timeout) = opts.connect_timeout else {
407 return Ok(None);
408 };
409 let ns = connect_timeout.as_nanos();
410 let ns = Duration::try_from(ns)
411 .context("connect timeout duration nanoseconds do not fit in u64")?;
412 Ok(Some(ns))
413 }
414
415 fn set_connect_timeout(
416 &mut self,
417 opts: Resource<RequestOptions>,
418 duration: Option<Duration>,
419 ) -> RequestOptionsResult<()> {
420 let opts = get_request_options_mut(self.table, &opts)?;
421 let opts = opts.get_mut().ok_or(RequestOptionsError::Immutable)?;
422 opts.connect_timeout = duration.map(core::time::Duration::from_nanos);
423 Ok(())
424 }
425
426 fn get_first_byte_timeout(
427 &mut self,
428 opts: Resource<RequestOptions>,
429 ) -> wasmtime::Result<Option<Duration>> {
430 let opts = get_request_options(self.table, &opts)?;
431 let Some(first_byte_timeout) = opts.first_byte_timeout else {
432 return Ok(None);
433 };
434 let ns = first_byte_timeout.as_nanos();
435 let ns = Duration::try_from(ns)
436 .context("first byte timeout duration nanoseconds do not fit in u64")?;
437 Ok(Some(ns))
438 }
439
440 fn set_first_byte_timeout(
441 &mut self,
442 opts: Resource<RequestOptions>,
443 duration: Option<Duration>,
444 ) -> RequestOptionsResult<()> {
445 let opts = get_request_options_mut(self.table, &opts)?;
446 let opts = opts.get_mut().ok_or(RequestOptionsError::Immutable)?;
447 opts.first_byte_timeout = duration.map(core::time::Duration::from_nanos);
448 Ok(())
449 }
450
451 fn get_between_bytes_timeout(
452 &mut self,
453 opts: Resource<RequestOptions>,
454 ) -> wasmtime::Result<Option<Duration>> {
455 let opts = get_request_options(self.table, &opts)?;
456 let Some(between_bytes_timeout) = opts.between_bytes_timeout else {
457 return Ok(None);
458 };
459 let ns = between_bytes_timeout.as_nanos();
460 let ns = Duration::try_from(ns)
461 .context("between bytes timeout duration nanoseconds do not fit in u64")?;
462 Ok(Some(ns))
463 }
464
465 fn set_between_bytes_timeout(
466 &mut self,
467 opts: Resource<RequestOptions>,
468 duration: Option<Duration>,
469 ) -> RequestOptionsResult<()> {
470 let opts = get_request_options_mut(self.table, &opts)?;
471 let opts = opts.get_mut().ok_or(RequestOptionsError::Immutable)?;
472 opts.between_bytes_timeout = duration.map(core::time::Duration::from_nanos);
473 Ok(())
474 }
475
476 fn clone(
477 &mut self,
478 opts: Resource<RequestOptions>,
479 ) -> wasmtime::Result<Resource<RequestOptions>> {
480 let opts = get_request_options(self.table, &opts)?;
481 push_request_options(self.table, RequestOptions::new_mutable(Arc::clone(opts)))
482 }
483
484 fn drop(&mut self, opts: Resource<RequestOptions>) -> wasmtime::Result<()> {
485 delete_request_options(self.table, opts)?;
486 Ok(())
487 }
488}
489
490fn new_response<S>(
491 mut store: S,
492 mut getter: impl FnMut(&mut S::Data) -> WasiHttpCtxView<'_> + Copy + Send + 'static,
493 headers: Resource<Headers>,
494 contents: Option<StreamReader<u8>>,
495 trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
496) -> wasmtime::Result<(Resource<Response>, FutureReader<Result<(), ErrorCode>>)>
497where
498 S: AsContextMut,
499{
500 let mut store = store.as_context_mut();
501 let (body, body_result) = Body::new_guest(&mut store, getter, contents, trailers)?;
502 let cx = getter(store.data_mut());
503 let headers = delete_fields(cx.table, headers)?;
504 let res = Response {
505 status: http::StatusCode::OK,
506 headers,
507 extensions: http::Extensions::new(),
508 body,
509 };
510 let res = cx.table.push(res)?;
511 Ok((res, body_result))
512}
513
514impl<T> HostResponseWithStore<T> for WasiHttp {
515 fn new(
516 store: Access<T, Self>,
517 headers: Resource<Headers>,
518 contents: Option<StreamReader<u8>>,
519 trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
520 ) -> wasmtime::Result<(Resource<Response>, FutureReader<Result<(), ErrorCode>>)> {
521 let getter = store.getter();
522 new_response(store, getter, headers, contents, trailers)
523 }
524
525 fn consume_body(
526 mut store: Access<T, Self>,
527 res: Resource<Response>,
528 fut: FutureReader<Result<(), ErrorCode>>,
529 ) -> wasmtime::Result<(
530 StreamReader<u8>,
531 FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
532 )> {
533 let getter = store.getter();
534 let Response { body, .. } = store.get().table.delete(res)?;
535 body.consume(store, fut, getter)
536 }
537
538 fn drop(mut store: Access<'_, T, Self>, res: Resource<Response>) -> wasmtime::Result<()> {
539 let Response { body, .. } = store.get().table.delete(res)?;
540 body.drop(store)?;
541 Ok(())
542 }
543}
544
545impl HostResponse for WasiHttpCtxView<'_> {
546 fn get_status_code(&mut self, res: Resource<Response>) -> wasmtime::Result<StatusCode> {
547 let res = get_response(self.table, &res)?;
548 Ok(res.status.into())
549 }
550
551 fn set_status_code(
552 &mut self,
553 res: Resource<Response>,
554 status_code: StatusCode,
555 ) -> wasmtime::Result<Result<(), ()>> {
556 let res = get_response_mut(self.table, &res)?;
557 match http::StatusCode::from_u16(status_code) {
558 Ok(status) if matches!(status_code, 100..=599) => {
559 res.status = status;
560 Ok(Ok(()))
561 }
562 _ => Ok(Err(())),
563 }
564 }
565
566 fn get_headers(&mut self, res: Resource<Response>) -> wasmtime::Result<Resource<Headers>> {
567 let Response { headers, .. } = get_response(self.table, &res)?;
568 let mut headers = headers.clone();
570 headers.set_immutable();
571 push_fields(self.table, headers)
572 }
573}
574
575impl Host for WasiHttpCtxView<'_> {
576 fn convert_error_code(&mut self, error: HttpError) -> wasmtime::Result<ErrorCode> {
577 error.downcast()
578 }
579
580 fn convert_header_error(
581 &mut self,
582 error: crate::p3::HeaderError,
583 ) -> wasmtime::Result<HeaderError> {
584 error.downcast()
585 }
586
587 fn convert_request_options_error(
588 &mut self,
589 error: crate::p3::RequestOptionsError,
590 ) -> wasmtime::Result<RequestOptionsError> {
591 error.downcast()
592 }
593}
594
595mod named {
596 use crate::p3::bindings::clocks::monotonic_clock::Duration;
597 use crate::p3::bindings::http::types::{
598 ErrorCode, FieldName, FieldValue, Fields, HeaderError, Headers, Method, Request,
599 RequestOptions, RequestOptionsError, Response, Scheme, StatusCode, Trailers,
600 };
601 use crate::p3::bindings::named_imports::wasi::http::types;
602 use crate::p3::{HeaderResult, HttpError, RequestOptionsResult};
603 use crate::{WasiHttpNamed, WasiHttpNamedView};
604 use wasmtime::component::{Access, FutureReader, Resource, StreamReader};
605 use wasmtime_wasi::{NamedId, WasiCtxNamedView};
606
607 impl<T> types::Host for WasiCtxNamedView<'_, T>
608 where
609 T: WasiHttpNamedView,
610 {
611 fn convert_error_code(&mut self, error: HttpError) -> wasmtime::Result<ErrorCode> {
612 error.downcast()
613 }
614
615 fn convert_header_error(
616 &mut self,
617 error: crate::p3::HeaderError,
618 ) -> wasmtime::Result<HeaderError> {
619 error.downcast()
620 }
621
622 fn convert_request_options_error(
623 &mut self,
624 error: crate::p3::RequestOptionsError,
625 ) -> wasmtime::Result<RequestOptionsError> {
626 error.downcast()
627 }
628 }
629
630 impl<T> types::HostFields for WasiCtxNamedView<'_, T>
631 where
632 T: WasiHttpNamedView,
633 {
634 fn new(&mut self, id: NamedId) -> wasmtime::Result<Resource<Fields>> {
635 super::HostFields::new(&mut self.0.http(id))
636 }
637
638 fn from_list(
639 &mut self,
640 id: NamedId,
641 entries: Vec<(FieldName, FieldValue)>,
642 ) -> HeaderResult<Resource<Fields>> {
643 super::HostFields::from_list(&mut self.0.http(id), entries)
644 }
645
646 fn get(
647 &mut self,
648 id: NamedId,
649 fields: Resource<Fields>,
650 name: FieldName,
651 ) -> wasmtime::Result<Vec<FieldValue>> {
652 super::HostFields::get(&mut self.0.http(id), fields, name)
653 }
654
655 fn has(
656 &mut self,
657 id: NamedId,
658 fields: Resource<Fields>,
659 name: FieldName,
660 ) -> wasmtime::Result<bool> {
661 super::HostFields::has(&mut self.0.http(id), fields, name)
662 }
663
664 fn set(
665 &mut self,
666 id: NamedId,
667 fields: Resource<Fields>,
668 name: FieldName,
669 values: Vec<FieldValue>,
670 ) -> HeaderResult<()> {
671 super::HostFields::set(&mut self.0.http(id), fields, name, values)
672 }
673
674 fn delete(
675 &mut self,
676 id: NamedId,
677 fields: Resource<Fields>,
678 name: FieldName,
679 ) -> HeaderResult<()> {
680 super::HostFields::delete(&mut self.0.http(id), fields, name)
681 }
682
683 fn get_and_delete(
684 &mut self,
685 id: NamedId,
686 fields: Resource<Fields>,
687 name: FieldName,
688 ) -> HeaderResult<Vec<FieldValue>> {
689 super::HostFields::get_and_delete(&mut self.0.http(id), fields, name)
690 }
691
692 fn append(
693 &mut self,
694 id: NamedId,
695 fields: Resource<Fields>,
696 name: FieldName,
697 value: FieldValue,
698 ) -> HeaderResult<()> {
699 super::HostFields::append(&mut self.0.http(id), fields, name, value)
700 }
701
702 fn copy_all(
703 &mut self,
704 id: NamedId,
705 fields: Resource<Fields>,
706 ) -> wasmtime::Result<Vec<(FieldName, FieldValue)>> {
707 super::HostFields::copy_all(&mut self.0.http(id), fields)
708 }
709
710 fn clone(
711 &mut self,
712 id: NamedId,
713 fields: Resource<Fields>,
714 ) -> wasmtime::Result<Resource<Fields>> {
715 super::HostFields::clone(&mut self.0.http(id), fields)
716 }
717
718 fn drop(&mut self, id: NamedId, fields: Resource<Fields>) -> wasmtime::Result<()> {
719 super::HostFields::drop(&mut self.0.http(id), fields)
720 }
721 }
722
723 impl<T> types::HostRequest for WasiCtxNamedView<'_, T>
724 where
725 T: WasiHttpNamedView,
726 {
727 fn get_method(&mut self, id: NamedId, req: Resource<Request>) -> wasmtime::Result<Method> {
728 super::HostRequest::get_method(&mut self.0.http(id), req)
729 }
730
731 fn set_method(
732 &mut self,
733 id: NamedId,
734 req: Resource<Request>,
735 method: Method,
736 ) -> wasmtime::Result<Result<(), ()>> {
737 super::HostRequest::set_method(&mut self.0.http(id), req, method)
738 }
739
740 fn get_path_with_query(
741 &mut self,
742 id: NamedId,
743 req: Resource<Request>,
744 ) -> wasmtime::Result<Option<String>> {
745 super::HostRequest::get_path_with_query(&mut self.0.http(id), req)
746 }
747
748 fn set_path_with_query(
749 &mut self,
750 id: NamedId,
751 req: Resource<Request>,
752 path_with_query: Option<String>,
753 ) -> wasmtime::Result<Result<(), ()>> {
754 super::HostRequest::set_path_with_query(&mut self.0.http(id), req, path_with_query)
755 }
756
757 fn get_scheme(
758 &mut self,
759 id: NamedId,
760 req: Resource<Request>,
761 ) -> wasmtime::Result<Option<Scheme>> {
762 super::HostRequest::get_scheme(&mut self.0.http(id), req)
763 }
764
765 fn set_scheme(
766 &mut self,
767 id: NamedId,
768 req: Resource<Request>,
769 scheme: Option<Scheme>,
770 ) -> wasmtime::Result<Result<(), ()>> {
771 super::HostRequest::set_scheme(&mut self.0.http(id), req, scheme)
772 }
773
774 fn get_authority(
775 &mut self,
776 id: NamedId,
777 req: Resource<Request>,
778 ) -> wasmtime::Result<Option<String>> {
779 super::HostRequest::get_authority(&mut self.0.http(id), req)
780 }
781
782 fn set_authority(
783 &mut self,
784 id: NamedId,
785 req: Resource<Request>,
786 authority: Option<String>,
787 ) -> wasmtime::Result<Result<(), ()>> {
788 super::HostRequest::set_authority(&mut self.0.http(id), req, authority)
789 }
790
791 fn get_options(
792 &mut self,
793 id: NamedId,
794 req: Resource<Request>,
795 ) -> wasmtime::Result<Option<Resource<RequestOptions>>> {
796 super::HostRequest::get_options(&mut self.0.http(id), req)
797 }
798
799 fn get_headers(
800 &mut self,
801 id: NamedId,
802 req: Resource<Request>,
803 ) -> wasmtime::Result<Resource<Headers>> {
804 super::HostRequest::get_headers(&mut self.0.http(id), req)
805 }
806 }
807
808 impl<T> types::HostRequestOptions for WasiCtxNamedView<'_, T>
809 where
810 T: WasiHttpNamedView,
811 {
812 fn new(&mut self, id: NamedId) -> wasmtime::Result<Resource<RequestOptions>> {
813 super::HostRequestOptions::new(&mut self.0.http(id))
814 }
815
816 fn get_connect_timeout(
817 &mut self,
818 id: NamedId,
819 opts: Resource<RequestOptions>,
820 ) -> wasmtime::Result<Option<Duration>> {
821 super::HostRequestOptions::get_connect_timeout(&mut self.0.http(id), opts)
822 }
823
824 fn set_connect_timeout(
825 &mut self,
826 id: NamedId,
827 opts: Resource<RequestOptions>,
828 duration: Option<Duration>,
829 ) -> RequestOptionsResult<()> {
830 super::HostRequestOptions::set_connect_timeout(&mut self.0.http(id), opts, duration)
831 }
832
833 fn get_first_byte_timeout(
834 &mut self,
835 id: NamedId,
836 opts: Resource<RequestOptions>,
837 ) -> wasmtime::Result<Option<Duration>> {
838 super::HostRequestOptions::get_first_byte_timeout(&mut self.0.http(id), opts)
839 }
840
841 fn set_first_byte_timeout(
842 &mut self,
843 id: NamedId,
844 opts: Resource<RequestOptions>,
845 duration: Option<Duration>,
846 ) -> RequestOptionsResult<()> {
847 super::HostRequestOptions::set_first_byte_timeout(&mut self.0.http(id), opts, duration)
848 }
849
850 fn get_between_bytes_timeout(
851 &mut self,
852 id: NamedId,
853 opts: Resource<RequestOptions>,
854 ) -> wasmtime::Result<Option<Duration>> {
855 super::HostRequestOptions::get_between_bytes_timeout(&mut self.0.http(id), opts)
856 }
857
858 fn set_between_bytes_timeout(
859 &mut self,
860 id: NamedId,
861 opts: Resource<RequestOptions>,
862 duration: Option<Duration>,
863 ) -> RequestOptionsResult<()> {
864 super::HostRequestOptions::set_between_bytes_timeout(
865 &mut self.0.http(id),
866 opts,
867 duration,
868 )
869 }
870
871 fn clone(
872 &mut self,
873 id: NamedId,
874 opts: Resource<RequestOptions>,
875 ) -> wasmtime::Result<Resource<RequestOptions>> {
876 super::HostRequestOptions::clone(&mut self.0.http(id), opts)
877 }
878
879 fn drop(&mut self, id: NamedId, opts: Resource<RequestOptions>) -> wasmtime::Result<()> {
880 super::HostRequestOptions::drop(&mut self.0.http(id), opts)
881 }
882 }
883
884 impl<T> types::HostResponse for WasiCtxNamedView<'_, T>
885 where
886 T: WasiHttpNamedView,
887 {
888 fn get_status_code(
889 &mut self,
890 id: NamedId,
891 res: Resource<Response>,
892 ) -> wasmtime::Result<StatusCode> {
893 super::HostResponse::get_status_code(&mut self.0.http(id), res)
894 }
895
896 fn set_status_code(
897 &mut self,
898 id: NamedId,
899 res: Resource<Response>,
900 status_code: StatusCode,
901 ) -> wasmtime::Result<Result<(), ()>> {
902 super::HostResponse::set_status_code(&mut self.0.http(id), res, status_code)
903 }
904
905 fn get_headers(
906 &mut self,
907 id: NamedId,
908 res: Resource<Response>,
909 ) -> wasmtime::Result<Resource<Headers>> {
910 super::HostResponse::get_headers(&mut self.0.http(id), res)
911 }
912 }
913
914 impl<T, U> types::HostRequestWithStore<U> for WasiHttpNamed<T>
915 where
916 T: WasiHttpNamedView,
917 U: 'static,
918 {
919 fn new(
920 store: Access<U, Self>,
921 id: NamedId,
922 headers: Resource<Headers>,
923 contents: Option<StreamReader<u8>>,
924 trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
925 options: Option<Resource<RequestOptions>>,
926 ) -> wasmtime::Result<(Resource<Request>, FutureReader<Result<(), ErrorCode>>)> {
927 let getter = store.getter();
928 super::new_request(
929 store,
930 move |data| getter(data).0.http(id),
931 headers,
932 contents,
933 trailers,
934 options,
935 )
936 }
937
938 fn consume_body(
939 mut store: Access<U, Self>,
940 id: NamedId,
941 req: Resource<Request>,
942 fut: FutureReader<Result<(), ErrorCode>>,
943 ) -> wasmtime::Result<(
944 StreamReader<u8>,
945 FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
946 )> {
947 let getter = store.getter();
948 let Request { body, .. } = store.get().0.http(id).table.delete(req)?;
949 body.consume(store, fut, move |data: &mut U| getter(data).0.http(id))
950 }
951
952 fn drop(
953 mut store: Access<'_, U, Self>,
954 id: NamedId,
955 req: Resource<Request>,
956 ) -> wasmtime::Result<()> {
957 let Request { body, .. } = store.get().0.http(id).table.delete(req)?;
958 body.drop(store)?;
959 Ok(())
960 }
961 }
962
963 impl<T, U> types::HostResponseWithStore<U> for WasiHttpNamed<T>
964 where
965 T: WasiHttpNamedView,
966 U: 'static,
967 {
968 fn new(
969 store: Access<U, Self>,
970 id: NamedId,
971 headers: Resource<Headers>,
972 contents: Option<StreamReader<u8>>,
973 trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
974 ) -> wasmtime::Result<(Resource<Response>, FutureReader<Result<(), ErrorCode>>)> {
975 let getter = store.getter();
976 super::new_response(
977 store,
978 move |data| getter(data).0.http(id),
979 headers,
980 contents,
981 trailers,
982 )
983 }
984
985 fn consume_body(
986 mut store: Access<U, Self>,
987 id: NamedId,
988 res: Resource<Response>,
989 fut: FutureReader<Result<(), ErrorCode>>,
990 ) -> wasmtime::Result<(
991 StreamReader<u8>,
992 FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
993 )> {
994 let getter = store.getter();
995 let Response { body, .. } = store.get().0.http(id).table.delete(res)?;
996 body.consume(store, fut, move |data: &mut U| getter(data).0.http(id))
997 }
998
999 fn drop(
1000 mut store: Access<'_, U, Self>,
1001 id: NamedId,
1002 res: Resource<Response>,
1003 ) -> wasmtime::Result<()> {
1004 let Response { body, .. } = store.get().0.http(id).table.delete(res)?;
1005 body.drop(store)?;
1006 Ok(())
1007 }
1008 }
1009}