dimples 0.3.4__tar.gz → 0.4.1__tar.gz

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

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

{dimples-0.3.4 → dimples-0.4.1}/dimples/client/network/state.py

@@ -79,7 +79,7 @@ class StateMachine(AutoMachine, Context):
     def status(self) -> DockerStatus:
         session = self.session
         gate = session.gate
-        docker = gate.get_docker(remote=session.remote_address, local=None, advance_party=[])
+        docker = gate.fetch_docker(remote=session.remote_address, local=None, advance_party=[])
         if docker is None:
             return DockerStatus.ERROR
         else:

{dimples-0.3.4 → 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.3.4 → dimples-0.4.1}/dimples/conn/gate.py

@@ -30,8 +30,9 @@
 
 import socket
 from abc import ABC
-from typing import Generic, TypeVar, Optional, Union, List, Tuple
+from typing import Generic, TypeVar, Optional, Union, List
 
+from startrek.types import SocketAddress
 from startrek import Hub, Channel
 from startrek import Connection, ConnectionState, ActiveConnection
 from startrek import Docker, DockerDelegate
@@ -65,30 +66,17 @@ class BaseGate(StarGate, Generic[H], ABC):
     #
     #   Docker
     #
-    def get_docker(self, remote: Tuple[str, int], local: Optional[Tuple[str, int]],
-                   advance_party: List[bytes]) -> Docker:
-        docker = self._get_docker(remote=remote, local=local)
-        if docker is None:
-            hub = self.hub
-            # from startrek import Hub
-            # assert isinstance(hub, Hub)
-            conn = hub.connect(remote=remote, local=local)
-            if conn is not None:
-                docker = self._create_docker(connection=conn, advance_party=advance_party)
-                assert docker is not None, 'failed to create docker: %s, %s' % (remote, local)
-                self._set_docker(remote=remote, local=local, docker=docker)
-        return docker
 
     # Override
-    def _get_docker(self, remote: Tuple[str, int], local: Optional[Tuple[str, int]]) -> Optional[Docker]:
+    def _get_docker(self, remote: SocketAddress, local: Optional[SocketAddress]) -> Optional[Docker]:
         return super()._get_docker(remote=remote, local=None)
 
     # Override
-    def _set_docker(self, remote: Tuple[str, int], local: Optional[Tuple[str, int]], docker: Docker):
+    def _set_docker(self, remote: SocketAddress, local: Optional[SocketAddress], docker: Docker):
         super()._set_docker(remote=remote, local=None, docker=docker)
 
     # Override
-    def _remove_docker(self, remote: Tuple[str, int], local: Optional[Tuple[str, int]], docker: Optional[Docker]):
+    def _remove_docker(self, remote: SocketAddress, local: Optional[SocketAddress], docker: Optional[Docker]):
         super()._remove_docker(remote=remote, local=None, docker=docker)
 
     # Override
@@ -171,14 +159,14 @@ class CommonGate(BaseGate, Logging, Generic[H], ABC):
         if error is not None and str(error).startswith('failed to send: '):
             self.warning(msg='ignore socket error: %s, remote=%s' % (error, connection.remote_address))
 
-    def get_channel(self, remote: Tuple[str, int], local: Optional[Tuple[str, int]]) -> Optional[Channel]:
+    def get_channel(self, remote: Optional[SocketAddress], local: Optional[SocketAddress]) -> Optional[Channel]:
         hub = self.hub
         assert isinstance(hub, Hub), 'hub error: %s' % hub
         return hub.open(remote=remote, local=local)
 
     def send_response(self, payload: bytes, ship: Arrival,
-                      remote: Tuple[str, int], local: Optional[Tuple[str, int]]) -> bool:
-        worker = self.get_docker(remote=remote, local=local, advance_party=[])
+                      remote: SocketAddress, local: Optional[SocketAddress]) -> bool:
+        worker = self._get_docker(remote=remote, local=local)
         if isinstance(worker, MTPStreamDocker):
             # sn = TransactionID.from_data(data=ship.sn)
             sn = TransactionID.generate()
