mod copy;
use super::{Database, Map, live_manifest, manifest_key, query, read_revision};
use crate::{
Entity, Error, QueryCursor, QueryPage, Schema,
codec::{Decoder, Encoder},
};
pub use copy::{CopyStep, RetiredSource, SchemaCopy};
use ic_storage::{Memory, RuntimeMemory};
use sha2::{Digest, Sha256};
pub(super) const MAGIC: &[u8; 8] = b"ICDBMT02";
const MAX_NAME: usize = 64;
const MAX_INPUTS: usize = 256;
const MAX_FRAME: usize = 421;
pub(super) fn admits_gate(bytes: &[u8]) -> Result<bool, Error> {
if bytes.starts_with(MAGIC) {
decode(bytes)?;
} else if bytes.starts_with(copy::MAGIC) {
copy::decode(bytes)?;
} else {
return Ok(false);
}
Ok(true)
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SchemaTransition {
source: [u8; 32],
target: [u8; 32],
name: String,
version: u32,
inputs: Vec<u8>,
}
impl SchemaTransition {
pub fn new(
source: &Schema,
target: &Schema,
name: &str,
version: u32,
inputs: &[u8],
) -> Result<Self, Error> {
if source.fingerprint() == target.fingerprint()
|| name.is_empty()
|| name.len() > MAX_NAME
|| version == 0
|| inputs.len() > MAX_INPUTS
{
return Err(Error::InvalidTransition);
}
Ok(Self {
source: source.fingerprint(),
target: target.fingerprint(),
name: name.into(),
version,
inputs: inputs.into(),
})
}
#[must_use]
pub const fn source(&self) -> [u8; 32] {
self.source
}
#[must_use]
pub const fn target(&self) -> [u8; 32] {
self.target
}
#[must_use]
pub fn name(&self) -> &str {
&self.name
}
#[must_use]
pub const fn version(&self) -> u32 {
self.version
}
#[must_use]
pub fn inputs(&self) -> &[u8] {
&self.inputs
}
fn freeze(&self, incarnation: [u8; 16]) -> Result<Vec<u8>, Error> {
let mut payload = Encoder::new();
payload.nat8(0)?; payload.nat32(self.version)?;
payload.bytes(self.name.as_bytes())?;
payload.bytes(&self.inputs)?;
let mut bytes = MAGIC.to_vec();
bytes.extend(self.source);
bytes.extend(self.target);
bytes.extend(incarnation);
bytes.extend(payload.finish());
Ok(bytes)
}
}
pub struct Maintenance<M: Memory> {
map: Map<M>,
transition: SchemaTransition,
incarnation: [u8; 16],
}
impl<M: Memory> Database<M> {
pub fn begin_maintenance(
mut self,
transition: &SchemaTransition,
) -> Result<Maintenance<M>, Error> {
if transition.source != self.schema.fingerprint() {
return Err(Error::InvalidTransition);
}
let bytes = transition.freeze(self.incarnation)?;
let transition = transition.clone();
self.map.insert(manifest_key(), bytes);
Ok(Maintenance {
map: self.map,
transition,
incarnation: self.incarnation,
})
}
}
impl<M: Memory> Maintenance<M> {
pub fn resume(memory: RuntimeMemory<M>, expected: &SchemaTransition) -> Result<Self, Error> {
if memory.size() == 0 {
return Err(Error::Corrupt);
}
let map = Map::load(memory);
let bytes = map.get(&manifest_key()).ok_or(Error::Corrupt)?;
let (transition, incarnation) = decode(&bytes)?;
if transition != *expected {
return Err(Error::InvalidTransition);
}
Ok(Self {
map,
transition,
incarnation,
})
}
#[must_use]
pub const fn transition(&self) -> &SchemaTransition {
&self.transition
}
#[must_use]
pub const fn incarnation(&self) -> [u8; 16] {
self.incarnation
}
pub fn source_page<E: Entity>(
&self,
source: &Schema,
after: Option<&QueryCursor>,
limit: usize,
bytes: usize,
) -> Result<QueryPage<E>, Error> {
if source.fingerprint() != self.transition.source {
return Err(Error::IncompatibleSchema);
}
source.admits(E::SCHEMA)?;
let revision = read_revision(&self.map, E::ID)?;
let mut hash = Sha256::new();
hash.update(b"ic-db:maintenance-source:v1\0");
hash.update(self.transition.freeze(self.incarnation)?);
hash.update(revision.to_le_bytes());
query::source_page(
&self.map,
E::SCHEMA,
hash.finalize().into(),
self.incarnation,
after,
limit,
bytes,
)?
.decode_entities()
}
pub fn cancel(mut self) {
let bytes = live_manifest(self.transition.source, self.incarnation);
self.map.insert(manifest_key(), bytes);
}
}
pub(super) fn decode(bytes: &[u8]) -> Result<(SchemaTransition, [u8; 16]), Error> {
if !bytes.starts_with(MAGIC) {
return Err(Error::InvalidTransition);
}
if !(102..=MAX_FRAME).contains(&bytes.len()) {
return Err(Error::Corrupt);
}
let source = bytes[8..40].try_into().map_err(|_| Error::Corrupt)?;
let target = bytes[40..72].try_into().map_err(|_| Error::Corrupt)?;
let incarnation = bytes[72..88].try_into().map_err(|_| Error::Corrupt)?;
let mut reader = Decoder::new(&bytes[88..])?;
if reader.nat8()? != 0 {
return Err(Error::IncompatibleSchema);
}
let version = reader.nat32()?;
let name = reader.text(MAX_NAME)?;
let inputs = reader.blob(MAX_INPUTS)?;
reader.finish()?;
if source == target || incarnation == [0; 16] || version == 0 || name.is_empty() {
return Err(Error::Corrupt);
}
Ok((
SchemaTransition {
source,
target,
name,
version,
inputs,
},
incarnation,
))
}