Implement HitHandler

Author: Joon-Mo Yang

codechain/main.rs

@@ -70,6 +70,7 @@ use clap::ArgMatches;
 use clogger::LoggerConfig;
 use cnetwork::{NetworkConfig, NetworkControl, NetworkControlError, NetworkService, SocketAddr};
 use creactor::EventLoop;
+use cstate::{ActionHandler, HitHandler};
 use csync::{BlockSyncExtension, ParcelSyncExtension, SnapshotService};
 use ctrlc::CtrlC;
 use fdlimit::raise_fd_limit;
@@ -266,7 +267,7 @@ fn run_node(matches: ArgMatches) -> Result<(), String> {
     let config = load_config(&matches)?;
 
     // Add handlers here to accept additional custom actions
-    let custom_action_handlers = vec![];
+    let custom_action_handlers: Vec<Arc<ActionHandler>> = vec![Arc::new(HitHandler::new())];
     let spec = config.operating.chain.spec(custom_action_handlers)?;
 
     let instance_id = config.operating.instance_id.unwrap_or(

state/src/action_handler/hit.rs

@@ -0,0 +1,85 @@
+// Copyright 2018 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use ccrypto::blake256;
+use ctypes::invoice::Invoice;
+use ctypes::parcel::Outcome;
+use primitives::{Bytes, H256};
+use rlp::{self, Decodable, DecoderError, Encodable, UntrustedRlp};
+use trie::TrieMut;
+
+use super::super::{StateResult, TopLevelState, TopState, TopStateInfo};
+use super::ActionHandler;
+
+const ACTION_ID: u8 = 0;
+
+pub struct HitAction {
+    increase: u8,
+}
+
+impl Decodable for HitAction {
+    fn decode(rlp: &UntrustedRlp) -> Result<Self, DecoderError> {
+        if rlp.item_count()? != 2 {
+            return Err(DecoderError::RlpIncorrectListLen)
+        }
+        if rlp.val_at::<u8>(0)? != ACTION_ID {
+            return Err(DecoderError::Custom("Unknown message id detected"))
+        }
+        Ok(Self {
+            increase: rlp.val_at(1)?,
+        })
+    }
+}
+
+pub struct HitHandler {}
+
+impl HitHandler {
+    pub fn new() -> Self {
+        Self {}
+    }
+
+    fn address(&self) -> H256 {
+        let mut hash: H256 = blake256(&b"metadata hit");
+        hash[0] = b'M';
+        hash
+    }
+}
+
+impl ActionHandler for HitHandler {
+    fn init(&self, state: &mut TrieMut) -> StateResult<()> {
+        let r = state.insert(&self.address(), &0u32.rlp_bytes());
+        debug_assert_eq!(Ok(None), r);
+        r?;
+        Ok(())
+    }
+
+    fn is_target(&self, bytes: &Bytes) -> bool {
+        HitAction::decode(&UntrustedRlp::new(bytes)).is_ok()
+    }
+
+    /// `bytes` must be valid encoding of HitAction
+    fn execute(&self, bytes: &Bytes, state: &mut TopLevelState) -> Option<StateResult<Outcome>> {
+        HitAction::decode(&UntrustedRlp::new(bytes)).ok().map(|action| {
+            let prev_counter: u32 = rlp::decode(&state.action_data(&self.address())?);
+            let increase = action.increase as u32;
+            state.update_action_data(&self.address(), (prev_counter + increase).rlp_bytes().to_vec())?;
+            Ok(Outcome::Single {
+                invoice: Invoice::Success,
+                error: None,
+            })
+        })
+    }
+}

state/src/action_handler/mod.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+mod hit;
+
 use ctypes::parcel::Outcome;
 use primitives::Bytes;
 use trie::TrieMut;
@@ -25,3 +27,5 @@ pub trait ActionHandler: Send + Sync {
     fn is_target(&self, bytes: &Bytes) -> bool;
     fn execute(&self, bytes: &Bytes, state: &mut TopLevelState) -> Option<StateResult<Outcome>>;
 }
+
+pub use self::hit::HitHandler;

state/src/lib.rs

@@ -51,7 +51,7 @@ mod traits;
 #[cfg(test)]
 pub mod tests;
 
-pub use action_handler::ActionHandler;
+pub use action_handler::{ActionHandler, HitHandler};
 pub use backend::{Backend, ShardBackend, TopBackend};
 pub use checkpoint::{CheckpointId, StateWithCheckpoint};
 pub use db::StateDB;