dimples 0.4.0__tar.gz → 0.4.1__tar.gz

{dimples-0.4.0 → dimples-0.4.1}/PKG-INFO

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

{dimples-0.4.0 → dimples-0.4.1}/dimples/client/terminal.py

@@ -149,6 +149,11 @@ class Terminal(Runner, StateDelegate, Logging):
             # broadcast current meta & visa document to all stations
             messenger = self.messenger
             messenger.handshake_success()
+            session = messenger.session
+            usr_id = session.identifier
+            if usr_id is not None and usr_id.type != EntityType.STATION:
+                # send login command to everyone to provide more information.
+                messenger.broadcast_login(sender=usr_id, user_agent=self.user_agent)
             # update last online time
             self.__last_time = time.time()
 

{dimples-0.4.0 → dimples-0.4.1}/dimples/conn/protocol/ws.py

@@ -76,7 +76,7 @@ class WebSocket:
             text = utf8_decode(data=stream).lower()
             pos1 = text.find('sec-websocket-key:')
             if pos1 > 0:
-                pos1 += len('sec-WebSocket-key:')
+                pos1 += len('sec-websocket-key:')
                 pos2 = text.find('\r\n', pos1)
                 if pos2 > 0:
                     return stream[pos1:pos2].strip()

{dimples-0.4.0 → dimples-0.4.1}/dimples/server/__init__.py

@@ -32,8 +32,6 @@
 from .session import ServerSession
 from .session_center import SessionCenter  # SessionPool
 
-from .broadcast import BroadcastRecipientManager
-
 from .push import BadgeKeeper, PushService
 from .push import PushCenter
 
