Feature/service persistence (#171)

* validator: adding Diesel ORM

* validator: making sure Iron::status is always avaialable

* ibid

* validator: presence-announcement REST API

* validator: adding Diesel setup

* Removing Diesel stuff from root of monorepo

* validator: adding Diesel migrations and setup

* validator: documenting how PresenceAnnouncement is different from presence.

* validator: added Chrono crate for datetime conversions into sql

* validator: restructured the presence module

* validator: removed presence announcements from persistence

* validator: commenting topology

* Adding staking to the mixmining service

* Start of mixmining + stake service

* validator: added a bit about mixmining to README

* validator: added Iron's params crate

* validator: reorganized mixmining service and db code

* validator: no need for this .env warning

* validator: removing params parser, it's now unused

* validator: adding json body parser library for Iron

* validator: adding spelling exceptions

* validator: adding bodyparser deps

* validator: ability to (de)serialize Mixnode struct

* validator: further announcement HTTP progress

* validator: simplified announcement route

* validator: injecting database and service into handler

* validator: renaming service and db variables

* validator: using camelCase json

* validator: using base Iron handler rather than middleware handler

* validator: better error message on unexpected json parsing

* validator: adding 'location' to  presence::Announcement

* comments on mixmining::Db

* validator: commenting out unused mixmining::Service methods for the moment

* validator: noting that we don't yet know how to measure capacity

* validator: comments

* validator: starting to add correct serializers in rest API

* validator: renaming a mixnode announcements

* validator: extracted route creation

* validator: going lower-case for node in "Mixnode"

* validator: removing the "announcement" model

* validator: renamed annoucements handlers

* validator: temporarily removed Chrono, remove it fully if it's not needed.

* validator: added all the needed Mixnode fields to the service model

* validator: moved models into their own file.

* validator: conversions to/from api vs service models

* validator: doing type conversions from rest to service models

* validator: unused import cleanup

* validator: rewrote mixmining service comments in light of recent thinking

* validator: some notes on type conversion tests

* wip

* validator: getting capacity from db works

* wip

* validator: eliminating borrows so we can have something pure to mutex out on

* validator: a working mutex on the mixmining service

* validator: renaming mixmining db get_capacity to capacity

* validator: making mixmining db capacity field private, using accessor

* validator: local capacity updates working

* validator: starting REST API for staking

* validator: fixing clippy warning

* validator: minor naming fixes on mixmining service

* validator: service mixnode and rest mixnode + topology conversions + tests

* validator: renaming mix_nodes to mixnodes for consistency

* validator: test fixtures for mixnode

* validator: moved service models into their own file

* validator: a properly-structured toplogy route

* validator: topology retrieval

* validator: killed test fixture warning

* validator: getting set for topology equality checks (testing purposes)

* validator: otherway conversions for topology and mixnode types

* validator: initial topology retrieval working

* validator: ditching go-ish variable name :)

* ibid

* validator: added a StakeUpdate struct to get around cargo fmt failing

* validator: commenting out struct so kill warning

* Ignoring validator vscode settings

* ibid

* ibid

Author: futurechimp

.gitignore

@@ -6,4 +6,5 @@
 target
 .env
 /.vscode/settings.json
+validator/.vscode
 sample-configs/validator-config.toml

Cargo.lock

@@ -9,10 +9,12 @@ edition = "2018"
 
 [dependencies]
 abci = "0.6.4"
+bodyparser = "0.8.0"
 byteorder = "1.3.2"
 clap = "2.33.0"
+# chrono = { version = "0.4.11", features = ["serde"] } TODO: remove this if I don't start using it again soon
+diesel = { version = "1.4.3", features = ["sqlite"] }
 dirs = "2.0.2"
-# Read notes https://crates.io/crates/dotenv - tl;dr: don't use in production, set environmental variables properly.
 dotenv = "0.15.0"
 futures = "0.3.1"
 iron = "0.6.1"

validator/Cargo.toml

@@ -4,10 +4,10 @@ Nym Validator
 The Nym Validator has several jobs: 
 
 * use Tendermint (v0.33.0) to maintain a total global ordering of incoming transactions
-* track quality of service for mixnet nodes (mixmining)
+* rewards + stake slashing based quality of service  measurements for mixnet nodes (aka "mixmining")
 * generate Coconut credentials and ensure they're not double spent
 * maintain a decentralized directory of all Nym nodes that have staked into the system
