Enum holochain_types::dht_op::DhtOp

StoreRecord(Signature, Action, Option<Box<Entry>>)

Used to notify the authority for an action that it has been created.

Conceptually, authorities receiving this DhtOp do three things:

Ensure that the record passes validation.
Store the action into their DHT shard.
Store the entry into their CAS.
- Note: they do not become responsible for keeping the set of references from that entry up-to-date.

StoreEntry(Signature, NewEntryAction, Box<Entry>)

Used to notify the authority for an entry that it has been created anew. (The same entry can be created more than once.)

Conceptually, authorities receiving this DhtOp do four things:

Ensure that the record passes validation.
Store the entry into their DHT shard.
Store the action into their CAS.
- Note: they do not become responsible for keeping the set of references from that action up-to-date.
Add a “created-by” reference from the entry to the hash of the action.

TODO: document how those “created-by” references are stored in reality.

RegisterAgentActivity(Signature, Action)

Used to notify the authority for an agent’s public key that that agent has committed a new action.

Conceptually, authorities receiving this DhtOp do three things:

Ensure that the action alone passes surface-level validation.
Store the action into their DHT shard.
- FIXME: @artbrock, do they?
Add an “agent-activity” reference from the public key to the hash of the action.

TODO: document how those “agent-activity” references are stored in reality.

RegisterUpdatedContent(Signature, Update, Option<Box<Entry>>)

Op for updating an entry. This is sent to the entry authority.

RegisterUpdatedRecord(Signature, Update, Option<Box<Entry>>)

Op for updating a record. This is sent to the record authority.

RegisterDeletedBy(Signature, Delete)

Op for registering an action deletion with the Action authority

RegisterDeletedEntryAction(Signature, Delete)

Op for registering an action deletion with the Entry authority, so that the Entry can be marked Dead if all of its Actions have been deleted

RegisterAddLink(Signature, CreateLink)

Op for adding a link

RegisterRemoveLink(Signature, DeleteLink)

Op for removing a link

Implementations§

impl DhtOp

pub fn dht_basis(&self) -> OpBasis

Returns the basis hash which determines which agents will receive this DhtOp

Examples found in repository ?

src/dht_op.rs (line 118)

    fn loc(&self) -> Loc {
        self.dht_basis().get_loc()
    }

    fn timestamp(&self) -> Timestamp {
        self.timestamp()
    }

    fn region_data(&self) -> RegionData {
        unimplemented!()
    }

    fn bound(_timestamp: Timestamp, _loc: kitsune_p2p_dht::Loc) -> Self {
        unimplemented!()
    }
}

/// A type for storing in databases that don't need the actual
/// data. Everything is a hash of the type except the signatures.
#[allow(missing_docs)]
#[derive(Clone, Debug, Serialize, Deserialize, derive_more::Display)]
pub enum DhtOpLight {
    #[display(fmt = "StoreRecord")]
    StoreRecord(ActionHash, Option<EntryHash>, OpBasis),
    #[display(fmt = "StoreEntry")]
    StoreEntry(ActionHash, EntryHash, OpBasis),
    #[display(fmt = "RegisterAgentActivity")]
    RegisterAgentActivity(ActionHash, OpBasis),
    #[display(fmt = "RegisterUpdatedContent")]
    RegisterUpdatedContent(ActionHash, EntryHash, OpBasis),
    #[display(fmt = "RegisterUpdatedRecord")]
    RegisterUpdatedRecord(ActionHash, EntryHash, OpBasis),
    #[display(fmt = "RegisterDeletedBy")]
    RegisterDeletedBy(ActionHash, OpBasis),
    #[display(fmt = "RegisterDeletedEntryAction")]
    RegisterDeletedEntryAction(ActionHash, OpBasis),
    #[display(fmt = "RegisterAddLink")]
    RegisterAddLink(ActionHash, OpBasis),
    #[display(fmt = "RegisterRemoveLink")]
    RegisterRemoveLink(ActionHash, OpBasis),
}

impl PartialEq for DhtOpLight {
    fn eq(&self, other: &Self) -> bool {
        // The ops are the same if they are the same type on the same action hash.
        // We can't derive eq because `Option<EntryHash>` doesn't make the op different.
        // We can ignore the basis because the basis is derived from the action and op type.
        self.get_type() == other.get_type() && self.action_hash() == other.action_hash()
    }
}

impl Eq for DhtOpLight {}

impl std::hash::Hash for DhtOpLight {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.get_type().hash(state);
        self.action_hash().hash(state);
    }
}

