diff --git a/changelog.md b/changelog.md new file mode 100644 index 0000000..bfbdf27 --- /dev/null +++ b/changelog.md @@ -0,0 +1,8 @@ +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) + +## [Unreleased] - 2026-09-14 + +### Changed +- Rename `DatagramWriteMemo` to **`DatagramSendMemo`** and `DatagramReadMemo` to **`DatagramReceiveMemo`** to distinguish meaning of read/write from the higher network layers (For example, in "DatagramWriteMemo" "Write" had two different meanings--one for port flow direction, one for request type, as it could be associated with a MemoryReadMemo. Now a MemoryReadMemo is associated with a "DatagramSendMemo" denoting it was requested by us but we may be still requesting a read such as in that case). diff --git a/examples/example_cdi_access.py b/examples/example_cdi_access.py index 334820f..91526f3 100644 --- a/examples/example_cdi_access.py +++ b/examples/example_cdi_access.py @@ -91,7 +91,7 @@ def printDatagram(memo): """A call-back for when datagrams received Args: - DatagramReadMemo: The datagram object + DatagramReceiveMemo: The datagram object Returns: bool: Always False (True would mean we sent a reply to the datagram, diff --git a/examples/example_datagram_transfer.py b/examples/example_datagram_transfer.py index e5af2e3..0be06cd 100644 --- a/examples/example_datagram_transfer.py +++ b/examples/example_datagram_transfer.py @@ -28,7 +28,7 @@ from openlcb.nodeid import NodeID # noqa:E402 from openlcb.datagramservice import ( # noqa:E402 DatagramService, - DatagramWriteMemo, + DatagramSendMemo, ) # specify connection information @@ -74,7 +74,7 @@ def printMessage(message): # create a call-back for replies to write datagram -def writeCallBackCheck(memo): +def sendCallBackCheck(memo): print("Write complete call back") @@ -82,7 +82,7 @@ def datagramReceiver(memo): """A call-back for when datagrams received Args: - DatagramReadMemo: The datagram object + DatagramReceiveMemo: The datagram object Returns: bool: Always True (means we sent the reply to this datagram) @@ -118,12 +118,12 @@ def datagramWrite(): import time time.sleep(1) - writeMemo = DatagramWriteMemo( + sendMemo = DatagramSendMemo( NodeID(settings['farNodeID']), bytearray([0x20, 0x43, 0x00, 0x00, 0x00, 0x00, 0x14]), - writeCallBackCheck + sendCallBackCheck ) - datagramService.sendDatagram(writeMemo) + datagramService.sendDatagram(sendMemo) thread = threading.Thread(target=datagramWrite) diff --git a/examples/example_memory_length_query.py b/examples/example_memory_length_query.py index c9974de..24eec09 100644 --- a/examples/example_memory_length_query.py +++ b/examples/example_memory_length_query.py @@ -26,8 +26,8 @@ from openlcb.canbus.canlink import CanLink # noqa: E402 from openlcb.nodeid import NodeID # noqa: E402 from openlcb.datagramservice import ( # noqa: E402 - # DatagramWriteMemo, - # DatagramReadMemo, + # DatagramSendMemo, + # DatagramReceiveMemo, DatagramService, ) from openlcb.memoryservice import ( # noqa: E402 @@ -82,7 +82,7 @@ def printDatagram(memo): """create a call-back to print datagram contents when received Args: - memo (DatagramReadMemo): The datagram received + memo (DatagramReceiveMemo): The datagram received Returns: bool: Always False (True would mean we sent a reply to this datagram, diff --git a/examples/example_memory_transfer.py b/examples/example_memory_transfer.py index 6d0a3b9..83ad6d4 100644 --- a/examples/example_memory_transfer.py +++ b/examples/example_memory_transfer.py @@ -27,8 +27,8 @@ from openlcb.canbus.canlink import CanLink # noqa: E402 from openlcb.nodeid import NodeID # noqa: E402 from openlcb.datagramservice import ( # noqa: E402 - # DatagramWriteMemo, - # DatagramReadMemo, + # DatagramSendMemo, + # DatagramReceiveMemo, DatagramService, ) from openlcb.memoryservice import ( # noqa: E402 @@ -83,7 +83,7 @@ def printDatagram(memo): """create a call-back to print datagram contents when received Args: - memo (DatagramReadMemo): The datagram received + memo (DatagramReceiveMemo): The datagram received Returns: bool: Always False (True would mean we sent a reply to this datagram, diff --git a/examples/example_node_implementation.py b/examples/example_node_implementation.py index ea6801a..be02264 100644 --- a/examples/example_node_implementation.py +++ b/examples/example_node_implementation.py @@ -99,7 +99,7 @@ def printDatagram(memo): """create a call-back to print datagram contents when received Args: - memo (DatagramReadMemo): The datagram received + memo (DatagramReceiveMemo): The datagram received Returns: bool: Always False (True would mean we sent a reply to the datagram, diff --git a/examples/example_node_memory_implementation.py b/examples/example_node_memory_implementation.py index 840fab1..5c42164 100644 --- a/examples/example_node_memory_implementation.py +++ b/examples/example_node_memory_implementation.py @@ -48,7 +48,7 @@ ) from openlcb.canbus.canlink import CanLink # noqa: E402 from openlcb.nodeid import NodeID # noqa: E402 -from openlcb.datagramservice import DatagramReadMemo, DatagramService # noqa: E402, E501 +from openlcb.datagramservice import DatagramReceiveMemo, DatagramService # noqa: E402, E501 from openlcb.memoryservice import MemoryService # noqa: E402 from openlcb.message import Message # noqa: E402 from openlcb.mti import MTI # noqa: E402 @@ -151,11 +151,11 @@ def printMessage(message: Message): assert_xml(cdi) -def handleDatagram(memo: DatagramReadMemo): +def handleDatagram(memo: DatagramReceiveMemo): """create a call-back to print datagram contents when received Args: - memo (DatagramReadMemo): The datagram received + memo (DatagramReceiveMemo): The datagram received Returns: bool: Always False (True would mean we sent a reply to the datagram, diff --git a/openlcb/datagramservice.py b/openlcb/datagramservice.py index ff412f4..81ab643 100644 --- a/openlcb/datagramservice.py +++ b/openlcb/datagramservice.py @@ -6,7 +6,7 @@ Provide a service interface for reading and writing Datagrams. Writes to remote node: -- Create a ``DatagramWriteMemo`` and submit via ``sendDatagram(_:)`` +- Create a ``DatagramSendMemo`` and submit via ``sendDatagram(_:)`` - Get an OK or NotOK callback Reads from remote node: @@ -40,12 +40,12 @@ def defaultIgnoreReply(memo: Union[Any, None]): - # ^ DatagramWriteMemo is the type, but that is not defined yet + # ^ DatagramSendMemo is the type, but that is not defined yet '''default handling of reply does nothing''' pass -class DatagramWriteMemo: +class DatagramSendMemo: '''Immutable memo carrying write request and two reply callbacks (In this context "Write" means sent to other node, even if associated with a MemoryReadMemo). @@ -54,7 +54,7 @@ class DatagramWriteMemo: def __init__(self, destID: NodeID, data, okReply=defaultIgnoreReply, rejectedReply=defaultIgnoreReply): - # type: (NodeID, bytearray, Callable[[Union[DatagramWriteMemo, None]], None], Callable[[Union[DatagramWriteMemo, None]], None]) -> None # noqa: E501 + # type: (NodeID, bytearray, Callable[[Union[DatagramSendMemo, None]], None], Callable[[Union[DatagramSendMemo, None]], None]) -> None # noqa: E501 assert isinstance(destID, NodeID) self.destID = destID # NOTE: No srcID since always from this node ("Write" means send @@ -63,8 +63,8 @@ def __init__(self, destID: NodeID, data, raise TypeError("Expected bytearray (formerly list[int]), got {}" .format(type(data).__name__)) self.data: bytearray = data - self.okReply: Callable[[Union[DatagramWriteMemo, None]], None] = okReply # noqa: E501 - self.rejectedReply: Callable[[Union[DatagramWriteMemo, None]], None] = rejectedReply # noqa: E501 + self.okReply: Callable[[Union[DatagramSendMemo, None]], None] = okReply # noqa: E501 + self.rejectedReply: Callable[[Union[DatagramSendMemo, None]], None] = rejectedReply # noqa: E501 def __eq__(lhs, rhs): if lhs.destID != rhs.destID: @@ -74,7 +74,7 @@ def __eq__(lhs, rhs): return True -class DatagramReadMemo: +class DatagramReceiveMemo: '''Immutable memo carrying read result (In this context "Read" means received from other node, *not* associated with a MemoryReadMemo which, however, may be what @@ -100,6 +100,16 @@ class DatagramService: Args: linkLayer (CanLink): Could actually be any link layer such as LinkMockLayer (for testing) or CanLink. + + Attributes: + pendingSendMemos: (formerly pendingWriteMemos) These are written + to the port, but a MemorySendMemo may be associated with a + MemoryReadMemo since the device instantiating the service is + making the request; or may be used to send replies as well + (See where MemoryService instantiates any MemorySendMemo to + respond to space info request especially when the node + instantiating MemoryService is a node other than a + Configuration Tool). """ class ProtocolID(Enum): @@ -117,9 +127,9 @@ class ProtocolID(Enum): def __init__(self, linkLayer: LinkLayer): self.linkLayer: LinkLayer = linkLayer self.quiesced: bool = False - self.currentOutstandingMemo: Union[DatagramWriteMemo, None] = None # noqa: E501 - self.pendingWriteMemos: List[DatagramWriteMemo] = [] - self._datagramReceivedListeners: List[Callable[[DatagramReadMemo], bool]] = [] # noqa: E501 + self.currentOutstandingMemo: Union[DatagramSendMemo, None] = None # noqa: E501 + self.pendingSendMemos: List[DatagramSendMemo] = [] + self._datagramReceivedListeners: List[Callable[[DatagramReceiveMemo], bool]] = [] # noqa: E501 def datagramType(self, data: Union[bytearray, List[int]]): """Determine the protocol type of the content of the datagram. @@ -154,19 +164,19 @@ def checkDestID(self, message, nodeID: NodeID): assert isinstance(nodeID, NodeID) return message.destination == nodeID - def sendDatagram(self, memo: DatagramWriteMemo): - '''Queue a ``DatagramWriteMemo`` to send a datagram to another node + def sendDatagram(self, memo: DatagramSendMemo): + '''Queue a ``DatagramSendMemo`` to send a datagram to another node on the network. ''' # Make a record of memo for reply - self.pendingWriteMemos.append(memo) + self.pendingSendMemos.append(memo) # can only have one outstanding at a time, so check it there was # already one there. - if len(self.pendingWriteMemos) == 1: + if len(self.pendingSendMemos) == 1: self.sendDatagramMessage(memo) - def sendDatagramMessage(self, memo: DatagramWriteMemo): + def sendDatagramMessage(self, memo: DatagramSendMemo): '''Send datagram message''' message = Message(MTI.Datagram, self.linkLayer.localNodeID, memo.destID, memo.data) @@ -174,14 +184,14 @@ def sendDatagramMessage(self, memo: DatagramWriteMemo): self.currentOutstandingMemo = memo def registerDatagramReceivedListener( - self, listener: Callable[[DatagramReadMemo], bool]): + self, listener: Callable[[DatagramReceiveMemo], bool]): '''Register a listener to be notified when each datagram arrives. One and only one listener should reply positively or negatively to the datagram and return true. Args: - listener (Callable): A function that accepts a DatagramReadMemo + listener (Callable): A function that accepts a DatagramReceiveMemo as an argument. ''' logger.debug( @@ -189,7 +199,7 @@ def registerDatagramReceivedListener( f" {len(self._datagramReceivedListeners) + 1}") self._datagramReceivedListeners.append(listener) - def fireDatagramReceived(self, dg: DatagramReadMemo): # internal for tests + def fireDatagramReceived(self, dg: DatagramReceiveMemo): # internal for tests """Fire *datagram received* listeners.""" logger.debug( f"FIRING listeners for datagram from {dg.srcID}," @@ -236,7 +246,7 @@ def process(self, message: Message): def handleDatagram(self, message: Message): '''create a read memo and pass to listeners''' - memo = DatagramReadMemo(message.source, message.data) + memo = DatagramReceiveMemo(message.source, message.data) self.fireDatagramReceived(memo) # ^ destination listener calls back to # positiveReplyToDatagram/negativeReplyToDatagram before returning @@ -244,7 +254,7 @@ def handleDatagram(self, message: Message): def handleDatagramReceivedOK(self, message: Message): '''OK reply to write''' # match to the memo and remove from queue - memo = self.matchToWriteMemo(message) # type: DatagramWriteMemo|None + memo = self.matchToWriteMemo(message) # type: DatagramSendMemo|None # check for whether a match was found, indicating this was for us if memo is None: @@ -307,16 +317,16 @@ def handleLinkRestarted(self, message: Message): return else: # are there any queued datagrams? If so, send first - if len(self.pendingWriteMemos) > 0: + if len(self.pendingSendMemos) > 0: self.sendNextDatagramFromQueue() def matchToWriteMemo(self, message: Message): - for memo in self.pendingWriteMemos: + for memo in self.pendingSendMemos: if memo.destID != message.source: continue # keep looking # remove the found element - might need a try/except on this - index = self.pendingWriteMemos.index(memo) - del self.pendingWriteMemos[index] + index = self.pendingSendMemos.index(memo) + del self.pendingSendMemos[index] return memo @@ -327,16 +337,16 @@ def matchToWriteMemo(self, message: Message): def sendNextDatagramFromQueue(self): # is there a next datagram request? - if len(self.pendingWriteMemos) > 0: + if len(self.pendingSendMemos) > 0: # yes, get it, process it - memo = self.pendingWriteMemos[0] + memo = self.pendingSendMemos[0] self.sendDatagramMessage(memo) - def positiveReplyToDatagram(self, dg: DatagramReadMemo, flags: int = 0): + def positiveReplyToDatagram(self, dg: DatagramReceiveMemo, flags: int = 0): """Send a positive reply to a received datagram. Args: - dg (DatagramReadMemo): Datagram memo being responded to. + dg (DatagramReceiveMemo): Datagram memo being responded to. flags (Optional[int]): Flag byte to be returned to sender, see Datagram Standard & Technical Note for meaning. Defaults to 0. """ @@ -344,11 +354,11 @@ def positiveReplyToDatagram(self, dg: DatagramReadMemo, flags: int = 0): dg.srcID, bytearray([flags])) self.linkLayer.sendMessage(message) - def negativeReplyToDatagram(self, dg: DatagramReadMemo, err: int): + def negativeReplyToDatagram(self, dg: DatagramReceiveMemo, err: int): """Send a negative reply to a received datagram. Args: - dg (DatagramReadMemo): Datagram memo being responded to. + dg (DatagramReceiveMemo): Datagram memo being responded to. err (int): Error code(s) to be returned to sender, see Datagram Standard & Technical Note for meaning. """ diff --git a/openlcb/memoryservice.py b/openlcb/memoryservice.py index c479908..d9f1a85 100644 --- a/openlcb/memoryservice.py +++ b/openlcb/memoryservice.py @@ -35,9 +35,9 @@ emit_cast, ) from openlcb.datagramservice import ( - # DatagramReadMemo, - DatagramReadMemo, - DatagramWriteMemo, + # DatagramReceiveMemo, + DatagramReceiveMemo, + DatagramSendMemo, DatagramService, ) from openlcb.convert import Convert @@ -154,7 +154,7 @@ class MCOpMasks: MEMORY_CONFIGURATION_PROTOCOL and other applicable protocols in its PIP set (See Node constructor). - Each node must have its own MemoryService instance since - DatagramReadMemo does not carry a destination address. + DatagramReceiveMemo does not carry a destination address. """ TWO_BIT_PARAMS = { # region *lists* (last 2 bits are MemorySpaceIndex.fromNumber param) @@ -316,7 +316,7 @@ def assertMemoOK(memo: Union[MemoryReadMemo, MemoryWriteMemo]): def parseReplyDatagram(memo: Union[MemoryReadMemo, MemoryWriteMemo], - dmemo: Union[DatagramReadMemo, DatagramWriteMemo]): + dmemo: Union[DatagramReceiveMemo, DatagramSendMemo]): """Parse dmemo and set errorCode and/or error attributes of memo""" if not dmemo.data or dmemo.data[0] != 0x20: logger.warning( @@ -470,19 +470,19 @@ def requestMemoryReadNext(self, memo, stream: bool = False): data.extend([(memo.space & 0xFF)]) data.extend([memo.size]) logger.debug( - "[requestMemoryReadNext] creating DatagramWriteMemo" + "[requestMemoryReadNext] creating DatagramSendMemo" f" to destID={memo.nodeID} with data={list(data)}") - dgWriteMemo = DatagramWriteMemo(memo.nodeID, data, - self.receivedOkReplyToWrite) - self.service.sendDatagram(dgWriteMemo) + dgSendMemo = DatagramSendMemo(memo.nodeID, data, + self.receivedOkReplyToWrite) + self.service.sendDatagram(dgSendMemo) - def receivedOkReplyToWrite(self, memo: Union[DatagramWriteMemo, None]): + def receivedOkReplyToWrite(self, memo: Union[DatagramSendMemo, None]): '''Wait for following response to be returned via listener. This is normal. ''' pass - def datagramReceivedListener(self, dmemo: DatagramReadMemo) -> bool: + def datagramReceivedListener(self, dmemo: DatagramReceiveMemo) -> bool: '''Process a datagram. Sends the positive reply and returns true if this is from our service. @@ -609,7 +609,7 @@ def datagramReceivedListener(self, dmemo: DatagramReadMemo) -> bool: # https://github.com/openlcb/documents/issues/190)? replyData += descBytes # FIXME: Need to send Datagram Received OK datagram 1st? - spaceInfoReplyMemo = DatagramWriteMemo( + spaceInfoReplyMemo = DatagramSendMemo( dmemo.srcID, replyData ) @@ -741,7 +741,7 @@ def datagramReceivedListener(self, dmemo: DatagramReadMemo) -> bool: " on invalid request (expected bytes, got None)") assert len(payload) <= 64 replyBytes += payload - requestedMemoryMemo = DatagramWriteMemo( + requestedMemoryMemo = DatagramSendMemo( dmemo.srcID, replyBytes ) @@ -789,7 +789,7 @@ def datagramReceivedListener(self, dmemo: DatagramReadMemo) -> bool: @staticmethod def failedMemo(mcOp: MCOp, srcID: NodeID, address: int, space: int, - errorCode: int, message) -> DatagramWriteMemo: + errorCode: int, message) -> DatagramSendMemo: assert isinstance(mcOp, MCOp) assert isinstance(srcID, NodeID) assert isinstance(address, int) @@ -811,7 +811,7 @@ def failedMemo(mcOp: MCOp, srcID: NodeID, address: int, space: int, messageBytes = bytearray(message.encode("utf-8")) messageBytes.append(0x00) # null terminator replyBytes += messageBytes - return DatagramWriteMemo( + return DatagramSendMemo( srcID, replyBytes ) @@ -842,7 +842,7 @@ def requestMemoryWrite(self, memo: MemoryWriteMemo, stream: bool = False): assert memo.space <= 0xFF, f"Space {memo.space} out of byte range" data.extend([(memo.space & 0xFF)]) data.extend(memo.data) - dgWriteMemo = DatagramWriteMemo(memo.nodeID, data) + dgWriteMemo = DatagramSendMemo(memo.nodeID, data) self.service.sendDatagram(dgWriteMemo) def requestSpaceLength(self, space: int, nodeID: NodeID, @@ -868,7 +868,7 @@ def requestSpaceLength(self, space: int, nodeID: NodeID, return self.spaceLengthCallback = callback # send request - dgReqMemo = DatagramWriteMemo( + dgReqMemo = DatagramSendMemo( nodeID, bytearray([ DatagramService.ProtocolID.MemoryOperation.value, diff --git a/openlcb/openlcbnetwork.py b/openlcb/openlcbnetwork.py index 8a3195d..3917f12 100644 --- a/openlcb/openlcbnetwork.py +++ b/openlcb/openlcbnetwork.py @@ -26,7 +26,7 @@ ) from openlcb.canbus.canlink import CanLink from openlcb.cdimemo import CDIMemo -from openlcb.datagramservice import DatagramReadMemo, DatagramService +from openlcb.datagramservice import DatagramReceiveMemo, DatagramService from openlcb.dataprocessor import DataFormat from openlcb.dataprocessormemo import DataProcessorMemo from openlcb.memoryservice import MemoryReadMemo, MemoryService @@ -211,11 +211,11 @@ def download(self, farNodeID: str, space: MemorySpace, # # print(" RL: {}".format(frame)) # pass - def _printDatagram(self, memo: DatagramReadMemo): + def _printDatagram(self, memo: DatagramReceiveMemo): """A call-back for when datagrams received Args: - memo (DatagramReadMemo): The datagram object + memo (DatagramReceiveMemo): The datagram object Returns: bool: Always False (True would mean we sent a reply to the diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_datagramservice.py b/tests/test_datagramservice.py index db2168d..dd85be0 100644 --- a/tests/test_datagramservice.py +++ b/tests/test_datagramservice.py @@ -1,8 +1,8 @@ import unittest from openlcb.datagramservice import ( - DatagramReadMemo, - DatagramWriteMemo, + DatagramReceiveMemo, + DatagramSendMemo, DatagramService, ) from openlcb.linklayer import LinkLayer @@ -41,16 +41,16 @@ def setUp(self): ) LinkMockLayer.sentMessages = [] self.received = False - self.readMemos = [] + self.receiveMemos = [] # type: list[DatagramReceiveMemo] self.callback = False def receiveListener(self, msg): self.received = True - self.readMemos.append(msg) + self.receiveMemos.append(msg) return True def testFireDatagramReceived(self): - msg = DatagramReadMemo(NodeID(12), bytearray()) + msg = DatagramReceiveMemo(NodeID(12), bytearray()) receiver = self.receiveListener self.service.registerDatagramReceivedListener(receiver) @@ -60,11 +60,11 @@ def testFireDatagramReceived(self): self.assertTrue(self.received) def testWriteMemoEquatable(self): - dm1a = DatagramWriteMemo(NodeID(2), bytearray()) - dm1b = DatagramWriteMemo(NodeID(2), bytearray()) - dm2 = DatagramWriteMemo(NodeID(12), bytearray()) - dm3 = DatagramWriteMemo(NodeID(12), bytearray([1])) - dm4 = DatagramWriteMemo(NodeID(12), bytearray([1, 2, 3])) + dm1a = DatagramSendMemo(NodeID(2), bytearray()) + dm1b = DatagramSendMemo(NodeID(2), bytearray()) + dm2 = DatagramSendMemo(NodeID(12), bytearray()) + dm3 = DatagramSendMemo(NodeID(12), bytearray([1])) + dm4 = DatagramSendMemo(NodeID(12), bytearray([1, 2, 3])) self.assertEqual(dm1a, dm1b) self.assertNotEqual(dm1a, dm2) @@ -74,11 +74,11 @@ def testWriteMemoEquatable(self): self.assertNotEqual(dm3, dm4) def testReadMemoEquatable(self): - dm1a = DatagramReadMemo(NodeID(1), bytearray()) - dm1b = DatagramReadMemo(NodeID(1), bytearray()) - dm2 = DatagramReadMemo(NodeID(11), bytearray()) - dm3 = DatagramReadMemo(NodeID(11), bytearray([1])) - dm4 = DatagramReadMemo(NodeID(11), bytearray([1, 2, 3])) + dm1a = DatagramReceiveMemo(NodeID(1), bytearray()) + dm1b = DatagramReceiveMemo(NodeID(1), bytearray()) + dm2 = DatagramReceiveMemo(NodeID(11), bytearray()) + dm3 = DatagramReceiveMemo(NodeID(11), bytearray([1])) + dm4 = DatagramReceiveMemo(NodeID(11), bytearray([1, 2, 3])) self.assertEqual(dm1a, dm1b) self.assertNotEqual(dm1a, dm2) @@ -96,15 +96,15 @@ def testDatagramType(self): self.assertEqual(self.service.datagramType([0x20, 2, 3]), DatagramService.ProtocolID.MemoryOperation) - def writeCallBackCheck(self, memo): + def sendCallBackCheck(self, memo): self.callback = True def testSendDatagramOK(self): - writeMemo = DatagramWriteMemo(NodeID(22), - bytearray([0x20, 0x42, 0x30]), - self.writeCallBackCheck) + sendMemo = DatagramSendMemo(NodeID(22), + bytearray([0x20, 0x42, 0x30]), + self.sendCallBackCheck) - self.service.sendDatagram(writeMemo) + self.service.sendDatagram(sendMemo) self.assertEqual(len(LinkMockLayer.sentMessages), 1) @@ -115,13 +115,13 @@ def testSendDatagramOK(self): self.assertTrue(self.callback) def testSendThreeDatagramOK(self): - writeMemo = DatagramWriteMemo(NodeID(22), - bytearray([0x20, 0x42, 0x30]), - self.writeCallBackCheck) + sendMemo = DatagramSendMemo(NodeID(22), + bytearray([0x20, 0x42, 0x30]), + self.sendCallBackCheck) - self.service.sendDatagram(writeMemo) - self.service.sendDatagram(writeMemo) - self.service.sendDatagram(writeMemo) + self.service.sendDatagram(sendMemo) + self.service.sendDatagram(sendMemo) + self.service.sendDatagram(sendMemo) self.assertEqual(len(LinkMockLayer.sentMessages), 1) # ^ only first is send until reply @@ -153,11 +153,11 @@ def testSendThreeDatagramOK(self): self.assertEqual(len(LinkMockLayer.sentMessages), 3) def testSendDatagramRejected(self): - writeMemo = DatagramWriteMemo(NodeID(22), - bytearray([0x20, 0x42, 0x30]), None, - self.writeCallBackCheck) + sendMemo = DatagramSendMemo(NodeID(22), + bytearray([0x20, 0x42, 0x30]), None, + self.sendCallBackCheck) - self.service.sendDatagram(writeMemo) + self.service.sendDatagram(sendMemo) self.assertEqual(len(LinkMockLayer.sentMessages), 1) @@ -178,9 +178,9 @@ def testReceiveDatagramOK(self): # check that it went through self.assertTrue(self.received) - self.assertEqual(len(self.readMemos), 1) + self.assertEqual(len(self.receiveMemos), 1) - self.service.positiveReplyToDatagram(self.readMemos[0], 0) + self.service.positiveReplyToDatagram(self.receiveMemos[0], 0) # check message came through self.assertEqual(len(LinkMockLayer.sentMessages), 1) diff --git a/tests/test_memorymanager.py b/tests/test_memorymanager.py index 8e8ff89..7bb45bc 100644 --- a/tests/test_memorymanager.py +++ b/tests/test_memorymanager.py @@ -11,7 +11,7 @@ from openlcb.canbus.canlink import CanLink from openlcb.canbus.canphysicallayergridconnect import CanPhysicalLayerGridConnect from openlcb.cdivar import SIGNED_INT_MINIMUMS, CDIVar -from openlcb.datagramservice import DatagramService, DatagramWriteMemo +from openlcb.datagramservice import DatagramService, DatagramSendMemo from openlcb.dataprocessormemo import DataProcessorMemo from openlcb.localnode import LocalNode from openlcb.localnodeprocessor import LocalNodeProcessor diff --git a/tests/test_memoryservice.py b/tests/test_memoryservice.py index ebac3a7..0541b17 100644 --- a/tests/test_memoryservice.py +++ b/tests/test_memoryservice.py @@ -40,8 +40,8 @@ MemoryService, ) from openlcb.datagramservice import ( # noqa: E402 - # DatagramWriteMemo, - # DatagramReadMemo, + # DatagramSendMemo, + # DatagramReceiveMemo, DatagramService, )