A minimal server and client showing the sslproto.py IndexError: deque index out of range error

Asyncio Client Issue

import asyncio
import ssl


class EchoClientProtocol(asyncio.Protocol):
    def __init__(self, message, on_con_lost, loop):
        self.message = message
        self.loop = loop
        self.on_con_lost = on_con_lost
        self.transport = None

    def connection_made(self, transport):
        self.transport = transport
        # elf.transport.write(self.message.encode())
        print('Data sent: {!r}'.format(self.message))

    def data_received(self, data):
        # self.transport.write(self.message.encode())
        print('Data received: {!r}'.format(data.decode()))

    def connection_lost(self, exc):
        print('The server closed the connection')
        self.on_con_lost.set_result(True)


async def main():
    ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
    ssl_context.load_cert_chain('local.crt', 'local.key')
    ssl_context.options = ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1_1
    ssl_context.set_ciphers('EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH')
    # Get a reference to the event loop as we plan to use
    # low-level APIs.
    loop = asyncio.get_running_loop()

    on_con_lost = loop.create_future()
    message = 'Hello World!'

    transport, protocol = await loop.create_connection(
        lambda: EchoClientProtocol(message, on_con_lost, loop),
        '127.0.0.1', 8888, ssl=ssl_context)

    # Wait until the protocol signals that the connection
    # is lost and close the transport.
    try:
        await on_con_lost
    finally:
        transport.close()


asyncio.run(main())

Asyncio Server Issue Example

import asyncio
import ssl
import time
import logging
import logging.handlers
import logging.config
import os
import json

logger = logging.getLogger(__name__)


class EchoServerProtocol(asyncio.Protocol):
    def __init__(self):
        self.transport = None

    def connection_made(self, transport):
        peername = transport.get_extra_info('peername')
        print('Connection from {}'.format(peername))
        self.transport = transport

    def connection_lost(self, exception):
        print('Close the client socket')
        self.transport.close()
        super().connection_lost(exception)

    def data_received(self, data):
        message = data.decode()
        print('Data received: {!r}'.format(message))

    def data_send(self, data):
        if self.transport:
            self.transport.write(data)


class EchoServer:
    def __init__(self):
        self._setup_logging()
        self.servers = []

    async def main(self):
        ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
        ssl_context.load_cert_chain('local.crt', 'local.key')
        ssl_context.options = ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1_1
        ssl_context.set_ciphers('EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH')

        loop = asyncio.get_running_loop()
        server = await loop.create_server(lambda: self.create_server(),
                                          '127.0.0.1',
                                          8888,
                                          ssl=ssl_context,
                                          start_serving=True)
        await loop.run_in_executor(None, self.dispatch)
        async with server:
            await server.serve_forever()

    def dispatch(self):
        while True:
            for server in self.servers:
                server.data_send(b'Test Sending')

    def create_server(self):
        server = EchoServerProtocol()
        self.servers.append(server)
        return server

    @staticmethod
    def _setup_logging():
        path = 'logging.json'
        log_config_path = os.getenv('LOG_CFG', None)
        if log_config_path:
            path = log_config_path
        if os.path.exists(path):
            with open(path, 'rt') as f:
                config = json.load(f)
            logging.config.dictConfig(config)
        else:
            logging.basicConfig(level=logging.INFO)


def main():
    server = EchoServer()
    asyncio.run(server.main())

if __name__ == '__main__':
    main()

logging.json

{
    "version": 1,
    "disable_existing_loggers": false,
    "formatters": {
        "simple": {
            "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
        }
    },
    "handlers": {
        "stdout": {
            "class": "logging.StreamHandler",
            "level": "DEBUG",
            "formatter": "simple",
            "stream": "ext://sys.stdout"
        },
        "file": {
            "class": "logging.handlers.RotatingFileHandler",
            "level": "INFO",
            "formatter": "simple",
            "filename": "aks_server.log",
            "maxBytes": 10485760,
            "backupCount": 5,
            "encoding": "utf8"
        }
    },
    "root": {
        "level": "DEBUG",
        "handlers": ["stdout", "file"]
    }
}

working_server.py

import ssl
import asyncio

async def handle_echo(reader, writer):
    while True:

        print("Send: Hello World Test!")
        writer.write(b"Send: Hello World Test!")
        await writer.drain()

async def main():
    ssl_context = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
    ssl_context.load_cert_chain('local.crt', 'local.key')
    ssl_context.options = ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3 | ssl.OP_NO_TLSv1_1
    ssl_context.set_ciphers('EECDH+AESGCM:EDH+AESGCM:AES256+EECDH:AES256+EDH')
    server = await asyncio.start_server(
        handle_echo, '127.0.0.1', 8888, ssl=ssl_context, start_serving=True)

    addr = server.sockets[0].getsockname()
    print(f'Serving on {addr}')

    async with server:
        await server.serve_forever()

asyncio.run(main())