Skip to main content

wasmtime_wasi_http/p3/host/
types.rs

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    // When fields are passed by ownership to the host that flags them as
44    // immutable within `wasi:http`, and this semantically means that putting
45    // fields in a request, then getting them back out, will return an immutable
46    // view of the headers rather than mutable for example.
47    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        // `get-headers` promises immutable headers; that includes requests built with `Request::new`.
390        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        // The response side makes the same promise as the request side.
569        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}