def __init__(self, wrappedFactory):
        """Constructor.

        See WrappingFactory.__init__.
        """
        WrappingFactory.__init__(self, wrappedFactory)
        self.allConnectionsGone = None

    def __init__(self, wrappedFactory, maxConnectionCount=sys.maxint):
        WrappingFactory.__init__(self, wrappedFactory)
        self.connectionCount = 0
        self.maxConnectionCount = maxConnectionCount

        self.ht = Hellanzb.ht
        self.ht.factories.append(self)

    def __init__(self, contextFactory, isClient, wrappedFactory):
        WrappingFactory.__init__(self, wrappedFactory)
        self._contextFactory = contextFactory
        self._isClient = isClient

        # Force some parameter checking in pyOpenSSL.  It's better to fail now
        # than after we've set up the transport.
        contextFactory.getContext()

 def unregisterProtocol(self, p):
     WrappingFactory.unregisterProtocol(self, p)
     self.connectionCount -= 1
     self.ht.connectionCount -= 1
     
     if self.ht.connectionCount == 0:
         for name in ('unthrottleReadsID', 'checkReadBandwidthID',
                      'unthrottleWritesID', 'checkWriteBandwidthID'):
             self.cancelScheduled(getattr(self.ht, name))

    def __init__(self, contextFactory, isClient, wrappedFactory):
        """
        Create a L{TLSMemoryBIOFactory}.

        @param contextFactory: Configuration parameters used to create an
            OpenSSL connection.  In order of preference, what you should pass
            here should be:

                1. L{twisted.internet.ssl.CertificateOptions} (if you're
                   writing a server) or the result of
                   L{twisted.internet.ssl.optionsForClientTLS} (if you're
                   writing a client).  If you want security you should really
                   use one of these.

                2. If you really want to implement something yourself, supply a
                   provider of L{IOpenSSLClientConnectionCreator} or
                   L{IOpenSSLServerConnectionCreator}.

                3. If you really have to, supply a
                   L{twisted.internet.ssl.ContextFactory}.  This will likely be
                   deprecated at some point so please upgrade to the new
                   interfaces.

        @type contextFactory: L{IOpenSSLClientConnectionCreator} or
            L{IOpenSSLServerConnectionCreator}, or, for compatibility with
            older code, anything implementing
            L{twisted.internet.interfaces.IOpenSSLContextFactory}.  See
            U{https://twistedmatrix.com/trac/ticket/7215} for information on
            the upcoming deprecation of passing a
            L{twisted.internet.ssl.ContextFactory} here.

        @param isClient: Is this a factory for TLS client connections; in other
            words, those that will send a C{ClientHello} greeting?  L{True} if
            so, L{False} otherwise.  This flag determines what interface is
            expected of C{contextFactory}.  If L{True}, C{contextFactory}
            should provide L{IOpenSSLClientConnectionCreator}; otherwise it
            should provide L{IOpenSSLServerConnectionCreator}.
        @type isClient: L{bool}

        @param wrappedFactory: A factory which will create the
            application-level protocol.
        @type wrappedFactory: L{twisted.internet.interfaces.IProtocolFactory}
        """
        WrappingFactory.__init__(self, wrappedFactory)
        if isClient:
            creatorInterface = IOpenSSLClientConnectionCreator
        else:
            creatorInterface = IOpenSSLServerConnectionCreator
        self._creatorInterface = creatorInterface
        if not creatorInterface.providedBy(contextFactory):
            contextFactory = _ContextFactoryToConnectionFactory(contextFactory)
        self._connectionCreator = contextFactory

 def buildProtocol(self, addr):
     remote_ip = ip_address(addr.host)
     if any(remote_ip in network for network in self.whitelist):
         return WrappingFactory.buildProtocol(self, addr)
     else:
         log.info("Attempted submission from non-whitelisted %s" % str(addr))
         return None

 def buildProtocol(self, addr):
     try:
         remote_ip = ip_address(addr.host)
         if not any(remote_ip in network for network in self.whitelist):
             log.info(f"Attempted {self.connection_type} from "
                      f"non-whitelisted {addr}")
             return None
     except AttributeError:
         log.warn(f"Bypassing whitelist for {self.connection_type} "
                  f"from {addr}")
     return WrappingFactory.buildProtocol(self, addr)

    def registerProtocol(self, p):
        """
        Called by protocol to register itself.
        """
        WrappingFactory.registerProtocol(self, p)

        if self.requests_countdown > 0:
            self.requests_countdown -= 1

        if self.requests_countdown == 0:
            # bai bai mai friend
            #
            # known bug: currently when the limit is reached all
            #            the active requests are trashed.
            #            this simple solution is used to achieve
            #            stronger stability.
            try:
                reactor.stop()
            except Exception:
                pass

    def buildProtocol(self, addr):
        if self.ht.connectionCount == 0:
            if self.ht.readLimit is not None:
                self.ht.checkReadBandwidth()
            if self.ht.writeLimit is not None:
                self.ht.checkWriteBandwidth()

        if self.connectionCount < self.maxConnectionCount:
            self.connectionCount += 1
            self.ht.connectionCount += 1
            return WrappingFactory.buildProtocol(self, addr)
        else:
            log.msg("Max connection count reached!")
            return None

 def __init__(self, wrappedFactory, whitelist, connection_type="connection"):
     self.whitelist = whitelist
     self.connection_type = connection_type
     WrappingFactory.__init__(self, wrappedFactory)

 def __init__(self, wrappedFactory, jsonEncoder=None, jsonDecoder=None):
     WrappingFactory.__init__(self, wrappedFactory)
     self.jsonEncoder = jsonEncoder
     self.jsonDecoder = jsonDecoder

 def __init__(self, wrappedFactory, allowedRequests):
     WrappingFactory.__init__(self, wrappedFactory)
     self.requests_countdown = allowedRequests

                                              privateKey=privateKey,
                                              verifierDB=verifierDB)
      else:
          Echo.connectionMade(self)

  def connectionLost(self, reason):
      pass #Handle any TLS exceptions here

