NextGraph
/
nextgraph-rs
1
2
Fork 0
Code Issues 1 Pull Requests Packages Projects 2 Releases 3 Activity

removed some warnings

Browse Source
pull/19/head
Niko PLP 6 months ago
parent f03b6bcc10
commit abf898ac00
16 changed files with 136 additions and 197 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 18
      ng-wallet/src/types.rs
  2. 4
      p2p-broker/src/broker_store/account.rs
  3. 24
      p2p-net/src/actor.rs
  4. 21
      p2p-net/src/broker.rs
  5. 57
      p2p-net/src/connection.rs
  6. 9
      p2p-net/src/errors.rs
  7. 4
      p2p-net/src/lib.rs
  8. 14
      p2p-net/src/types.rs
  9. 7
      p2p-net/src/utils.rs
  10. 14
      p2p-repo/src/branch.rs
  11. 14
      p2p-repo/src/commit.rs
  12. 6
      p2p-repo/src/errors.rs
  13. 78
      p2p-repo/src/object.rs
  14. 12
      p2p-repo/src/site.rs
  15. 7
      p2p-repo/src/store.rs
  16. 44
      p2p-repo/src/types.rs

18
ng-wallet/src/types.rs
Unescape View File

@ -160,11 +160,23 @@ impl ClientV0 {
pub fn id(&self) -> String { pub fn id(&self) -> String {
self.priv_key.to_pub().to_string() self.priv_key.to_pub().to_string()
} }
#[deprecated(note = "**Don't use dummy method**")]
#[deprecated(note = "**Don't use nil method**")]
#[allow(deprecated)]
pub fn nil() -> Self {
ClientV0 {
priv_key: PrivKey::nil(),
storage_master_key: SymKey::nil(),
auto_open: vec![],
}
}
#[cfg(test)]
#[allow(deprecated)]
pub fn dummy() -> Self { pub fn dummy() -> Self {
ClientV0 { ClientV0 {
priv_key: PrivKey::dummy(), priv_key: PrivKey::nil(),
storage_master_key: SymKey::random(), storage_master_key: SymKey::nil(),
auto_open: vec![], auto_open: vec![],
} }
} }

4
p2p-broker/src/broker_store/account.rs
Unescape View File

@ -63,6 +63,8 @@ impl<'a> Account<'a> {
store.put(Self::PREFIX_ACCOUNT, &to_vec(&id)?, None, to_vec(&admin)?)?; store.put(Self::PREFIX_ACCOUNT, &to_vec(&id)?, None, to_vec(&admin)?)?;
Ok(acc) Ok(acc)
} }
#[allow(deprecated)]
pub fn get_all_users( pub fn get_all_users(
admins: bool, admins: bool,
store: &'a dyn KCVStore, store: &'a dyn KCVStore,
@ -199,7 +201,7 @@ impl<'a> Account<'a> {
// let mut id_and_client = to_vec(&self.id)?; // let mut id_and_client = to_vec(&self.id)?;
// let client_key = (client.clone(), hash); // let client_key = (client.clone(), hash);
// let mut client_key_ser = to_vec(&client_key)?; // let mut client_key_ser = to_vec(&client_key)?;
#[allow(deprecated)]
let client_key = (ClientId::nil(), 0u64); let client_key = (ClientId::nil(), 0u64);
let mut client_key_ser = to_vec(&client_key)?; let mut client_key_ser = to_vec(&client_key)?;
let size = client_key_ser.len() + id.len(); let size = client_key_ser.len() + id.len();

24
p2p-net/src/actor.rs
Unescape View File

@ -10,11 +10,9 @@
*/ */
use async_std::stream::StreamExt; use async_std::stream::StreamExt;
use async_std::sync::{Mutex, MutexGuard}; use async_std::sync::Mutex;
use futures::{channel::mpsc, SinkExt}; use futures::{channel::mpsc, SinkExt};
use serde::de::DeserializeOwned; use std::any::TypeId;
use std::any::{Any, TypeId};
use std::convert::From;
use std::sync::Arc; use std::sync::Arc;
use crate::utils::{spawn_and_log_error, Receiver, ResultSend, Sender}; use crate::utils::{spawn_and_log_error, Receiver, ResultSend, Sender};
@ -23,7 +21,7 @@ use std::marker::PhantomData;
impl TryFrom<ProtocolMessage> for () { impl TryFrom<ProtocolMessage> for () {
type Error = ProtocolError; type Error = ProtocolError;
fn try_from(msg: ProtocolMessage) -> Result<Self, Self::Error> { fn try_from(_msg: ProtocolMessage) -> Result<Self, Self::Error> {
Ok(()) Ok(())
} }
} }
@ -58,7 +56,7 @@ pub enum SoS<B> {
impl<B> SoS<B> { impl<B> SoS<B> {
pub fn is_single(&self) -> bool { pub fn is_single(&self) -> bool {
if let Self::Single(b) = self { if let Self::Single(_b) = self {
true true
} else { } else {
false false
@ -70,7 +68,7 @@ impl<B> SoS<B> {
pub fn unwrap_single(self) -> B { pub fn unwrap_single(self) -> B {
match self { match self {
Self::Single(s) => s, Self::Single(s) => s,
Self::Stream(s) => { Self::Stream(_s) => {
panic!("called `unwrap_single()` on a `Stream` value") panic!("called `unwrap_single()` on a `Stream` value")
} }
} }
@ -78,7 +76,7 @@ impl<B> SoS<B> {
pub fn unwrap_stream(self) -> Receiver<B> { pub fn unwrap_stream(self) -> Receiver<B> {
match self { match self {
Self::Stream(s) => s, Self::Stream(s) => s,
Self::Single(s) => { Self::Single(_s) => {
panic!("called `unwrap_stream()` on a `Single` value") panic!("called `unwrap_stream()` on a `Single` value")
} }
} }
@ -91,7 +89,7 @@ impl<
> Actor<'_, A, B> > Actor<'_, A, B>
{ {
pub fn new(id: i64, initiator: bool) -> Self { pub fn new(id: i64, initiator: bool) -> Self {
let (mut receiver_tx, receiver) = mpsc::unbounded::<ConnectionCommand>(); let (receiver_tx, receiver) = mpsc::unbounded::<ConnectionCommand>();
Self { Self {
id, id,
receiver: Some(receiver), receiver: Some(receiver),
@ -125,11 +123,11 @@ impl<
&& TypeId::of::<B>() != TypeId::of::<()>() && TypeId::of::<B>() != TypeId::of::<()>()
{ {
let (mut b_sender, b_receiver) = mpsc::unbounded::<B>(); let (mut b_sender, b_receiver) = mpsc::unbounded::<B>();
let response = msg.try_into().map_err(|e| ProtocolError::ActorError)?; let response = msg.try_into().map_err(|_e| ProtocolError::ActorError)?;
b_sender b_sender
.send(response) .send(response)
.await .await
.map_err(|err| ProtocolError::IoError)?; .map_err(|_err| ProtocolError::IoError)?;
async fn pump_stream<C: TryFrom<ProtocolMessage, Error = ProtocolError>>( async fn pump_stream<C: TryFrom<ProtocolMessage, Error = ProtocolError>>(
mut actor_receiver: Receiver<ConnectionCommand>, mut actor_receiver: Receiver<ConnectionCommand>,
mut sos_sender: Sender<C>, mut sos_sender: Sender<C>,
@ -193,15 +191,15 @@ impl<
} }
} }
#[cfg(test)]
mod test { mod test {
use crate::actor::*; use crate::actor::*;
use crate::actors::*; use crate::actors::*;
use crate::types::*;
#[async_std::test] #[async_std::test]
pub async fn test_actor() { pub async fn test_actor() {
let mut a = Actor::<Noise, Noise>::new(1, true); let _a = Actor::<Noise, Noise>::new(1, true);
// a.handle(ProtocolMessage::Start(StartProtocol::Client( // a.handle(ProtocolMessage::Start(StartProtocol::Client(
// ClientHello::Noise3(Noise::V0(NoiseV0 { data: vec![] })), // ClientHello::Noise3(Noise::V0(NoiseV0 { data: vec![] })),
// ))) // )))

21
p2p-net/src/broker.rs
Unescape View File

@ -9,7 +9,6 @@
* according to those terms. * according to those terms.
*/ */
use crate::actor::*;
use crate::connection::*; use crate::connection::*;
use crate::errors::*; use crate::errors::*;
use crate::server_storage::ServerStorage; use crate::server_storage::ServerStorage;
@ -21,8 +20,6 @@ use async_std::sync::{Arc, RwLock};
use either::Either; use either::Either;
use futures::channel::mpsc; use futures::channel::mpsc;
use futures::SinkExt; use futures::SinkExt;
use noise_protocol::U8Array;
use noise_rust_crypto::sensitive::Sensitive;
use once_cell::sync::Lazy; use once_cell::sync::Lazy;
use p2p_repo::log::*; use p2p_repo::log::*;
use p2p_repo::object::Object; use p2p_repo::object::Object;
@ -31,12 +28,6 @@ use p2p_repo::store::HashMapRepoStore;
use p2p_repo::types::*; use p2p_repo::types::*;
use p2p_repo::utils::generate_keypair; use p2p_repo::utils::generate_keypair;
use std::collections::HashMap; use std::collections::HashMap;
use std::net::IpAddr;
use std::ops::Deref;
use std::io::BufReader;
use std::io::Read;
use std::path::PathBuf;
#[derive(Debug)] #[derive(Debug)]
pub enum PeerConnection { pub enum PeerConnection {
@ -332,7 +323,7 @@ impl<'a> Broker<'a> {
} }
pub async fn doc_sync_branch(&mut self, anuri: String) -> (Receiver<Commit>, Sender<Commit>) { pub async fn doc_sync_branch(&mut self, anuri: String) -> (Receiver<Commit>, Sender<Commit>) {
let (mut tx, rx) = mpsc::unbounded::<Commit>(); let (tx, rx) = mpsc::unbounded::<Commit>();
let obj_ref = ObjectRef { let obj_ref = ObjectRef {
id: ObjectId::Blake3Digest32([ id: ObjectId::Blake3Digest32([
@ -637,7 +628,7 @@ impl<'a> Broker<'a> {
log_debug!("ATTACH PEER_ID {:?}", remote_peer_id); log_debug!("ATTACH PEER_ID {:?}", remote_peer_id);
let already = self.peers.get(&(None, remote_peer_id)); let already = self.peers.get(&(None, remote_peer_id));
if (already.is_some()) { if already.is_some() {
match already.unwrap().connected { match already.unwrap().connected {
PeerConnection::NONE => {} PeerConnection::NONE => {}
_ => { _ => {
@ -923,11 +914,11 @@ impl<'a> Broker<'a> {
} }
pub fn print_status(&self) { pub fn print_status(&self) {
self.peers.iter().for_each(|(peerId, peerInfo)| { self.peers.iter().for_each(|(peer_id, peer_info)| {
log_info!("PEER in BROKER {:?} {:?}", peerId, peerInfo); log_info!("PEER in BROKER {:?} {:?}", peer_id, peer_info);
}); });
self.direct_connections.iter().for_each(|(ip, directCnx)| { self.direct_connections.iter().for_each(|(ip, direct_cnx)| {
log_info!("direct_connection in BROKER {:?} {:?}", ip, directCnx); log_info!("direct_connection in BROKER {:?} {:?}", ip, direct_cnx);
}); });
self.anonymous_connections.iter().for_each(|(binds, cb)| { self.anonymous_connections.iter().for_each(|(binds, cb)| {
log_info!( log_info!(

57
p2p-net/src/connection.rs
Unescape View File

@ -23,14 +23,12 @@ use crate::errors::NetError;
use crate::errors::ProtocolError; use crate::errors::ProtocolError;
use crate::types::*; use crate::types::*;
use crate::utils::*; use crate::utils::*;
use async_std::future::TimeoutError;
use async_std::stream::StreamExt; use async_std::stream::StreamExt;
use async_std::sync::Mutex; use async_std::sync::Mutex;
use either::Either; use either::Either;
use futures::{channel::mpsc, select, Future, FutureExt, SinkExt}; use futures::{channel::mpsc, select, FutureExt, SinkExt};
use noise_protocol::U8Array;
use noise_protocol::{patterns::noise_xk, CipherState, HandshakeState}; use noise_protocol::{patterns::noise_xk, CipherState, HandshakeState};
use noise_rust_crypto::sensitive::Sensitive;
use noise_rust_crypto::*; use noise_rust_crypto::*;
use p2p_repo::log::*; use p2p_repo::log::*;
use p2p_repo::types::{PrivKey, PubKey, X25519PrivKey}; use p2p_repo::types::{PrivKey, PubKey, X25519PrivKey};
@ -260,7 +258,7 @@ impl NoiseFSM {
.as_mut() .as_mut()
.unwrap() .unwrap()
.decrypt_vec(ciphertext.data()) .decrypt_vec(ciphertext.data())
.map_err(|e| ProtocolError::DecryptionError)?; .map_err(|_e| ProtocolError::DecryptionError)?;
Ok(from_slice::<ProtocolMessage>(&ser)?) Ok(from_slice::<ProtocolMessage>(&ser)?)
} }
@ -288,13 +286,13 @@ impl NoiseFSM {
self.sender self.sender
.send(ConnectionCommand::Msg(ProtocolMessage::Noise(cipher))) .send(ConnectionCommand::Msg(ProtocolMessage::Noise(cipher)))
.await .await
.map_err(|e| ProtocolError::IoError)?; .map_err(|_e| ProtocolError::IoError)?;
return Ok(()); return Ok(());
} else { } else {
self.sender self.sender
.send(ConnectionCommand::Msg(msg)) .send(ConnectionCommand::Msg(msg))
.await .await
.map_err(|e| ProtocolError::IoError)?; .map_err(|_e| ProtocolError::IoError)?;
return Ok(()); return Ok(());
} }
} }
@ -351,7 +349,7 @@ impl NoiseFSM {
let _ = handshake let _ = handshake
.read_message_vec(noise.data()) .read_message_vec(noise.data())
.map_err(|e| ProtocolError::NoiseHandshakeFailed)?; .map_err(|_e| ProtocolError::NoiseHandshakeFailed)?;
if !handshake.completed() { if !handshake.completed() {
return Err(ProtocolError::NoiseHandshakeFailed); return Err(ProtocolError::NoiseHandshakeFailed);
@ -394,14 +392,14 @@ impl NoiseFSM {
// CLIENT LOCAL // CLIENT LOCAL
if !self.dir.is_server() && msg_opt.is_none() { if !self.dir.is_server() && msg_opt.is_none() {
self.state = FSMstate::ClientHello; self.state = FSMstate::ClientHello;
Box::new(Actor::<ClientHello, ServerHello>::new(0, true)); //Box::new(Actor::<ClientHello, ServerHello>::new(0, true));
return Ok(StepReply::NONE); return Ok(StepReply::NONE);
} }
// SERVER LOCAL // SERVER LOCAL
else if let Some(msg) = msg_opt.as_ref() { else if let Some(msg) = msg_opt.as_ref() {
if self.dir.is_server() && msg.type_id() == ClientHello::Local.type_id() { if self.dir.is_server() && msg.type_id() == ClientHello::Local.type_id() {
self.state = FSMstate::ServerHello; self.state = FSMstate::ServerHello;
Box::new(Actor::<ClientHello, ServerHello>::new(msg.id(), false)); //Box::new(Actor::<ClientHello, ServerHello>::new(msg.id(), false));
return Ok(StepReply::NONE); return Ok(StepReply::NONE);
} }
} }
@ -417,7 +415,7 @@ impl NoiseFSM {
self.state = FSMstate::Probe; self.state = FSMstate::Probe;
return Ok(StepReply::NONE); return Ok(StepReply::NONE);
} }
StartConfig::Relay(relay_to) => { StartConfig::Relay(_relay_to) => {
// RELAY REQUEST // RELAY REQUEST
//self.state //self.state
todo!(); todo!();
@ -439,7 +437,7 @@ impl NoiseFSM {
let payload = handshake let payload = handshake
.write_message_vec(&[]) .write_message_vec(&[])
.map_err(|e| ProtocolError::NoiseHandshakeFailed)?; .map_err(|_e| ProtocolError::NoiseHandshakeFailed)?;
let noise = Noise::V0(NoiseV0 { data: payload }); let noise = Noise::V0(NoiseV0 { data: payload });
self.send(noise.into()).await?; self.send(noise.into()).await?;
@ -514,7 +512,7 @@ impl NoiseFSM {
if id != 0 { if id != 0 {
return Err(ProtocolError::InvalidState); return Err(ProtocolError::InvalidState);
} }
if let ProtocolMessage::ProbeResponse(probe_res) = &msg { if let ProtocolMessage::ProbeResponse(_probe_res) = &msg {
return Ok(StepReply::Response(msg)); return Ok(StepReply::Response(msg));
} }
} }
@ -537,7 +535,7 @@ impl NoiseFSM {
let mut payload = handshake let mut payload = handshake
.read_message_vec(noise.data()) .read_message_vec(noise.data())
.map_err(|e| ProtocolError::NoiseHandshakeFailed)?; .map_err(|_e| ProtocolError::NoiseHandshakeFailed)?;
payload = handshake.write_message_vec(&payload).map_err(|e| { payload = handshake.write_message_vec(&payload).map_err(|e| {
log_debug!("{:?}", e); log_debug!("{:?}", e);
@ -552,19 +550,19 @@ impl NoiseFSM {
let mut next_step = StepReply::NONE; let mut next_step = StepReply::NONE;
match self.config.as_ref().unwrap() { match self.config.as_ref().unwrap() {
StartConfig::Client(client_config) => { StartConfig::Client(_client_config) => {
let noise3 = let noise3 =
ClientHello::Noise3(Noise::V0(NoiseV0 { data: payload })); ClientHello::Noise3(Noise::V0(NoiseV0 { data: payload }));
self.send(noise3.into()).await?; self.send(noise3.into()).await?;
self.state = FSMstate::ClientHello; self.state = FSMstate::ClientHello;
} }
StartConfig::Ext(ext_config) => { StartConfig::Ext(_ext_config) => {
todo!(); todo!();
} }
StartConfig::Core(core_config) => { StartConfig::Core(_core_config) => {
todo!(); todo!();
} }
StartConfig::Admin(admin_config) => { StartConfig::Admin(_admin_config) => {
let noise = Noise::V0(NoiseV0 { data: payload }); let noise = Noise::V0(NoiseV0 { data: payload });
self.send(noise.into()).await?; self.send(noise.into()).await?;
self.state = FSMstate::Noise3; self.state = FSMstate::Noise3;
@ -623,10 +621,10 @@ impl NoiseFSM {
StartConfig::Client(_) => { StartConfig::Client(_) => {
return Err(ProtocolError::InvalidState); return Err(ProtocolError::InvalidState);
} }
StartConfig::Ext(ext_config) => { StartConfig::Ext(_ext_config) => {
todo!(); todo!();
} }
StartConfig::Core(core_config) => { StartConfig::Core(_core_config) => {
todo!(); todo!();
} }
StartConfig::Admin(admin_config) => { StartConfig::Admin(admin_config) => {
@ -656,7 +654,7 @@ impl NoiseFSM {
StartProtocol::Client(_) => { StartProtocol::Client(_) => {
return Err(ProtocolError::InvalidState); return Err(ProtocolError::InvalidState);
} }
StartProtocol::Ext(ext_config) => { StartProtocol::Ext(_ext_config) => {
todo!(); todo!();
} }
// StartProtocol::Core(core_config) => { // StartProtocol::Core(core_config) => {
@ -730,8 +728,7 @@ impl NoiseFSM {
} }
} }
} }
FSMstate::ServerHello => FSMstate::ServerHello => {
{
#[cfg(not(target_arch = "wasm32"))] #[cfg(not(target_arch = "wasm32"))]
if let Some(msg) = msg_opt.as_ref() { if let Some(msg) = msg_opt.as_ref() {
if self.dir.is_server() { if self.dir.is_server() {
@ -742,7 +739,7 @@ impl NoiseFSM {
let ser = serde_bare::to_vec(&client_auth.content_v0())?; let ser = serde_bare::to_vec(&client_auth.content_v0())?;
let mut result = ProtocolError::NoError; let result; //= ProtocolError::NoError;
let verif = verify(&ser, client_auth.sig(), client_auth.user()); let verif = verify(&ser, client_auth.sig(), client_auth.user());
if verif.is_err() { if verif.is_err() {
result = verif.unwrap_err().into(); result = verif.unwrap_err().into();
@ -768,7 +765,7 @@ impl NoiseFSM {
}); });
self.send(auth_result.into()).await?; self.send(auth_result.into()).await?;
if (result.is_err()) { if result.is_err() {
return Err(result); return Err(result);
} }
log_debug!("AUTHENTICATION SUCCESSFUL ! waiting for requests on the server side"); log_debug!("AUTHENTICATION SUCCESSFUL ! waiting for requests on the server side");
@ -782,7 +779,7 @@ impl NoiseFSM {
if let Some(msg) = msg_opt.as_ref() { if let Some(msg) = msg_opt.as_ref() {
if !self.dir.is_server() { if !self.dir.is_server() {
if let ProtocolMessage::AuthResult(auth_res) = msg { if let ProtocolMessage::AuthResult(auth_res) = msg {
if let StartConfig::Client(client_config) = if let StartConfig::Client(_client_config) =
self.config.as_ref().unwrap() self.config.as_ref().unwrap()
{ {
if auth_res.result() != 0 { if auth_res.result() != 0 {
@ -930,7 +927,7 @@ impl ConnectionBase {
log_debug!("EXIT READ LOOP because : {:?}", msg); log_debug!("EXIT READ LOOP because : {:?}", msg);
let mut lock = actors.lock().await; let mut lock = actors.lock().await;
for actor in lock.values_mut() { for actor in lock.values_mut() {
actor.send(msg.clone()).await; _ = actor.send(msg.clone()).await;
} }
break; break;
} }
@ -1146,7 +1143,7 @@ impl ConnectionBase {
self.close().await; self.close().await;
return Err(ProtocolError::WhereIsTheMagic); return Err(ProtocolError::WhereIsTheMagic);
}, },
r = shutdown.next().fuse() => { _r = shutdown.next().fuse() => {
self.fsm self.fsm
.as_mut() .as_mut()
.unwrap() .unwrap()
@ -1230,11 +1227,11 @@ impl ConnectionBase {
} }
} }
#[cfg(test)]
mod test { mod test {
use crate::actor::*;
use crate::actors::*; use crate::actors::*;
use crate::types::*;
use p2p_repo::log::*; use p2p_repo::log::*;
use std::any::{Any, TypeId}; use std::any::{Any, TypeId};

9
p2p-net/src/errors.rs
Unescape View File

@ -12,10 +12,7 @@ use num_enum::IntoPrimitive;
use num_enum::TryFromPrimitive; use num_enum::TryFromPrimitive;
use p2p_repo::object::ObjectParseError; use p2p_repo::object::ObjectParseError;
use p2p_repo::store::StorageError; use p2p_repo::store::StorageError;
use p2p_repo::types::Block;
use p2p_repo::types::ObjectId;
use std::convert::From; use std::convert::From;
use std::convert::TryFrom;
use std::error::Error; use std::error::Error;
#[derive(Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive, Clone)] #[derive(Debug, Eq, PartialEq, TryFromPrimitive, IntoPrimitive, Clone)]
@ -143,19 +140,19 @@ impl From<p2p_repo::errors::NgError> for ProtocolError {
} }
impl From<ObjectParseError> for ProtocolError { impl From<ObjectParseError> for ProtocolError {
fn from(e: ObjectParseError) -> Self { fn from(_e: ObjectParseError) -> Self {
ProtocolError::ObjectParseError ProtocolError::ObjectParseError
} }
} }
impl From<serde_bare::error::Error> for ProtocolError { impl From<serde_bare::error::Error> for ProtocolError {
fn from(e: serde_bare::error::Error) -> Self { fn from(_e: serde_bare::error::Error) -> Self {
ProtocolError::SerializationError ProtocolError::SerializationError
} }
} }
impl From<serde_bare::error::Error> for NetError { impl From<serde_bare::error::Error> for NetError {
fn from(e: serde_bare::error::Error) -> Self { fn from(_e: serde_bare::error::Error) -> Self {
NetError::SerializationError NetError::SerializationError
} }
} }

4
p2p-net/src/lib.rs
Unescape View File

@ -8,8 +8,8 @@
* notice may not be copied, modified, or distributed except * notice may not be copied, modified, or distributed except
* according to those terms. * according to those terms.
*/ */
#[macro_use] //#[macro_use]
extern crate p2p_repo; //extern crate p2p_repo;
pub mod types; pub mod types;

14
p2p-net/src/types.rs
Unescape View File

@ -12,16 +12,15 @@
//! Corresponds to the BARE schema //! Corresponds to the BARE schema
use crate::utils::{ use crate::utils::{
get_domain_without_port, get_domain_without_port_443, is_ipv4_private, is_ipv6_private, get_domain_without_port_443, is_ipv4_private, is_ipv6_private, is_private_ip, is_public_ip,
is_private_ip, is_public_ip, is_public_ipv4, is_public_ipv6, is_public_ipv4, is_public_ipv6,
}; };
use crate::{actor::EActor, actors::*, errors::ProtocolError}; use crate::{actor::EActor, actors::*, errors::ProtocolError};
use core::fmt; use core::fmt;
use p2p_repo::errors::NgError; use p2p_repo::errors::NgError;
use p2p_repo::log::*;
use p2p_repo::types::*; use p2p_repo::types::*;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::{ use std::{
any::{Any, TypeId}, any::{Any, TypeId},
net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr}, net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
@ -157,6 +156,7 @@ pub const APP_NG_ONE_URL: &str = "https://app.nextgraph.one";
pub const APP_NG_ONE_WS_URL: &str = "wss://app.nextgraph.one"; pub const APP_NG_ONE_WS_URL: &str = "wss://app.nextgraph.one";
#[allow(dead_code)]
fn api_dyn_peer_url(peer_id: &PubKey) -> String { fn api_dyn_peer_url(peer_id: &PubKey) -> String {
format!("https://nextgraph.one/api/v1/dynpeer/{}", peer_id) format!("https://nextgraph.one/api/v1/dynpeer/{}", peer_id)
} }
@ -328,7 +328,6 @@ impl BrokerServerV0 {
None None
} }
} }
_ => None,
} }
} }
@ -867,8 +866,8 @@ impl AcceptForwardForV0 {
pub fn get_public_bind_ipv6_address(&self) -> Option<IP> { pub fn get_public_bind_ipv6_address(&self) -> Option<IP> {
match self { match self {
AcceptForwardForV0::PublicStatic((ipv4, ipv6, _)) => { AcceptForwardForV0::PublicStatic((_ipv4, ipv6, _)) => {
let mut res = vec![ipv4.clone()]; //let _res = vec![ipv4.clone()];
if ipv6.is_some() { if ipv6.is_some() {
return Some(ipv6.unwrap().ip.clone()); return Some(ipv6.unwrap().ip.clone());
} else { } else {
@ -1087,7 +1086,6 @@ impl ListenerV0 {
res.push(BrokerServerTypeV0::BoxPrivate(addrs)); res.push(BrokerServerTypeV0::BoxPrivate(addrs));
} }
} }
_ => panic!("get_bootstrap missing"),
} }
res res
} }

7
p2p-net/src/utils.rs
Unescape View File

@ -9,16 +9,13 @@
* according to those terms. * according to those terms.
*/ */
use crate::broker::BROKER;
use crate::types::*; use crate::types::*;
use crate::NG_BOOTSTRAP_LOCAL_PATH;
use async_std::task; use async_std::task;
use ed25519_dalek::*; use ed25519_dalek::*;
use futures::{channel::mpsc, select, Future, FutureExt, SinkExt}; use futures::{channel::mpsc, Future};
use noise_protocol::U8Array; use noise_protocol::U8Array;
use noise_protocol::DH; use noise_protocol::DH;
use noise_rust_crypto::sensitive::Sensitive; use noise_rust_crypto::sensitive::Sensitive;
use p2p_repo::errors::NgError;
use p2p_repo::types::PubKey; use p2p_repo::types::PubKey;
use p2p_repo::{log::*, types::PrivKey}; use p2p_repo::{log::*, types::PrivKey};
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr}; use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
@ -54,9 +51,11 @@ where
}) })
} }
#[cfg(target_arch = "wasm32")]
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
const APP_PREFIX: &str = "http://localhost:14400"; const APP_PREFIX: &str = "http://localhost:14400";
#[cfg(target_arch = "wasm32")]
#[cfg(not(debug_assertions))] #[cfg(not(debug_assertions))]
const APP_PREFIX: &str = ""; const APP_PREFIX: &str = "";

14
p2p-repo/src/branch.rs
Unescape View File

@ -9,10 +9,9 @@
//! Branch of a Repository //! Branch of a Repository
use crate::log::*;
use std::collections::HashSet; use std::collections::HashSet;
use fastbloom_rs::{BloomFilter as Filter, Membership}; // use fastbloom_rs::{BloomFilter as Filter, Membership};
use crate::object::*; use crate::object::*;
use crate::store::*; use crate::store::*;
@ -145,17 +144,16 @@ impl Branch {
} }
} }
#[cfg(test)]
mod test { mod test {
use std::collections::HashMap;
//use fastbloom_rs::{BloomFilter as Filter, FilterBuilder, Membership}; //use fastbloom_rs::{BloomFilter as Filter, FilterBuilder, Membership};
use crate::branch::*; use crate::branch::*;
use crate::commit::*;
use crate::object::*;
use crate::repo;
use crate::repo::Repo; use crate::repo::Repo;
use crate::store::*;
use crate::log::*;
use crate::utils::*; use crate::utils::*;
#[test] #[test]
@ -441,7 +439,7 @@ mod test {
repo.get_store(), repo.get_store(),
); );
let mut c7 = Commit::load(a7.clone(), repo.get_store(), true).unwrap(); let c7 = Commit::load(a7.clone(), repo.get_store(), true).unwrap();
c7.verify(&repo).unwrap(); c7.verify(&repo).unwrap();
// let mut filter = Filter::new(FilterBuilder::new(10, 0.01)); // let mut filter = Filter::new(FilterBuilder::new(10, 0.01));

14
p2p-repo/src/commit.rs
Unescape View File

@ -14,7 +14,7 @@ use core::fmt;
use once_cell::sync::OnceCell; use once_cell::sync::OnceCell;
use crate::errors::NgError; use crate::errors::NgError;
use crate::log::*;
use crate::object::*; use crate::object::*;
use crate::repo::Repo; use crate::repo::Repo;
use crate::store::*; use crate::store::*;
@ -349,7 +349,6 @@ impl Commit {
Some(CommitHeaderKeys::V0(hk)) => hk.acks.is_empty() && hk.nacks.is_empty(), Some(CommitHeaderKeys::V0(hk)) => hk.acks.is_empty() && hk.nacks.is_empty(),
None => true, None => true,
}, },
_ => unimplemented!(),
} }
} }
@ -368,7 +367,6 @@ impl Commit {
}, },
None => {} None => {}
}, },
_ => {}
}; };
res res
} }
@ -388,7 +386,6 @@ impl Commit {
}, },
None => {} None => {}
}, },
_ => {}
}; };
res res
} }
@ -413,7 +410,6 @@ impl Commit {
} }
_ => {} _ => {}
}, },
_ => {}
}; };
res res
} }
@ -1121,14 +1117,10 @@ impl fmt::Display for CommitHeaderKeys {
} }
} }
#[cfg(test)]
mod test { mod test {
use std::collections::HashMap;
use crate::branch::*;
use crate::commit::*; use crate::commit::*;
use crate::store::*; use crate::log::*;
use crate::types::*;
use crate::utils::*;
#[test] #[test]
pub fn test_commit() { pub fn test_commit() {

6
p2p-repo/src/errors.rs
Unescape View File

@ -36,19 +36,19 @@ impl fmt::Display for NgError {
} }
impl From<serde_bare::error::Error> for NgError { impl From<serde_bare::error::Error> for NgError {
fn from(e: serde_bare::error::Error) -> Self { fn from(_e: serde_bare::error::Error) -> Self {
NgError::SerializationError NgError::SerializationError
} }
} }
impl From<ed25519_dalek::ed25519::Error> for NgError { impl From<ed25519_dalek::ed25519::Error> for NgError {
fn from(e: ed25519_dalek::ed25519::Error) -> Self { fn from(_e: ed25519_dalek::ed25519::Error) -> Self {
NgError::InvalidSignature NgError::InvalidSignature
} }
} }
impl From<CommitLoadError> for NgError { impl From<CommitLoadError> for NgError {
fn from(e: CommitLoadError) -> Self { fn from(_e: CommitLoadError) -> Self {
NgError::RepoLoadError NgError::RepoLoadError
} }
} }

78
p2p-repo/src/object.rs
Unescape View File

@ -293,7 +293,7 @@ impl Object {
/// * `store_secret`: store's read capability secret, needed to generate the convergence key /// * `store_secret`: store's read capability secret, needed to generate the convergence key
pub fn new( pub fn new(
content: ObjectContent, content: ObjectContent,
mut header: Option<CommitHeader>, header: Option<CommitHeader>,
block_size: usize, block_size: usize,
store: &StoreRepo, store: &StoreRepo,
store_secret: &ReadCapSecret, store_secret: &ReadCapSecret,
@ -512,7 +512,7 @@ impl Object {
Ok(ObjectContent::V0(ObjectContentV0::CommitHeader(commit_header))) => { Ok(ObjectContent::V0(ObjectContentV0::CommitHeader(commit_header))) => {
(Some(commit_header), None) (Some(commit_header), None)
} }
Err(e) => return Err(ObjectParseError::InvalidHeader), Err(_e) => return Err(ObjectParseError::InvalidHeader),
_ => return Err(ObjectParseError::InvalidHeader), _ => return Err(ObjectParseError::InvalidHeader),
} }
} }
@ -688,7 +688,8 @@ impl Object {
if leaves.is_none() && obj_content.is_none() { if leaves.is_none() && obj_content.is_none() {
// we just want to calculate the depth. no need to decrypt // we just want to calculate the depth. no need to decrypt
for id in b_children { for id in b_children {
children.push((id.clone(), ObjectKey::dummy())); #[allow(deprecated)]
children.push((id.clone(), ObjectKey::nil()));
} }
continue; continue;
} }
@ -828,7 +829,6 @@ impl Object {
match self.content() { match self.content() {
Ok(ObjectContent::V0(v0)) => Ok(v0), Ok(ObjectContent::V0(v0)) => Ok(v0),
Err(e) => Err(e), Err(e) => Err(e),
_ => unimplemented!(),
} }
} }
} }
@ -877,7 +877,7 @@ impl ObjectContent {
} }
} }
pub fn new_file_V0_with_content(content: Vec<u8>, content_type: &str) -> Self { pub fn new_file_v0_with_content(content: Vec<u8>, content_type: &str) -> Self {
ObjectContent::V0(ObjectContentV0::File(File::V0(FileV0 { ObjectContent::V0(ObjectContentV0::File(File::V0(FileV0 {
content_type: content_type.into(), content_type: content_type.into(),
metadata: vec![], metadata: vec![],
@ -916,8 +916,6 @@ impl fmt::Display for ObjectContent {
mod test { mod test {
use crate::object::*; use crate::object::*;
use crate::store::*;
use crate::types::*;
use std::io::BufReader; use std::io::BufReader;
use std::io::Read; use std::io::Read;
use std::io::Write; use std::io::Write;
@ -968,7 +966,7 @@ mod test {
reader reader
.read_to_end(&mut img_buffer) .read_to_end(&mut img_buffer)
.expect("read of test.jpg"); .expect("read of test.jpg");
let content = ObjectContent::new_file_V0_with_content(img_buffer, "image/jpeg"); let content = ObjectContent::new_file_v0_with_content(img_buffer, "image/jpeg");
let max_object_size = store_max_value_size(); let max_object_size = store_max_value_size();
let (store_repo, store_secret) = StoreRepo::dummy_public_v0(); let (store_repo, store_secret) = StoreRepo::dummy_public_v0();
@ -1696,69 +1694,5 @@ mod test {
test_block(store_valid_value_size(100000)); test_block(store_valid_value_size(100000));
test_block(store_valid_value_size(1000000)); test_block(store_valid_value_size(1000000));
test_block(store_valid_value_size(5000)); test_block(store_valid_value_size(5000));
///////////////////
/*
let max_arity_leaves = (max_block_size - EMPTY_BLOCK_SIZE - BIG_VARINT_EXTRA * 2)
/ (BLOCK_ID_SIZE + BLOCK_KEY_SIZE);
log_debug!("max_arity_leaves: {}", max_arity_leaves);
assert_eq!(max_arity_leaves, MAX_ARITY_LEAVES);
assert_eq!(
max_block_size - EMPTY_BLOCK_SIZE - DATA_VARINT_EXTRA,
max_data_payload_size
);
let max_arity_root =
(max_block_size - EMPTY_BLOCK_SIZE - MAX_HEADER_SIZE - BIG_VARINT_EXTRA * 2)
/ (BLOCK_ID_SIZE + BLOCK_KEY_SIZE);
log_debug!("max_arity_root: {}", max_arity_root);
assert_eq!(max_arity_root, MAX_ARITY_ROOT);
log_debug!("store_max_value_size: {}", leaf_full_data_ser.len());
assert_eq!(leaf_full_data_ser.len(), max_block_size);
log_debug!("leaf_empty: {}", leaf_empty_ser.len());
assert_eq!(leaf_empty_ser.len(), EMPTY_BLOCK_SIZE);
// log_debug!("root_depsref: {}", root_depsref_ser.len());
// assert_eq!(root_depsref_ser.len(), EMPTY_ROOT_SIZE_DEPSREF);
log_debug!("internal_max: {}", internal_max_ser.len());
assert_eq!(
internal_max_ser.len(),
EMPTY_BLOCK_SIZE
+ BIG_VARINT_EXTRA * 2
+ MAX_ARITY_LEAVES * (BLOCK_ID_SIZE + BLOCK_KEY_SIZE)
);
assert!(internal_max_ser.len() < max_block_size);
log_debug!("internal_one: {}", internal_one_ser.len());
assert_eq!(
internal_one_ser.len(),
EMPTY_BLOCK_SIZE + 1 * BLOCK_ID_SIZE + 1 * BLOCK_KEY_SIZE
);
log_debug!("internal_two: {}", internal_two_ser.len());
assert_eq!(
internal_two_ser.len(),
EMPTY_BLOCK_SIZE + 2 * BLOCK_ID_SIZE + 2 * BLOCK_KEY_SIZE
);
log_debug!("root_one: {}", root_one_ser.len());
assert_eq!(
root_one_ser.len(),
EMPTY_BLOCK_SIZE + 8 * BLOCK_ID_SIZE + 1 * BLOCK_ID_SIZE + 1 * BLOCK_KEY_SIZE
);
log_debug!("root_two: {}", root_two_ser.len());
assert_eq!(
root_two_ser.len(),
EMPTY_BLOCK_SIZE + 8 * BLOCK_ID_SIZE + 2 * BLOCK_ID_SIZE + 2 * BLOCK_KEY_SIZE
);*/
// let object_size_1 = 4096 * 1 - VALUE_HEADER_SIZE;
// let object_size_512 = 4096 * MAX_PAGES_PER_VALUE - VALUE_HEADER_SIZE;
// let arity_1: usize =
// (object_size_1 - 8 * OBJECT_ID_SIZE) / (OBJECT_ID_SIZE + OBJECT_KEY_SIZE);
// let arity_512: usize =
// (object_size_512 - 8 * OBJECT_ID_SIZE) / (OBJECT_ID_SIZE + OBJECT_KEY_SIZE);
// log_debug!("1-page object_size: {}", object_size_1);
// log_debug!("512-page object_size: {}", object_size_512);
// log_debug!("max arity of 1-page object: {}", arity_1);
// log_debug!("max arity of 512-page object: {}", arity_512);
} }
} }

12
p2p-repo/src/site.rs
Unescape View File

@ -42,20 +42,20 @@ impl SiteV0 {
pub write_cap: RepoWriteCapSecret, */ pub write_cap: RepoWriteCapSecret, */
let public = SiteStore { let public = SiteStore {
key: PrivKey::dummy(), key: PrivKey::nil(),
read_cap: BlockRef::dummy(), read_cap: BlockRef::nil(),
write_cap: SymKey::random(), write_cap: SymKey::random(),
}; };
let protected = SiteStore { let protected = SiteStore {
key: PrivKey::dummy(), key: PrivKey::nil(),
read_cap: BlockRef::dummy(), read_cap: BlockRef::nil(),
write_cap: SymKey::random(), write_cap: SymKey::random(),
}; };
let private = SiteStore { let private = SiteStore {
key: PrivKey::dummy(), key: PrivKey::nil(),
read_cap: BlockRef::dummy(), read_cap: BlockRef::nil(),
write_cap: SymKey::random(), write_cap: SymKey::random(),
}; };

7
p2p-repo/src/store.rs
Unescape View File

@ -13,13 +13,12 @@
use futures::StreamExt; use futures::StreamExt;
use crate::log::*;
use crate::types::*; use crate::types::*;
use crate::utils::Receiver; use crate::utils::Receiver;
use std::sync::{Arc, RwLock}; use std::sync::RwLock;
use std::{ use std::{
cmp::{max, min}, cmp::{max, min},
collections::{hash_map::Iter, HashMap}, collections::HashMap,
mem::size_of_val, mem::size_of_val,
}; };
@ -55,7 +54,7 @@ impl core::fmt::Display for StorageError {
} }
impl From<serde_bare::error::Error> for StorageError { impl From<serde_bare::error::Error> for StorageError {
fn from(e: serde_bare::error::Error) -> Self { fn from(_e: serde_bare::error::Error) -> Self {
StorageError::SerializationError StorageError::SerializationError
} }
} }

44
p2p-repo/src/types.rs
Unescape View File

@ -19,8 +19,6 @@ use crate::utils::{
use core::fmt; use core::fmt;
use once_cell::sync::OnceCell; use once_cell::sync::OnceCell;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use serde_bare::to_vec;
use std::collections::{HashMap, HashSet};
use std::hash::Hash; use std::hash::Hash;
use zeroize::{Zeroize, ZeroizeOnDrop}; use zeroize::{Zeroize, ZeroizeOnDrop};
@ -86,7 +84,11 @@ impl SymKey {
pub fn from_array(array: [u8; 32]) -> Self { pub fn from_array(array: [u8; 32]) -> Self {
SymKey::ChaCha20Key(array) SymKey::ChaCha20Key(array)
} }
#[deprecated(note = "**Don't use dummy method**")] #[deprecated(note = "**Don't use nil method**")]
pub fn nil() -> Self {
SymKey::ChaCha20Key([0; 32])
}
#[cfg(test)]
pub fn dummy() -> Self { pub fn dummy() -> Self {
SymKey::ChaCha20Key([0; 32]) SymKey::ChaCha20Key([0; 32])
} }
@ -151,6 +153,8 @@ impl PubKey {
_ => panic!("can only convert an edward key to montgomery"), _ => panic!("can only convert an edward key to montgomery"),
} }
} }
#[deprecated(note = "**Don't use nil method**")]
pub fn nil() -> Self { pub fn nil() -> Self {
PubKey::Ed25519PubKey([0u8; 32]) PubKey::Ed25519PubKey([0u8; 32])
} }
@ -194,7 +198,12 @@ impl PrivKey {
} }
} }
#[deprecated(note = "**Don't use dummy method**")] #[deprecated(note = "**Don't use nil method**")]
pub fn nil() -> PrivKey {
PrivKey::Ed25519PrivKey([0u8; 32])
}
#[cfg(test)]
pub fn dummy() -> PrivKey { pub fn dummy() -> PrivKey {
PrivKey::Ed25519PrivKey([0u8; 32]) PrivKey::Ed25519PrivKey([0u8; 32])
} }
@ -267,9 +276,6 @@ impl fmt::Display for Sig {
base64_url::encode(&ed[1]) base64_url::encode(&ed[1])
) )
} }
_ => {
unimplemented!();
}
} }
} }
} }
@ -362,20 +368,34 @@ pub struct BlockRef {
} }
impl BlockId { impl BlockId {
#[deprecated(note = "**Don't use dummy method**")] #[cfg(test)]
pub fn dummy() -> Self { pub fn dummy() -> Self {
Digest::Blake3Digest32([0u8; 32]) Digest::Blake3Digest32([0u8; 32])
} }
#[deprecated(note = "**Don't use nil method**")]
pub fn nil() -> Self {
Digest::Blake3Digest32([0u8; 32])
}
} }
impl BlockRef { impl BlockRef {
#[deprecated(note = "**Don't use dummy method**")] #[cfg(test)]
pub fn dummy() -> Self { pub fn dummy() -> Self {
BlockRef { BlockRef {
id: Digest::Blake3Digest32([0u8; 32]), id: Digest::Blake3Digest32([0u8; 32]),
key: SymKey::ChaCha20Key([0u8; 32]), key: SymKey::ChaCha20Key([0u8; 32]),
} }
} }
#[deprecated(note = "**Don't use nil method**")]
pub fn nil() -> Self {
BlockRef {
id: Digest::Blake3Digest32([0u8; 32]),
key: SymKey::ChaCha20Key([0u8; 32]),
}
}
pub fn from_id_key(id: BlockId, key: BlockKey) -> Self { pub fn from_id_key(id: BlockId, key: BlockKey) -> Self {
BlockRef { id, key } BlockRef { id, key }
} }
@ -508,6 +528,8 @@ impl StoreRepo {
}, },
} }
} }
#[cfg(test)]
#[allow(deprecated)]
pub fn dummy_public_v0() -> (Self, SymKey) { pub fn dummy_public_v0() -> (Self, SymKey) {
let readcap = SymKey::dummy(); let readcap = SymKey::dummy();
let store_pubkey = PubKey::nil(); let store_pubkey = PubKey::nil();
@ -1464,10 +1486,10 @@ pub struct CertificateContentV0 {
pub readcap_id: ObjectId, pub readcap_id: ObjectId,
/// PublicKey Set used by the Owners. verifier uses this PKset if the signature was issued by the Owners. /// PublicKey Set used by the Owners. verifier uses this PKset if the signature was issued by the Owners.
pub owners_PKset: threshold_crypto::PublicKeySet, pub owners_pk_set: threshold_crypto::PublicKeySet,
/// two "orders" PublicKey Sets (total_order and partial_order). /// two "orders" PublicKey Sets (total_order and partial_order).
pub orders_PKsets: OrdersPublicKeySetsV0, pub orders_pk_sets: OrdersPublicKeySetsV0,
} }
/// A Signature of a Certificate and the threshold set or public key used to generate it /// A Signature of a Certificate and the threshold set or public key used to generate it

Write Preview
Loading…
Cancel
Save