[needs review] 946 feature HeaderWithItsEntry

.gitignore

@@ -44,3 +44,5 @@ Cargo.lock
 !/Cargo.lock
 
 stress-test/passthrough-dna.dna.json
+
+.vscode/

crates/cli/src/main.rs

@@ -209,7 +209,7 @@ fn run() -> HolochainResult<()> {
                     return Err(HolochainError::Default(format_err!(
                         "Failed to parse properties argument as JSON: {:?}",
                         e
-                    )))
+                    )));
                 }
             }
         }

crates/conductor_lib/src/conductor/admin.rs

@@ -222,7 +222,7 @@ impl ConductorAdmin for Conductor {
                 return Err(HolochainError::ConfigError(format!(
                     "Invalid storage option: {}",
                     s
-                )))
+                )));
             }
         };
 

crates/core/src/action.rs

@@ -4,7 +4,7 @@ use crate::{
     network::{
         direct_message::DirectMessage,
         entry_aspect::EntryAspect,
-        entry_with_header::EntryWithHeader,
+        header_with_its_entry::HeaderWithItsEntry,
         query::{GetLinksNetworkQuery, NetworkQueryResult},
         state::NetworkState,
     },
@@ -127,7 +127,7 @@ pub enum Action {
     HoldAspect(EntryAspect),
 
     //action for updating crudstatus
-    CrudStatus((EntryWithHeader, CrudStatus)),
+    CrudStatus((HeaderWithItsEntry, CrudStatus)),
 
     // ----------------
     // Network actions:

crates/core/src/agent/state.rs

@@ -1,7 +1,7 @@
 use crate::{
     action::{Action, ActionWrapper, AgentReduceFn},
     agent::chain_store::{ChainStore, ChainStoreIterator},
-    network::entry_with_header::EntryWithHeader,
+    network::header_with_its_entry::HeaderWithItsEntry,
     state::State,
 };
 use holochain_persistence_api::cas::content::{Address, AddressableContent, Content};
@@ -221,13 +221,13 @@ pub fn create_new_chain_header(
     ))
 }
 
-/// Create an entry-with-header for a header.
+/// Creates a `HeaderWithItsEntry` for a `ChainHeader`.
 /// Since published headers are treated as entries, the header must also
 /// have its own header!
-pub fn create_entry_with_header_for_header(
+pub fn create_header_with_its_entry_for_header(
     root_state: &StateWrapper,
     chain_header: ChainHeader,
-) -> Result<EntryWithHeader, HolochainError> {
+) -> Result<HeaderWithItsEntry, HolochainError> {
     let timestamp = chain_header.timestamp().clone();
     let entry = Entry::ChainHeader(chain_header);
     // This header entry needs its own header so we can publish it.
@@ -251,7 +251,7 @@ pub fn create_entry_with_header_for_header(
         &None,
         &timestamp,
     );
-    Ok(EntryWithHeader { entry, header })
+    HeaderWithItsEntry::try_from_header_and_entry(header, entry)
 }
 
 /// Do a Commit Action against an agent state.

crates/core/src/dht/dht_reducers.rs

@@ -6,6 +6,7 @@ use crate::{
         dht_store::DhtStore,
         pending_validations::{PendingValidationWithTimeout, ValidationTimeout},
     },
+    error::HolochainError,
 };
 use std::sync::Arc;
 