-  
+
 Some of these functions may be moved away to their own node types in the future, for example to increase scalability or performance. At the moment, we'd like to keep deployments simple, so they're all in the validator node.
 
 Running the validator on your local machine

validator/README.md

@@ -0,0 +1,5 @@
+# For documentation on how to configure this file,
+# see diesel.rs/guides/configuring-diesel-cli
+
+[print_schema]
+file = "src/schema.rs"

validator/diesel.toml

@@ -0,0 +1,62 @@
+use serde::{Deserialize, Serialize};
+
+use super::*;
+use bodyparser::Struct;
+use iron::mime::Mime;
+use iron::status;
+use iron::Handler;
+
+/// Holds data for a capacity update (json)
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Capacity {
+    value: usize,
+}
+
+pub struct Update {
+    service: Arc<Mutex<mixmining::Service>>,
+}
+
+impl Update {
+    pub fn new(service: Arc<Mutex<mixmining::Service>>) -> Update {
+        Update { service }
+    }
+}
+
+impl Handler for Update {
+    fn handle(&self, req: &mut Request) -> IronResult<Response> {
+        let json_parse = req.get::<Struct<Capacity>>();
+
+        if json_parse.is_ok() {
+            let capacity = json_parse
+                .unwrap()
+                .expect("Unexpected JSON parsing problem")
+                .value;
+            self.service.lock().unwrap().set_capacity(capacity);
+            Ok(Response::with(status::Created))
+        } else {
+            let error = json_parse.unwrap_err();
+            Ok(Response::with((status::BadRequest, error.detail)))
+        }
+    }
+}
+
+pub struct Get {
+    service: Arc<Mutex<mixmining::Service>>,
+}
+
+impl Get {
+    pub fn new(service: Arc<Mutex<mixmining::Service>>) -> Get {
+        Get { service }
+    }
+}
+
+impl Handler for Get {
+    fn handle(&self, _: &mut Request) -> IronResult<Response> {
+        let content_type = "application/json".parse::<Mime>().unwrap();
+        let value = self.service.lock().unwrap().capacity();
+        let c = Capacity { value };
+        let json = serde_json::to_string(&c).unwrap();
+        Ok(Response::with((content_type, status::Ok, json)))
+    }
+}

validator/migrations/.gitkeep

@@ -11,33 +11,62 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-
+use crate::services::mixmining;
 use iron::prelude::*;
+use presence::mixnode;
+use presence::topology;
 use router::Router;
+use std::sync::{Arc, Mutex};
 
-mod models;
-mod routes;
+mod capacity;
+mod presence;
+mod staking;
 
-pub struct Api {}
+pub struct Api {
+    mixmining_service: Arc<Mutex<mixmining::Service>>,
+}
 
 impl Api {
-    pub fn new() -> Api {
-        Api {}
+    pub fn new(mixmining_service: mixmining::Service) -> Api {
+        let service = Arc::new(Mutex::new(mixmining_service));
+        Api {
+            mixmining_service: service,
+        }
     }
 
+    /// Run the REST API.
     pub async fn run(self) {
-        let port = 3000;
-        println!("* starting REST API on localhost:{}", port);
+        let port = 3000; // TODO: make this configurable
+        let address = format!("localhost:{}", port);
+        println!("* starting REST API on http://{}", address);
+
+        let router = self.setup_router();
 
-        let router = self.setup_routes();
-        Iron::new(router)
-            .http(format!("localhost:{}", port))
-            .unwrap();
+        Iron::new(router).http(address).unwrap();
     }
 
-    pub fn setup_routes(&self) -> Router {
+    /// Tie together URL route paths with handler functions.
+    fn setup_router(self) -> Router {
+        // define a Router to hold our routes
         let mut router = Router::new();
-        router.get("/topology", routes::topology::get, "topology_get");
+
+        // set up handlers
+        let capacity_update = capacity::Update::new(Arc::clone(&self.mixmining_service));
+        let capacity_get = capacity::Get::new(Arc::clone(&self.mixmining_service));
+        let presence_mixnode_create =
+            mixnode::CreatePresence::new(Arc::clone(&self.mixmining_service));
+        let topology_get = topology::GetTopology::new(Arc::clone(&self.mixmining_service));
+
+        // tie routes to handlers
+        router.get("/capacity", capacity_get, "capacity_get");
+        router.post("/capacity", capacity_update, "capacity_update");
+        router.get("/topology", topology_get, "topology_get");
+        router.post(
+            "/presence/mixnodes",
+            presence_mixnode_create,
+            "presence_mixnodes_post",
+        );
+
         router
     }
 }