Revisions to Scalable design of a system with multiple state machines, where valid state transitions depend on the state of other machines

deleted 13 characters in body; edited tags

Source Link

edited May 5, 2020 at 0:17

Jamal

35.2k
13
134
238

Surely this is a common problem and has already been solved? What is the standard design to use in a situation like this? If there isn't a standard design pattern, Dodo you think the design I have suggested is good design?

Thanks.

Rollback to Revision 5

Source Link

edited Apr 22, 2020 at 9:55

Mast ♦

13.9k
12
57
128

In the real system, the predicates are not as simple as this. An example from my requirements is:

a implies b && (c ∥ d) && e where each letter is a particular state of a piece of equipment. The states are also more complex, for example, one state might be item1 is inside item2 exclusion zone. There are also transition states, such as "Turning On", and "Turning Off".

#                     ,----------------------------,
#                     v                            |
#    ,----------[BothOffState]--------,            |
#    | turnOn1()                      | turnOn2()  |
#    v                                v            |
# [Item1_OnState[item1_OnState ]             [Item2_OnState][item2_OnState]     |
#        | turnOff1()                | turnOff2()  |
#        `---------------------------'-------------'
#

class IState(metaclass=ABCMeta):
     def __init__(self, fsm):
        print("system : " + fsm.currentState.__class__.__name__ + " -> " + self.__class__.__name__)
        self._fsm = fsm

class BothOffState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOn1(self):
        self._fsm.currentState = Item1_OnStateitem1_OnState(self._fsm)
        
    def turnOn2(self):
        self._fsm.currentState = Item2_OnStateitem2_OnState(self._fsm)

class Item1_OnStateitem1_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff1(self):
        self._fsm.currentState = BothOffState(self._fsm)

class Item2_OnStateitem2_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff2(self):
        self._fsm.currentState = BothOffState(self._fsm)

class FSM:
    currentState = None
    def __init__(self):
        self.currentState = BothOffState(self)

if __name__ == "__main__":
    
    system = FSM()
    print("<turning on 1>")
    system.currentState.turnOn1()
    #system.currentState.turnOn2() AttributeError because this state transition doesn't exist
    print("<turning off 1>")
    system.currentState.turnOff1()
    print("<turning on 2>")
    system.currentState.turnOn2()
    
    #Output:
    #
    # system : NoneType -> BothOffState
    # <turning on 1>
    # system : BothOffState -> Item1_OnStateitem1_OnState
    # <turning off 1>
    # system : Item1_OnStateitem1_OnState -> BothOffState
    # <turning on 2>
    # system : BothOffState -> Item2_OnStateitem2_OnState

In the real system, the predicates are not as simple as this. An example from my requirements is:

a implies b && (c ∥ d) && e where each letter is a particular state of a piece of equipment. The states are also more complex, for example, one state might be item1 is inside item2 exclusion zone. There are also transition states, such as "Turning On", and "Turning Off".

#                     ,----------------------------,
#                     v                            |
#    ,----------[BothOffState]--------,            |
#    | turnOn1()                      | turnOn2()  |
#    v                                v            |
# [Item1_OnState ]             [Item2_OnState]     |
#        | turnOff1()                | turnOff2()  |
#        `---------------------------'-------------'
#

class IState(metaclass=ABCMeta):
     def __init__(self, fsm):
        print("system : " + fsm.currentState.__class__.__name__ + " -> " + self.__class__.__name__)
        self._fsm = fsm

class BothOffState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOn1(self):
        self._fsm.currentState = Item1_OnState(self._fsm)
        
    def turnOn2(self):
        self._fsm.currentState = Item2_OnState(self._fsm)

class Item1_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff1(self):
        self._fsm.currentState = BothOffState(self._fsm)

class Item2_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff2(self):
        self._fsm.currentState = BothOffState(self._fsm)

class FSM:
    currentState = None
    def __init__(self):
        self.currentState = BothOffState(self)

