Client TLS transport connected state out of sync

endpoint_client_server.py

#
# Script to demonstrate the Client.transport.connected state
#
from twisted.internet.protocol import Protocol
from twisted.internet.protocol import Factory
from twisted.internet.endpoints import SSL4ServerEndpoint, TCP4ServerEndpoint
from twisted.internet.endpoints import (
    SSL4ClientEndpoint, TCP4ClientEndpoint, connectProtocol)
from twisted.internet import reactor
from twisted.internet.ssl import PrivateCertificate, ClientContextFactory


class ServerEcho(Protocol):
    """
    Server side protocol.
    """

    def connectionMade(self):
        print 'server:client connected'
        self.transport.write('Welcome!')

    def connectionLost(self, reason):
        print "server:client disconnected"

    def dataReceived(self, data):
        print "server:data received"
        self.transport.write(data)
        self.transport.loseConnection()



class Greeter(Protocol):
    """
    Client side protocol.
    """
    def connectionLost(self, reason):
        """
        Called when connection to server was lost.
        """
        print "client:connection-lost"
        check_transport_status(self.transport)
        # Check transport status later... in case there is a waiting shutdown.
        reactor.callLater(3, check_transport_status, self.transport)

    def sendMessage(self, msg):
        print "client:send-message"
        self.transport.write("MESSAGE %s\n" % msg)


def gotProtocol(p):
    """
    Called when protocol was connected.
    """
    print 'client:connected'
    p.sendMessage("Hello")


def check_transport_status(transport):
    if not USE_SSL:
        wrapped_transport = transport
    else:
        wrapped_transport = transport.transport

    print 'client:transport-status:%s:wrapped-transport->%s' % (
        transport.connected, wrapped_transport.connected)


port_number = 8000
USE_SSL=False

if USE_SSL:
    certData = open('cert-key.pem')
    certificate = PrivateCertificate.loadPEM(certData.read())
    server_endpoint = SSL4ServerEndpoint(
        reactor, port_number, sslContextFactory=certificate.options())
    client_endpoint = SSL4ClientEndpoint(
        reactor, "localhost", port_number,
        sslContextFactory=ClientContextFactory())
else:
    server_endpoint = TCP4ServerEndpoint(reactor, port_number)
    client_endpoint = TCP4ClientEndpoint(reactor, "localhost", port_number)


factory = Factory()
factory.protocol = ServerEcho
server_endpoint.listen(factory)


d = connectProtocol(client_endpoint, Greeter())
d.addCallback(gotProtocol)

reactor.run()