Import from Firecracker

Signed-off-by: Adrian Catangiu <[email protected]>

Author: acatangiu

Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "versionize_derive"
+version = "0.1.0"
+authors = ["Amazon Firecracker team <[email protected]>"]
+
+[dependencies]
+proc-macro2 = ">=1.0"
+quote = ">=1.0"
+syn = { version = ">=1.0.13", features=["full", "extra-traits"]}
+
+[lib]
+proc-macro = true
+
+[dev-dependencies]
+versionize = { git = "https://github.com/firecracker-microvm/versionize" }
+

src/common.rs

@@ -0,0 +1,67 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/// An interface for generating serialzer and deserializers based on
+/// field descriptions.
+pub trait Descriptor {
+    /// Returns the serializer code block as a token stream.
+    fn generate_serializer(&self) -> proc_macro2::TokenStream;
+    /// Returns the deserializer code block as a token stream.
+    fn generate_deserializer(&self) -> proc_macro2::TokenStream;
+    /// Returns the curent version.
+    fn version(&self) -> u16;
+    /// Returns the type name as string.
+    fn ty(&self) -> String;
+}
+
+/// Describes a structure and it's fields.
+pub(crate) struct GenericDescriptor<T> {
+    // The structure type identifier.
+    pub ty: syn::Ident,
+    pub version: u16,
+    pub fields: Vec<T>,
+}
+
+// A trait that defines an interface to check if a certain field
+// exists at a specified version.
+pub(crate) trait Exists {
+    fn exists_at(&self, version: u16) -> bool {
+        // All fields have a start version.
+        // Some field do not have an end version specified.
+        version >= self.start_version()
+            && (0 == self.end_version() || (self.end_version() > 0 && version < self.end_version()))
+    }
+
+    fn start_version(&self) -> u16;
+    fn end_version(&self) -> u16;
+}
+
+// A trait that defines an interface for exposing a field type.
+pub(crate) trait FieldType {
+    fn ty(&self) -> syn::Type;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Exists;
+
+    #[test]
+    fn test_exists_at() {
+        impl Exists for u32 {
+            fn start_version(&self) -> u16 {
+                3
+            }
+
+            fn end_version(&self) -> u16 {
+                5
+            }
+        }
+
+        let test = 1234;
+        assert!(!test.exists_at(2));
+        assert!(test.exists_at(3));
+        assert!(test.exists_at(4));
+        assert!(!test.exists_at(5));
+        assert!(!test.exists_at(6));
+    }
+}

src/descriptors/enum_desc.rs

@@ -0,0 +1,83 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use common::{Descriptor, GenericDescriptor};
+use fields::enum_variant::*;
+use helpers::compute_version;
+use quote::quote;
+
+pub(crate) type EnumDescriptor = GenericDescriptor<EnumVariant>;
+
+impl Descriptor for EnumDescriptor {
+    fn generate_serializer(&self) -> proc_macro2::TokenStream {
+        let mut versioned_serializers = proc_macro2::TokenStream::new();
+
+        for i in 1..=self.version {
+            let mut versioned_serializer = proc_macro2::TokenStream::new();
+
+            for field in &self.fields {
+                versioned_serializer.extend(field.generate_serializer(i));
+            }
+
+            // Generate the match arm for version `i` serializer.
+            versioned_serializers.extend(quote! {
+                #i => {
+                    match self {
+                        #versioned_serializer
+                    }
+                }
+            });
+        }
+
+        versioned_serializers
+    }
+
+    // Versioned/semantic deserialization is not implemented for enums.
+    fn generate_deserializer(&self) -> proc_macro2::TokenStream {
+        let mut versioned_deserializers = proc_macro2::TokenStream::new();
+
+        for field in &self.fields {
+            versioned_deserializers.extend(field.generate_deserializer());
+        }
+
+        quote! {
+            let variant_index = <u32 as Versionize>::deserialize(&mut reader, version_map, app_version)?;
+            match variant_index {
+                #versioned_deserializers
+                x => return Err(VersionizeError::Deserialize(format!("Unknown variant_index {}", x)))
+            }
+        }
+    }
+
+    fn version(&self) -> u16 {
+        self.version
+    }
+
+    fn ty(&self) -> String {
+        self.ty.to_string()
+    }
+}
+
+impl EnumDescriptor {
+    pub fn new(input: &syn::DataEnum, ident: syn::Ident) -> Self {
+        let mut descriptor = EnumDescriptor {
+            ty: ident,
+            version: 1,
+            fields: vec![],
+        };
+
+        descriptor.parse_enum_variants(&input.variants);
+        descriptor.version = compute_version(&descriptor.fields);
+        descriptor
+    }
+
+    fn parse_enum_variants(
+        &mut self,
+        variants: &syn::punctuated::Punctuated<syn::Variant, syn::token::Comma>,
+    ) {
+        for (index, variant) in variants.iter().enumerate() {
+            self.fields
+                .push(EnumVariant::new(self.version, variant, index as u32));
+        }
+    }
+}

