Added async interface.

rcon/__init__.py

@@ -1,6 +1,7 @@
 """RCON client library."""
 
+from rcon.asyncio import rcon
 from rcon.proto import Client
 
 
-__all__ = ['Client']
+__all__ = ['Client', 'rcon']

rcon/asyncio.py

@@ -0,0 +1,37 @@
+"""Asynchronous RCON."""
+
+from asyncio import open_connection
+from typing import IO
+
+from rcon.proto import Packet
+
+
+__all__ = ['rcon']
+
+
+async def communicate(reader: IO, writer: IO, packet: Packet) -> Packet:
+    """Asynchronous requests."""
+
+    writer.write(bytes(packet))
+    await writer.drain()
+    return await Packet.aread(reader)
+
+
+async def rcon(command: str, *arguments: str, host: str, port: int,
+               passwd: str) -> str:
+    """Runs a command asynchronously."""
+
+    reader, writer = await open_connection(host, port)
+    login = Packet.make_login(passwd)
+    response = await communicate(reader, writer, login)
+
+    if response.id == -1:
+        raise RuntimeError('Wrong password.')
+
+    request = Packet.make_command(command, *arguments)
+    response = await communicate(reader, writer, request)
+
+    if response.id != request.id:
+        raise RuntimeError('Request ID mismatch.')
+
+    return response.payload

rcon/proto.py

@@ -44,6 +44,11 @@ class LittleEndianSignedInt32(int):
         """Returns the integer as signed little endian."""
         return self.to_bytes(4, 'little', signed=True)
 
+    @classmethod
+    async def aread(cls, file: IO) -> LittleEndianSignedInt32:
+        """Reads the integer from an ansynchronous file-like object."""
+        return cls.from_bytes(await file.read(4), 'little', signed=True)
+
     @classmethod
     def read(cls, file: IO) -> LittleEndianSignedInt32:
         """Reads the integer from a file-like object."""
@@ -66,6 +71,11 @@ class Type(Enum):
         """Returns the integer value as little endian."""
         return bytes(self.value)
 
+    @classmethod
+    async def aread(cls, file: IO) -> Type:
+        """Reads the type from an asynchronous file-like object."""
+        return cls(await LittleEndianSignedInt32.read(file))
+
     @classmethod
     def read(cls, file: IO) -> Type:
         """Reads the type from a file-like object."""
@@ -89,6 +99,20 @@ class Packet(NamedTuple):
         size = bytes(LittleEndianSignedInt32(len(payload)))
         return size + payload
 
+    @classmethod
+    async def aread(cls, file: IO) -> Packet:
+        """Reads a packet from an asynchronous file-like object."""
+        size = await LittleEndianSignedInt32.read(file)
+        id_ = await LittleEndianSignedInt32.read(file)
+        type_ = await Type.read(file)
+        payload = await file.read(size - 10)
+        terminator = await file.read(2)
+
+        if terminator != TERMINATOR:
+            LOGGER.warning('Unexpected terminator: %s', terminator)
+
+        return cls(id_, type_, payload.decode(), terminator.decode())
+
     @classmethod
     def read(cls, file: IO) -> Packet:
         """Reads a packet from a file-like object."""