This issue has been automatically marked as stale because it has been a
full year without activity. It will be closed if no further activity occurs.
Thank you for your contributions.

Hello,
It is me again.
As far as I understand you want to have events emitter/listener for TCP conn established/failed to establish in additional to onOpen/onClose events. Am I right?
How complex do you think this task is? Can I work on it?

@arsenalzp I don't think it's too complex, so you can give it a go.

You can start by finding the place in the code that initiate connection establishment, the place where the connection establishment is complete, and the place where the connection establishment is failed.

Then it's a matter of designing the listener APIs, and then emitting the events.

Let me know if you need guidance, but please one at a time 😄

Thanks!

I guess the right place is in ClientConnector.ClientSelectorManager

        public void connectionOpened(Connection connection, Object context)
        {
          ....
        }

        protected void connectionFailed(SelectableChannel channel, Throwable failure, Object attachment)
        {
         ....
        }

A draft implementation is showing connectionFailed() method is invoked more than one time, I suppose it is due to try-reconnect behavior. Is it valid to invoke onConnectionFailed() listener method more than one time?
Another question - what is listener methods signature, I mean what should be put as argument:

void onConnectionEstablished(Connection c)
void onConnectionFailed(Throwable failure)

@arsenalzp connectionFailed() should not be called multiple times.
Do you have stack traces from where it is called the first time, and the subsequent times?

We want to track connection establishment, so we want an event when the connection is initiated, and one when it is completed (either success or failure).
See ClientConnector.connect() as the initiating point.

The API should be lower level, so:

onConnectBegin(SocketChannel s)
onConnectSuccess(SocketChannel s);
onConnectFailure(SocketChannel s, Throwable x);

I found a connection behaviour, localhost host name is resolved into two IP-addresses: IPv4 and IPv6, so HttpClient tries to connect to both addresses. If host name is resolved in more addresses (addresses number are getting from socketAddresses.size()) then HttpClient tries to connect to all of them:

private void connect(List<InetSocketAddress> socketAddresses, int index, Map<String, Object> context)
 {
                    context.put(HttpClientTransport.HTTP_CONNECTION_PROMISE_CONTEXT_KEY, new Promise.Wrapper<>(promise)
                    {
                        @Override
                        public void failed(Throwable x)
                        {
                            int nextIndex = index + 1;
                            if (nextIndex == socketAddresses.size())
                                super.failed(x);
                            else
                                connect(socketAddresses, nextIndex, context);
                        }
                    });
                    HttpClient.this.transport.connect((SocketAddress)socketAddresses.get(index), context);
}

@arsenalzp good finding!

Can you please check that in the "begin" event, you get two different SocketChannel instances?
Can you also check that in the "begin" event, you can access the SocketAddress.getLocalAddress() and it reports in one case the IPv4 and in the other the IPv6?

We should get 2 "begin" events and 2 "failure" events and 0 "success" events.
If that's the case, everything works as expected and you can wire in the listener to emit the events to.

@arsenalzp good finding!

Can you please check that in the "begin" event, you get two different SocketChannel instances? Can you also check that in the "begin" event, you can access the SocketAddress.getLocalAddress() and it reports in one case the IPv4 and in the other the IPv6?

We should get 2 "begin" events and 2 "failure" events and 0 "success" events. If that's the case, everything works as expected and you can wire in the listener to emit the events to.

Yes, of course, there two different SocketChannel instances.

However, it is not possible to get local address when channel is not connected (connection state is pending), meanwhile it is possible to get remote address, check a channel state, etc.

Moreover, calling getLocalAddress on closed channel throws ClosedChannelException exception.

My expectation is that bind operation is the first one before any connection attempt.
Look at the ClientConnector.connect() it is good place for onConnectionBegin event.
However, there is no bind operation for SocketChannel instance, but NetworkChannel one, so it is not possible to get local address by calling getLocalAddress() method; doing so method returns null .

Obviously, connection can't be established without binding to local address and port, so this operation is done somewhere else (ManagedSelector.submit()).
Here is Javadoc for SocketChannel:

public abstract SocketChannel bind(SocketAddress local)
throws IOException

Binds the channel's socket to a local address.

This method is used to establish an association between the socket and a local address. Once an association is established then the socket remains bound until the channel is closed. If the local parameter has the value null
then the socket will be bound to an address that is assigned automatically.

It means getting null local address during the initial phase of connection is valid behavior.

It is still possible to get local address on successful connection event.

/assign