src/descriptors/mod.rs

@@ -0,0 +1,6 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+pub mod enum_desc;
+pub mod struct_desc;
+pub mod union_desc;

src/descriptors/struct_desc.rs

@@ -0,0 +1,117 @@
+// Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use common::{Descriptor, GenericDescriptor};
+use fields::struct_field::*;
+use helpers::compute_version;
+use quote::{format_ident, quote};
+
+pub(crate) type StructDescriptor = GenericDescriptor<StructField>;
+
+impl Descriptor for StructDescriptor {
+    fn generate_serializer(&self) -> proc_macro2::TokenStream {
+        let mut versioned_serializers = proc_macro2::TokenStream::new();
+
+        for i in 1..=self.version {
+            let mut versioned_serializer = proc_macro2::TokenStream::new();
+            let mut semantic_serializer = proc_macro2::TokenStream::new();
+
+            // Generate field and semantic serializers for all fields.
+            // Not all fields have semantic serializers defined and some fields
+            // might be missing in version `i`. In these cases the generate_serializer() and
+            // generate_semantic_serializer() will return an empty token stream.
+            for field in &self.fields {
+                versioned_serializer.extend(field.generate_serializer(i));
+                semantic_serializer.extend(field.generate_semantic_serializer(i));
+            }
+
+            // Generate the match arm for version `i`.
+            versioned_serializers.extend(quote! {
+                #i => {
+                    #semantic_serializer
+                    #versioned_serializer
+                }
+            });
+        }
+
+        versioned_serializers
+    }
+
+    fn generate_deserializer(&self) -> proc_macro2::TokenStream {
+        let mut versioned_deserializers = proc_macro2::TokenStream::new();
+        let struct_ident = format_ident!("{}", self.ty);
+
+        for i in 1..=self.version {
+            let mut versioned_deserializer = proc_macro2::TokenStream::new();
+            let mut semantic_deserializer = proc_macro2::TokenStream::new();
+
+            // Generate field and semantic deserializers for all fields.
+            // Not all fields have semantic deserializers defined and some fields
+            // might be missing in version `i`. In these cases the generate_deserializer() and
+            // generate_semantic_deserializer() will return an empty token stream.
+            for field in &self.fields {
+                versioned_deserializer.extend(field.generate_deserializer(i));
+                semantic_deserializer.extend(field.generate_semantic_deserializer(i));
+            }
+
+            // Generate the match arm for version `i`.
+            //
+            // The semantic deserialization functions will be called after the object is constructed
+            // using the previously generated field deserializers.
+            versioned_deserializers.extend(quote! {
+                #i => {
+                    let mut object = #struct_ident {
+                        #versioned_deserializer
+                    };
+                    #semantic_deserializer
+                    Ok(object)
+                }
+            });
+        }
+
+        // Generate code to map the app version to struct version and wrap the
+        // deserializers with the `version` match.
+        quote! {
+            let version = version_map.get_type_version(app_version, <Self as Versionize>::type_id());
+            match version {
+                #versioned_deserializers
+                _ => panic!("Unknown {:?} version {}.", <Self as Versionize>::type_id(), version)
+            }
+        }
+    }
+
+    fn version(&self) -> u16 {
+        self.version
+    }
+
+    fn ty(&self) -> String {
+        self.ty.to_string()
+    }
+}
+
+impl StructDescriptor {
+    pub fn new(input: &syn::DataStruct, ident: syn::Ident) -> Self {
+        let mut descriptor = StructDescriptor {
+            ty: ident,
+            version: 1, // struct start at version 1.
+            fields: vec![],
+        };
+
+        // Fills self.fields.
+        descriptor.parse_struct_fields(&input.fields);
+        descriptor.version = compute_version(&descriptor.fields);
+        descriptor
+    }
+
+    fn parse_struct_fields(&mut self, fields: &syn::Fields) {
+        match fields {
+            syn::Fields::Named(ref named_fields) => {
+                let pairs = named_fields.named.pairs();
+                for field in pairs.into_iter() {
+                    self.fields.push(StructField::new(self.version, field));
+                }
+            }
+            _ => panic!("Only named fields are supported."),
+        }
+    }
+}