/// This enum is used to
#[allow(missing_docs)]
#[derive(
    Clone,
    Copy,
    Debug,
    Serialize,
    Deserialize,
    Eq,
    PartialEq,
    Hash,
    derive_more::Display,
    strum_macros::EnumString,
)]
pub enum DhtOpType {
    #[display(fmt = "StoreRecord")]
    StoreRecord,
    #[display(fmt = "StoreEntry")]
    StoreEntry,
    #[display(fmt = "RegisterAgentActivity")]
    RegisterAgentActivity,
    #[display(fmt = "RegisterUpdatedContent")]
    RegisterUpdatedContent,
    #[display(fmt = "RegisterUpdatedRecord")]
    RegisterUpdatedRecord,
    #[display(fmt = "RegisterDeletedBy")]
    RegisterDeletedBy,
    #[display(fmt = "RegisterDeletedEntryAction")]
    RegisterDeletedEntryAction,
    #[display(fmt = "RegisterAddLink")]
    RegisterAddLink,
    #[display(fmt = "RegisterRemoveLink")]
    RegisterRemoveLink,
}

impl ToSql for DhtOpType {
    fn to_sql(
        &self,
    ) -> holochain_sqlite::rusqlite::Result<holochain_sqlite::rusqlite::types::ToSqlOutput> {
        Ok(holochain_sqlite::rusqlite::types::ToSqlOutput::Owned(
            format!("{}", self).into(),
        ))
    }
}

impl FromSql for DhtOpType {
    fn column_result(
        value: holochain_sqlite::rusqlite::types::ValueRef<'_>,
    ) -> holochain_sqlite::rusqlite::types::FromSqlResult<Self> {
        String::column_result(value).and_then(|string| {
            DhtOpType::from_str(&string)
                .map_err(|_| holochain_sqlite::rusqlite::types::FromSqlError::InvalidType)
        })
    }
}

impl DhtOp {
    fn as_unique_form(&self) -> UniqueForm<'_> {
        match self {
            Self::StoreRecord(_, action, _) => UniqueForm::StoreRecord(action),
            Self::StoreEntry(_, action, _) => UniqueForm::StoreEntry(action),
            Self::RegisterAgentActivity(_, action) => UniqueForm::RegisterAgentActivity(action),
            Self::RegisterUpdatedContent(_, action, _) => {
                UniqueForm::RegisterUpdatedContent(action)
            }
            Self::RegisterUpdatedRecord(_, action, _) => UniqueForm::RegisterUpdatedRecord(action),
            Self::RegisterDeletedBy(_, action) => UniqueForm::RegisterDeletedBy(action),
            Self::RegisterDeletedEntryAction(_, action) => {
                UniqueForm::RegisterDeletedEntryAction(action)
            }
            Self::RegisterAddLink(_, action) => UniqueForm::RegisterAddLink(action),
            Self::RegisterRemoveLink(_, action) => UniqueForm::RegisterRemoveLink(action),
        }
    }

    /// Returns the basis hash which determines which agents will receive this DhtOp
    pub fn dht_basis(&self) -> OpBasis {
        self.as_unique_form().basis()
    }

    /// Convert a [DhtOp] to a [DhtOpLight] and basis
    pub fn to_light(
        // Hoping one day we can work out how to go from `&Create`
        // to `&Action::Create(Create)` so punting on a reference
        &self,
    ) -> DhtOpLight {
        let basis = self.dht_basis();
        match self {
            DhtOp::StoreRecord(_, a, _) => {
                let e = a.entry_data().map(|(e, _)| e.clone());
                let h = ActionHash::with_data_sync(a);
                DhtOpLight::StoreRecord(h, e, basis)
            }
            DhtOp::StoreEntry(_, a, _) => {
                let e = a.entry().clone();
                let h = ActionHash::with_data_sync(&Action::from(a.clone()));
                DhtOpLight::StoreEntry(h, e, basis)
            }
            DhtOp::RegisterAgentActivity(_, a) => {
                let h = ActionHash::with_data_sync(a);
                DhtOpLight::RegisterAgentActivity(h, basis)
            }
            DhtOp::RegisterUpdatedContent(_, a, _) => {
                let e = a.entry_hash.clone();
                let h = ActionHash::with_data_sync(&Action::from(a.clone()));
                DhtOpLight::RegisterUpdatedContent(h, e, basis)
            }
            DhtOp::RegisterUpdatedRecord(_, a, _) => {
                let e = a.entry_hash.clone();
                let h = ActionHash::with_data_sync(&Action::from(a.clone()));
                DhtOpLight::RegisterUpdatedRecord(h, e, basis)
            }
            DhtOp::RegisterDeletedBy(_, a) => {
                let h = ActionHash::with_data_sync(&Action::from(a.clone()));
                DhtOpLight::RegisterDeletedBy(h, basis)
            }
            DhtOp::RegisterDeletedEntryAction(_, a) => {
                let h = ActionHash::with_data_sync(&Action::from(a.clone()));
                DhtOpLight::RegisterDeletedEntryAction(h, basis)
            }
            DhtOp::RegisterAddLink(_, a) => {
                let h = ActionHash::with_data_sync(&Action::from(a.clone()));
                DhtOpLight::RegisterAddLink(h, basis)
            }
            DhtOp::RegisterRemoveLink(_, a) => {
                let h = ActionHash::with_data_sync(&Action::from(a.clone()));
                DhtOpLight::RegisterRemoveLink(h, basis)
            }
        }
    }

