Merge pull request #37 from softprops/upgrade-wasmtime

upgrade wasmtime*  0.22 => 0.23

Author: softprops

Cargo.lock

@@ -28,8 +28,9 @@ structopt = "0.3"
 tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }
 tokio-rustls = "0.22"
 user-agent-parser = "0.2.7"
-wasmtime = "0.22"
-wasmtime-wasi = "0.22"
+wasmtime = "0.23"
+wasmtime-wasi = "0.23"
+wasi-cap-std-sync = "0.23"
 chrono = "0.4"
 toml = "0.5"
 serde_derive = "1.0" # why is this needed?

Cargo.toml

@@ -40,7 +40,7 @@ fn open(
                 addr, len, dict_out
             );
             let mut memory = memory!(caller);
-            let (_, buf) = match memory.read(addr, len) {
+            let (_, buf) = match memory.read_bytes(addr, len) {
                 Ok(result) => result,
                 _ => return Err(Trap::new("failed to read dictionary name")),
             };
@@ -84,14 +84,14 @@ fn get(
             {
                 Some(dict) => {
                     let mut memory = memory!(caller);
-                    let (_, buf) = match memory!(caller).read(key_addr, key_len) {
+                    let (_, buf) = match memory!(caller).read_bytes(key_addr, key_len) {
                         Ok(result) => result,
                         _ => return Err(Trap::new("failed to read dictionary name")),
                     };
                     let key = str::from_utf8(&buf).unwrap();
                     debug!("getting dictionary key {}", key);
                     match dict.get(key) {
-                        Some(value) => match memory.write(value_addr, &value.as_bytes()) {
+                        Some(value) => match memory.write_bytes(value_addr, &value.as_bytes()) {
                             Ok(written) => {
                                 memory.write_i32(nwritten, written as i32);
                             }

src/fastly_dictionary.rs

@@ -100,7 +100,7 @@ fn write(
             match handler.inner.borrow_mut().bodies.get_mut(handle as usize) {
                 Some(body) => {
                     let mut mem = memory!(caller);
-                    let (read, buf) = match mem.read(addr, size) {
+                    let (read, buf) = match mem.read_bytes(addr, size) {
                         Ok((num, buf)) => (num, buf),
                         _ => return Err(Trap::new("Failed to read body memory")),
                     };
@@ -139,7 +139,7 @@ fn read(
             {
                 Some(body) => {
                     let mut memory = memory!(caller);
-                    match memory.write(buf, body.as_ref()) {
+                    match memory.write_bytes(buf, body.as_ref()) {
                         Ok(written) => {
                             debug!("fastly_http_body::read write {} bytes", written);
                             memory.write_i32(nread_out, written as i32);

src/fastly_http_body.rs

@@ -212,7 +212,7 @@ fn original_header_names_get(
                 Some(hdr) => {
                     let mut bytes = hdr.as_bytes().to_vec();
                     bytes.push(0); // api requires a terminating \x00 byte
-                    let written = memory.write(buf, &bytes).unwrap();
+                    let written = memory.write_bytes(buf, &bytes).unwrap();
                     memory.write_i32(nwritten, written as i32);
                     memory.write_i32(
                         ending_cursor,
@@ -325,7 +325,7 @@ fn downstream_client_ip_addr(
                         IpAddr::V4(ip) => ip.octets().to_vec(),
                         IpAddr::V6(ip) => ip.octets().to_vec(),
                     };
-                    match memory.write(addr, &bytes) {
+                    match memory.write_bytes(addr, &bytes) {
                         Ok(written) => memory.write_i32(num_written, written as i32),
                         _ => return Err(Trap::new("failed to write ip address")),
                     }
@@ -371,7 +371,7 @@ fn method_get(
             match handler.inner.borrow().requests.get(handle as usize) {
                 Some(req) => {
                     debug!("fastly_http_req::method_get => {}", req.method);
-                    let written = match mem.write(addr, req.method.as_ref().as_bytes()) {
+                    let written = match mem.write_bytes(addr, req.method.as_ref().as_bytes()) {
                         Ok(num) => num,
                         _ => return Err(Trap::new("Failed to write request HTTP method bytes")),
                     };
@@ -392,7 +392,7 @@ fn method_set(
     Func::wrap(
         store,
         move |caller: Caller<'_>, handle: RequestHandle, addr: i32, size: i32| {
-            let (_, buf) = match memory!(caller).read(addr, size) {
+            let (_, buf) = match memory!(caller).read_bytes(addr, size) {
                 Ok(result) => result,
                 _ => return Err(Trap::new("failed to read body memory")),
             };
@@ -429,7 +429,7 @@ fn uri_get(
                 Some(request) => {
                     let uri = request.uri.to_string();
                     debug!("fastly_http_req::uri_get => {}", uri);
-                    let written = match mem.write(addr, uri.as_bytes()) {
+                    let written = match mem.write_bytes(addr, uri.as_bytes()) {
                         Ok(num) => num,
                         _ => return Err(Trap::new("failed to write method bytes")),
                     };
@@ -459,7 +459,7 @@ fn send(
               resp_body_handle_out: BodyHandle| {
             debug!("fastly_http_req::send req_handle={}, body_handle={} backend_addr={} backend_len={} resp_handle_out={} resp_body_handle_out={}", req_handle, body_handle, backend_addr, backend_len, resp_handle_out, resp_body_handle_out);
             let mut memory = memory!(caller);
-            let (_, buf) = match memory.read(backend_addr, backend_len) {
+            let (_, buf) = match memory.read_bytes(backend_addr, backend_len) {
                 Ok(result) => result,
                 _ => return Err(Trap::new("error reading backend name")),
             };
@@ -525,7 +525,7 @@ fn uri_set(
                 .get_mut(rhandle as usize)
             {
                 Some(req) => {
-                    let (_, buf) = match memory!(caller).read(addr, size) {
+                    let (_, buf) = match memory!(caller).read_bytes(addr, size) {
                         Ok(result) => result,
                         _ => return Err(Trap::new("failed to read request uri")),
                     };
@@ -605,7 +605,7 @@ fn header_names_get(
                         Some(hdr) => {
                             let mut bytes = hdr.as_bytes().to_vec();
                             bytes.push(0); // api requires a terminating \x00 byte
-                            let written = memory.write(addr, &bytes).unwrap();
+                            let written = memory.write_bytes(addr, &bytes).unwrap();
                             memory.write_i32(nwritten_out, written as i32);
                             memory.write_i32(
                                 ending_cursor_out,
@@ -649,7 +649,7 @@ fn header_values_get(
             match handler.inner.borrow_mut().requests.get_mut(handle as usize) {
                 Some(req) => {
                     let mut memory = memory!(caller);
-                    let (_, header) = match memory.read(name_addr, name_size) {
+                    let (_, header) = match memory.read_bytes(name_addr, name_size) {
                         Ok(result) => result,
                         _ => return Err(Trap::new("Failed to read header name")),
                     };
@@ -668,7 +668,7 @@ fn header_values_get(
                         Some(val) => {
                             let mut bytes = val.to_vec();
                             bytes.push(0); // api requires a terminating \x00 byte
-                            let written = memory.write(addr, &bytes).unwrap();
+                            let written = memory.write_bytes(addr, &bytes).unwrap();
                             memory.write_i32(nwritten_out, written as i32);
                             memory.write_i32(
                                 ending_cursor_out,
@@ -710,7 +710,7 @@ fn header_values_set(
             match handler.inner.borrow_mut().requests.get_mut(handle as usize) {
                 Some(req) => {
                     let mut memory = memory!(caller);
-                    let name = match memory.read(name_addr, name_size) {
+                    let name = match memory.read_bytes(name_addr, name_size) {
                         Ok((_, bytes)) => match HeaderName::from_bytes(&bytes) {
                             Ok(name) => name,
                             _ => {
@@ -723,7 +723,7 @@ fn header_values_set(
                         _ => return Err(Trap::new("failed to read header name")),
                     };
                     // values are \u{0} terminated so read 1 less byte
-                    let value = match memory.read(values_addr, values_size - 1) {
+                    let value = match memory.read_bytes(values_addr, values_size - 1) {
                         Ok((_, bytes)) => match HeaderValue::from_bytes(&bytes) {
                             Ok(value) => value,
                             _ => {

src/fastly_http_req.rs

@@ -167,7 +167,7 @@ fn header_names_get(
                         Some(hdr) => {
                             let mut bytes = hdr.as_bytes().to_vec();
                             bytes.push(0); // api requires a terminating \x00 byte
-                            let written = memory.write(addr, &bytes).unwrap();
+                            let written = memory.write_bytes(addr, &bytes).unwrap();
                             memory.write_i32(nwritten_out, written as i32);
                             memory.write_i32(
                                 ending_cursor_out,
@@ -218,7 +218,7 @@ fn header_values_get(
                 .get_mut(handle as usize)
             {
                 Some(resp) => {
-                    let name = match memory.read(name_addr, name_size) {
+                    let name = match memory.read_bytes(name_addr, name_size) {
                         Ok((_, bytes)) => HeaderName::from_bytes(&bytes).unwrap(),
                         _ => return Err(Trap::new("Failed to read header name")),
                     };
@@ -236,7 +236,7 @@ fn header_values_get(
                         Some(val) => {
                             let mut bytes = val.to_vec();
                             bytes.push(0); // api requires a terminating \x00 byte
-                            let written = memory.write(addr, &bytes).unwrap();
+                            let written = memory.write_bytes(addr, &bytes).unwrap();
                             memory.write_i32(nwritten_out, written as i32);
                             memory.write_i32(
                                 ending_cursor_out,
@@ -284,7 +284,7 @@ fn header_values_set(
                 .get_mut(handle as usize)
             {
                 Some(resp) => {
-                    let name = match memory.read(name_addr, name_size) {
+                    let name = match memory.read_bytes(name_addr, name_size) {
                         Ok((_, bytes)) => match HeaderName::from_bytes(&bytes) {
                             Ok(name) => name,
                             _ => {
@@ -297,7 +297,7 @@ fn header_values_set(
                         _ => return Err(Trap::new("Failed to read header name")),
                     };
                     // values are \u{0} terminated so read one less byte
-                    let value = match memory.read(values_addr, values_size - 1) {
+                    let value = match memory.read_bytes(values_addr, values_size - 1) {
                         Ok((_, bytes)) => match HeaderValue::from_bytes(&bytes) {
                             Ok(value) => value,
                             _ => {

src/fastly_http_resp.rs

@@ -37,7 +37,7 @@ fn endpoint_get(
                 name, name_len, endpoint_handle_out
             );
             let mut memory = memory!(caller);
-            let endpoint = match memory.read(name, name_len) {
+            let endpoint = match memory.read_bytes(name, name_len) {
                 Ok((_, bytes)) => match str::from_utf8(&bytes) {
                     Ok(name) => name.to_owned(),
                     _ => return Err(Trap::new("Invalid endpoint name")),
@@ -80,7 +80,7 @@ fn write(
             {
                 Some(endpoint) => {
                     let mut memory = memory!(caller);
-                    let message = match memory.read(msg, msg_len) {
+                    let message = match memory.read_bytes(msg, msg_len) {
                         Ok((_, bytes)) => match str::from_utf8(&bytes) {
                             Ok(data) => data.to_owned(),
                             _ => return Err(Trap::new("Invalid endpoint name")),

src/fastly_log.rs

@@ -40,7 +40,7 @@ fn parse(store: &Store) -> Func {
          patch_written: i32| {
             debug!("fastly_uap::parse");
             let mut memory = memory!(caller);
-            match memory.read(user_agent, user_agent_max_len) {
+            match memory.read_bytes(user_agent, user_agent_max_len) {
                 Ok((_, bytes)) => match str::from_utf8(&bytes) {
                     Ok(a) => {
                         let Product {
@@ -50,25 +50,25 @@ fn parse(store: &Store) -> Func {
                             patch,
                         } = UAP.parse_product(a);
                         if let Some(fam) = name {
-                            match memory.write(family_pos, fam.as_bytes()) {
+                            match memory.write_bytes(family_pos, fam.as_bytes()) {
                                 Ok(bytes) => memory.write_i32(family_written, bytes as i32),
                                 _ => return Err(Trap::i32_exit(FastlyStatus::ERROR.code)),
                             }
                         }
                         if let Some(maj) = major {
-                            match memory.write(major_pos, maj.as_bytes()) {
+                            match memory.write_bytes(major_pos, maj.as_bytes()) {
                                 Ok(bytes) => memory.write_i32(major_written, bytes as i32),
                                 _ => return Err(Trap::i32_exit(FastlyStatus::ERROR.code)),
                             }
                         }
                         if let Some(min) = minor {
-                            match memory.write(minor_pos, min.as_bytes()) {
+                            match memory.write_bytes(minor_pos, min.as_bytes()) {
                                 Ok(bytes) => memory.write_i32(minor_written, bytes as i32),
                                 _ => return Err(Trap::i32_exit(FastlyStatus::ERROR.code)),
                             }
                         }
                         if let Some(pat) = patch {
-                            match memory.write(patch_pos, pat.as_bytes()) {
+                            match memory.write_bytes(patch_pos, pat.as_bytes()) {
                                 Ok(bytes) => memory.write_i32(patch_written, bytes as i32),
                                 _ => return Err(Trap::i32_exit(FastlyStatus::ERROR.code)),
                             }

src/fastly_uap.rs

@@ -7,8 +7,9 @@ use http::{request::Parts as RequestParts, response::Parts as ResponseParts};
 use hyper::{Body, Request, Response};
 use log::debug;
 use std::{cell::RefCell, collections::HashMap, net::IpAddr, rc::Rc};
+use wasi_cap_std_sync::WasiCtxBuilder;
 use wasmtime::{Linker, Module, Store, Trap};
-use wasmtime_wasi::{Wasi, WasiCtxBuilder};
+use wasmtime_wasi::Wasi;
 
 #[derive(Debug, Default)]
 pub struct Endpoint(pub String);

src/handler.rs

@@ -33,7 +33,7 @@ pub trait WriteMem {
         value: u32,
     );
 
-    fn write(
+    fn write_bytes(
         &mut self,
         index: i32,
         bytes: &[u8],
@@ -63,7 +63,7 @@ impl WriteMem for Memory {
         )
     }
 
-    fn write(
+    fn write_bytes(
         &mut self,
         index: i32,
         bytes: &[u8],
@@ -74,15 +74,15 @@ impl WriteMem for Memory {
 
 /// Convience api for common read operations
 pub trait ReadMem {
-    fn read(
+    fn read_bytes(
         &mut self,
         index: i32,
         amount: i32,
     ) -> io::Result<(usize, Vec<u8>)>;
 }
 
 impl ReadMem for Memory {
-    fn read(
+    fn read_bytes(
         &mut self,
         index: i32,
         amount: i32,