public Transport compositeConfigure(Transport transport,
    WireFormat format,
    Map options) 
{
        TcpTransport tcpTransport = (TcpTransport)transport.narrow(TcpTransport.class);
        IntrospectionSupport.setProperties(tcpTransport, options);
        Map< String, Object > socketOptions = IntrospectionSupport.extractProperties(options, "socket.");
        tcpTransport.setSocketOptions(socketOptions);
        if (tcpTransport.isTrace()) {
            try {
                transport = TransportLoggerFactory.getInstance().createTransportLogger(transport, tcpTransport.getLogWriterName(),
                        tcpTransport.isDynamicManagement(), tcpTransport.isStartLogging(), tcpTransport.getJmxPort());
            } catch (Throwable e) {
                LOG.error("Could not create TransportLogger object for: " + tcpTransport.getLogWriterName() + ", reason: " + e, e);
            }
        }
        boolean useInactivityMonitor = "true".equals(getOption(options, "useInactivityMonitor", "true"));
        if (useInactivityMonitor && isUseInactivityMonitor(transport)) {
            transport = new InactivityMonitor(transport, format);
            IntrospectionSupport.setProperties(transport, options);
        }
        // Only need the WireFormatNegotiator if using openwire
        if (format instanceof OpenWireFormat) {
            transport = new WireFormatNegotiator(transport, (OpenWireFormat)format, tcpTransport.getMinmumWireFormatVersion());
        }
        return super.compositeConfigure(transport, format, options);
}

 protected ServerSocketFactory createServerSocketFactory() throws IOException 
{
        return ServerSocketFactory.getDefault();
}

 protected SocketFactory createSocketFactory() throws IOException 
{
        return SocketFactory.getDefault();
}

 protected TcpTransport createTcpTransport(WireFormat wf,
    SocketFactory socketFactory,
    URI location,
    URI localLocation) throws UnknownHostException, IOException 
{
        return new TcpTransport(wf, socketFactory, location, localLocation);
}

Allows subclasses of TcpTransportFactory to provide a create custom TcpTransport intances.

 protected TcpTransportServer createTcpTransportServer(URI location,
    ServerSocketFactory serverSocketFactory) throws IOException, URISyntaxException 
{
        return new TcpTransportServer(this, location, serverSocketFactory);
}

Allows subclasses of TcpTransportFactory to create custom instances of TcpTransportServer.

 protected Transport createTransport(URI location,
    WireFormat wf) throws UnknownHostException, IOException 
{
        URI localLocation = null;
        String path = location.getPath();
        // see if the path is a local URI location
        if (path != null && path.length()  > 0) {
            int localPortIndex = path.indexOf(':');
            try {
                Integer.parseInt(path.substring(localPortIndex + 1, path.length()));
                String localString = location.getScheme() + ":/" + path;
                localLocation = new URI(localString);
            } catch (Exception e) {
                LOG.warn("path isn't a valid local location for TcpTransport to use", e);
            }
        }
        SocketFactory socketFactory = createSocketFactory();
        return createTcpTransport(wf, socketFactory, location, localLocation);
}

 public TransportServer doBind(URI location) throws IOException 
{
        try {
            Map< String, String > options = new HashMap< String, String >(URISupport.parseParamters(location));
            ServerSocketFactory serverSocketFactory = createServerSocketFactory();
            TcpTransportServer server = createTcpTransportServer(location, serverSocketFactory);
            server.setWireFormatFactory(createWireFormatFactory(options));
            IntrospectionSupport.setProperties(server, options);
            Map< String, Object > transportOptions = IntrospectionSupport.extractProperties(options, "transport.");
            server.setTransportOption(transportOptions);
            server.bind();
            return server;
        } catch (URISyntaxException e) {
            throw IOExceptionSupport.create(e);
        }
}

 protected boolean isUseInactivityMonitor(Transport transport) 
{
        return true;
}

Returns true if the inactivity monitor should be used on the transport