Merge pull request nervosnetwork#78 from nervosnetwork/refactor-identify

Refactor identify protocol

Makefile

@@ -0,0 +1,15 @@
+
+fmt:
+	cargo fmt --all -- --check
+
+clippy:
+	RUSTFLAGS='-F warnings' cargo clippy --all --tests
+
+test:
+	RUSTFLAGS='-F warnings' cargo test --all
+
+examples:
+	cargo build --examples --all
+
+ci: fmt clippy test examples
+	git diff --exit-code Cargo.lock

examples/id.rs

@@ -2,24 +2,24 @@ use env_logger;
 use log::debug;
 
 use futures::{future::lazy, prelude::*};
-use identify::{AddrManager, IdentifyProtocol, MisbehaveResult, Misbehavior};
+use identify::{Callback, IdentifyProtocol, MisbehaveResult, Misbehavior};
 use tentacle::{
     builder::{MetaBuilder, ServiceBuilder},
     context::ServiceContext,
     multiaddr::Multiaddr,
     secio::{PeerId, SecioKeyPair},
-    service::{DialProtocol, ProtocolHandle, ServiceError, ServiceEvent},
+    service::{DialProtocol, ProtocolHandle, ServiceError, ServiceEvent, SessionType},
     traits::ServiceHandle,
 };
 
 fn main() {
     env_logger::init();
-    let addr_mgr = SimpleAddrManager {};
+    let callback = IdentifyCallback {
+        local_listen_addrs: Vec::new(),
+    };
     let protocol = MetaBuilder::default()
         .id(1)
-        .service_handle(move || {
-            ProtocolHandle::Callback(Box::new(IdentifyProtocol::new(1, addr_mgr)))
-        })
+        .service_handle(move || ProtocolHandle::Callback(Box::new(IdentifyProtocol::new(callback))))
         .build();
     if std::env::args().nth(1) == Some("server".to_string()) {
         debug!("Starting server ......");
@@ -51,13 +51,24 @@ fn main() {
 }
 
 #[derive(Clone)]
-struct SimpleAddrManager {}
+struct IdentifyCallback {
+    local_listen_addrs: Vec<Multiaddr>,
+}
 
-impl AddrManager for SimpleAddrManager {
+impl Callback for IdentifyCallback {
+    /// Get local listen addresses
+    fn local_listen_addrs(&mut self) -> Vec<Multiaddr> {
+        self.local_listen_addrs.clone()
+    }
     /// Add remote peer's listen addresses
-    fn add_listen_addrs(&mut self, _peer: &PeerId, _addrs: Vec<Multiaddr>) {}
+    fn add_remote_listen_addrs(&mut self, _peer: &PeerId, _addrs: Vec<Multiaddr>) {}
     /// Add our address observed by remote peer
-    fn add_observed_addr(&mut self, _peer: &PeerId, _addr: Multiaddr) -> MisbehaveResult {
+    fn add_observed_addr(
+        &mut self,
+        _peer: &PeerId,
+        _addr: Multiaddr,
+        _: SessionType,
+    ) -> MisbehaveResult {
         MisbehaveResult::Continue
     }
     /// Report misbehavior
@@ -69,11 +80,11 @@ impl AddrManager for SimpleAddrManager {
 struct SimpleHandler {}
 
 impl ServiceHandle for SimpleHandler {
-    fn handle_error(&mut self, _env: &mut ServiceContext, error: ServiceError) {
+    fn handle_error(&mut self, _context: &mut ServiceContext, error: ServiceError) {
         debug!("service error: {:?}", error);
     }
 
-    fn handle_event(&mut self, _env: &mut ServiceContext, event: ServiceEvent) {
+    fn handle_event(&mut self, _context: &mut ServiceContext, event: ServiceEvent) {
         debug!("service event: {:?}", event);
     }
 }

protocols/discovery/src/addr.rs

@@ -3,7 +3,11 @@ use std::net::{IpAddr, SocketAddr};
 use std::time::Instant;
 
 use fnv::{FnvHashMap, FnvHashSet};
-use p2p::{multiaddr::Multiaddr, utils::multiaddr_to_socketaddr, SessionId};
+use p2p::{
+    multiaddr::Multiaddr,
+    utils::{is_reachable, multiaddr_to_socketaddr},
+    SessionId,
+};
 use serde_derive::{Deserialize, Serialize};
 
 // See: bitcoin/netaddress.cpp pchIPv4[12]
@@ -170,48 +174,6 @@ impl RawAddr {
 
     // Copy from std::net::IpAddr::is_global
     pub fn is_reachable(&self) -> bool {
-        match self.socket_addr().ip() {
-            IpAddr::V4(ipv4) => {
-                !ipv4.is_private()
-                    && !ipv4.is_loopback()
-                    && !ipv4.is_link_local()
-                    && !ipv4.is_broadcast()
-                    && !ipv4.is_documentation()
-                    && !ipv4.is_unspecified()
-            }
-            IpAddr::V6(ipv6) => {
-                let scope = if ipv6.is_multicast() {
-                    match ipv6.segments()[0] & 0x000f {
-                        1 => Some(false),
-                        2 => Some(false),
-                        3 => Some(false),
-                        4 => Some(false),
-                        5 => Some(false),
-                        8 => Some(false),
-                        14 => Some(true),
-                        _ => None,
-                    }
-                } else {
-                    None
-                };
-                match scope {
-                    Some(true) => true,
-                    None => {
-                        !(ipv6.is_multicast()
-                          || ipv6.is_loopback()
-                          // && !ipv6.is_unicast_link_local()
-                          || ((ipv6.segments()[0] & 0xffc0) == 0xfe80)
-                          // && !ipv6.is_unicast_site_local()
-                          || ((ipv6.segments()[0] & 0xffc0) == 0xfec0)
-                          // && !ipv6.is_unique_local()
-                          || ((ipv6.segments()[0] & 0xfe00) == 0xfc00)
-                          || ipv6.is_unspecified()
-                          // && !ipv6.is_documentation()
-                          || ((ipv6.segments()[0] == 0x2001) && (ipv6.segments()[1] == 0xdb8)))
-                    }
-                    _ => false,
-                }
-            }
-        }
+        is_reachable(self.socket_addr().ip())
     }
 }