@@ -195,6 +183,20 @@ class CommonGate(BaseGate, Logging, Generic[H], ABC):
         else:
             raise LookupError('docker error (%s, %s): %s' % (remote, local, worker))
 
+    def fetch_docker(self, remote: SocketAddress, local: Optional[SocketAddress], advance_party: List[bytes]) -> Docker:
+        docker = self._get_docker(remote=remote, local=local)
+        if docker is None:  # and advance_party is not None:
+            hub = self.hub
+            assert isinstance(hub, Hub), 'gate hub error: %s' % hub
+            conn = hub.connect(remote=remote, local=local)
+            if conn is not None:
+                docker = self._create_docker(connection=conn, advance_party=advance_party)
+                if docker is None:
+                    assert False, 'failed to create docker: %s, %s' % (remote, local)
+                else:
+                    self._set_docker(remote=remote, local=local, docker=docker)
+        return docker
+
 
 #
 #   Server Gates

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

@@ -236,7 +236,7 @@ class GateKeeper(Runner, DockerDelegate, Logging):
         return ok
 
     def _docker_pack(self, payload: bytes, priority: int = 0) -> Departure:
-        docker = self.gate.get_docker(remote=self.remote_address, local=None, advance_party=[])
+        docker = self.gate.fetch_docker(remote=self.remote_address, local=None, advance_party=[])
         assert isinstance(docker, DeparturePacker), 'departure packer error: %s' % docker
         return docker.pack(payload=payload, priority=priority)
 

{dimples-0.3.4 → dimples-0.4.1}/dimples/conn/mars.py

@@ -189,7 +189,7 @@ class MarsStreamDocker(PlainDocker, DeparturePacker):
         self.__chunks_lock = threading.RLock()
         self.__package_received = False
 
-    def _parse_package(self, data: bytes) -> Optional[NetMsg]:
+    def _parse_package(self, data: bytes) -> Tuple[Optional[NetMsg], int]:
         with self.__chunks_lock:
             # join the data to the memory cache
             data = self.__chunks + data
@@ -197,16 +197,18 @@ class MarsStreamDocker(PlainDocker, DeparturePacker):
             # try to fetch a package
             pack, offset = MarsHelper.seek_package(data=data)
             self.__package_received = pack is not None
+            remain_len = len(data)
             if offset >= 0:
                 # 'error part' + 'mars package' + 'remaining data
                 if pack is not None:
                     offset += pack.length
                 if offset == 0:
                     self.__chunks = data + self.__chunks
-                elif offset < len(data):
+                elif offset < remain_len:
                     data = data[offset:]
                     self.__chunks = data + self.__chunks
-            return pack
+                remain_len -= offset
+            return pack, remain_len
 
     # Override
     def process_received(self, data: bytes):
@@ -219,13 +221,23 @@ class MarsStreamDocker(PlainDocker, DeparturePacker):
             data = b''
 
     # Override
-    def _get_arrival(self, data: bytes) -> Optional[Arrival]:
-        pack = self._parse_package(data=data)
-        if pack is None:
-            return None
-        # if pack.body is None:
-        #     return None
-        return MarsStreamArrival(mars=pack)
+    def _get_arrivals(self, data: bytes) -> List[Arrival]:
+        ships = []
+        while True:
+            pack, remain_len = self._parse_package(data=data)
+            if pack is None:
+                # waiting for more data
+                break
+            # if pack.body is None:
+            #     continue
+            ships.append(MarsStreamArrival(mars=pack))
+            if remain_len > 0:
+                # continue to check the tail
+                data = b''
+            else:
+                # all data processed
+                break
+        return ships
 
     # Override
     def _check_arrival(self, ship: Arrival) -> Optional[Arrival]:

{dimples-0.3.4 → dimples-0.4.1}/dimples/conn/mtp.py

@@ -121,6 +121,7 @@ class MTPStreamDocker(PackageDocker, DeparturePacker):
             # try to fetch a package
             pack, offset = MTPHelper.seek_package(data=data)
             self.__package_received = pack is not None
+            remain_len = len(data)
             if offset >= 0:
                 # 'error part' + 'MTP package' + 'remaining data
                 if pack is not None:
