update readme for new usage

more simple!

Author: namuyan

README.md

@@ -3,32 +3,99 @@ p2p-python
 I seek a library that can make a simple P2P network.  
 This library enables you create P2P application.
 
-## Require
-* Python3 (>=3.5)
-* Rust **nightly**
+## Specification
+* Asynchronous IO
+* Pure Python code
+* TCP and UDP connection
+* Automatic network build
+* Python**3.6+**
 
 ## How to install
+warning: **Destructive change from 3.0.0**
 ```commandline
-pip3 install --user setuptools-rust
-pip3 install --user nem-ed25519-rust
-pip3 install --user p2p-python
+pip3 install --user p2p-python>=3.0.0
 ```
 
-## how to use
-* command
-    * [Basic](doc/BASIC.md)
-    * [Direct cmd](doc/DIRECT_CMD.md)
-    * [Broadcast cmd](doc/BROADCAST_CMD.md)
-    * [another cmd](doc/ANOTHER_CMD.md)
-
-## Tutorial
-Please read first of all.
-[Example](doc/EXAMPLE.md)  
-[Document -p2p-pythonの内部動作について-](https://ameblo.jp/namuyan/entry-12398575560.html)
+## How to use
+basic usage with debug tool `aiomonitor`.  
+install by `pip3 install --user aiomonitor`.  
+```python
+from p2p_python.utils import setup_p2p_params, setup_logger
+from p2p_python.server import Peer2Peer, Peer2PeerCmd
+import logging
+import asyncio
+import aiomonitor
+import time
+ 
+loop = asyncio.get_event_loop()
+log = logging.getLogger(__name__)
+ 
+setup_logger(logging.INFO)
+ 
+# setup Peer2Peer
+setup_p2p_params(
+    network_ver=11111,  # (int) identify other network
+    p2p_port=2000, # (int) P2P listen port
+    p2p_accept=True, # (bool) switch on TCP server
+    p2p_udp_accept=True, # (bool) switch on UDP server
+)
+p2p = Peer2Peer(listen=100)  # allow 100 connection
+p2p.setup()
+ 
+# close method example
+def close():
+    p2p.close()
+    loop.call_later(1.0, loop.stop)
+ 
+# You can setup DirectDmd method
+class DirectCmd(object):
+ 
+    @staticmethod
+    async def what_is_your_name(user, data):
+        print("what_is_your_name", user, data)
+        return {"you return": time.time()}
+ 
+    @staticmethod
+    async def get_time_now(user, data):
+        print("get_time_now", user, data)
+        return {"get time now": time.time()}
+ 
+# register methods for DirectCmd
+p2p.event.setup_events_from_class(DirectCmd)
+# throw cmd by `await p2p.send_direct_cmd(DirectCmd.what_is_your_name, 'kelly')`
+# or `await p2p.send_direct_cmd('what_is_your_name', 'kelly')`
+ 
+# You can setup broadcast policy (default disabled)
+# WARNING: You must set strict policy or will be broken by users
+async def broadcast_check_normal(user, data):
+    return True
+ 
+# overwrite method
+p2p.broadcast_check = broadcast_check_normal
+ 
+# setup netcat monitor
+local = locals().copy()
+local.update({k: v for k, v in globals().items() if not k.startswith('__')})
+log.info('local', list(local.keys()))
+aiomonitor.start_monitor(loop, port=3000, locals=local)
+log.info(f"you can connect by `nc 127.0.0.1 3000`")
+ 
+# start event loop
+# close by `close()` on netcat console
+try:
+    loop.run_forever()
+except KeyboardInterrupt:
+    log.info("closing")
+loop.close()
+```
 
+## Documents
+* [about inner commands](doc/INNER_CMD.md)
+* [for debug](doc/FOR_DEBUG.md)
+* [how to work p2p-python? (OLD and JP)](https://ameblo.jp/namuyan/entry-12398575560.html)
 
 ## Author
 [@namuyan_mine](http://twitter.com/namuyan_mine/)
 
 ## Licence
-MIT
+[MIT](LICENSE)

doc/ANOTHER_CMD.md

@@ -0,0 +1,57 @@
+Another commands
+================
+Used for network stabilize.  
+Please import commands by `from p2p_python.server import Peer2PeerCmd`.  
+
+commands
+----------------
+**ping-pong**
+```text
+# check delay your node to a peer
+ 
+<<< await p2p.send_command(Peer2PeerCmd.PING_PONG, data=time.time())
+ 
+>>> (<User Key:12027 open 23m 127.0.0.1:2001 0/0>, {'ping': None, 'pong': 1561109423.2927444})
+```
+
+**get-peer-info**
+```text
+# find a peer's peer list
+ 
+<<< await p2p.send_command(Peer2PeerCmd.GET_PEER_INFO)
+ 
+>>> (<User Army:54510 open 26m 127.0.0.1:2002 0/0>, [[['127.0.0.1', 2000], {'name': 'Army:54510', 'client_ver': '3.0.0', 'network_ver': 12345, 'p2p_accept': True, 'p2p_udp_accept': True, 'p2p_port': 2000, 'start_time': 1561107522, 'last_seen': 1561109616}]])
+```
+
+**get-nears**
+```text
+# for : get peer's connection info
+ 
+<<< await p2p.send_command(Peer2PeerCmd.GET_NEARS)
+ 
+>>> (<User Table:48590 open 24m 127.0.0.1:2002 0/0>, [[['127.0.0.1', 2000], {'name': 'Army:54510', 'client_ver': '3.0.0', 'network_ver': 12345, 'p2p_accept': True, 'p2p_udp_accept': True, 'p2p_port': 2000, 'start_time': 1561107522, 'last_seen': 1561109473}]])
+```
+
+**check-reachable**
+```text
+# check PORT connection reachable from outside
+ 
+<<< await p2p.send_command(Peer2PeerCmd.CHECK_REACHABLE, data={'port': 1000})
+ 
+>>> (<User Key:12027 open 28m 127.0.0.1:2001 0/0>, False)
+```
+
+**direct-cmd**
+```text
+# You can define any command like README.md
+# warning: do not forget check data format is can convert json
+ 
+ <<< await p2p.send_direct_cmd(DirectCmd.what_is_your_name, data='kelly')
+ 
+ >>> (<User Table:48590 open 44m 127.0.0.1:2002 0/0>, {"you return": 1561110.0})
+```
+
+note
+----
+I checked by netcat console.
+

doc/BASIC.md

@@ -0,0 +1,13 @@
+for debugging
+====
+Good option for debuggers.
+
+```python
+from p2p_python.config import Debug
+ 
+Debug.P_PRINT_EXCEPTION = False  # print full exception info
+Debug.P_SEND_RECEIVE_DETAIL = False  # print send/receive msg info
+Debug.F_RECODE_TRAFFIC = False  # recode traffic recode to file
+```
+
+You can switch debug option online.

doc/BROADCAST_CMD.md

@@ -3,7 +3,6 @@
 class V:
     # path
     DATA_PATH = None
-    TMP_PATH = None
 
     # info
     CLIENT_VER = None
@@ -21,8 +20,6 @@ class Debug:
     P_PRINT_EXCEPTION = False  # print exception info
     P_SEND_RECEIVE_DETAIL = False  # print receive msg info
     F_RECODE_TRAFFIC = False  # recode traffic to file
-    F_SEND_CHANNEL_INFO = False  # send to details with channel fnc
-    F_LONG_MSG_INFO = False  # long message info
 
 
 class PeerToPeerError(Exception):

doc/COMMANDS.md

@@ -98,7 +98,8 @@ def start(self, s_family=socket.AF_UNSPEC):
                  f"tcp{len(tcp_servers)}={V.P2P_ACCEPT} udp{len(udp_servers)}={V.P2P_UDP_ACCEPT}")
         self.f_running = True
 
-    def get_server_header(self):
+    def get_my_user_header(self):
+        """return my UserHeader format dict"""
         return {
             'name': V.SERVER_NAME,
             'client_ver': V.CLIENT_VER,
@@ -107,7 +108,7 @@ def get_server_header(self):
             'p2p_udp_accept': V.P2P_UDP_ACCEPT,
             'p2p_port': V.P2P_PORT,
             'start_time': self.start_time,
-            'last_seen': int(time())
+            'last_seen': int(time()),
         }
 
     async def create_connection(self, host, port):
@@ -148,7 +149,7 @@ async def create_connection(self, host, port):
                 raise PeerToPeerError('timeout on first plain msg receive')
 
             # 2. send my header
-            send = json.dumps(self.get_server_header()).encode()
+            send = json.dumps(self.get_my_user_header()).encode()
             writer.write(send)
             await writer.drain()
             self.traffic.put_traffic_up(send)
@@ -318,7 +319,7 @@ async def initial_connection_check(self, reader: StreamReader, writer: StreamWri
             # 6. encrypt and send AES key and header
             send = json.dumps({
                 'aes-key': new_user.aeskey,
-                'header': self.get_server_header(),
+                'header': self.get_my_user_header(),
             })
             key = generate_shared_key(my_sec, data['public-key'])
             encrypted = AESCipher.encrypt(key, send.encode())

doc/DIRECT_CMD.md

@@ -56,7 +56,7 @@ def __init__(self, listen=15, f_local=False, default_hook=None, object_hook=None
         self.peers = PeerData(os.path.join(V.DATA_PATH, 'peer.dat'))  # {(host, port): header,..}
         # recode traffic if f_debug true
         if Debug.F_RECODE_TRAFFIC:
-            self.core.traffic.recode_dir = V.TMP_PATH
+            self.core.traffic.recode_dir = V.DATA_PATH
         # serializer/deserializer function
         self.default_hook = default_hook
         self.object_hook = object_hook
@@ -307,6 +307,9 @@ async def try_reconnect(self, user, reason):
     async def send_direct_cmd(self, cmd, data, user=None) -> (User, dict):
         if len(self.core.user) == 0:
             raise PeerToPeerError('not found peers')
+        if callable(cmd):
+            cmd = cmd.__name__
+        assert isinstance(cmd, str)
         user = user if user else random.choice(self.core.user)
         send_data = {'cmd': cmd, 'data': data}
         receive_user, item = await self.send_command(Peer2PeerCmd.DIRECT_CMD, send_data, user)

doc/EXAMPLE.md

@@ -21,13 +21,20 @@ class EventIgnition(object):
     def __init__(self):
         self.event = dict()
 
-    def add_event(self, cmd, fnc, post_fnc=None):
+    def setup_events_from_class(self, klass):
+        for cmd, fnc in klass.__dict__.items():
+            if cmd.startswith('_'):
+                continue
+            if isinstance(fnc, staticmethod):
+                fnc = fnc.__func__
+            self.add_event(cmd, fnc)
+
+    def add_event(self, cmd, fnc):
         assert fnc.__code__.co_argcount == 2
-        if post_fnc:
-            assert post_fnc.__code__.co_argcount == 2
         if cmd in self.event:
             raise Exception('already registered cmd')
-        self.event[cmd] = (fnc, post_fnc)
+        self.event[cmd] = fnc
+        log.info(f"add DirectCmd event '{cmd}'")
 
     def remove_event(self, cmd):
         if cmd in self.event:
@@ -38,18 +45,11 @@ def have_event(self, cmd):
 
     async def ignition(self, user, cmd, data):
         if cmd in self.event:
-            fnc, post_fnc = self.event[cmd]
+            fnc = self.event[cmd]
             if asyncio.iscoroutinefunction(fnc):
-                result = await fnc(user, data)
+                return await fnc(user, data)
             else:
-                result = fnc(user, data)
-            if post_fnc:
-                if asyncio.iscoroutinefunction(post_fnc):
-                    return await post_fnc(user, result)
-                else:
-                    return post_fnc(user, result)
-            else:
-                return result
+                return fnc(user, data)
         else:
             raise KeyError('Not found cmd "{}"'.format(cmd))
 

doc/FOR_DEBUG.md

@@ -1,8 +1,8 @@
+from p2p_python.config import V, Debug
+import logging
 import socket
-import os
 import random
-from tempfile import gettempdir
-from p2p_python.config import V, Debug
+import os
 
 
 NAMES = (
@@ -38,30 +38,22 @@ def get_name():
     return "{}:{}".format(random.choice(NAMES), random.randint(10000, 99999))
 
 
-def setup_p2p_params(network_ver, p2p_port, p2p_accept=True, p2p_udp_accept=True, sub_dir=None,
-                     f_debug=False):
+def setup_p2p_params(network_ver, p2p_port, p2p_accept=True, p2p_udp_accept=True, sub_dir=None):
     """ setup general connection setting """
-    if f_debug:
-        Debug.P_PRINT_EXCEPTION = True
-        Debug.P_SEND_RECEIVE_DETAIL = True
-        Debug.F_LONG_MSG_INFO = True
     # directory params
     if V.DATA_PATH is not None:
         raise Exception('Already setup params.')
-    V.DATA_PATH = os.path.join(os.path.expanduser('~'), 'p2p-python')
-    V.TMP_PATH = os.path.join(gettempdir(), 'p2p-python')
+    root_data_dir = os.path.join(os.path.expanduser('~'), 'p2p-python')
+    if not os.path.exists(root_data_dir):
+        os.makedirs(root_data_dir)
+    V.DATA_PATH = os.path.join(root_data_dir, str(p2p_port))
     if not os.path.exists(V.DATA_PATH):
         os.makedirs(V.DATA_PATH)
-    if not os.path.exists(V.TMP_PATH):
-        os.makedirs(V.TMP_PATH)
     if sub_dir:
         V.DATA_PATH = os.path.join(V.DATA_PATH, sub_dir)
-        V.TMP_PATH = os.path.join(V.TMP_PATH, sub_dir)
-    if not os.path.exists(V.DATA_PATH):
-        os.makedirs(V.DATA_PATH)
-    if not os.path.exists(V.TMP_PATH):
-        os.makedirs(V.TMP_PATH)
-    # Network params
+        if not os.path.exists(V.DATA_PATH):
+            os.makedirs(V.DATA_PATH)
+    # network params
     V.CLIENT_VER = get_version()
     V.SERVER_NAME = get_name()
     V.NETWORK_VER = network_ver
@@ -104,10 +96,17 @@ def is_reachable(host, port):
         return False
 
 
-def trim_msg(item, num):
-    """limit a message"""
-    str_item = str(item)
-    return str_item[:num] + ('...' if len(str_item) > num else '')
+def setup_logger(level=logging.DEBUG, format_str='[%(levelname)-6s] [%(threadName)-10s] [%(asctime)-24s] %(message)s'):
+    """setup basic logging handler"""
+    logger = logging.getLogger()
+    for sh in logger.handlers:
+        logger.removeHandler(sh)
+    logger.setLevel(logging.DEBUG)
+    formatter = logging.Formatter(format_str)
+    sh = logging.StreamHandler()
+    sh.setLevel(level)
+    sh.setFormatter(formatter)
+    logger.addHandler(sh)
 
 
 __all__ = [
@@ -117,5 +116,5 @@ def trim_msg(item, num):
     "is_reachable",
     "setup_tor_connection",
     "setup_p2p_params",
-    "trim_msg",
+    "setup_logger",
 ]