273 lines
10 KiB
Python
273 lines
10 KiB
Python
from __future__ import print_function, absolute_import, unicode_literals
|
|
import re
|
|
import six
|
|
from zope.interface import implementer
|
|
from attr import attrs, attrib
|
|
from attr.validators import provides, instance_of
|
|
from twisted.python import log
|
|
from automat import MethodicalMachine
|
|
from . import _interfaces
|
|
from ._nameplate import Nameplate
|
|
from ._mailbox import Mailbox
|
|
from ._send import Send
|
|
from ._order import Order
|
|
from ._key import Key
|
|
from ._receive import Receive
|
|
from ._rendezvous import RendezvousConnector
|
|
from ._lister import Lister
|
|
from ._code import Code
|
|
from ._terminator import Terminator
|
|
from .errors import ServerError, LonelyError, WrongPasswordError
|
|
from .util import bytes_to_dict
|
|
|
|
@attrs
|
|
@implementer(_interfaces.IBoss)
|
|
class Boss(object):
|
|
_W = attrib()
|
|
_side = attrib(validator=instance_of(type(u"")))
|
|
_url = attrib(validator=instance_of(type(u"")))
|
|
_appid = attrib(validator=instance_of(type(u"")))
|
|
_reactor = attrib()
|
|
_journal = attrib(validator=provides(_interfaces.IJournal))
|
|
_timing = attrib(validator=provides(_interfaces.ITiming))
|
|
m = MethodicalMachine()
|
|
@m.setTrace()
|
|
def set_trace(): pass # pragma: no cover
|
|
|
|
def __attrs_post_init__(self):
|
|
self._N = Nameplate()
|
|
self._M = Mailbox(self._side)
|
|
self._S = Send(self._side, self._timing)
|
|
self._O = Order(self._side, self._timing)
|
|
self._K = Key(self._appid, self._side, self._timing)
|
|
self._R = Receive(self._side, self._timing)
|
|
self._RC = RendezvousConnector(self._url, self._appid, self._side,
|
|
self._reactor, self._journal,
|
|
self._timing)
|
|
self._L = Lister()
|
|
self._C = Code(self._timing)
|
|
self._T = Terminator()
|
|
|
|
self._N.wire(self._M, self._RC, self._T)
|
|
self._M.wire(self._N, self._RC, self._O, self._T)
|
|
self._S.wire(self._M)
|
|
self._O.wire(self._K, self._R)
|
|
self._K.wire(self, self._M, self._R)
|
|
self._R.wire(self, self._S)
|
|
self._RC.wire(self, self._N, self._M, self._C, self._L, self._T)
|
|
self._L.wire(self._RC, self._C)
|
|
self._C.wire(self, self._RC, self._L)
|
|
self._T.wire(self, self._RC, self._N, self._M)
|
|
|
|
self._next_tx_phase = 0
|
|
self._next_rx_phase = 0
|
|
self._rx_phases = {} # phase -> plaintext
|
|
|
|
self._result = "empty"
|
|
|
|
# these methods are called from outside
|
|
def start(self):
|
|
self._RC.start()
|
|
|
|
def _set_trace(self, client_name, which, logger):
|
|
names = {"B": self, "N": self._N, "M": self._M, "S": self._S,
|
|
"O": self._O, "K": self._K, "R": self._R,
|
|
"RC": self._RC, "L": self._L, "C": self._C,
|
|
"T": self._T}
|
|
for machine in which.split():
|
|
def tracer(old_state, input, new_state, machine=machine):
|
|
print("%s.%s[%s].%s -> [%s]" % (client_name, machine,
|
|
old_state, input, new_state))
|
|
names[machine].set_trace(tracer)
|
|
|
|
def serialize(self):
|
|
raise NotImplemented
|
|
|
|
# and these are the state-machine transition functions, which don't take
|
|
# args
|
|
@m.state(initial=True)
|
|
def S0_empty(self): pass # pragma: no cover
|
|
@m.state()
|
|
def S1_lonely(self): pass # pragma: no cover
|
|
@m.state()
|
|
def S2_happy(self): pass # pragma: no cover
|
|
@m.state()
|
|
def S3_closing(self): pass # pragma: no cover
|
|
@m.state(terminal=True)
|
|
def S4_closed(self): pass # pragma: no cover
|
|
|
|
# from the Wormhole
|
|
|
|
# input/allocate/set_code are regular methods, not state-transition
|
|
# inputs. We expect them to be called just after initialization, while
|
|
# we're in the S0_empty state. You must call exactly one of them, and the
|
|
# call must happen while we're in S0_empty, which makes them good
|
|
# candiates for being a proper @m.input, but set_code() will immediately
|
|
# (reentrantly) cause self.got_code() to be fired, which is messy. These
|
|
# are all passthroughs to the Code machine, so one alternative would be
|
|
# to have Wormhole call Code.{input,allocate,set_code} instead, but that
|
|
# would require the Wormhole to be aware of Code (whereas right now
|
|
# Wormhole only knows about this Boss instance, and everything else is
|
|
# hidden away).
|
|
def input_code(self, stdio):
|
|
self._C.input_code(stdio)
|
|
def allocate_code(self, code_length):
|
|
self._C.allocate_code(code_length)
|
|
def set_code(self, code):
|
|
self._C.set_code(code)
|
|
|
|
@m.input()
|
|
def send(self, plaintext): pass
|
|
@m.input()
|
|
def close(self): pass
|
|
|
|
# from RendezvousConnector. rx_error an error message from the server
|
|
# (probably because of something we did, or due to CrowdedError). error
|
|
# is when an exception happened while it tried to deliver something else
|
|
@m.input()
|
|
def rx_welcome(self, welcome): pass
|
|
@m.input()
|
|
def rx_error(self, errmsg, orig): pass
|
|
@m.input()
|
|
def error(self, err): pass
|
|
|
|
# from Code (provoked by input/allocate/set_code)
|
|
@m.input()
|
|
def got_code(self, code): pass
|
|
|
|
# Key sends (got_verifier, scared)
|
|
# Receive sends (got_message, happy, scared)
|
|
@m.input()
|
|
def happy(self): pass
|
|
@m.input()
|
|
def scared(self): pass
|
|
|
|
def got_message(self, phase, plaintext):
|
|
assert isinstance(phase, type("")), type(phase)
|
|
assert isinstance(plaintext, type(b"")), type(plaintext)
|
|
if phase == "version":
|
|
self.got_version(plaintext)
|
|
elif re.search(r'^\d+$', phase):
|
|
self.got_phase(int(phase), plaintext)
|
|
else:
|
|
# Ignore unrecognized phases, for forwards-compatibility. Use
|
|
# log.err so tests will catch surprises.
|
|
log.err("received unknown phase '%s'" % phase)
|
|
@m.input()
|
|
def got_version(self, plaintext): pass
|
|
@m.input()
|
|
def got_phase(self, phase, plaintext): pass
|
|
@m.input()
|
|
def got_verifier(self, verifier): pass
|
|
|
|
# Terminator sends closed
|
|
@m.input()
|
|
def closed(self): pass
|
|
|
|
|
|
@m.output()
|
|
def process_welcome(self, welcome):
|
|
pass # TODO: ignored for now
|
|
|
|
@m.output()
|
|
def do_got_code(self, code):
|
|
nameplate = code.split("-")[0]
|
|
self._N.set_nameplate(nameplate)
|
|
self._K.got_code(code)
|
|
self._W.got_code(code)
|
|
@m.output()
|
|
def process_version(self, plaintext):
|
|
self._their_versions = bytes_to_dict(plaintext)
|
|
# ignored for now
|
|
|
|
@m.output()
|
|
def S_send(self, plaintext):
|
|
assert isinstance(plaintext, type(b"")), type(plaintext)
|
|
phase = self._next_tx_phase
|
|
self._next_tx_phase += 1
|
|
self._S.send("%d" % phase, plaintext)
|
|
|
|
@m.output()
|
|
def close_error(self, errmsg, orig):
|
|
self._result = ServerError(errmsg)
|
|
self._T.close("errory")
|
|
@m.output()
|
|
def close_scared(self):
|
|
self._result = WrongPasswordError()
|
|
self._T.close("scary")
|
|
@m.output()
|
|
def close_lonely(self):
|
|
self._result = LonelyError()
|
|
self._T.close("lonely")
|
|
@m.output()
|
|
def close_happy(self):
|
|
self._result = "happy"
|
|
self._T.close("happy")
|
|
|
|
@m.output()
|
|
def W_got_verifier(self, verifier):
|
|
self._W.got_verifier(verifier)
|
|
@m.output()
|
|
def W_received(self, phase, plaintext):
|
|
assert isinstance(phase, six.integer_types), type(phase)
|
|
# we call Wormhole.received() in strict phase order, with no gaps
|
|
self._rx_phases[phase] = plaintext
|
|
while self._next_rx_phase in self._rx_phases:
|
|
self._W.received(self._rx_phases.pop(self._next_rx_phase))
|
|
self._next_rx_phase += 1
|
|
|
|
@m.output()
|
|
def W_close_with_error(self, err):
|
|
self._result = err # exception
|
|
self._W.closed(self._result)
|
|
|
|
@m.output()
|
|
def W_closed(self):
|
|
# result is either "happy" or a WormholeError of some sort
|
|
self._W.closed(self._result)
|
|
|
|
S0_empty.upon(close, enter=S3_closing, outputs=[close_lonely])
|
|
S0_empty.upon(send, enter=S0_empty, outputs=[S_send])
|
|
S0_empty.upon(rx_welcome, enter=S0_empty, outputs=[process_welcome])
|
|
S0_empty.upon(got_code, enter=S1_lonely, outputs=[do_got_code])
|
|
S0_empty.upon(rx_error, enter=S3_closing, outputs=[close_error])
|
|
S0_empty.upon(error, enter=S4_closed, outputs=[W_close_with_error])
|
|
|
|
S1_lonely.upon(rx_welcome, enter=S1_lonely, outputs=[process_welcome])
|
|
S1_lonely.upon(happy, enter=S2_happy, outputs=[])
|
|
S1_lonely.upon(scared, enter=S3_closing, outputs=[close_scared])
|
|
S1_lonely.upon(close, enter=S3_closing, outputs=[close_lonely])
|
|
S1_lonely.upon(send, enter=S1_lonely, outputs=[S_send])
|
|
S1_lonely.upon(got_verifier, enter=S1_lonely, outputs=[W_got_verifier])
|
|
S1_lonely.upon(rx_error, enter=S3_closing, outputs=[close_error])
|
|
S1_lonely.upon(error, enter=S4_closed, outputs=[W_close_with_error])
|
|
|
|
S2_happy.upon(rx_welcome, enter=S2_happy, outputs=[process_welcome])
|
|
S2_happy.upon(got_phase, enter=S2_happy, outputs=[W_received])
|
|
S2_happy.upon(got_version, enter=S2_happy, outputs=[process_version])
|
|
S2_happy.upon(scared, enter=S3_closing, outputs=[close_scared])
|
|
S2_happy.upon(close, enter=S3_closing, outputs=[close_happy])
|
|
S2_happy.upon(send, enter=S2_happy, outputs=[S_send])
|
|
S2_happy.upon(rx_error, enter=S3_closing, outputs=[close_error])
|
|
S2_happy.upon(error, enter=S4_closed, outputs=[W_close_with_error])
|
|
|
|
S3_closing.upon(rx_welcome, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(rx_error, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(got_phase, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(got_version, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(happy, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(scared, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(close, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(send, enter=S3_closing, outputs=[])
|
|
S3_closing.upon(closed, enter=S4_closed, outputs=[W_closed])
|
|
S3_closing.upon(error, enter=S4_closed, outputs=[W_close_with_error])
|
|
|
|
S4_closed.upon(rx_welcome, enter=S4_closed, outputs=[])
|
|
S4_closed.upon(got_phase, enter=S4_closed, outputs=[])
|
|
S4_closed.upon(got_version, enter=S4_closed, outputs=[])
|
|
S4_closed.upon(happy, enter=S4_closed, outputs=[])
|
|
S4_closed.upon(scared, enter=S4_closed, outputs=[])
|
|
S4_closed.upon(close, enter=S4_closed, outputs=[])
|
|
S4_closed.upon(send, enter=S4_closed, outputs=[])
|
|
S4_closed.upon(error, enter=S4_closed, outputs=[])
|