@@ -130,6 +131,7 @@ class MTPStreamDocker(PackageDocker, DeparturePacker):
                 elif offset < data.size:
                     data = data.slice(start=offset)
                     self.__chunks = data.concat(self.__chunks)
+                remain_len -= offset
             return pack
 
     # Override

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

@@ -34,11 +34,11 @@
 
 """
 
-import hashlib
 import struct
 from typing import Optional, Tuple
 
-from ...utils import base64_encode, utf8_encode
+from ...utils import sha1, base64_encode, utf8_encode, utf8_decode
+from ...utils import Log
 
 
 class WebSocket:
@@ -57,22 +57,35 @@ class WebSocket:
 
     @classmethod
     def handshake(cls, stream: bytes) -> Optional[bytes]:
-        pos1 = stream.find(b'Sec-WebSocket-Key:')
-        if pos1 < 0:
+        key = cls.__fetch_key(stream=stream)
+        if key is None:
             return None
-        pos1 += len('Sec-WebSocket-Key:')
-        pos2 = stream.find(b'\r\n', pos1)
-        if pos2 < 0:
-            return None
-        key = stream[pos1:pos2].strip()
-        sec = hashlib.sha1(key + cls.ws_magic).digest()
+        # build response with sec-key
+        sec = sha1(key + cls.ws_magic)
         sec = base64_encode(data=sec)
         sec = utf8_encode(string=sec)
         return cls.ws_prefix + sec + cls.ws_suffix
 
     @classmethod
     def is_handshake(cls, stream: bytes) -> bool:
-        return stream.find(b'Sec-WebSocket-Key') > 0
+        return cls.__fetch_key(stream=stream) is not None
+
+    @classmethod
+    def __fetch_key(cls, stream: bytes) -> Optional[bytes]:
+        if cls.__check_http(stream=stream):
+            text = utf8_decode(data=stream).lower()
+            pos1 = text.find('sec-websocket-key:')
+            if pos1 > 0:
+                pos1 += len('sec-websocket-key:')
+                pos2 = text.find('\r\n', pos1)
+                if pos2 > 0:
+                    return stream[pos1:pos2].strip()
+
+    @classmethod
+    def __check_http(cls, stream: bytes) -> bool:
+        if stream.startswith(b'GET /'):
+            pos = stream.find(b'HTTP/')
+            return 5 < pos < 512
 
     """
         RFC: https://tools.ietf.org/html/rfc6455#section-5.2