if __name__ == "__main__":
    
    system = FSM()
    print("<turning on 1>")
    system.currentState.turnOn1()
    #system.currentState.turnOn2() AttributeError because this state transition doesn't exist
    print("<turning off 1>")
    system.currentState.turnOff1()
    print("<turning on 2>")
    system.currentState.turnOn2()
    
    #Output:
    #
    # system : NoneType -> BothOffState
    # <turning on 1>
    # system : BothOffState -> Item1_OnState
    # <turning off 1>
    # system : Item1_OnState -> BothOffState
    # <turning on 2>
    # system : BothOffState -> Item2_OnState

#                     ,----------------------------,
#                     v                            |
#    ,----------[BothOffState]--------,            |
#    | turnOn1()                      | turnOn2()  |
#    v                                v            |
# [item1_OnState ]             [item2_OnState]     |
#        | turnOff1()                | turnOff2()  |
#        `---------------------------'-------------'
#

class IState(metaclass=ABCMeta):
     def __init__(self, fsm):
        print("system : " + fsm.currentState.__class__.__name__ + " -> " + self.__class__.__name__)
        self._fsm = fsm

class BothOffState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOn1(self):
        self._fsm.currentState = item1_OnState(self._fsm)
        
    def turnOn2(self):
        self._fsm.currentState = item2_OnState(self._fsm)

class item1_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff1(self):
        self._fsm.currentState = BothOffState(self._fsm)

class item2_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff2(self):
        self._fsm.currentState = BothOffState(self._fsm)

class FSM:
    currentState = None
    def __init__(self):
        self.currentState = BothOffState(self)

if __name__ == "__main__":
    
    system = FSM()
    print("<turning on 1>")
    system.currentState.turnOn1()
    #system.currentState.turnOn2() AttributeError because this state transition doesn't exist
    print("<turning off 1>")
    system.currentState.turnOff1()
    print("<turning on 2>")
    system.currentState.turnOn2()
    
    #Output:
    #
    # system : NoneType -> BothOffState
    # <turning on 1>
    # system : BothOffState -> item1_OnState
    # <turning off 1>
    # system : item1_OnState -> BothOffState
    # <turning on 2>
    # system : BothOffState -> item2_OnState

added 42 characters in body

Source Link

edited Apr 22, 2020 at 9:17

Blue7

373
2
10

In the real system, the predicates are not as simple as this. An example from my requirements is:

a implies b && (c ∥ d) && e where each letter is a particular state of a piece of equipment. The states are also more complex, for example, one state might be item1 is inside item2 exclusion zone. There are also transition states, such as "Turning On", and "Turning Off".

#                     ,----------------------------,
#                     v                            |
#    ,----------[BothOffState]--------,            |
#    | turnOn1()                      | turnOn2()  |
#    v                                v            |
# [item1_OnState[Item1_OnState ]             [item2_OnState][Item2_OnState]     |
#        | turnOff1()                | turnOff2()  |
#        `---------------------------'-------------'
#

class IState(metaclass=ABCMeta):
     def __init__(self, fsm):
        print("system : " + fsm.currentState.__class__.__name__ + " -> " + self.__class__.__name__)
        self._fsm = fsm

class BothOffState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOn1(self):
        self._fsm.currentState = item1_OnStateItem1_OnState(self._fsm)
        
    def turnOn2(self):
        self._fsm.currentState = item2_OnStateItem2_OnState(self._fsm)

class item1_OnStateItem1_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff1(self):
        self._fsm.currentState = BothOffState(self._fsm)

class item2_OnStateItem2_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff2(self):
        self._fsm.currentState = BothOffState(self._fsm)

class FSM:
    currentState = None
    def __init__(self):
        self.currentState = BothOffState(self)

if __name__ == "__main__":
    
    system = FSM()
    print("<turning on 1>")
    system.currentState.turnOn1()
    #system.currentState.turnOn2() AttributeError because this state transition doesn't exist
    print("<turning off 1>")
    system.currentState.turnOff1()
    print("<turning on 2>")
    system.currentState.turnOn2()
    
    #Output:
    #
    # system : NoneType -> BothOffState
    # <turning on 1>
    # system : BothOffState -> item1_OnStateItem1_OnState
    # <turning off 1>
    # system : item1_OnStateItem1_OnState -> BothOffState
    # <turning on 2>
    # system : BothOffState -> item2_OnStateItem2_OnState

