Trapping exceptions raised during parsing.

This allows users of the ParserProtocol to abort the connection and trap errors
by raising exceptions. Additionally, parse errors are exposed if they happen.

Author: habnabit

ometa/protocol.py

@@ -1,4 +1,5 @@
 from twisted.internet.protocol import Protocol
+from twisted.python.failure import Failure
 
 from ometa.interp import TrampolinedGrammarInterpreter, _feed_me
 
@@ -10,6 +11,7 @@ def __init__(self, grammar, senderFactory, stateFactory, bindings):
         self.bindings = dict(bindings)
         self.senderFactory = senderFactory
         self.stateFactory = stateFactory
+        self.disconnecting = False
 
     def setNextRule(self, rule):
         self.currentRule = rule
@@ -30,11 +32,24 @@ def _parsedRule(self, nextRule, position):
             self.currentRule = nextRule
 
     def dataReceived(self, data):
+        if self.disconnecting:
+            return
+
         while data:
-            if self._interp.receive(data) is _feed_me:
+            try:
+                status = self._interp.receive(data)
+            except Exception:
+                self.connectionLost(Failure())
+                self.transport.abortConnection()
                 return
+            else:
+                if status is _feed_me:
+                    return
             data = ''.join(self._interp.input.data[self._interp.input.position:])
             self._setupInterp()
 
     def connectionLost(self, reason):
+        if self.disconnecting:
+            return
         self.state.connectionLost(reason)
+        self.disconnecting = True

ometa/test/test_protocol.py

@@ -1,16 +1,18 @@
-import unittest
+from twisted.trial import unittest
 
 from ometa.grammar import OMeta
 from ometa.protocol import ParserProtocol
+from ometa.runtime import ParseError
 
 
 testingGrammarSource = """
 
 someA = ('a' 'a') -> state('a')
 someB = ('b' 'b') -> state('b')
 someC = ('c' 'c') -> state('c')
+someExc = 'e' -> state.raiseSomething()
 
-initial = someA
+initial = someA | someExc
 
 """
 testGrammar = OMeta(testingGrammarSource).parseGrammar('testGrammar')
@@ -21,6 +23,10 @@ def __init__(self, transport):
         self.transport = transport
 
 
+class SomeException(Exception):
+    pass
+
+
 class StateFactory(object):
     def __init__(self, sender, parser):
         self.sender = sender
@@ -37,10 +43,21 @@ def __call__(self, v):
         self.calls.append(v)
         return self.returnMap.get(v)
 
+    def raiseSomething(self):
+        raise SomeException()
+
     def connectionLost(self, reason):
         self.lossReason = reason
 
 
+class FakeTransport(object):
+    def __init__(self):
+        self.aborted = False
+
+    def abortConnection(self):
+        self.aborted = True
+
+
 class ParserProtocolTestCase(unittest.TestCase):
     def setUp(self):
         self.protocol = ParserProtocol(
@@ -140,3 +157,39 @@ def test_connectionLoss(self):
         reason = object()
         self.protocol.connectionLost(reason)
         self.assertEqual(self.protocol.state.lossReason, reason)
+
+    def test_parseFailure(self):
+        """
+        Parse failures cause connection abortion with the parse error as the
+        reason.
+        """
+        transport = FakeTransport()
+        self.protocol.makeConnection(transport)
+        self.protocol.dataReceived('b')
+        self.failIfEqual(self.protocol.state.lossReason, None)
+        self.failUnlessIsInstance(self.protocol.state.lossReason.value,
+                                  ParseError)
+        self.assert_(transport.aborted)
+
+    def test_exceptionsRaisedFromState(self):
+        """
+        Raising an exception from state methods called from the grammar
+        propagate to connectionLost.
+        """
+        transport = FakeTransport()
+        self.protocol.makeConnection(transport)
+        self.protocol.dataReceived('e')
+        self.failIfEqual(self.protocol.state.lossReason, None)
+        self.failUnlessIsInstance(self.protocol.state.lossReason.value,
+                                  SomeException)
+        self.assert_(transport.aborted)
+
+    def test_dataIgnoredAfterDisconnection(self):
+        """After connectionLost is called, all incoming data is ignored."""
+        transport = FakeTransport()
+        self.protocol.makeConnection(transport)
+        reason = object()
+        self.protocol.connectionLost(reason)
+        self.protocol.dataReceived('d')
+        self.assertEqual(self.protocol.state.lossReason, reason)
+        self.assert_(not transport.aborted)