@@ -105,13 +118,14 @@ class WebSocket:
         :return: (payload, remaining_data)
         """
         stream_len = len(stream)
+        print('parsing stream: %d bytes' % stream_len)
         if stream_len < 2:
             return None, stream
         data = b''
         pos = 0
         while True:
             if stream_len < pos + 2:
-                # self.info(msg='incomplete ws package for op code: %d' % stream_len)
+                Log.info(msg='incomplete ws package for op code: %d' % stream_len)
                 return None, stream
             # 1. check whether a continuation frame
             ch0 = stream[pos+0]
@@ -125,7 +139,7 @@ class WebSocket:
             msg_len = ch1 & 0x7F
             if msg_len == 126:
                 if stream_len < pos + 4:
-                    # self.info(msg='incomplete ws package for msg len: %d' % stream_len)
+                    Log.info(msg='incomplete ws package for msg len: %d' % stream_len)
                     return None, stream
                 b2 = stream[pos+2]
                 b3 = stream[pos+3]
@@ -133,7 +147,7 @@ class WebSocket:
                 pos += 4
             elif msg_len == 127:
                 if stream_len < pos + 10:
-                    # self.info(msg='incomplete ws package for msg len: %d' % stream_len)
+                    Log.info(msg='incomplete ws package for msg len: %d' % stream_len)
                     return None, stream
                 b2 = stream[pos+2]
                 b3 = stream[pos+3]
@@ -150,7 +164,7 @@ class WebSocket:
             # 3. get masking-key
             if mask == 1:
                 if stream_len < pos + 4:
-                    # self.info(msg='incomplete ws package for mask: %d' % stream_len)
+                    Log.info(msg='incomplete ws package for mask: %d' % stream_len)
                     return None, stream
                 mask = stream[pos:pos+4]
                 pos += 4
@@ -158,7 +172,7 @@ class WebSocket:
                 mask = None
             # 4. get payload
             if stream_len < pos + msg_len:
-                # self.info(msg='incomplete ws package for payload: %d' % stream_len)
+                Log.info(msg='incomplete ws package for payload: %d' % stream_len)
                 return None, stream
             payload = stream[pos:pos+msg_len]
             pos += msg_len
@@ -179,22 +193,25 @@ class WebSocket:
                 data += content
             elif op == 8:
                 # TODO: CLOSE
+                Log.warning(msg='CLOSE')
                 pass
             elif op == 9:
                 # TODO: PING
+                Log.warning(msg='PING')
                 pass
             elif op == 10:
                 # TODO: PONG
+                Log.warning(msg='PONG')
                 pass
             else:
-                # self.error(msg='ws op error: %d => %s' % (op, stream))
+                Log.error(msg='ws op error: %d => %s' % (op, stream))
                 return None, b''
             # 6. check final fragment
             if fin == 1 or op == 0:
                 # cut the received package(s) and return the remaining
                 stream = stream[pos:]
                 break
-        # self.info(msg='received ws payload len: %d' % len(data))
+        Log.info(msg='received ws payload len: %d, left: %d' % (len(data), len(stream)))
         return data, stream
 
     @classmethod

{dimples-0.3.4 → dimples-0.4.1}/dimples/conn/ws.py

@@ -114,24 +114,25 @@ class WSDocker(PlainDocker, DeparturePacker):
         self.__chunks_lock = threading.RLock()
         self.__package_received = False
 
-    def _parse_package(self, data: bytes) -> Tuple[Optional[bytes], Optional[bytes]]:
+    def _parse_package(self, data: bytes) -> Tuple[Optional[bytes], Optional[bytes], int]:
         with self.__chunks_lock:
             # join the data to the memory cache
             data = self.__chunks + data
             self.__chunks = b''
             # try to fetch a package
             payload, remaining = WebSocket.parse(stream=data)
-            tail_len = len(remaining)
-            if tail_len > 0:
+            self.__package_received = payload is not None
+            remain_len = len(remaining)
+            if remain_len > 0:
                 # put the remaining data back to memory cache
                 self.__chunks = remaining + self.__chunks
             pack = None
             if payload is not None:
                 data_len = len(data)
-                pack_len = data_len - tail_len
+                pack_len = data_len - len(remaining)
                 if pack_len > 0:
                     pack = data[:pack_len]
-            return pack, payload
+            return pack, payload, remain_len
 
     # Override
     def process_received(self, data: bytes):
@@ -144,7 +145,7 @@ class WSDocker(PlainDocker, DeparturePacker):
             data = b''
 
     # Override
-    def _get_arrival(self, data: bytes) -> Optional[Arrival]:
+    def _get_arrivals(self, data: bytes) -> List[Arrival]:
         # check for first request
         if self.__handshaking:
             # join the data to the memory cache
@@ -159,11 +160,22 @@ class WSDocker(PlainDocker, DeparturePacker):
             elif len(data) < self.MAX_PACK_LENGTH:
                 # waiting for more data
                 self.__chunks = data + self.__chunks
-        else:
-            # normal state
-            pack, payload = self._parse_package(data=data)
-            if pack is not None:
-                return WSArrival(package=pack, payload=payload)
+            return []
+        # normal state
+        ships = []
+        while True:
+            pack, payload, remain_len = self._parse_package(data=data)
+            if pack is None:
+                # waiting for more data
+                break
+            ships.append(WSArrival(package=pack, payload=payload))
+            if remain_len > 0:
+                # continue to check the tail
+                data = b''
+            else:
+                # all data processed
+                break
+        return ships
 
     # Override
     def _check_arrival(self, ship: Arrival) -> Optional[Arrival]:

{dimples-0.3.4 → 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.3.4 → 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.3.4 → 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