Enum hdk::prelude::Op

pub enum Op {
    StoreElement {
        element: Element,
    },
    StoreEntry {
        header: SignedHashed<EntryCreationHeader>,
        entry: Entry,
    },
    RegisterUpdate {
        update: SignedHashed<Update>,
        new_entry: Entry,
        original_header: EntryCreationHeader,
        original_entry: Entry,
    },
    RegisterDelete {
        delete: SignedHashed<Delete>,
        original_header: EntryCreationHeader,
        original_entry: Entry,
    },
    RegisterAgentActivity {
        header: SignedHashed<Header>,
    },
    RegisterCreateLink {
        create_link: SignedHashed<CreateLink>,
    },
    RegisterDeleteLink {
        delete_link: SignedHashed<DeleteLink>,
        create_link: CreateLink,
    },
}

Dht Operational Transforms

These are the operational transformations that can be applied to Holochain data. Every Header produces a set of operations. These operations are each sent to an authority for validation.

Producing Operations

The following is a list of the operations that can be produced by each Header:

• Every Header produces a Op::RegisterAgentActivity and a Op::StoreElement.
• Header::Create also produces a Op::StoreEntry.
• Header::Update also produces a Op::StoreEntry and a Op::RegisterUpdate.
• Header::Delete also produces a Op::RegisterDelete.
• Header::CreateLink also produces a Op::RegisterCreateLink.
• Header::DeleteLink also produces a Op::RegisterDeleteLink.

Authorities

There are three types of authorities in Holochain:

The Header Authority

This set of authorities receives the Op::StoreElement. This is where you can implement your own logic for checking that it is valid to store any of the Header variants according to your own applications rules.

The Entry Authority

This set of authorities receives the Op::StoreEntry. This is where you can implement your own logic for checking that it is valid to store an Entry. You can think of this as the “Create” from the CRUD acronym.

Metadata

The entry authority is also responsible for storing the metadata for each entry. They receive the Op::RegisterUpdate and Op::RegisterDelete. This is where you can implement your own logic for checking that it is valid to update or delete any of the Entry types defined in your application. You can think of this as the “Update” and “Delete” from the CRUD acronym.

They receive the Op::RegisterCreateLink and Op::RegisterDeleteLink. This is where you can implement your own logic for checking that it is valid to place a link on a base Entry.

The Chain Authority

This set of authorities receives the Op::RegisterAgentActivity. This is where you can implement your own logic for checking that it is valid to add a new Header to an agent source chain. You are not validating the individual element but the entire agents source chain.

Author

When authoring a new Header to your source chain, the validation will be run from the perspective of every authority.

A note on metadata for the Header authority.

Technically speaking the Header authority also receives and validates the Op::RegisterUpdate and Op::RegisterDelete but they run the same callback as the Entry authority because it would be inconsistent to have two separate validation outcomes for these ops.

Running Validation

When the fn validate(op: Op) -> ExternResult<ValidateCallbackResult> is called it will be passed the operation variant for the authority that is actually running the validation.

For example the entry authority will be passed the Op::StoreEntry operation. The operational transforms that can are applied to Holochain data. Operations beginning with Store are concerned with creating and storing data. Operations beginning with Register are concerned with registering metadata about the data.

Variants

StoreElement

Fields

element: Element

The Element to store.

Stores a new Element in the DHT. This is the act of creating a new Header and publishing it to the DHT. Note that not all Headers contain an Entry.

StoreEntry

Fields

header: SignedHashed<EntryCreationHeader>

The signed and hashed EntryCreationHeader that creates a new instance of the Entry.

entry: Entry

The new Entry to store.

Stores a new Entry in the DHT. This is the act of creating a either a Header::Create or a Header::Update and publishing it to the DHT. These headers create a new instance of an Entry.

RegisterUpdate

Fields

update: SignedHashed<Update>

The signed and hashed Header::Update that registers the update.

new_entry: Entry

The new Entry that is being updated to.

original_header: EntryCreationHeader

The original EntryCreationHeader that created the original Entry. Note that the update points to a specific instance of the of the original Entry.

original_entry: Entry

The original Entry that is being updated from.

Registers an update from an instance of an Entry in the DHT. This is the act of creating a Header::Update and publishing it to the DHT. Note that the Header::Update stores an new instance of an Entry and registers it as an update to the original Entry. This operation is only concerned with registering the update.

RegisterDelete

Fields

delete: SignedHashed<Delete>

The signed and hashed Header::Delete that registers the deletion.

original_header: EntryCreationHeader

The original EntryCreationHeader that created the original Entry.

original_entry: Entry

The original Entry that is being deleted.

Registers a deletion of an instance of an Entry in the DHT. This is the act of creating a Header::Delete and publishing it to the DHT.

RegisterAgentActivity

Fields

header: SignedHashed<Header>

The signed and hashed Header that is being registered.

Registers a new Header on an agent source chain. This is the act of creating any Header and publishing it to the DHT.

RegisterCreateLink

Fields

create_link: SignedHashed<CreateLink>

The signed and hashed Header::CreateLink that registers the link.

Registers a link between two Entrys. This is the act of creating a Header::CreateLink and publishing it to the DHT. The authority is the entry authority for the base Entry.

RegisterDeleteLink

Fields

delete_link: SignedHashed<DeleteLink>

The signed and hashed Header::DeleteLink that registers the deletion.

create_link: CreateLink

The link that is being deleted.

Deletes a link between two Entrys. This is the act of creating a Header::DeleteLink and publishing it to the DHT. The delete always references a specific Header::CreateLink.

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Op

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Op, <__D as Deserializer<'de>>::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<Op> for Op

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

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

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

This method tests for !=.

impl Serialize for Op

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'_> TryFrom<&'_ Op> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<Op> for SerializedBytes

type Error = SerializedBytesError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<SerializedBytes> for Op

type Error = SerializedBytesError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl StructuralPartialEq for Op