Skip to main content

AdapterConformanceManifest

riffdb_application

Struct AdapterConformanceManifest 

Source 
pub struct AdapterConformanceManifest { /* private fields */ }
Expand description

One immutable content-addressed adapter conformance manifest.

Implementations§

Source§

impl AdapterConformanceManifest

Source

pub fn compile( input: AdapterConformanceManifestInput, ) -> Result<Self, AdapterConformanceError>

Compiles one canonical manifest without filesystem, server, or application execution.

Source

pub fn compile_v2( input: AdapterConformanceManifestInput, ) -> Result<Self, AdapterConformanceError>

Compiles the current manifest format with an exhaustive feature disposition catalog.

Source

pub fn decode_canonical(bytes: &[u8]) -> Result<Self, AdapterConformanceError>

Strictly decodes and revalidates one canonical manifest.

Examples found in repository?
examples/generate_portability_fixtures.rs (lines 102-109)
93fn generate_domain(root: &Path, domain: &Domain<'_>, write: bool) {
94    let bundle = ContractBundle::decode(
95        &fs::read(
96            root.join(domain.application_root)
97                .join("generated/riffdb.contract.bundle"),
98        )
99        .expect("read adapter contract bundle"),
100    )
101    .expect("decode adapter contract bundle");
102    let adapter = AdapterConformanceManifest::decode_canonical(
103        &fs::read(
104            root.join("fixtures/adapters/conformance")
105                .join(domain.name)
106                .join("adapter.conformance.json"),
107        )
108        .expect("read adapter manifest"),
109    )
110    .expect("decode adapter manifest");
111    let observation_hash = empty_observation_hash(domain.empty_collection);
112    let module_hash = adapter
113        .input()
114        .artifacts
115        .iter()
116        .find(|artifact| artifact.kind() == InstallationArtifactKind::QueryModule)
117        .map(|artifact| QueryModuleHash::from_bytes(*artifact.content_hash().as_bytes()))
118        .expect("adapter query module");
119    let manifest = ApplicationPortabilityManifest::compile(ApplicationPortabilityManifestInput {
120        adapter_manifest_hash: adapter.identity(),
121        contract_lineage: bundle.lineage().clone(),
122        contract_version: bundle.contract_version(),
123        contract_bundle_hash: bundle.bundle_hash(),
124        mappings: domain
125            .mappings
126            .iter()
127            .map(|(entity, command)| {
128                PortableRecordMapping::new(
129                    PortableRecordClass::Entity,
130                    symbol(entity),
131                    PortableReimportStrategy::reimport_command(symbol(command)),
132                )
133            })
134            .collect(),
135        omissions: vec![
136            PortableOmission::new(
137                PortableOmissionClass::Provenance,
138                None,
139                PortableOmissionReason::HistoricalRecordsNotRegenerable,
140            )
141            .expect("provenance omission"),
142            PortableOmission::new(
143                PortableOmissionClass::PublicAudit,
144                None,
145                PortableOmissionReason::HistoricalRecordsNotRegenerable,
146            )
147            .expect("audit omission"),
148        ],
149        observations: vec![
150            ReimportObservation::new_with_parameters(
151                symbol("application_observation"),
152                symbol(domain.query),
153                module_hash,
154                domain
155                    .parameters
156                    .iter()
157                    .map(|(name, suffix)| {
158                        ReimportObservationParameter::new(
159                            symbol(name),
160                            CanonicalValue::Uuid(application_uuid(*suffix)),
161                        )
162                        .expect("observation parameter")
163                    })
164                    .collect(),
165                observation_hash,
166                500,
167            )
168            .expect("observation"),
169        ],
170    })
171    .expect("compile portability manifest");
172    manifest
173        .validate_compiled_contract(&bundle)
174        .expect("compiled contract mapping");
175    assert_eq!(manifest.input().adapter_manifest_hash, adapter.identity());
176    assert_eq!(
177        manifest.input().contract_lineage,
178        adapter.input().contract_lineage
179    );
180    assert!(adapter.input().evolution.iter().any(|evolution| {
181        evolution.successor().version() == manifest.input().contract_version
182            && evolution.successor().bundle_hash() == manifest.input().contract_bundle_hash
183    }));
184    manifest
185        .validate_adapter_conformance(&adapter)
186        .unwrap_or_else(|error| panic!("{} adapter mapping: {error:?}", domain.name));
187
188    let outcome_hash = hash_generated_artifact(format!("{}-outcomes-v1", domain.name).as_bytes());
189    let destination = root.join("fixtures/export").join(domain.name);
190    let receipt = reimport_receipt(&manifest, domain, outcome_hash);
191    update(
192        destination.join("portability-manifest-v3.json"),
193        manifest.canonical_bytes(),
194        write,
195    );
196    let legacy_manifest_path = destination.join("portability-manifest-v2.json");
197    if legacy_manifest_path.is_file() {
198        let legacy_manifest = ApplicationPortabilityManifest::decode_canonical(
199            &fs::read(legacy_manifest_path).expect("read V2 portability manifest"),
200        )
201        .expect("decode V2 portability manifest");
202        let legacy_receipt = reimport_receipt(&legacy_manifest, domain, outcome_hash);
203        update(
204            destination.join("reimport-receipt-v2.json"),
205            legacy_receipt.canonical_bytes(),
206            write,
207        );
208    }
209    update(
210        destination.join("reimport-receipt-v3.json"),
211        receipt.canonical_bytes(),
212        write,
213    );
214}
Source