@@ -81,10 +82,22 @@ pub(crate) fn reduce_hold_aspect(
     match aspect {
         EntryAspect::Content(entry, header) => {
             match reduce_store_entry_inner(&mut new_store, entry) {
-                Ok(()) => {
-                    new_store.add_header_for_entry(&entry, &header).ok()?;
-                    Some(new_store)
-                }
+                Ok(()) => match new_store.add_header_for_entry(&entry, &header) {
+                    Ok(()) => Some(new_store),
+                    Err(err) => {
+                        let err_msg = format!(
+                            "Tried to add the header for entry to the new
+                                store in reduce_hold_aspect, got error. {}",
+                            err
+                        );
+                        debug!(
+                            "{}, entry:\n{:?}\nheader:\n{:?} \nnew_store:\n{:?}",
+                            err_msg, entry, header, new_store
+                        );
+                        error!("{}", err_msg);
+                        None
+                    }
+                },
                 Err(e) => {
                     error!("{}", e);
                     None
@@ -191,7 +204,11 @@ pub fn reduce_prune(old_store: &DhtStore, _action_wrapper: &ActionWrapper) -> Op
         .unique_by(|p| {
             (
                 p.pending.workflow.clone(),
-                p.pending.entry_with_header.header.entry_address(),
+                p.pending
+                    .header_with_its_entry
+                    .header()
+                    .entry_address()
+                    .clone(),
             )
         })
         .cloned()
@@ -251,15 +268,18 @@ pub mod tests {
             pending_validations::{PendingValidation, PendingValidationStruct, ValidatingWorkflow},
         },
         instance::tests::test_context,
-        network::entry_with_header::EntryWithHeader,
+        network::header_with_its_entry::HeaderWithItsEntry,
         state::test_store,
     };
     use bitflags::_core::time::Duration;
     use holochain_core_types::{
         agent::{test_agent_id, test_agent_id_with_name},
-        chain_header::test_chain_header,
+        chain_header::{
+            test_chain_header, test_chain_header_for_link_entry, test_chain_header_for_sys_entry,
+            ChainHeader,
+        },
         eav::Attribute,
-        entry::{test_entry, test_sys_entry, Entry},
+        entry::{test_entry, test_link_entry, test_sys_entry, Entry},
         link::{link_data::LinkData, Link, LinkActionKind},
         network::entry_aspect::EntryAspect,
     };
@@ -280,6 +300,7 @@ pub mod tests {
 
     #[test]
     fn reduce_hold_aspect_test() {
+        enable_logging_for_test();
         let context = test_context("bob", None);
         let store = test_store(context);
 
@@ -290,7 +311,7 @@ pub mod tests {
             &store.dht(),
             &ActionWrapper::new(Action::HoldAspect(EntryAspect::Content(
                 sys_entry.clone(),
-                test_chain_header(),
+                test_chain_header_for_sys_entry(),
             ))),
         )
         .expect("there should be a new store for committing a sys entry");
@@ -541,23 +562,47 @@ pub mod tests {
         assert_eq!(&entry, &result_entry,);
     }
 
-    fn create_pending_validation(entry: Entry, workflow: ValidatingWorkflow) -> PendingValidation {
-        let entry_with_header = EntryWithHeader {
-            entry: entry.clone(),
-            header: test_chain_header(),
-        };
-
-        Arc::new(PendingValidationStruct::new(entry_with_header, workflow))
+    fn try_create_pending_validation(
+        entry: Entry,
+        header: ChainHeader,
+        workflow: ValidatingWorkflow,
+    ) -> Result<PendingValidation, HolochainError> {
+        match HeaderWithItsEntry::try_from_header_and_entry(header.clone(), entry.clone()) {
+            Ok(header_with_its_entry) => Arc::new(PendingValidationStruct::new(
+                header_with_its_entry,
+                workflow,
+            )),
+            Err(err) => {
+                let err_msg = format!(
+                    "Tried to create a pending validation, got an error: {}",
+                    err
+                );
+                debug!(
+                    "{}, entry:\n{:?}\nheader from test_chain_header():\n{:?}\n",
+                    err_msg, entry, header
+                );
+                Err(err_msg)
+            }
+        }
     }
 
+    // Causes a header and entry mismatch when calling try_create_pending_validation()
+    // -> try_from_header_and_entry().
+    // Should be since link_entry doesn't match with test chain header
     #[test]
     pub fn test_holding_queue() {
+        enable_logging_for_test();
         let context = test_context("test", None);
         let store = DhtStore::new(context.dht_storage.clone(), context.eav_storage.clone());
         assert_eq!(store.queued_holding_workflows().len(), 0);
 
         let test_entry = test_entry();
-        let hold = create_pending_validation(test_entry.clone(), ValidatingWorkflow::HoldEntry);
+        let test_header = test_chain_header();
+        let hold = try_create_pending_validation(
+            test_entry.clone(),
+            test_header.clone(),
+            ValidatingWorkflow::HoldEntry,
+        );
         let action = ActionWrapper::new(Action::QueueHoldingWorkflow((
             hold.clone(),
             Some((SystemTime::now(), Duration::from_secs(10000))),
@@ -567,23 +612,11 @@ pub mod tests {
         assert_eq!(store.queued_holding_workflows().len(), 1);
         assert!(store.has_exact_queued_holding_workflow(&hold));
 
-        let test_link = String::from("test_link");
-        let test_tag = String::from("test-tag");
-        let link = Link::new(
-            &test_entry.address(),
-            &test_entry.address(),
-            &test_link.clone(),
-            &test_tag.clone(),
+        let hold_link = try_create_pending_validation(
+            test_link_entry(),
+            test_chain_header_for_link_entry(),
+            ValidatingWorkflow::HoldLink,
         );
-        let link_data = LinkData::from_link(
-            &link,
-            LinkActionKind::ADD,
-            test_chain_header(),
-            test_agent_id(),
-        );
-
-        let link_entry = Entry::LinkAdd(link_data.clone());
-        let hold_link = create_pending_validation(link_entry, ValidatingWorkflow::HoldLink);
         let action = ActionWrapper::new(Action::QueueHoldingWorkflow((hold_link.clone(), None)));
         let store = reduce_queue_holding_workflow(&store, &action).unwrap();
 
@@ -597,7 +630,11 @@ pub mod tests {
         let (next_pending, _) = store.next_queued_holding_workflow().unwrap();
         assert_eq!(hold_link, next_pending);
 
-        let update = create_pending_validation(test_entry.clone(), ValidatingWorkflow::UpdateEntry);
+        let update = try_create_pending_validation(
+            test_entry.clone(),
+            test_header,
+            ValidatingWorkflow::UpdateEntry,
+        );
         let action = ActionWrapper::new(Action::QueueHoldingWorkflow((update.clone(), None)));
         let store = reduce_queue_holding_workflow(&store, &action).unwrap();