1use crate::session::Session;
2
3use super::fastly_http_cache::FastlyHttpCache;
4use super::{types, Error};
5
6use wiggle::{GuestMemory, GuestPtr};
7
8#[allow(unused_variables)]
9#[wiggle::async_trait]
10impl FastlyHttpCache for Session {
11 async fn lookup(
12 &mut self,
13 memory: &mut GuestMemory<'_>,
14 request: types::RequestHandle,
15 options_mask: types::HttpCacheLookupOptionsMask,
16 options: GuestPtr<types::HttpCacheLookupOptions>,
17 ) -> Result<types::HttpCacheHandle, Error> {
18 Err(Error::NotAvailable("HTTP Cache API primitives"))
19 }
20
21 async fn transaction_lookup(
22 &mut self,
23 memory: &mut GuestMemory<'_>,
24 request: types::RequestHandle,
25 options_mask: types::HttpCacheLookupOptionsMask,
26 options: GuestPtr<types::HttpCacheLookupOptions>,
27 ) -> Result<types::HttpCacheHandle, Error> {
28 Err(Error::NotAvailable("HTTP Cache API primitives"))
29 }
30
31 async fn transaction_insert(
32 &mut self,
33 memory: &mut GuestMemory<'_>,
34 cache_handle: types::HttpCacheHandle,
35 response_handle: types::ResponseHandle,
36 options_mask: types::HttpCacheWriteOptionsMask,
37 abi_options: GuestPtr<types::HttpCacheWriteOptions>,
38 ) -> Result<types::BodyHandle, Error> {
39 Err(Error::NotAvailable("HTTP Cache API primitives"))
40 }
41
42 async fn transaction_insert_and_stream_back(
43 &mut self,
44 memory: &mut GuestMemory<'_>,
45 cache_handle: types::HttpCacheHandle,
46 response_handle: types::ResponseHandle,
47 options_mask: types::HttpCacheWriteOptionsMask,
48 abi_options: GuestPtr<types::HttpCacheWriteOptions>,
49 ) -> Result<(types::BodyHandle, types::HttpCacheHandle), Error> {
50 Err(Error::NotAvailable("HTTP Cache API primitives"))
51 }
52
53 async fn transaction_update(
54 &mut self,
55 memory: &mut GuestMemory<'_>,
56 cache_handle: types::HttpCacheHandle,
57 response_handle: types::ResponseHandle,
58 options_mask: types::HttpCacheWriteOptionsMask,
59 abi_options: GuestPtr<types::HttpCacheWriteOptions>,
60 ) -> Result<(), Error> {
61 Err(Error::NotAvailable("HTTP Cache API primitives"))
62 }
63
64 async fn transaction_update_and_return_fresh(
65 &mut self,
66 memory: &mut GuestMemory<'_>,
67 cache_handle: types::HttpCacheHandle,
68 response_handle: types::ResponseHandle,
69 options_mask: types::HttpCacheWriteOptionsMask,
70 abi_options: GuestPtr<types::HttpCacheWriteOptions>,
71 ) -> Result<types::HttpCacheHandle, Error> {
72 Err(Error::NotAvailable("HTTP Cache API primitives"))
73 }
74
75 async fn transaction_record_not_cacheable(
76 &mut self,
77 memory: &mut GuestMemory<'_>,
78 cache_handle: types::HttpCacheHandle,
79 options_mask: types::HttpCacheWriteOptionsMask,
80 abi_options: GuestPtr<types::HttpCacheWriteOptions>,
81 ) -> Result<(), Error> {
82 Err(Error::NotAvailable("HTTP Cache API primitives"))
83 }
84
85 async fn transaction_abandon(
86 &mut self,
87 _memory: &mut GuestMemory<'_>,
88 cache_handle: types::HttpCacheHandle,
89 ) -> Result<(), Error> {
90 Err(Error::NotAvailable("HTTP Cache API primitives"))
91 }
92
93 async fn close(
94 &mut self,
95 _memory: &mut GuestMemory<'_>,
96 cache_handle: types::HttpCacheHandle,
97 ) -> Result<(), Error> {
98 Err(Error::NotAvailable("HTTP Cache API primitives"))
99 }
100
101 fn is_request_cacheable(
102 &mut self,
103 _memory: &mut GuestMemory<'_>,
104 request_handle: types::RequestHandle,
105 ) -> Result<u32, Error> {
106 Err(Error::NotAvailable("HTTP Cache API primitives"))
107 }
108
109 fn get_suggested_cache_key(
110 &mut self,
111 memory: &mut GuestMemory<'_>,
112 request_handle: types::RequestHandle,
113 key_out_ptr: GuestPtr<u8>,
114 key_out_len: u32,
115 nwritten_out: GuestPtr<u32>,
116 ) -> Result<(), Error> {
117 Err(Error::NotAvailable("HTTP Cache API primitives"))
118 }
119
120 async fn get_suggested_backend_request(
121 &mut self,
122 _memory: &mut GuestMemory<'_>,
123 cache_handle: types::HttpCacheHandle,
124 ) -> Result<types::RequestHandle, Error> {
125 Err(Error::NotAvailable("HTTP Cache API primitives"))
126 }
127
128 async fn get_suggested_cache_options(
129 &mut self,
130 memory: &mut GuestMemory<'_>,
131 cache_handle: types::HttpCacheHandle,
132 response_handle: types::ResponseHandle,
133 options_wanted: types::HttpCacheWriteOptionsMask,
134 pointers: GuestPtr<types::HttpCacheWriteOptions>,
135 pointer_mask_out: GuestPtr<types::HttpCacheWriteOptionsMask>,
136 options_out: GuestPtr<types::HttpCacheWriteOptions>,
137 ) -> Result<(), Error> {
138 Err(Error::NotAvailable("HTTP Cache API primitives"))
139 }
140
141 async fn prepare_response_for_storage(
142 &mut self,
143 _memory: &mut GuestMemory<'_>,
144 cache_handle: types::HttpCacheHandle,
145 response_handle: types::ResponseHandle,
146 ) -> Result<(types::HttpStorageAction, types::ResponseHandle), Error> {
147 Err(Error::NotAvailable("HTTP Cache API primitives"))
148 }
149
150 async fn get_found_response(
151 &mut self,
152 _memory: &mut GuestMemory<'_>,
153 cache_handle: types::HttpCacheHandle,
154 transform_for_client: u32,
155 ) -> Result<(types::ResponseHandle, types::BodyHandle), Error> {
156 Err(Error::NotAvailable("HTTP Cache API primitives"))
157 }
158
159 async fn get_state(
160 &mut self,
161 _memory: &mut GuestMemory<'_>,
162 cache_handle: types::HttpCacheHandle,
163 ) -> Result<types::CacheLookupState, Error> {
164 Err(Error::NotAvailable("HTTP Cache API primitives"))
165 }
166
167 async fn get_length(
168 &mut self,
169 _memory: &mut GuestMemory<'_>,
170 cache_handle: types::HttpCacheHandle,
171 ) -> Result<types::CacheObjectLength, Error> {
172 Err(Error::NotAvailable("HTTP Cache API primitives"))
173 }
174
175 async fn get_max_age_ns(
176 &mut self,
177 _memory: &mut GuestMemory<'_>,
178 cache_handle: types::HttpCacheHandle,
179 ) -> Result<types::CacheDurationNs, Error> {
180 Err(Error::NotAvailable("HTTP Cache API primitives"))
181 }
182
183 async fn get_stale_while_revalidate_ns(
184 &mut self,
185 _memory: &mut GuestMemory<'_>,
186 cache_handle: types::HttpCacheHandle,
187 ) -> Result<types::CacheDurationNs, Error> {
188 Err(Error::NotAvailable("HTTP Cache API primitives"))
189 }
190
191 async fn get_age_ns(
192 &mut self,
193 _memory: &mut GuestMemory<'_>,
194 cache_handle: types::HttpCacheHandle,
195 ) -> Result<types::CacheDurationNs, Error> {
196 Err(Error::NotAvailable("HTTP Cache API primitives"))
197 }
198
199 async fn get_hits(
200 &mut self,
201 _memory: &mut GuestMemory<'_>,
202 cache_handle: types::HttpCacheHandle,
203 ) -> Result<types::CacheHitCount, Error> {
204 Err(Error::NotAvailable("HTTP Cache API primitives"))
205 }
206
207 async fn get_sensitive_data(
208 &mut self,
209 _memory: &mut GuestMemory<'_>,
210 cache_handle: types::HttpCacheHandle,
211 ) -> Result<types::IsSensitive, Error> {
212 Err(Error::NotAvailable("HTTP Cache API primitives"))
213 }
214
215 async fn get_surrogate_keys(
216 &mut self,
217 memory: &mut GuestMemory<'_>,
218 cache_handle: types::HttpCacheHandle,
219 surrogate_keys_out_ptr: GuestPtr<u8>,
220 surrogate_keys_out_len: u32,
221 nwritten_out: GuestPtr<u32>,
222 ) -> Result<(), Error> {
223 Err(Error::NotAvailable("HTTP Cache API primitives"))
224 }
225
226 async fn get_vary_rule(
227 &mut self,
228 memory: &mut GuestMemory<'_>,
229 cache_handle: types::HttpCacheHandle,
230 vary_rule_out_ptr: GuestPtr<u8>,
231 vary_rule_out_len: u32,
232 nwritten_out: GuestPtr<u32>,
233 ) -> Result<(), Error> {
234 Err(Error::NotAvailable("HTTP Cache API primitives"))
235 }
236}