Feature/service persistence

.gitignore

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

validator/Cargo.toml

@@ -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/README.md

@@ -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/diesel.toml

@@ -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/src/network/rest/capacity/mod.rs

@@ -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/src/network/rest/mod.rs

@@ -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
     }
 }