build/sdk/meta/src/product_bundle.rs - fuchsia - Git at Google

 // Copyright 2021 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 //! Representation of the product_bundle metadata.

 use crate::common::{ElementType, Envelope};
 use crate::json::{schema, JsonObject};
 use anyhow::Result;
 use serde::{Deserialize, Serialize};

 impl JsonObject for Envelope<ProductBundleV1> {
     fn get_schema() -> &'static str {
         include_str!("../product_bundle-6320eef1.json")
     }

     fn get_referenced_schemata() -> &'static [&'static str] {
         &[schema::COMMON, schema::HARDWARE_V1, schema::EMU_MANIFEST, schema::FLASH_MANIFEST_V1]
     }
 }

 impl Envelope<ProductBundleV1> {
     pub fn from(data: ProductBundleV1) -> Result<Envelope<ProductBundleV1>> {
         let envelope = Envelope { data, schema_id: Envelope::<ProductBundleV1>::get_schema_id()? };
         Ok(envelope)
     }
 }

 /// A manifest that describes how to boot an emulator.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct EmuManifest {
     /// A list of one or more disk image paths to FVM images. Each path is
     /// relative to the image bundle base. Expect at least one entry.
     pub disk_images: Vec<String>,

     /// A path to the initial ramdisk, the kernel ZBI. The path is relative to
     /// the image bundle base. Expect at least one character.
     pub initial_ramdisk: String,

     /// A path to the kernel image file. The path is relative to the image
     /// bundle base.  Expect at least one character.
     pub kernel: String,
 }

 /// A manifest that describes how to flash a device.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct FlashManifest {
     /// A board name used to verify whether the device can be flashed using this
     /// manifest.
     pub hw_revision: String,

     /// A list of product specifications that can be flashed onto the device.
     /// Expect at least one entry.
     pub products: Vec<Product>,

     /// A list of credential files needed for unlocking fastboot devices.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub credentials: Vec<String>,
 }

 /// A set of artifacts necessary to provision a physical or virtual device.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct ImageBundle {
     /// A base URI for accessing artifacts in the bundle.
     pub base_uri: String,

     /// Bundle format: files - a directory layout; tgz - a gzipped tarball.
     pub format: String,
 }

 /// Manifests describing how to boot the product on a device.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize, Default)]
 #[serde(deny_unknown_fields)]
 pub struct Manifests {
     /// Optional manifest that describes how to boot an emulator.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub emu: Option<EmuManifest>,

     /// Optional manifest that describes how to flash a device.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub flash: Option<FlashManifest>,
 }

 /// A set of artifacts necessary to run a physical or virtual device.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct PackageBundle {
     /// An optional blob repository URI. If omitted, it is assumed to be
     /// <repo_uri>/blobs. If repo_uri refers to a gzipped tarball, ./blobs
     /// directory is expected to be found inside the tarball.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub blob_uri: Option<String>,

     /// Repository format: files - a directory layout; tgz - a gzipped tarball.
     pub format: String,

     /// A package repository URI. This may be an archive or a directory.
     pub repo_uri: String,
 }

 /// A named product specification.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct Product {
     /// A list of partition names and file names corresponding to the
     /// partitions.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub bootloader_partitions: Vec<Partition>,

     /// A unique name of this manifest.
     pub name: String,

     /// A list of OEM command and file names corresponding to the command.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub oem_files: Vec<OemFile>,

     /// A list of partition names and file names corresponding to then
     /// partitions.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub partitions: Vec<Partition>,

     /// Does this product require fastboot to be unlocked.
     #[serde(default)]
     pub requires_unlock: bool,
 }

 /// A partition to flash on the target.
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub struct Partition {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub condition: Option<Condition>,
     /// Name of the partition.
     pub name: String,
     /// Path to file on host to upload.
     pub path: String,
 }

 /// A file to upload and run an OEM command afterwards.
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub struct OemFile {
     /// OEM Command to run after uploading the file.
     pub command: String,
     /// Path to file on host to upload.
     pub path: String,
 }

 /// A condition that must be true in order to flash a partition.
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
 pub struct Condition {
     /// Variable to check for this flashing condition.
     pub variable: String,
     /// Value of the variable that must match for this condition to be true.
     pub value: String,
 }

 /// Product bundle metadata can be an integer, string, or boolean.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(untagged)]
 pub enum MetadataValue {
     Integer(u64),
     StringValue(String),
     Boolean(bool),
 }

 /// Description of the data needed to set up (flash) a device.
 #[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
 #[serde(deny_unknown_fields)]
 pub struct ProductBundleV1 {
     /// A human readable description of the product bundle.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,

     /// A list of physical or virtual device names this product can run on.
     /// Expect at least one entry.
     pub device_refs: Vec<String>,

     /// A list of system image bundles. Expect at least one entry.
     pub images: Vec<ImageBundle>,

     /// Manifests describing how to boot the product on a device.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub manifests: Option<Manifests>,

     /// A list of key-value pairs describing product dimensions. Tools must not
     /// rely on the presence or absence of certain keys. Tools may display them
     /// to the human user in order to assist them in selecting a desired image
     /// or log them for the sake of analytics. Typical metadata keys are:
     /// build_info_board, build_info_product, is_debug.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<Vec<(String, MetadataValue)>>,

     /// A list of package bundles. Expect at least one entry.
     pub packages: Vec<PackageBundle>,

     /// A unique name identifying this FMS entry.
     pub name: String,

     /// Always "product_bundle" for a ProductBundle. This is valuable for
     /// debugging or when writing this record to a json string.
     #[serde(rename = "type")]
     pub kind: ElementType,
 }

 #[cfg(test)]
 mod tests {
     use super::*;

     test_validation! {
         name = test_validation_minimal,
         kind = Envelope::<ProductBundleV1>,
         data = r#"
         {
             "schema_id": "http://fuchsia.com/schemas/sdk/product_bundle-6320eef1.json",
             "data": {
                 "name": "generic-x64",
                 "type": "product_bundle",
                 "device_refs": ["generic-x64"],
                 "images": [{
                     "base_uri": "gs://fuchsia/development/0.20201216.2.1/images/generic-x64.tgz",
                     "format": "tgz"
                 }],
                 "packages": [{
                     "format": "tgz",
                     "repo_uri": "gs://fuchsia/development/0.20201216.2.1/packages/generic-x64.tar.gz"
                 }]
             }
         }
         "#,
         valid = true,
     }

     test_validation! {
         name = test_validation_full,
         kind = Envelope::<ProductBundleV1>,
         data = r#"
         {
             "schema_id": "http://fuchsia.com/schemas/sdk/product_bundle-6320eef1.json",
             "data": {
                 "name": "generic-x64",
                 "type": "product_bundle",
                 "device_refs": ["generic-x64"],
                 "images": [{
                     "base_uri": "gs://fuchsia/development/0.20201216.2.1/images/generic-x64.tgz",
                     "format": "tgz"
                 }],
                 "manifests": {
                     "flash": {
                         "hw_revision": "x64",
                         "products": [{
                             "bootloader_partitions": [],
                             "name": "fuchsia",
                             "oem_files": [],
                             "partitions": [
                                 {
                                     "name": "",
                                     "path": "fuchsia.zbi"
                                 },
                                 {
                                     "name": "",
                                     "path": "zedboot.zbi"
                                 },
                                 {
                                     "name": "",
                                     "path": "fuchsia.vbmeta"
                                 },
                                 {
                                     "name": "",
                                     "path": "zedboot.vbmeta"
                                 }
                             ]}
                         ]
                     },
                     "emu": {
                         "disk_images": ["fuchsia.zbi"],
                         "initial_ramdisk": "fuchsia.fvm",
                         "kernel": "multiboot.bin"
                     }
                 },
                 "metadata": [
                     ["build-type", "release"],
                     ["product", "terminal"]
                 ],
                 "packages": [{
                     "format": "files",
                     "blob_uri": "file:///fuchsia/out/default/amber-files/blobs",
                     "repo_uri": "file:///fuchsia/out/default/amber-files"
                 }]
             }
         }
         "#,
         valid = true,
     }

     test_validation! {
         name = test_validation_invalid,
         kind = Envelope::<ProductBundleV1>,
         data = r#"
         {
             "schema_id": "http://fuchsia.com/schemas/sdk/product_bundle-6320eef1.json",
             "data": {
                 "name": "generic-x64",
                 "type": "cc_prebuilt_library",
                 "device_refs": ["generic-x64"],
                 "images": [{
                     "base_uri": "gs://fuchsia/development/0.20201216.2.1/images/generic-x64.tgz",
                     "format": "tgz"
                 }],
                 "packages": [{
                     "format": "tgz",
                     "repo_uri": "gs://fuchsia/development/0.20201216.2.1/packages/generic-x64.tar.gz"
                 }]
             }
         }
         "#,
         // Incorrect type
         valid = false,
     }
 }
	// Copyright 2021 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	//! Representation of the product_bundle metadata.

	use crate::common::{ElementType, Envelope};
	use crate::json::{schema, JsonObject};
	use anyhow::Result;
	use serde::{Deserialize, Serialize};

	impl JsonObject for Envelope<ProductBundleV1> {
	fn get_schema() -> &'static str {
	include_str!("../product_bundle-6320eef1.json")
	}

	fn get_referenced_schemata() -> &'static [&'static str] {
	&[schema::COMMON, schema::HARDWARE_V1, schema::EMU_MANIFEST, schema::FLASH_MANIFEST_V1]
	}
	}

	impl Envelope<ProductBundleV1> {
	pub fn from(data: ProductBundleV1) -> Result<Envelope<ProductBundleV1>> {
	let envelope = Envelope { data, schema_id: Envelope::<ProductBundleV1>::get_schema_id()? };
	Ok(envelope)
	}
	}

	/// A manifest that describes how to boot an emulator.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
	#[serde(deny_unknown_fields)]
	pub struct EmuManifest {
	/// A list of one or more disk image paths to FVM images. Each path is
	/// relative to the image bundle base. Expect at least one entry.
	pub disk_images: Vec<String>,

	/// A path to the initial ramdisk, the kernel ZBI. The path is relative to
	/// the image bundle base. Expect at least one character.
	pub initial_ramdisk: String,

	/// A path to the kernel image file. The path is relative to the image
	/// bundle base. Expect at least one character.
	pub kernel: String,
	}

	/// A manifest that describes how to flash a device.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
	#[serde(deny_unknown_fields)]
	pub struct FlashManifest {
	/// A board name used to verify whether the device can be flashed using this
	/// manifest.
	pub hw_revision: String,

	/// A list of product specifications that can be flashed onto the device.
	/// Expect at least one entry.
	pub products: Vec<Product>,

	/// A list of credential files needed for unlocking fastboot devices.
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub credentials: Vec<String>,
	}

	/// A set of artifacts necessary to provision a physical or virtual device.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
	#[serde(deny_unknown_fields)]
	pub struct ImageBundle {
	/// A base URI for accessing artifacts in the bundle.
	pub base_uri: String,

	/// Bundle format: files - a directory layout; tgz - a gzipped tarball.
	pub format: String,
	}

	/// Manifests describing how to boot the product on a device.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize, Default)]
	#[serde(deny_unknown_fields)]
	pub struct Manifests {
	/// Optional manifest that describes how to boot an emulator.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub emu: Option<EmuManifest>,

	/// Optional manifest that describes how to flash a device.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub flash: Option<FlashManifest>,
	}

	/// A set of artifacts necessary to run a physical or virtual device.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
	#[serde(deny_unknown_fields)]
	pub struct PackageBundle {
	/// An optional blob repository URI. If omitted, it is assumed to be
	/// <repo_uri>/blobs. If repo_uri refers to a gzipped tarball, ./blobs
	/// directory is expected to be found inside the tarball.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub blob_uri: Option<String>,

	/// Repository format: files - a directory layout; tgz - a gzipped tarball.
	pub format: String,

	/// A package repository URI. This may be an archive or a directory.
	pub repo_uri: String,
	}

	/// A named product specification.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
	#[serde(deny_unknown_fields)]
	pub struct Product {
	/// A list of partition names and file names corresponding to the
	/// partitions.
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub bootloader_partitions: Vec<Partition>,

	/// A unique name of this manifest.
	pub name: String,

	/// A list of OEM command and file names corresponding to the command.
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub oem_files: Vec<OemFile>,

	/// A list of partition names and file names corresponding to then
	/// partitions.
	#[serde(default, skip_serializing_if = "Vec::is_empty")]
	pub partitions: Vec<Partition>,

	/// Does this product require fastboot to be unlocked.
	#[serde(default)]
	pub requires_unlock: bool,
	}

	/// A partition to flash on the target.
	#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
	pub struct Partition {
	#[serde(skip_serializing_if = "Option::is_none")]
	pub condition: Option<Condition>,
	/// Name of the partition.
	pub name: String,
	/// Path to file on host to upload.
	pub path: String,
	}

	/// A file to upload and run an OEM command afterwards.
	#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
	pub struct OemFile {
	/// OEM Command to run after uploading the file.
	pub command: String,
	/// Path to file on host to upload.
	pub path: String,
	}

	/// A condition that must be true in order to flash a partition.
	#[derive(Clone, Debug, PartialEq, Deserialize, Serialize)]
	pub struct Condition {
	/// Variable to check for this flashing condition.
	pub variable: String,
	/// Value of the variable that must match for this condition to be true.
	pub value: String,
	}

	/// Product bundle metadata can be an integer, string, or boolean.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
	#[serde(untagged)]
	pub enum MetadataValue {
	Integer(u64),
	StringValue(String),
	Boolean(bool),
	}

	/// Description of the data needed to set up (flash) a device.
	#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
	#[serde(deny_unknown_fields)]
	pub struct ProductBundleV1 {
	/// A human readable description of the product bundle.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub description: Option<String>,

	/// A list of physical or virtual device names this product can run on.
	/// Expect at least one entry.
	pub device_refs: Vec<String>,

	/// A list of system image bundles. Expect at least one entry.
	pub images: Vec<ImageBundle>,

	/// Manifests describing how to boot the product on a device.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub manifests: Option<Manifests>,

	/// A list of key-value pairs describing product dimensions. Tools must not
	/// rely on the presence or absence of certain keys. Tools may display them
	/// to the human user in order to assist them in selecting a desired image
	/// or log them for the sake of analytics. Typical metadata keys are:
	/// build_info_board, build_info_product, is_debug.
	#[serde(skip_serializing_if = "Option::is_none")]
	pub metadata: Option<Vec<(String, MetadataValue)>>,

	/// A list of package bundles. Expect at least one entry.
	pub packages: Vec<PackageBundle>,

	/// A unique name identifying this FMS entry.
	pub name: String,

	/// Always "product_bundle" for a ProductBundle. This is valuable for
	/// debugging or when writing this record to a json string.
	#[serde(rename = "type")]
	pub kind: ElementType,
	}

	#[cfg(test)]
	mod tests {
	use super::*;

	test_validation! {
	name = test_validation_minimal,
	kind = Envelope::<ProductBundleV1>,
	data = r#"
	{
	"schema_id": "http://fuchsia.com/schemas/sdk/product_bundle-6320eef1.json",
	"data": {
	"name": "generic-x64",
	"type": "product_bundle",
	"device_refs": ["generic-x64"],
	"images": [{
	"base_uri": "gs://fuchsia/development/0.20201216.2.1/images/generic-x64.tgz",
	"format": "tgz"
	}],
	"packages": [{
	"format": "tgz",
	"repo_uri": "gs://fuchsia/development/0.20201216.2.1/packages/generic-x64.tar.gz"
	}]
	}
	}
	"#,
	valid = true,
	}

	test_validation! {
	name = test_validation_full,
	kind = Envelope::<ProductBundleV1>,
	data = r#"
	{
	"schema_id": "http://fuchsia.com/schemas/sdk/product_bundle-6320eef1.json",
	"data": {
	"name": "generic-x64",
	"type": "product_bundle",
	"device_refs": ["generic-x64"],
	"images": [{
	"base_uri": "gs://fuchsia/development/0.20201216.2.1/images/generic-x64.tgz",
	"format": "tgz"
	}],
	"manifests": {
	"flash": {
	"hw_revision": "x64",
	"products": [{
	"bootloader_partitions": [],
	"name": "fuchsia",
	"oem_files": [],
	"partitions": [
	{
	"name": "",
	"path": "fuchsia.zbi"
	},
	{
	"name": "",
	"path": "zedboot.zbi"
	},
	{
	"name": "",
	"path": "fuchsia.vbmeta"
	},
	{
	"name": "",
	"path": "zedboot.vbmeta"
	}
	]}
	]
	},
	"emu": {
	"disk_images": ["fuchsia.zbi"],
	"initial_ramdisk": "fuchsia.fvm",
	"kernel": "multiboot.bin"
	}
	},
	"metadata": [
	["build-type", "release"],
	["product", "terminal"]
	],
	"packages": [{
	"format": "files",
	"blob_uri": "file:///fuchsia/out/default/amber-files/blobs",
	"repo_uri": "file:///fuchsia/out/default/amber-files"
	}]
	}
	}
	"#,
	valid = true,
	}

	test_validation! {
	name = test_validation_invalid,
	kind = Envelope::<ProductBundleV1>,
	data = r#"
	{
	"schema_id": "http://fuchsia.com/schemas/sdk/product_bundle-6320eef1.json",
	"data": {
	"name": "generic-x64",
	"type": "cc_prebuilt_library",
	"device_refs": ["generic-x64"],
	"images": [{
	"base_uri": "gs://fuchsia/development/0.20201216.2.1/images/generic-x64.tgz",
	"format": "tgz"
	}],
	"packages": [{
	"format": "tgz",
	"repo_uri": "gs://fuchsia/development/0.20201216.2.1/packages/generic-x64.tar.gz"
	}]
	}
	}
	"#,
	// Incorrect type
	valid = false,
	}
	}