dimples 0.4.2__tar.gz → 0.5.0__tar.gz

{dimples-0.4.2 → dimples-0.5.0}/PKG-INFO

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

{dimples-0.4.2 → dimples-0.5.0}/dimples/client/network/session.py

@@ -36,11 +36,12 @@
 """
 
 import traceback
-from threading import Thread
 from typing import Optional, List
 
 from dimsdk import Station
 
+from startrek.fsm import Daemon
+from startrek.fsm import Delegate as StateDelegate
 from startrek import Docker, DockerStatus
 from startrek import Arrival
 
@@ -48,6 +49,8 @@ from ...common import SessionDBI
 from ...conn import BaseSession
 from ...conn import MTPStreamArrival
 
+from .state import StateMachine, SessionState
+
 
 class ClientSession(BaseSession):
     """
@@ -76,8 +79,12 @@ class ClientSession(BaseSession):
     def __init__(self, station: Station, database: SessionDBI):
         super().__init__(remote=(station.host, station.port), sock=None, database=database)
         self.__station = station
+        # session key
         self.__key: Optional[str] = None
-        self.__thread: Optional[Thread] = None
+        # state machine
+        self.__fsm = StateMachine(session=self)
+        # background thread to drive gate & hub processing
+        self.__daemon = Daemon(target=self.run)
 
     @property
     def station(self) -> Station:
@@ -91,23 +98,29 @@ class ClientSession(BaseSession):
     def key(self, session_key: str):
         self.__key = session_key
 
-    def start(self):
-        self.__force_stop()
-        t = Thread(target=self.run, daemon=True)
-        self.__thread = t
-        t.start()
-
-    def __force_stop(self):
-        t: Thread = self.__thread
-        if t is not None:
-            # waiting 2 seconds for stopping the thread
-            self.__thread = None
-            t.join(timeout=2.0)
+    @property
+    def state(self) -> SessionState:
+        ss = self.__fsm.current_state
+        assert ss is None or isinstance(ss, SessionState), 'session state error: %s' % ss
+        return ss
+
+    def start(self, delegate: StateDelegate):
+        if self.running:
+            self.stop()
+        # start a background thread
+        self.__daemon.start()
+        # start state machine
+        fsm = self.__fsm
+        fsm.delegate = delegate
+        fsm.start()
 
     # Override
     def stop(self):
         super().stop()
-        self.__force_stop()
+        # stop state machine
+        self.__fsm.stop()
+        # wait for thread stop
+        self.__daemon.stop()
 
     # Override
     def setup(self):

{dimples-0.4.2 → dimples-0.5.0}/dimples/client/network/state.py

@@ -25,32 +25,33 @@
 
 import weakref
 from abc import ABC
-from typing import Optional
+from enum import IntEnum
+from typing import Optional, Union
 
 from dimsdk import ID
 
 from startrek.fsm import Context, BaseTransition, BaseState, AutoMachine
 from startrek import DockerStatus
 
-from .session import ClientSession
+# from .session import ClientSession
 
 
 class StateMachine(AutoMachine, Context):
 
-    def __init__(self, session: ClientSession):
-        super().__init__(default=SessionState.DEFAULT)
+    def __init__(self, session):
+        super().__init__()
         self.__session = weakref.ref(session)
         # init states
         builder = self._create_state_builder()
-        self.__set_state(state=builder.get_default_state())
-        self.__set_state(state=builder.get_connecting_state())
-        self.__set_state(state=builder.get_connected_state())
-        self.__set_state(state=builder.get_handshaking_state())
-        self.__set_state(state=builder.get_running_state())
-        self.__set_state(state=builder.get_error_state())
+        self.add_state(state=builder.get_default_state())
+        self.add_state(state=builder.get_connecting_state())
+        self.add_state(state=builder.get_connected_state())
+        self.add_state(state=builder.get_handshaking_state())
+        self.add_state(state=builder.get_running_state())
+        self.add_state(state=builder.get_error_state())
 
     @property
-    def session(self) -> ClientSession:
+    def session(self):  # -> ClientSession:
         return self.__session()
 
     # noinspection PyMethodMayBeStatic
@@ -58,9 +59,6 @@ class StateMachine(AutoMachine, Context):
         from .transition import TransitionBuilder
         return StateBuilder(transition_builder=TransitionBuilder())
 
-    def __set_state(self, state):
-        self.set_state(name=state.name, state=state)
-
     @property  # Override
     def context(self) -> Context:
         return self