#                     ,----------------------------,
#                     v                            |
#    ,----------[BothOffState]--------,            |
#    | turnOn1()                      | turnOn2()  |
#    v                                v            |
# [item1_OnState ]             [item2_OnState]     |
#        | turnOff1()                | turnOff2()  |
#        `---------------------------'-------------'
#

class IState(metaclass=ABCMeta):
     def __init__(self, fsm):
        print("system : " + fsm.currentState.__class__.__name__ + " -> " + self.__class__.__name__)
        self._fsm = fsm

class BothOffState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOn1(self):
        self._fsm.currentState = item1_OnState(self._fsm)
        
    def turnOn2(self):
        self._fsm.currentState = item2_OnState(self._fsm)

class item1_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff1(self):
        self._fsm.currentState = BothOffState(self._fsm)

class item2_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff2(self):
        self._fsm.currentState = BothOffState(self._fsm)

class FSM:
    currentState = None
    def __init__(self):
        self.currentState = BothOffState(self)

if __name__ == "__main__":
    
    system = FSM()
    print("<turning on 1>")
    system.currentState.turnOn1()
    #system.currentState.turnOn2() AttributeError because this state transition doesn't exist
    print("<turning off 1>")
    system.currentState.turnOff1()
    print("<turning on 2>")
    system.currentState.turnOn2()
    
    #Output:
    #
    # system : NoneType -> BothOffState
    # <turning on 1>
    # system : BothOffState -> item1_OnState
    # <turning off 1>
    # system : item1_OnState -> BothOffState
    # <turning on 2>
    # system : BothOffState -> item2_OnState

In the real system, the predicates are not as simple as this. An example from my requirements is:

a implies b && (c ∥ d) && e where each letter is a particular state of a piece of equipment. The states are also more complex, for example, one state might be item1 is inside item2 exclusion zone. There are also transition states, such as "Turning On", and "Turning Off".

#                     ,----------------------------,
#                     v                            |
#    ,----------[BothOffState]--------,            |
#    | turnOn1()                      | turnOn2()  |
#    v                                v            |
# [Item1_OnState ]             [Item2_OnState]     |
#        | turnOff1()                | turnOff2()  |
#        `---------------------------'-------------'
#

class IState(metaclass=ABCMeta):
     def __init__(self, fsm):
        print("system : " + fsm.currentState.__class__.__name__ + " -> " + self.__class__.__name__)
        self._fsm = fsm

class BothOffState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOn1(self):
        self._fsm.currentState = Item1_OnState(self._fsm)
        
    def turnOn2(self):
        self._fsm.currentState = Item2_OnState(self._fsm)

class Item1_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff1(self):
        self._fsm.currentState = BothOffState(self._fsm)

class Item2_OnState(IState):
    def __init__(self, fsm):
        super().__init__(fsm)
        
    def turnOff2(self):
        self._fsm.currentState = BothOffState(self._fsm)

class FSM:
    currentState = None
    def __init__(self):
        self.currentState = BothOffState(self)

if __name__ == "__main__":
    
    system = FSM()
    print("<turning on 1>")
    system.currentState.turnOn1()
    #system.currentState.turnOn2() AttributeError because this state transition doesn't exist
    print("<turning off 1>")
    system.currentState.turnOff1()
    print("<turning on 2>")
    system.currentState.turnOn2()
    
    #Output:
    #
    # system : NoneType -> BothOffState
    # <turning on 1>
    # system : BothOffState -> Item1_OnState
    # <turning off 1>
    # system : Item1_OnState -> BothOffState
    # <turning on 2>
    # system : BothOffState -> Item2_OnState

added 42 characters in body

Source Link

edited Apr 22, 2020 at 8:44

Blue7

373
2
10

Loading

edited title

Link

edited Apr 22, 2020 at 6:42

BCdotWEB

11.4k
2
28
45

Loading

Tweeted twitter.com/StackCodeReview/status/1252839579729588224

occurred Apr 22, 2020 at 6:00

spelling

Source Link

edited Apr 22, 2020 at 3:29

Reinderien

71.2k
5
76
257

Loading

added 76 characters in body

Source Link

edited Apr 21, 2020 at 17:46

Blue7

373
2
10

Loading

Source Link

asked Apr 21, 2020 at 17:36

Blue7

373
2
10

Loading

Stack Exchange Network

Return to Question