pub const fn identity(&self) -> AdapterConformanceManifestHash

Content identity recorded in installation plans and receipts.

Examples found in repository?
examples/generate_portability_fixtures.rs (line 120)
93fn generate_domain(root: &Path, domain: &Domain<'_>, write: bool) {
94    let bundle = ContractBundle::decode(
95        &fs::read(
96            root.join(domain.application_root)
97                .join("generated/riffdb.contract.bundle"),
98        )
99        .expect("read adapter contract bundle"),
100    )
101    .expect("decode adapter contract bundle");
102    let adapter = AdapterConformanceManifest::decode_canonical(
103        &fs::read(
104            root.join("fixtures/adapters/conformance")
105                .join(domain.name)
106                .join("adapter.conformance.json"),
107        )
108        .expect("read adapter manifest"),
109    )
110    .expect("decode adapter manifest");
111    let observation_hash = empty_observation_hash(domain.empty_collection);
112    let module_hash = adapter
113        .input()
114        .artifacts
115        .iter()
116        .find(|artifact| artifact.kind() == InstallationArtifactKind::QueryModule)
117        .map(|artifact| QueryModuleHash::from_bytes(*artifact.content_hash().as_bytes()))
118        .expect("adapter query module");
119    let manifest = ApplicationPortabilityManifest::compile(ApplicationPortabilityManifestInput {
120        adapter_manifest_hash: adapter.identity(),
121        contract_lineage: bundle.lineage().clone(),
122        contract_version: bundle.contract_version(),
123        contract_bundle_hash: bundle.bundle_hash(),
124        mappings: domain
125            .mappings
126            .iter()
127            .map(|(entity, command)| {
128                PortableRecordMapping::new(
129                    PortableRecordClass::Entity,
130                    symbol(entity),
131                    PortableReimportStrategy::reimport_command(symbol(command)),
132                )
133            })
134            .collect(),
135        omissions: vec![
136            PortableOmission::new(
137                PortableOmissionClass::Provenance,
138                None,
139                PortableOmissionReason::HistoricalRecordsNotRegenerable,
140            )
141            .expect("provenance omission"),
142            PortableOmission::new(
143                PortableOmissionClass::PublicAudit,
144                None,
145                PortableOmissionReason::HistoricalRecordsNotRegenerable,
146            )
147            .expect("audit omission"),
148        ],
149        observations: vec![
150            ReimportObservation::new_with_parameters(
151                symbol("application_observation"),
152                symbol(domain.query),
153                module_hash,
154                domain
155                    .parameters
156                    .iter()
157                    .map(|(name, suffix)| {
158                        ReimportObservationParameter::new(
159                            symbol(name),
160                            CanonicalValue::Uuid(application_uuid(*suffix)),
161                        )
162                        .expect("observation parameter")
163                    })
164                    .collect(),
165                observation_hash,
166                500,
167            )
168            .expect("observation"),
169        ],
170    })
171    .expect("compile portability manifest");
172    manifest
173        .validate_compiled_contract(&bundle)
174        .expect("compiled contract mapping");
175    assert_eq!(manifest.input().adapter_manifest_hash, adapter.identity());
176    assert_eq!(
177        manifest.input().contract_lineage,
178        adapter.input().contract_lineage
179    );
180    assert!(adapter.input().evolution.iter().any(|evolution| {
181        evolution.successor().version() == manifest.input().contract_version
182            && evolution.successor().bundle_hash() == manifest.input().contract_bundle_hash
183    }));
184    manifest
185        .validate_adapter_conformance(&adapter)
186        .unwrap_or_else(|error| panic!("{} adapter mapping: {error:?}", domain.name));
187
188    let outcome_hash = hash_generated_artifact(format!("{}-outcomes-v1", domain.name).as_bytes());
189    let destination = root.join("fixtures/export").join(domain.name);
190    let receipt = reimport_receipt(&manifest, domain, outcome_hash);
191    update(
192        destination.join("portability-manifest-v3.json"),
193        manifest.canonical_bytes(),
194        write,
195    );
196    let legacy_manifest_path = destination.join("portability-manifest-v2.json");
197    if legacy_manifest_path.is_file() {
198        let legacy_manifest = ApplicationPortabilityManifest::decode_canonical(
199            &fs::read(legacy_manifest_path).expect("read V2 portability manifest"),
200        )
201        .expect("decode V2 portability manifest");
202        let legacy_receipt = reimport_receipt(&legacy_manifest, domain, outcome_hash);
203        update(
204            destination.join("reimport-receipt-v2.json"),
205            legacy_receipt.canonical_bytes(),
206            write,
207        );
208    }
209    update(
210        destination.join("reimport-receipt-v3.json"),
211        receipt.canonical_bytes(),
212        write,
213    );
214}
Source