pub fn to_light(&self) -> DhtOpLight

Convert a DhtOp to a DhtOpLight and basis

pub fn signature(&self) -> &Signature

Get the signature for this op

pub fn into_inner(self) -> (Signature, Action, Option<Entry>)

Extract inner Signature, Action and Option from an op

pub fn action(&self) -> Action

Get the action from this op This requires cloning and converting the action as some ops don’t hold the Action type

Examples found in repository ?

src/dht_op/facts.rs (line 21)

pub fn valid_dht_op(
    keystore: MetaLairClient,
    author: AgentPubKey,
    must_be_public: bool,
) -> Facts<'static, DhtOp> {
    facts![
        brute(
            "Action type matches Entry existence, and is public if exists",
            move |op: &DhtOp| {
                let action = op.action();
                let h = action.entry_data();
                let e = op.entry();
                match (h, e) {
                    (Some((_entry_hash, entry_type)), Some(_e)) => {
                        // Ensure that entries are public
                        !must_be_public || entry_type.visibility().is_public()
                    }
                    (None, None) => true,
                    _ => false,
                }
            }
        ),
        mapped(
            "If there is entry data, the action must point to it",
            |op: &DhtOp| {
                if let Some(entry) = op.entry() {
                    // NOTE: this could be a `lens` if the previous check were short-circuiting,
                    // but it is possible that this check will run even if the previous check fails,
                    // so use a prism instead.
                    facts![prism(
                        "action's entry hash",
                        |op: &mut DhtOp| op.action_entry_data_mut().map(|(hash, _)| hash),
                        eq("hash of matching entry", EntryHash::with_data_sync(entry)),
                    )]
                } else {
                    facts![always()]
                }
            }
        ),
        lens(
            "The author is the one specified",
            DhtOp::author_mut,
            eq_(author)
        ),
        mapped("The Signature matches the Action", move |op: &DhtOp| {
            use holochain_keystore::AgentPubKeyExt;
            let action = op.action();
            let agent = action.author();
            let actual = tokio_helper::block_forever_on(agent.sign(&keystore, &action))
                .expect("Can sign the action");
            facts![lens("signature", DhtOp::signature_mut, eq_(actual))]
        })
    ]
}

pub fn entry(&self) -> Option<&Entry>

Get the entry from this op, if one exists

Examples found in repository ?

src/dht_op.rs (line 431)

    pub fn enzymatic_countersigning_enzyme(&self) -> Option<&AgentPubKey> {
        if let Some(Entry::CounterSign(session_data, _)) = self.entry() {
            if session_data.preflight_request().enzymatic {
                session_data
                    .preflight_request()
                    .signing_agents
                    .get(0)
                    .map(|(pubkey, _)| pubkey)
            } else {
                None
            }
        } else {
            None
        }
    }

More examples

Hide additional examples

src/dht_op/facts.rs (line 23)

pub fn valid_dht_op(
    keystore: MetaLairClient,
    author: AgentPubKey,
    must_be_public: bool,
) -> Facts<'static, DhtOp> {
    facts![
        brute(
            "Action type matches Entry existence, and is public if exists",
            move |op: &DhtOp| {
                let action = op.action();
                let h = action.entry_data();
                let e = op.entry();
                match (h, e) {
                    (Some((_entry_hash, entry_type)), Some(_e)) => {
                        // Ensure that entries are public
                        !must_be_public || entry_type.visibility().is_public()
                    }
                    (None, None) => true,
                    _ => false,
                }
            }
        ),
        mapped(
            "If there is entry data, the action must point to it",
            |op: &DhtOp| {
                if let Some(entry) = op.entry() {
                    // NOTE: this could be a `lens` if the previous check were short-circuiting,
                    // but it is possible that this check will run even if the previous check fails,
                    // so use a prism instead.
                    facts![prism(
                        "action's entry hash",
                        |op: &mut DhtOp| op.action_entry_data_mut().map(|(hash, _)| hash),
                        eq("hash of matching entry", EntryHash::with_data_sync(entry)),
                    )]
                } else {
                    facts![always()]
                }
            }
        ),
        lens(
            "The author is the one specified",
            DhtOp::author_mut,
            eq_(author)
        ),
        mapped("The Signature matches the Action", move |op: &DhtOp| {
            use holochain_keystore::AgentPubKeyExt;
            let action = op.action();
            let agent = action.author();
            let actual = tokio_helper::block_forever_on(agent.sign(&keystore, &action))
                .expect("Can sign the action");
            facts![lens("signature", DhtOp::signature_mut, eq_(actual))]
        })
    ]
}