@@ -56,8 +54,6 @@ __all__ = [
     # Session
     'ServerSession', 'SessionCenter',  # 'SessionPool',
 
-    'BroadcastRecipientManager',
-
     # Push Notification
     'BadgeKeeper', 'PushService',
     'PushCenter',

{dimples-0.4.0 → dimples-0.4.1}/dimples/server/archivist.py

@@ -28,11 +28,13 @@
 # SOFTWARE.
 # ==============================================================================
 
+import threading
 from abc import ABC
-from typing import Dict, List
+from typing import Dict, List, Set
 
+from dimsdk import DateTime
 from dimsdk import FrequencyChecker
-from dimsdk import ID, Document
+from dimsdk import EntityType, ID, Document
 from dimsdk import Envelope, InstantMessage
 from dimsdk import Command, MetaCommand, DocumentCommand
 from dimsdk import Station
@@ -40,8 +42,10 @@ from dimsdk import Station
 from ..common import AccountDBI
 from ..common import CommonArchivist
 from ..common import CommonFacebook, CommonMessenger
+from ..common import StationInfo
 
-from .broadcast import broadcast_reliable_message
+from .dispatcher import Dispatcher
+from .session_center import SessionCenter
 
 
 def get_facebook(archivist: CommonArchivist):
@@ -67,21 +71,79 @@ class ServerArchivist(CommonArchivist, ABC):
         super().__init__(database=database)
         self.__document_responses = FrequencyChecker(expires=self.RESPOND_EXPIRES)
         self.__last_active_members: Dict[ID, ID] = {}  # group => member
-
-    def _broadcast_command(self, content: Command, receiver: ID) -> bool:
+        # neighbor stations
+        self.__neighbors = set()
+        self.__lock = threading.Lock()
+        self.__expires = 0
+
+    @property
+    def active_stations(self) -> Set[ID]:
+        """ get neighbor stations connected to current station """
+        now = DateTime.now()
+        with self.__lock:
+            if self.__expires < now.timestamp:
+                neighbors = set()
+                center = SessionCenter()
+                all_users = center.all_users()
+                for item in all_users:
+                    if item.type == EntityType.STATION:
+                        neighbors.add(item)
+                self.__neighbors = neighbors
+                self.__expires = now.timestamp + 128
+            return self.__neighbors
+
+    @property
+    def all_stations(self) -> List[StationInfo]:
+        """ get stations from database """
+        dispatcher = Dispatcher()
+        db = dispatcher.sdb
+        # TODO: get chosen provider
+        providers = db.all_providers()
+        assert len(providers) > 0, 'service provider not found'
+        gsp = providers[0].identifier
+        return db.all_stations(provider=gsp)
+
+    @property
+    def all_neighbors(self) -> Set[ID]:
+        """ get all stations """
+        neighbors = set()
+        # get stations from chosen provider
+        chosen_stations = self.all_stations
+        for item in chosen_stations:
+            sid = item.identifier
+            if sid is None or sid.is_broadcast:
+                continue
+            neighbors.add(sid)
+        # get neighbor station from session server
+        proactive_neighbors = self.active_stations
+        for sid in proactive_neighbors:
+            if sid is None or sid.is_broadcast:
+                self.error(msg='neighbor station ID error: %s' % sid)
+                continue
+            neighbors.add(sid)
+        return neighbors
+
+    def _broadcast_command(self, command: Command) -> bool:
         facebook = get_facebook(archivist=self)
         messenger = get_messenger(archivist=self)
         if facebook is None or messenger is None:
             self.error(msg='twins not ready yet: %s, %s' % (facebook, messenger))
             return False
         sid = facebook.current_user.identifier
-        env = Envelope.create(sender=sid, receiver=receiver)
-        i_msg = InstantMessage.create(head=env, body=content)
+        env = Envelope.create(sender=sid, receiver=Station.EVERY)
+        i_msg = InstantMessage.create(head=env, body=command)
         # pack & deliver message
         s_msg = messenger.encrypt_message(msg=i_msg)
         r_msg = messenger.sign_message(msg=s_msg)
-        cnt = broadcast_reliable_message(msg=r_msg, station=sid)
-        return cnt > 0
+        # dispatch
+        dispatcher = Dispatcher()
+        neighbors = self.all_neighbors
+        for receiver in neighbors:
+            if receiver == sid:
+                self.debug(msg='skip cycled message: %s -> %s' % (sid, receiver))
+                continue
+            dispatcher.deliver_message(msg=r_msg, receiver=receiver)
+        return len(neighbors) > 0
 
     # protected
     def is_documents_respond_expired(self, identifier: ID, force: bool) -> bool:
@@ -98,7 +160,7 @@ class ServerArchivist(CommonArchivist, ABC):
             return False
         self.info(msg='querying meta for: %s' % identifier)
         command = MetaCommand.query(identifier=identifier)
-        return self._broadcast_command(content=command, receiver=Station.EVERY)
+        return self._broadcast_command(command=command)
 
     # Override
     def query_documents(self, identifier: ID, documents: List[Document]) -> bool:
@@ -109,7 +171,7 @@ class ServerArchivist(CommonArchivist, ABC):
         last_time = self.get_last_document_time(identifier=identifier, documents=documents)
         self.info(msg='querying document for: %s, last time: %s' % (identifier, last_time))
         command = DocumentCommand.query(identifier=identifier, last_time=last_time)
-        return self._broadcast_command(content=command, receiver=Station.EVERY)
+        return self._broadcast_command(command=command)
 
     # Override
     def query_members(self, group: ID, members: List[ID]) -> bool:

{dimples-0.4.0 → dimples-0.4.1}/dimples/server/processor.py

@@ -31,7 +31,7 @@
 import time
 from typing import Optional, Union, List, Dict
 
-from dimsdk import EntityType, ID, ANYONE
+from dimsdk import EntityType, ID, ANYONE, EVERYONE
 from dimsdk import Station
 from dimsdk import InstantMessage, ReliableMessage
 from dimsdk import Envelope
@@ -58,7 +58,7 @@ from .cpu import DocumentCommandProcessor
 
 from .packer import FilterManager
 from .dispatcher import Dispatcher
-from .broadcast import broadcast_reliable_message
+from .archivist import ServerArchivist
 
 
 class ServerMessageProcessor(MessageProcessor, Logging):
@@ -95,8 +95,7 @@ class ServerMessageProcessor(MessageProcessor, Logging):
         messenger = self.messenger
         session = messenger.session
         current = self.facebook.current_user
-        sid = current.identifier
-        sender = msg.sender
+        station = current.identifier
         receiver = msg.receiver
         # 0. verify message
         s_msg = messenger.verify_message(msg=msg)
@@ -104,7 +103,7 @@ class ServerMessageProcessor(MessageProcessor, Logging):
             # TODO: suspend and waiting for sender's meta if not exists
             return []
         # 1. check receiver
-        if receiver == sid:
+        if receiver == station:
             # message to this station
             # maybe a meta command, document command, etc ...
             pass
@@ -131,16 +130,22 @@ class ServerMessageProcessor(MessageProcessor, Logging):
             #   we can trust this message an no need to verify it;
             # else if sender is a neighbor station,
             #   we can trust it too;
-            if receiver.is_broadcast:
-                # broadcast message (to neighbor stations, or station bots)
-                # e.g.: 'stations@everywhere',
-                #       'archivist@anywhere', 'announcer@anywhere', 'monitor@anywhere'
-                broadcast_reliable_message(msg=msg, station=sid)
-                # if receiver.is_group:
-                #     broadcast message to multiple destinations,
+            if receiver == Station.EVERY or receiver == EVERYONE:
+                # broadcast message (to neighbor stations)
+                # e.g.: 'stations@everywhere'
+                self._broadcast_message(msg=msg, station=station)
+                # if receiver == 'everyone@everywhere':
+                #     broadcast message to all destinations,
                 #     current station is it's receiver too.
+            elif receiver.is_broadcast:
+                # broadcast message (to station bots)
+                # e.g.: 'archivist@anywhere', 'announcer@anywhere', 'monitor@anywhere'
+                self._broadcast_message(msg=msg, station=station)
+                return []
             elif receiver.is_group:
-                self.error(msg='group message should not send to station: %s -> %s' % (sender, receiver))
+                # encrypted group messages should be sent to the group assistant,
+                # the station will never process these messages.
+                self._split_group_message(msg=msg, station=station)
                 return []
             else:
                 # this message is not for current station,
@@ -180,6 +185,32 @@ class ServerMessageProcessor(MessageProcessor, Logging):
         else:
             return [r_msg]
 
+    def _broadcast_message(self, msg: ReliableMessage, station: ID):
+        """ broadcast message to neighbor stations """
+        archivist = self.facebook.archivist
+        assert isinstance(archivist, ServerArchivist)
+        neighbors = archivist.all_neighbors
+        sender = msg.sender
+        self.info(msg='broadcast message %s -> %s (%s): from station %s to %s'
+                      % (sender, msg.receiver, msg.group, station, neighbors))
+        # dispatch
+        dispatcher = Dispatcher()
+        for receiver in neighbors:
+            if receiver == sender:
+                self.debug(msg='skip cycled message: %s -> %s' % (sender, receiver))
+                continue
+            elif receiver == station:
+                self.debug(msg='skip current station: %s -> %s' % (sender, receiver))
+                continue
+            dispatcher.deliver_message(msg=msg, receiver=receiver)
+        return len(neighbors) > 0
+
+    def _split_group_message(self, msg: ReliableMessage, station: ID):
+        """ redirect group message to assistant """
+        sender = msg.sender
+        receiver = msg.receiver
+        self.error(msg='group message should not send to station: %s, %s -> %s' % (station, sender, receiver))
+
     def _deliver_message(self, msg: ReliableMessage) -> List[ReliableMessage]:
         messenger = self.messenger
         current = self.facebook.current_user

{dimples-0.4.0 → dimples-0.4.1}/dimples/station/shared.py

@@ -42,7 +42,6 @@ from ..server import ServerSession
 from ..server import ServerMessenger
 from ..server import ServerMessagePacker
 from ..server import ServerMessageProcessor
-from ..server import BroadcastRecipientManager
 from ..server import Dispatcher
 
 
@@ -189,12 +188,4 @@ def create_ans(config: Config) -> AddressNameServer:
     ans_records = config.ans_records
     if ans_records is not None:
         ans.fix(records=ans_records)
-    # set bots to receive message for 'everyone@everywhere'
-    bots = set()
-    se = ans.identifier(name='archivist')  # Search Engine
-    if se is not None:
-        bots.add(se)
-    if len(bots) > 0:
-        manager = BroadcastRecipientManager()
-        manager.station_bots = bots
     return ans

{dimples-0.4.0 → dimples-0.4.1}/dimples.egg-info/PKG-INFO

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

{dimples-0.4.0 → dimples-0.4.1}/dimples.egg-info/SOURCES.txt

@@ -114,7 +114,6 @@ dimples/register/run.py
 dimples/register/shared.py
 dimples/server/__init__.py
 dimples/server/archivist.py
-dimples/server/broadcast.py
 dimples/server/dispatcher.py
 dimples/server/messenger.py
 dimples/server/packer.py

{dimples-0.4.0 → dimples-0.4.1}/setup.py

@@ -14,7 +14,7 @@ import io
 
 from setuptools import setup, find_packages
 
-__version__ = '0.4.0'
+__version__ = '0.4.1'
 __author__ = 'Albert Moky'
 __contact__ = 'albert.moky@gmail.com'
 

dimples-0.4.0/dimples/server/broadcast.py

@@ -1,219 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-#   DIM-SDK : Decentralized Instant Messaging Software Development Kit
-#
-# ==============================================================================
-# MIT License
-#
-# Copyright (c) 2023 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.
-# ==============================================================================
-
-"""
-    Broadcast Recipient Manager
-    ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-"""
-
-import threading
-from typing import Set, List
-
-from dimsdk import DateTime
-from dimsdk import EntityType, ID, EVERYONE
-from dimsdk import Station
-from dimsdk import ReliableMessage
-
-from ..utils import Singleton, Log, Logging
-from ..common import StationInfo
-
-from .cpu import AnsCommandProcessor
-from .trace import TraceNode, TraceList, TraceManager
-from .dispatcher import Dispatcher
-from .session_center import SessionCenter
-
-
-@Singleton
-class BroadcastRecipientManager(Logging):
-
-    def __init__(self):
-        super().__init__()
-        self.__lock = threading.Lock()
-        self.__expires = 0
-        self.__neighbors = set()
-        self.__bots = set()
-
-    @property
-    def station_bots(self) -> Set[ID]:
-        """ get station bots """
-        return self.__bots
-
-    @station_bots.setter
-    def station_bots(self, bots: Set[ID]):
-        """ set station bots to receive message for 'everyone@everywhere' """
-        assert isinstance(bots, Set), 'bots error: %s' % bots
-        self.__bots = bots
-
-    @property
-    def proactive_neighbors(self) -> Set[ID]:
-        """ get neighbor stations connected to current station """
-        now = DateTime.now()
-        with self.__lock:
-            if self.__expires < now.timestamp:
-                neighbors = set()
-                center = SessionCenter()
-                all_users = center.all_users()
-                for item in all_users:
-                    if item.type == EntityType.STATION:
-                        neighbors.add(item)
-                self.__neighbors = neighbors
-                self.__expires = now.timestamp + 128
-            return self.__neighbors
-
-    @property
-    def all_stations(self) -> List[StationInfo]:
-        """ get stations from database """
-        dispatcher = Dispatcher()
-        db = dispatcher.sdb
-        # TODO: get chosen provider
-        providers = db.all_providers()
-        assert len(providers) > 0, 'service provider not found'
-        gsp = providers[0].identifier
-        return db.all_stations(provider=gsp)
-
-    @property
-    def all_neighbors(self) -> Set[ID]:
-        """ get all stations """
-        neighbors = set()
-        # get stations from chosen provider
-        stations = self.all_stations
-        for item in stations:
-            sid = item.identifier
-            if sid is None or sid.is_broadcast:
-                continue
-            neighbors.add(sid)
-        # get neighbor station from session server
-        proactive_neighbors = self.proactive_neighbors
-        for sid in proactive_neighbors:
-            if sid is None or sid.is_broadcast:
-                assert False, 'neighbor station ID error: %s' % sid
-                # continue
-            neighbors.add(sid)
-        return neighbors
-
-    def get_recipients(self, msg: ReliableMessage, receiver: ID, station: ID) -> Set[ID]:
-        """ get nodes passed through, includes current node which is just added before """
-        recipients = set()
-        tm = TraceManager()
-        traces = tm.get_traces(msg=msg)
-        # if this message is sending to 'stations@everywhere' or 'everyone@everywhere'
-        # get all neighbor stations to broadcast, but
-        # traced nodes should be ignored to avoid cycled delivering
-        if receiver == Station.EVERY or receiver == EVERYONE:
-            self.info(msg='forward to neighbors: %s' % receiver)
-            # get neighbor stations
-            neighbors = self.all_neighbors
-            for sid in neighbors:
-                if traces.search(node=sid) >= 0 or sid == station:
-                    self.warning(msg='skip duplicated station: %s' % sid)
-                    continue
-                recipients.add(sid)
-            # get station bots
-            if receiver == EVERYONE:
-                # include station bots as 'everyone@everywhere'
-                bots = self.station_bots
-                for bid in bots:
-                    if traces.search(node=bid) >= 0:
-                        self.warning(msg='skip duplicated bot: %s' % bid)
-                        continue
-                    recipients.add(bid)
-        elif receiver.is_user:
-            # 'archivist@anywhere', 'announcer@anywhere', 'monitor@anywhere'
-            name = receiver.name
-            if name is not None:
-                assert name != 'station' and name != 'anyone', 'receiver error: %s' % receiver
-                bot = AnsCommandProcessor.ans_id(name=name)
-                self.info(msg='forward to bot: %s -> %s' % (name, bot))
-                if bot is not None and traces.search(node=bot) < 0:
-                    recipients.add(bot)
-        self.info(msg='recipients: %s -> %s' % (receiver, recipients))
-        return recipients
-
-
-def broadcast_reliable_message(msg: ReliableMessage, station: ID):
-    receiver = msg.receiver
-    # get other recipients for broadcast message
-    manager = BroadcastRecipientManager()
-    recipients = manager.get_recipients(msg=msg, receiver=receiver, station=station)
-    if len(recipients) == 0:
-        Log.warning('other recipients not found: %s' % receiver)
-        return 0
-    sender = msg.sender
-    # dispatch
-    dispatcher = Dispatcher()
-    for target in recipients:
-        assert not target.is_broadcast, 'recipient error: %s, %s' % (target, receiver)
-        deliver_message(msg=msg, receiver=target, recipients=recipients, station=station, dispatcher=dispatcher)
-        # TODO: after deliver to connected neighbors, the dispatcher will continue
-        #       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)
-
-
-def deliver_message(msg: ReliableMessage, receiver: ID, recipients: Set[ID], station: ID, dispatcher: Dispatcher):
-    if receiver == station:
-        Log.warning(msg='skip current node: %s, %s' % (receiver, recipients))
-        return None
-    elif receiver == msg.sender:
-        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
-    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())