pub const fn schema(&self) -> &'static str

Exact accepted compatibility schema.

Source

pub const fn input(&self) -> &AdapterConformanceManifestInput

Validated manifest contents.

Examples found in repository?
examples/generate_portability_fixtures.rs (line 113)
93fn generate_domain(root: &Path, domain: &Domain<'_>, write: bool) {
94    let bundle = ContractBundle::decode(
95        &fs::read(
96            root.join(domain.application_root)
97                .join("generated/riffdb.contract.bundle"),
98        )
99        .expect("read adapter contract bundle"),
100    )
101    .expect("decode adapter contract bundle");
102    let adapter = AdapterConformanceManifest::decode_canonical(
103        &fs::read(
104            root.join("fixtures/adapters/conformance")
105                .join(domain.name)
106                .join("adapter.conformance.json"),
107        )
108        .expect("read adapter manifest"),
109    )
110    .expect("decode adapter manifest");
111    let observation_hash = empty_observation_hash(domain.empty_collection);
112    let module_hash = adapter
113        .input()
114        .artifacts
115        .iter()
116        .find(|artifact| artifact.kind() == InstallationArtifactKind::QueryModule)
117        .map(|artifact| QueryModuleHash::from_bytes(*artifact.content_hash().as_bytes()))
118        .expect("adapter query module");
119    let manifest = ApplicationPortabilityManifest::compile(ApplicationPortabilityManifestInput {
120        adapter_manifest_hash: adapter.identity(),
121        contract_lineage: bundle.lineage().clone(),
122        contract_version: bundle.contract_version(),
123        contract_bundle_hash: bundle.bundle_hash(),
124        mappings: domain
125            .mappings
126            .iter()
127            .map(|(entity, command)| {
128                PortableRecordMapping::new(
129                    PortableRecordClass::Entity,
130                    symbol(entity),
131                    PortableReimportStrategy::reimport_command(symbol(command)),
132                )
133            })
134            .collect(),
135        omissions: vec![
136            PortableOmission::new(
137                PortableOmissionClass::Provenance,
138                None,
139                PortableOmissionReason::HistoricalRecordsNotRegenerable,
140            )
141            .expect("provenance omission"),
142            PortableOmission::new(
143                PortableOmissionClass::PublicAudit,
144                None,
145                PortableOmissionReason::HistoricalRecordsNotRegenerable,
146            )
147            .expect("audit omission"),
148        ],
149        observations: vec![
150            ReimportObservation::new_with_parameters(
151                symbol("application_observation"),
152                symbol(domain.query),
153                module_hash,
154                domain
155                    .parameters
156                    .iter()
157                    .map(|(name, suffix)| {
158                        ReimportObservationParameter::new(
159                            symbol(name),
160                            CanonicalValue::Uuid(application_uuid(*suffix)),
161                        )
162                        .expect("observation parameter")
163                    })
164                    .collect(),
165                observation_hash,
166                500,
167            )
168            .expect("observation"),
169        ],
170    })
171    .expect("compile portability manifest");
172    manifest
173        .validate_compiled_contract(&bundle)
174        .expect("compiled contract mapping");
175    assert_eq!(manifest.input().adapter_manifest_hash, adapter.identity());
176    assert_eq!(
177        manifest.input().contract_lineage,
178        adapter.input().contract_lineage
179    );
180    assert!(adapter.input().evolution.iter().any(|evolution| {
181        evolution.successor().version() == manifest.input().contract_version
182            && evolution.successor().bundle_hash() == manifest.input().contract_bundle_hash
183    }));
184    manifest
185        .validate_adapter_conformance(&adapter)
186        .unwrap_or_else(|error| panic!("{} adapter mapping: {error:?}", domain.name));
187
188    let outcome_hash = hash_generated_artifact(format!("{}-outcomes-v1", domain.name).as_bytes());
189    let destination = root.join("fixtures/export").join(domain.name);
190    let receipt = reimport_receipt(&manifest, domain, outcome_hash);
191    update(
192        destination.join("portability-manifest-v3.json"),
193        manifest.canonical_bytes(),
194        write,
195    );
196    let legacy_manifest_path = destination.join("portability-manifest-v2.json");
197    if legacy_manifest_path.is_file() {
198        let legacy_manifest = ApplicationPortabilityManifest::decode_canonical(
199            &fs::read(legacy_manifest_path).expect("read V2 portability manifest"),
200        )
201        .expect("decode V2 portability manifest");
202        let legacy_receipt = reimport_receipt(&legacy_manifest, domain, outcome_hash);
203        update(
204            destination.join("reimport-receipt-v2.json"),
205            legacy_receipt.canonical_bytes(),
206            write,
207        );
208    }
209    update(
210        destination.join("reimport-receipt-v3.json"),
211        receipt.canonical_bytes(),
212        write,
213    );
214}
Source

pub fn canonical_bytes(&self) -> &[u8] ⓘ

Canonical compatibility bytes.

Source

pub fn validate_installation_plan( &self, plan: &ApplicationInstallationPlan, ) -> Result<(), AdapterConformanceError>

Verifies one installation plan is exactly the adapter-reviewed plan.

Source

pub fn validate_catalog( &self, supported_features: &[InstallationFeature], supported_drivers: &[AdapterDriverRequirement], ) -> Result<(), AdapterConformanceError>

Verifies required features and exact driver conformance identities against a closed catalog.

Trait Implementations§

Source§

impl Clone for AdapterConformanceManifest

Source§

fn clone(&self) -> Self

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for AdapterConformanceManifest

Source§

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
Source§

impl Eq for AdapterConformanceManifest

Source§

impl PartialEq for AdapterConformanceManifest

Source§

fn eq(&self, other: &Self) -> bool

Equality operator ==. Read more
1.0.0 (const: unstable) · Source§

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=. Read more
Source§

impl StructuralPartialEq for AdapterConformanceManifest

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = !

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, !>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.