pub fn get_type(&self) -> DhtOpType

Get the type as a unit enum, for Display purposes

Examples found in repository ?

src/dht_op.rs (line 423)

422
423
424

    fn to_order(&self) -> OpOrder {
        OpOrder::new(self.get_type(), self.timestamp())
    }

pub fn from_type(
 op_type: DhtOpType,
 action: SignedAction,
 entry: Option<Entry>
) -> DhtOpResult<Self>

From a type, action and an entry (if there is one)

pub fn enzymatic_countersigning_enzyme(&self) -> Option<&AgentPubKey>

Enzymatic countersigning session ops need special handling so that they arrive at the enzyme and not elsewhere. If this isn’t an enzymatic countersigning session then the return will be None so can be used as a boolean for filtering with is_some().

Trait Implementations§

impl<'arbitrary> Arbitrary<'arbitrary> for DhtOp

fn arbitrary(u: &mut Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the given unstructured data. Read more

fn arbitrary_take_rest(u: Unstructured<'arbitrary>) -> Result<Self>

Generate an arbitrary value of Self from the entirety of the given unstructured data. Read more

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself. Read more

impl Clone for DhtOp

fn clone(&self) -> DhtOp

Returns a copy of the value. Read more

1.0.0 · source§

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

Performs copy-assignment from source. Read more

impl Debug for DhtOp

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

Formats the value using the given formatter. Read more

impl<'de> Deserialize<'de> for DhtOp

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>where
__D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

impl Display for DhtOp

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

Formats the value using the given formatter. Read more

impl HashableContent for DhtOp

type HashType = DhtOp

The HashType which this content will be hashed to

fn hash_type(&self) -> Self::HashType

The HashType which this content will be hashed to

fn hashable_content(&self) -> HashableContentBytes

Return a subset of the content, either as SerializedBytes “content”, which will be used to compute the hash, or as an already precomputed hash which will be used directly

impl OpRegion<RegionData> for DhtOp

fn loc(&self) -> Loc

The op’s Location

fn timestamp(&self) -> Timestamp

The op’s Timestamp

fn region_data(&self) -> RegionData

The RegionData that would be produced if this op were the only op in the region. The sum of these produces the RegionData for the whole region.

fn bound(_timestamp: Timestamp, _loc: Loc) -> Self

Create an Op with arbitrary data but that has the given timestamp and location. Used for bounded range queries based on the PartialOrd impl of the op.

fn coords(&self, topo: &Topology) -> SpacetimeQuantumCoords

The quantized space and time coordinates, based on the location and timestamp.

impl Ord for DhtOp

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 · source§

fn max(self, other: Self) -> Selfwhere
Self: Sized,

Compares and returns the maximum of two values. Read more

1.21.0 · source§

fn min(self, other: Self) -> Selfwhere
Self: Sized,

Compares and returns the minimum of two values. Read more

1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval. Read more

impl PartialEq<DhtOp> for DhtOp

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

This method tests for self and other values to be equal, and is used by ==.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<DhtOp> for DhtOp

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more

1.0.0 · source§

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

This method tests less than (for self and other) and is used by the < operator. Read more

1.0.0 · source§

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

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more

1.0.0 · source§

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

This method tests greater than (for self and other) and is used by the > operator. Read more

1.0.0 · source§

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

This method tests greater than or equal to (for self and other) and is used by the >= operator. Read more

impl Serialize for DhtOp

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
S: Serializer,

Serialize this value into the given Serde serializer. Read more

impl TryFrom<&DhtOp> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(t: &DhtOp) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl TryFrom<DhtOp> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(t: DhtOp) -> Result<SerializedBytes, SerializedBytesError>

Performs the conversion.

impl TryFrom<SerializedBytes> for DhtOp

type Error = SerializedBytesError

The type returned in the event of a conversion error.

fn try_from(sb: SerializedBytes) -> Result<DhtOp, SerializedBytesError>

Performs the conversion.

impl Eq for DhtOp

impl StructuralEq for DhtOp

impl StructuralPartialEq for DhtOp

Auto Trait Implementations§

impl UnwindSafe for DhtOp

Blanket Implementations§

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

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Any for Twhere
T: Any + ?Sized,

fn type_id_compat(&self) -> TypeId

TODO: once 1.33.0 is the minimum supported compiler version, remove Any::type_id_compat and use StdAny::type_id instead. https://github.com/rust-lang/rust/issues/27745