dimples 0.3.3__tar.gz → 0.3.4__tar.gz

{dimples-0.3.3 → dimples-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dimples
-Version: 0.3.3
+Version: 0.3.4
 Summary: DIMP Library for Edges and Stations
 Home-page: https://github.com/dimchat/demo-py
 Author: Albert Moky

{dimples-0.3.3 → dimples-0.3.4}/dimples/client/packer.py

@@ -30,7 +30,7 @@
 from typing import Optional
 
 from dimsdk import ID
-from dimsdk import InstantMessage, ReliableMessage
+from dimsdk import InstantMessage, SecureMessage, ReliableMessage
 
 from ..utils import get_msg_sig
 from ..common import CommonMessagePacker
@@ -40,14 +40,14 @@ from .checkpoint import Checkpoint
 class ClientMessagePacker(CommonMessagePacker):
 
     # Override
-    def _check_instant_message_receiver(self, msg: InstantMessage) -> bool:
+    def _check_receiver(self, msg: InstantMessage) -> bool:
         receiver = msg.receiver
         if receiver.is_broadcast:
             # broadcast message
             return True
         elif receiver.is_user:
             # check user's meta & document
-            return super()._check_instant_message_receiver(msg=msg)
+            return super()._check_receiver(msg=msg)
         #
         #   check group's meta & members
         #
@@ -85,6 +85,47 @@ class ClientMessagePacker(CommonMessagePacker):
         # when the member's visa is responded, we should send the suspended message again.
         return len(waiting) < len(members)
 
+    # protected
+    def _check_group(self, msg: ReliableMessage) -> bool:
+        receiver = msg.receiver
+        # check group
+        group = ID.parse(identifier=msg.get('group'))
+        if group is None and receiver.is_group:
+            # Transform:
+            #     (B) => (J)
+            #     (D) => (G)
+            group = receiver
+        if group is None or group.is_broadcast:
+            # A, C - personal message (or hidden group message)
+            #     the packer will call the facebook to select a user from local
+            #     for this receiver, if no user matched (private key not found),
+            #     this message will be ignored;
+            # E, F, G - broadcast group message
+            #     broadcast message is not encrypted, so it can be read by anyone.
+            return True
+        # H, J, K - group message
+        #     check for received group message
+        members = self._members(group=group)
+        if len(members) > 0:
+            # group is ready
+            return True
+        # group not ready, suspend message for waiting members
+        error = {
+            'message': 'group not ready',
+            'group': str(receiver),
+        }
+        self.suspend_reliable_message(msg=msg, error=error)  # msg['error'] = error
+        return False
+
+    # Override
+    def verify_message(self, msg: ReliableMessage) -> Optional[SecureMessage]:
+        # check receiver/group with local user
+        if not self._check_group(msg=msg):
+            # receiver (group) not ready
+            self.warning(msg='receiver not ready: %s' % msg.receiver)
+            return None
+        return super().verify_message(msg=msg)
+
     # # Override
     # def serialize_message(self, msg: ReliableMessage) -> bytes:
     #     attach_key_digest(msg=msg, messenger=self.messenger)

{dimples-0.3.3 → dimples-0.3.4}/dimples/common/packer.py

@@ -109,7 +109,7 @@ class CommonMessagePacker(MessagePacker, Logging, ABC):
         return self.facebook.members(identifier=group)
 
     # protected
-    def _check_reliable_message_sender(self, msg: ReliableMessage) -> bool:
+    def _check_sender(self, msg: ReliableMessage) -> bool:
         """ Check sender before verifying received message """
         sender = msg.sender
         assert sender.is_user, 'sender error: %s' % sender
@@ -132,39 +132,7 @@ class CommonMessagePacker(MessagePacker, Logging, ABC):
         return False
 
     # protected
-    def _check_reliable_message_receiver(self, msg: ReliableMessage) -> bool:
-        receiver = msg.receiver
-        # check group
-        group = ID.parse(identifier=msg.get('group'))
-        if group is None and receiver.is_group:
-            # Transform:
-            #     (B) => (J)
-            #     (D) => (G)
-            group = receiver
-        if group is None or group.is_broadcast:
-            # A, C - personal message (or hidden group message)
-            #     the packer will call the facebook to select a user from local
-            #     for this receiver, if no user matched (private key not found),
-            #     this message will be ignored;
-            # E, F, G - broadcast group message
-            #     broadcast message is not encrypted, so it can be read by anyone.
-            return True
-        # H, J, K - group message
-        #     check for received group message
-        members = self._members(group=group)
-        if len(members) > 0:
-            # group is ready
-            return True
-        # group not ready, suspend message for waiting members
-        error = {
-            'message': 'group not ready',
-            'group': str(receiver),
-        }
-        self.suspend_reliable_message(msg=msg, error=error)  # msg['error'] = error
-        return False
-
-    # protected
-    def _check_instant_message_receiver(self, msg: InstantMessage) -> bool:
+    def _check_receiver(self, msg: InstantMessage) -> bool:
         """ Check receiver before encrypting message """
         receiver = msg.receiver
         if receiver.is_broadcast:
@@ -196,7 +164,7 @@ class CommonMessagePacker(MessagePacker, Logging, ABC):
     def encrypt_message(self, msg: InstantMessage) -> Optional[SecureMessage]:
         # 1. check contact info
         # 2. check group members info
-        if not self._check_instant_message_receiver(msg=msg):
+        if not self._check_receiver(msg=msg):
             # receiver not ready
             self.warning(msg='receiver not ready: %s' % msg.receiver)
             return None
@@ -221,16 +189,12 @@ class CommonMessagePacker(MessagePacker, Logging, ABC):
 
     # Override
     def verify_message(self, msg: ReliableMessage) -> Optional[SecureMessage]:
-        # 1. check sender's meta
-        if not self._check_reliable_message_sender(msg=msg):
+        # 1. check receiver/group with local user
+        # 2. check sender's meta
+        if not self._check_sender(msg=msg):
             # sender not ready
             self.warning(msg='sender not ready: %s' % msg.sender)
             return None
-        # 2. check receiver/group with local user
-        if not self._check_reliable_message_receiver(msg=msg):
-            # receiver (group) not ready
-            self.warning(msg='receiver not ready: %s' % msg.receiver)
-            return None
         return super().verify_message(msg=msg)
 
     # Override

{dimples-0.3.3 → dimples-0.3.4}/dimples/conn/gatekeeper.py

@@ -30,6 +30,7 @@
 
 import socket
 import time
+import traceback
 from typing import Optional, Tuple
 
 from dimsdk import ReliableMessage
@@ -44,12 +45,13 @@ from tcp import StreamChannel
 from tcp import ServerHub, ClientHub
 
 from ..utils import get_remote_address, get_local_address
+from ..utils import get_msg_info
 from ..utils import Runner, Logging
 
 from .protocol import DeparturePacker
 
 from .gate import CommonGate, TCPServerGate, TCPClientGate
-from .queue import MessageQueue
+from .queue import MessageQueue, MessageWrapper
 
 
 class StreamServerHub(ServerHub):
@@ -209,6 +211,7 @@ class GateKeeper(Runner, DockerDelegate, Logging):
                 return True
         except Exception as e:
             self.error(msg='process error: %s' % e)
+            traceback.print_exc()
             return False
         if not self.active:
             # inactive, wait a while to check again
@@ -264,3 +267,7 @@ class GateKeeper(Runner, DockerDelegate, Logging):
     # Override
     def docker_error(self, error: IOError, ship: Departure, docker: Docker):
         self.error(msg='docker error while sending ship: %s, %s' % (ship, docker))
+        if isinstance(ship, MessageWrapper):
+            msg = ship.msg
+            if msg is not None:
+                self.error(msg='error message: %s' % get_msg_info(msg=msg))

{dimples-0.3.3 → dimples-0.3.4}/dimples/database/t_login.py

@@ -60,7 +60,7 @@ class LoginTable(LoginDBI):
         old, _ = self.login_command_message(user=user)
         if old is not None and is_before(old_time=old.time, new_time=new_time):
             # command expired
-            return False
+            return True
 
     #
     #   Login DBI

{dimples-0.3.3 → dimples-0.3.4}/dimples/group/emitter.py

@@ -155,6 +155,7 @@ class GroupEmitter(Logging):
             success = self.__split_send_message(msg=msg, members=members, group=group, priority=priority)
             self.info(msg='split %d message(s) for group: %s' % (success, group))
         else:
+            self.info(msg='splitting message for %d members of group: %s' % (len(members), group))
             # encrypt and sign this message first,
             # then split and send to all members one by one
             return self.__disperse_message(msg=msg, members=members, group=group, priority=priority)

{dimples-0.3.3 → dimples-0.3.4}/dimples/server/broadcast.py

@@ -43,7 +43,7 @@ from ..utils import Singleton, Log, Logging
 from ..common import StationInfo
 
 from .cpu import AnsCommandProcessor
-from .trace import TraceManager
+from .trace import TraceNode, TraceList, TraceManager
 from .dispatcher import Dispatcher
 from .session_center import SessionCenter
 
@@ -173,6 +173,9 @@ def broadcast_reliable_message(msg: ReliableMessage, station: ID):
         #       delivering via station bridge, should we mark 'sent_neighbors' in
         #       only one message to the bridge, let the bridge to separate for other
         #       neighbors which not connect to this station directly?
+    # set trace nodes
+    tm = TraceManager()
+    tm.set_nodes(msg=msg, nodes=recipients)
     # OK
     Log.info(msg='Broadcast message delivered: %s => %s' % (sender, recipients))
     return len(recipients)
@@ -186,13 +189,31 @@ def deliver_message(msg: ReliableMessage, receiver: ID, recipients: Set[ID], sta
         Log.warning(msg='skip sender: %s, %s' % (receiver, recipients))
         return None
     assert isinstance(recipients, set), 'recipients error: %s' % recipients
+    tm = TraceManager()
+    traces = tm.get_traces(msg=msg)
+    if traces.search(node=receiver) >= 0:
+        Log.warning(msg='skip cycled message: %s, %s' % (msg.sender, receiver))
+        return None
     # clone
     msg = ReliableMessage.parse(msg=msg.dictionary)
+    traces = copy_traces(traces=traces)
+    # add these recipients into traces, exclude current receiver
     recipients = recipients.copy()
     recipients.discard(receiver)  # exclude receiver
     recipients.add(station)       # include current station
-    # set trace nodes
-    tm = TraceManager()
-    tm.set_nodes(msg=msg, nodes=recipients)
+    for mta in recipients:
+        node = TraceNode.create(identifier=mta)
+        traces.insert(node=node)
+    msg['traces'] = TraceNode.revert(nodes=traces.nodes)
     # deliver message with traces
     return dispatcher.deliver_message(msg=msg, receiver=receiver)
+
+
+def copy_traces(traces: TraceList) -> TraceList:
+    when = traces.time
+    if when is None:
+        when = DateTime.now()
+    else:
+        when = DateTime.parse(value=when)
+    nodes = traces.nodes
+    return TraceList(msg_time=when, traces=nodes.copy())

{dimples-0.3.3 → dimples-0.3.4}/dimples/server/cpu/handshake.py

@@ -67,11 +67,15 @@ class HandshakeCommandProcessor(BaseCommandProcessor):
         # set/update session in session server with new session key
         messenger = self.messenger
         session = messenger.session
+        sess_id = session.identifier
+        sender = r_msg.sender
+        if sess_id is not None:
+            assert sess_id == sender, 'sender error: %s, %s' % (sender, sess_id)
         if session.key == content.session:
             # session key match
-            Log.info(msg='handshake accepted: %s, session: %s' % (r_msg.sender, session.key))
+            Log.info(msg='handshake accepted: %s, session: %s' % (sender, session.key))
             # verified success
-            handshake_accepted(identifier=r_msg.sender, session=session, messenger=messenger)
+            handshake_accepted(identifier=sender, session=session, messenger=messenger)
             res = HandshakeCommand.success(session=session.key)
         else:
             # session key not match

{dimples-0.3.3 → dimples-0.3.4}/dimples/server/cpu/report.py

@@ -59,6 +59,7 @@ class ReportCommandProcessor(BaseCommandProcessor, Logging):
         if session.identifier is None:
             self.error(msg='session not login, drop report command: %s => %s' % (sender, content))
             return []
+        # FIXME: send via bridge?
         assert sender == session.identifier, 'report sender error: %s not %s' % (sender, session.identifier)
         # check report title
         title = content.title

{dimples-0.3.3 → dimples-0.3.4}/dimples/server/dispatcher.py

@@ -185,6 +185,9 @@ class Dispatcher(MessageDeliver):
         if receiver.type == EntityType.STATION or msg.sender.type == EntityType.STATION:
             # no need to save station message
             return False
+        elif msg.receiver.is_broadcast:
+            # no need to save broadcast message
+            return False
         db = self.__mdb
         return db.cache_reliable_message(msg=msg, receiver=receiver)
 

dimples-0.3.4/dimples/server/messenger.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+# ==============================================================================
+# MIT License
+#
+# Copyright (c) 2019 Albert Moky
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# ==============================================================================
+
+"""
+    Messenger for request handler in station
+    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Transform and send message
+"""
+
+from typing import List
+
+from dimsdk import ID
+from dimsdk import Station
+from dimsdk import ReliableMessage
+from dimsdk import MessageHelper
+
+from ..common import CommonMessenger, CommonMessagePacker
+
+from .dispatcher import Dispatcher
+
+
+class ServerMessenger(CommonMessenger):
+
+    # Override
+    def handshake_success(self):
+        session = self.session
+        identifier = session.identifier
+        remote_address = session.remote_address
+        self.warning(msg='user login: %s, socket: %s' % (identifier, remote_address))
+        # process suspended messages
+        self._resume_reliable_messages()
+
+    def _resume_reliable_messages(self):
+        packer = self.packer
+        assert isinstance(packer, CommonMessagePacker), 'message packer error: %s' % packer
+        messages = packer.resume_reliable_messages()
+        for msg in messages:
+            self.info(msg='processing suspended message: %s -> %s' % (msg.sender, msg.receiver))
+            try:
+                responses = self.process_reliable_message(msg=msg)
+                for res in responses:
+                    self.send_reliable_message(msg=res, priority=1)
+            except Exception as error:
+                self.error(msg='failed to process incoming message: %s' % error)
+
+    # Override
+    def process_reliable_message(self, msg: ReliableMessage) -> List[ReliableMessage]:
+        session = self.session
+        current = self.facebook.current_user
+        sid = current.identifier
+        receiver = msg.receiver
+        # call super
+        responses = super().process_reliable_message(msg=msg)
+        # check for first handshake
+        if receiver == Station.ANY or msg.group == Station.EVERY:
+            # if this message sent to 'station@anywhere', or with group ID 'stations@everywhere',
+            # it means the client doesn't have the station's meta (e.g.: first handshaking)
+            # or visa maybe expired, here attach them to the first response.
+            for res in responses:
+                if res.sender == sid:
+                    # let the first responding message to carry the station's meta & visa
+                    MessageHelper.set_meta(meta=current.meta, msg=res)
+                    MessageHelper.set_visa(visa=current.visa, msg=res)
+                    break
+        elif session.identifier == sid:
+            # station bridge
+            responses = pick_out(messages=responses, bridge=sid)
+        return responses
+
+
+def pick_out(messages: List[ReliableMessage], bridge: ID) -> List[ReliableMessage]:
+    responses = []
+    dispatcher = Dispatcher()
+    for msg in messages:
+        receiver = msg.receiver
+        if receiver == bridge:
+            # respond to the bridge
+            responses.append(msg)
+        else:
+            # this message is not respond to the bridge, the receiver may be
+            # roaming to other station, so deliver it via dispatcher here.
+            dispatcher.deliver_message(msg=msg, receiver=receiver)
+    return responses

{dimples-0.3.3 → dimples-0.3.4}/dimples/server/packer.py

@@ -85,15 +85,13 @@ class ServerMessagePacker(CommonMessagePacker):
             # cycled message
             if sender.type == EntityType.STATION or receiver.type == EntityType.STATION:
                 # ignore cycled station message
+                self.warning(msg='cycled station message: %s -> %s' % (sender, receiver))
                 return None
             elif receiver.is_broadcast:
                 # ignore cycled broadcast message
+                self.warning(msg='cycled broadcast message: %s -> %s' % (sender, receiver))
                 return None
             self.warning(msg='cycled message: %s -> %s' % (sender, receiver))
-        if not self.__check_reliable_message_receiver(msg=msg):
-            # receiver (group) not ready
-            self.warning(msg='receiver not ready: %s' % msg.receiver)
-            return None
         # check session
         if self.__is_trusted(sender=msg.sender):
             # no need to verify message from this sender
@@ -102,15 +100,6 @@ class ServerMessagePacker(CommonMessagePacker):
         # verify after sender is OK
         return super().verify_message(msg=msg)
 
-    # Override
-    def _check_reliable_message_receiver(self, msg: ReliableMessage) -> bool:
-        # skip for "super().verify_message(msg=msg)"
-        return True
-
-    def __check_reliable_message_receiver(self, msg: ReliableMessage) -> bool:
-        # check for group
-        return super()._check_reliable_message_receiver(msg=msg)
-
 
 def get_facebook(packer: CommonMessagePacker) -> CommonFacebook:
     barrack = packer.facebook