class Echo2(Echo):
  def lineReceived(self, data):
      if data == "STARTTLS":
          self.transport.setServerHandshakeOp(certChain=certChain,
                                              privateKey=privateKey,
                                              verifierDB=verifierDB)
      else:
          Echo.lineReceived(self, data)

  def connectionLost(self, reason):
      pass #Handle any TLS exceptions here

factory = Factory()
factory.protocol = Echo1
#factory.protocol = Echo2

wrappingFactory = WrappingFactory(factory)
wrappingFactory.protocol = TLSTwistedProtocolWrapper

log.startLogging(sys.stdout)
reactor.listenTCP(1079, wrappingFactory)
reactor.run()

 def __init__(self, wrappedFactory):
     WrappingFactory.__init__(self, wrappedFactory)
     self.logs = []
     self.finishedLogs = []

 def __init__(self, wrappedFactory, host, port, optimistic):
     WrappingFactory.__init__(self, wrappedFactory)
     self._host = host
     self._port = port
     self._optimistic = optimistic
     self._onConnection = defer.Deferred()

 def stopFactory(self):
     """See WrappingFactory.stopFactory."""
     WrappingFactory.stopFactory(self)
     self.allConnectionsGone = Deferred()
     if len(self.protocols) == 0:
         self.allConnectionsGone.callback(None)

 def buildProtocol(self, addr):
     protocol = WrappingFactory.buildProtocol(self, addr)
     protocol.setWriteLimit(self.writeLimit)
     return protocol

 def __init__(self, wrappedFactory, writeLimit):
     WrappingFactory.__init__(self, wrappedFactory)
     self.writeLimit = writeLimit

 def unregisterProtocol(self, p):
     """See WrappingFactory.unregisterProtocol."""
     WrappingFactory.unregisterProtocol(self, p)
     if len(self.protocols) == 0:
         if self.allConnectionsGone is not None:
             self.allConnectionsGone.callback(None)

 def unregisterProtocol(self, protocol):
     WrappingFactory.unregisterProtocol(self, protocol)
     self.logs.remove(protocol.logfile)
     self.finishedLogs.append(protocol.logfile)
     del self.finishedLogs[:-self.LOGFILE_LIMIT]