@@ -79,16 +77,31 @@ class StateMachine(AutoMachine, Context):
     def status(self) -> DockerStatus:
         session = self.session
         gate = session.gate
-        docker = gate.fetch_docker(remote=session.remote_address, local=None, advance_party=[])
+        docker = gate.fetch_docker([], remote=session.remote_address, local=None)
         if docker is None:
             return DockerStatus.ERROR
         else:
             return docker.status
 
 
+class StateOrder(IntEnum):
+    """ Connection State Order """
+    INIT = 0  # default
+    CONNECTING = 1
+    CONNECTED = 2
+    HANDSHAKING = 3
+    RUNNING = 4
+    ERROR = 5
+
+
 # noinspection PyAbstractClass
 class StateTransition(BaseTransition[StateMachine], ABC):
 
+    def __init__(self, target: Union[int, StateOrder]):
+        if isinstance(target, StateOrder):
+            target = target.value
+        super().__init__(target=target)
+
     # noinspection PyMethodMayBeStatic
     def is_expired(self, state, now: float) -> bool:
         assert isinstance(state, SessionState), 'state error: %s' % state
@@ -110,16 +123,9 @@ class SessionState(BaseState[StateMachine, StateTransition]):
             ERROR       - network error
     """
 
-    DEFAULT = 'default'
-    CONNECTING = 'connecting'
-    CONNECTED = 'connected'
-    HANDSHAKING = 'handshaking'
-    RUNNING = 'running'
-    ERROR = 'error'
-
-    def __init__(self, name: str):
-        super().__init__()
-        self.__name = name
+    def __init__(self, order: StateOrder):
+        super().__init__(index=order.value)
+        self.__name = str(order)
         self.__time: float = 0  # enter time
 
     @property
@@ -137,20 +143,28 @@ class SessionState(BaseState[StateMachine, StateTransition]):
         return self.__name
 
     def __eq__(self, other) -> bool:
-        if self is other:
-            return True
-        elif isinstance(other, SessionState):
-            return self.__name == other.name
+        if isinstance(other, SessionState):
+            if self is other:
+                return True
+            return self.index == other.index
+        elif isinstance(other, StateOrder):
+            return self.index == other.value
+        elif isinstance(other, int):
+            return self.index == other
         elif isinstance(other, str):
             return self.__name == other
         else:
             return False
 
     def __ne__(self, other) -> bool:
-        if self is other:
-            return False
-        elif isinstance(other, SessionState):
-            return self.__name != other.name
+        if isinstance(other, SessionState):
+            if self is other:
+                return False
+            return self.index != other.index
+        elif isinstance(other, StateOrder):
+            return self.index != other.value
+        elif isinstance(other, int):
+            return self.index != other
         elif isinstance(other, str):
             return self.__name != other
         else:
@@ -165,11 +179,11 @@ class SessionState(BaseState[StateMachine, StateTransition]):
         self.__time = 0
 
     # Override
-    def on_pause(self, ctx: StateMachine):
+    def on_pause(self, ctx: StateMachine, now: float):
         pass
 
     # Override
-    def on_resume(self, ctx: StateMachine):
+    def on_resume(self, ctx: StateMachine, now: float):
         pass
 
 
@@ -183,14 +197,10 @@ class StateBuilder:
         super().__init__()
         self.__builder = transition_builder
 
-    # noinspection PyMethodMayBeStatic
-    def get_named_state(self, name: str) -> SessionState:
-        return SessionState(name=name)
-
     def get_default_state(self) -> SessionState:
         builder = self.__builder
         # assert isinstance(builder, TransitionBuilder)
-        state = self.get_named_state(name=SessionState.DEFAULT)
+        state = SessionState(order=StateOrder.INIT)
         # Default -> Connecting
         state.add_transition(transition=builder.get_default_connecting_transition())
         return state
@@ -198,7 +208,7 @@ class StateBuilder:
     def get_connecting_state(self) -> SessionState:
         builder = self.__builder
         # assert isinstance(builder, TransitionBuilder)
-        state = self.get_named_state(name=SessionState.CONNECTING)
+        state = SessionState(order=StateOrder.CONNECTING)
         # Connecting -> Connected
         state.add_transition(transition=builder.get_connecting_connected_transition())
         # Connecting -> Error
@@ -208,7 +218,7 @@ class StateBuilder:
     def get_connected_state(self) -> SessionState:
         builder = self.__builder
         # assert isinstance(builder, TransitionBuilder)
-        state = self.get_named_state(name=SessionState.CONNECTED)
+        state = SessionState(order=StateOrder.CONNECTED)
         # Connected -> Handshaking
         state.add_transition(transition=builder.get_connected_handshaking_transition())
         # Connected -> Error
@@ -218,7 +228,7 @@ class StateBuilder:
     def get_handshaking_state(self) -> SessionState:
         builder = self.__builder
         # assert isinstance(builder, TransitionBuilder)
-        state = self.get_named_state(name=SessionState.HANDSHAKING)
+        state = SessionState(order=StateOrder.HANDSHAKING)
         # Handshaking -> Running
         state.add_transition(transition=builder.get_handshaking_running_transition())
         # Handshaking -> Connected
@@ -230,7 +240,7 @@ class StateBuilder:
     def get_running_state(self) -> SessionState:
         builder = self.__builder
         # assert isinstance(builder, TransitionBuilder)
-        state = self.get_named_state(name=SessionState.RUNNING)
+        state = SessionState(order=StateOrder.RUNNING)
         # Running -> Default
         state.add_transition(transition=builder.get_running_default_transition())
         # Running -> Error
@@ -240,7 +250,7 @@ class StateBuilder:
     def get_error_state(self) -> SessionState:
         builder = self.__builder
         # assert isinstance(builder, TransitionBuilder)
-        state = self.get_named_state(name=SessionState.ERROR)
+        state = SessionState(order=StateOrder.ERROR)
         # Error -> Default
         state.add_transition(transition=builder.get_error_default_transition())
         return state

{dimples-0.4.2 → dimples-0.5.0}/dimples/client/network/transition.py

@@ -26,64 +26,64 @@
 from startrek import DockerStatus
 
 from .state import StateMachine, StateTransition
-from .state import SessionState
+from .state import StateOrder
 
 
 class TransitionBuilder:
 
     # noinspection PyMethodMayBeStatic
     def get_default_connecting_transition(self):
-        return DefaultConnectingTransition(target=SessionState.CONNECTING)
+        return DefaultConnectingTransition(target=StateOrder.CONNECTING)
 
     # Connecting
 
     # noinspection PyMethodMayBeStatic
     def get_connecting_connected_transition(self):
-        return ConnectingConnectedTransition(target=SessionState.CONNECTED)
+        return ConnectingConnectedTransition(target=StateOrder.CONNECTED)
 
     # noinspection PyMethodMayBeStatic
     def get_connecting_error_transition(self):
-        return ConnectingErrorTransition(target=SessionState.ERROR)
+        return ConnectingErrorTransition(target=StateOrder.ERROR)
 
     # Connected
 
     # noinspection PyMethodMayBeStatic
     def get_connected_handshaking_transition(self):
-        return ConnectedHandshakingTransition(target=SessionState.HANDSHAKING)
+        return ConnectedHandshakingTransition(target=StateOrder.HANDSHAKING)
 
     # noinspection PyMethodMayBeStatic
     def get_connected_error_transition(self):
-        return ConnectedErrorTransition(target=SessionState.ERROR)
+        return ConnectedErrorTransition(target=StateOrder.ERROR)
 
     # Handshaking
 
     # noinspection PyMethodMayBeStatic
     def get_handshaking_running_transition(self):
-        return HandshakingRunningTransition(target=SessionState.RUNNING)
+        return HandshakingRunningTransition(target=StateOrder.RUNNING)
 
     # noinspection PyMethodMayBeStatic
     def get_handshaking_connected_transition(self):
-        return HandshakingConnectedTransition(target=SessionState.CONNECTED)
+        return HandshakingConnectedTransition(target=StateOrder.CONNECTED)
 
     # noinspection PyMethodMayBeStatic
     def get_handshaking_error_transition(self):
-        return HandshakingErrorTransition(target=SessionState.ERROR)
+        return HandshakingErrorTransition(target=StateOrder.ERROR)
 
     # Running
 
     # noinspection PyMethodMayBeStatic
     def get_running_default_transition(self):
-        return RunningDefaultTransition(target=SessionState.DEFAULT)
+        return RunningDefaultTransition(target=StateOrder.INIT)
 
     # noinspection PyMethodMayBeStatic
     def get_running_error_transition(self):
-        return RunningErrorTransition(target=SessionState.ERROR)
+        return RunningErrorTransition(target=StateOrder.ERROR)
 
     # Error
 
     # noinspection PyMethodMayBeStatic
     def get_error_default_transition(self):
-        return ErrorDefaultTransition(target=SessionState.DEFAULT)
+        return ErrorDefaultTransition(target=StateOrder.INIT)
 
 
 #

{dimples-0.4.2 → dimples-0.5.0}/dimples/client/terminal.py

@@ -40,26 +40,26 @@ from ..utils import StateDelegate
 
 from .network import ClientSession
 from .network import StateMachine, SessionState
+from .network.state import StateOrder
 
 from .messenger import ClientMessenger
 
 
-class Terminal(Runner, StateDelegate, Logging):
+class DeviceMixin:
+
+    @property
+    def user_agent(self) -> str:
+        return 'DIMP/0.4 (Client; Linux; en-US) DIMCoreKit/0.9 (Terminal) DIM-by-GSP/1.0'
+
+
+class Terminal(Runner, DeviceMixin, Logging, StateDelegate):
 
     def __init__(self, messenger: ClientMessenger):
         super().__init__(interval=60)
         self.__messenger = messenger
-        # session state
-        fsm = StateMachine(session=messenger.session)
-        fsm.delegate = self
-        self.__fsm = fsm
         # default online time
         self.__last_time = time.time()
 
-    @property
-    def user_agent(self) -> str:
-        return 'DIMP/0.4 (Client; Linux; en-US) DIMCoreKit/0.9 (Terminal) DIM-by-GSP/1.0'
-
     @property
     def messenger(self) -> ClientMessenger:
         return self.__messenger
@@ -68,18 +68,10 @@ class Terminal(Runner, StateDelegate, Logging):
     def session(self) -> ClientSession:
         return self.messenger.session
 
-    @property
-    def state(self) -> SessionState:
-        ss = self.__fsm.current_state
-        assert ss is None or isinstance(ss, SessionState), 'session state error: %s' % ss
-        return ss
-
-    @property
-    def is_alive(self) -> bool:
-        # if more than 10 minutes no online command sent
-        # means this terminal is dead
-        now = time.time()
-        return now < (self.__last_time + 600)
+    @property  # Override
+    def running(self) -> bool:
+        if super().running:
+            return self.session.running
 
     def start(self):
         thread = threading.Thread(target=self.run, daemon=True)
@@ -88,12 +80,10 @@ class Terminal(Runner, StateDelegate, Logging):
     # Override
     def setup(self):
         super().setup()
-        self.session.start()
-        self.__fsm.start()
+        self.session.start(delegate=self)
 
     # Override
     def finish(self):
-        self.__fsm.stop()
         self.session.stop()
         super().finish()
 
@@ -107,7 +97,7 @@ class Terminal(Runner, StateDelegate, Logging):
         messenger = self.messenger
         session = messenger.session
         usr_id = session.identifier
-        if usr_id is None or self.state != SessionState.RUNNING:
+        if usr_id is None or session.state != StateOrder.RUNNING:
             # handshake not accepted
             return False
         # report every 5 minutes to keep user online
@@ -128,24 +118,26 @@ class Terminal(Runner, StateDelegate, Logging):
     #
 
     # Override
-    def enter_state(self, state: SessionState, ctx: StateMachine):
+    def enter_state(self, state: SessionState, ctx: StateMachine, now: float):
         # called before state changed
         session = self.session
         station = session.station
         self.info(msg='enter state: %s, %s => %s' % (state, session.identifier, station.identifier))
 
     # Override
-    def exit_state(self, state: SessionState, ctx: StateMachine):
+    def exit_state(self, state: SessionState, ctx: StateMachine, now: float):
         # called after state changed
         current = ctx.current_state
         self.info(msg='server state changed: %s -> %s' % (state, current))
-        if current is None:
-            return
-        elif current == SessionState.HANDSHAKING:
+        if isinstance(current, SessionState):
+            index = current.index
+        else:
+            index = -1
+        if index == StateOrder.HANDSHAKING:
             # start handshake
             messenger = self.messenger
             messenger.handshake(session_key=None)
-        elif current == SessionState.RUNNING:
+        elif index == StateOrder.RUNNING:
             # broadcast current meta & visa document to all stations
             messenger = self.messenger
             messenger.handshake_success()
@@ -158,10 +150,10 @@ class Terminal(Runner, StateDelegate, Logging):
             self.__last_time = time.time()
 
     # Override
-    def pause_state(self, state: SessionState, ctx: StateMachine):
+    def pause_state(self, state: SessionState, ctx: StateMachine, now: float):
         pass
 
     # Override
-    def resume_state(self, state: SessionState, ctx: StateMachine):
+    def resume_state(self, state: SessionState, ctx: StateMachine, now: float):
         # TODO: clear session key for re-login?
         pass