cmoulliard,
Thanks for the reply! Let me try to explain the problem again. FIX protocol
is session based where client is the initiator. That is:
client ------> server (IP:port)
never:
client (IP:port) <------- server
As you say, after client makes the connection to server, a session is
established. So, we practically have something like this:
client ----------------> server (IP:port)
| ---------> |
| <--------- |
i.e. both client and server can send messages (whether heartbeat or real
business messages) through the tunnel (what I tried to draw with |). This is
not analogous with jetty/http you mentioned - jetty/http is really
client-server and you actually listen with jetty, but connect with http -
but rarely to the client, mostly to other web sites to gather data.
With Quickfix, you don't connect from a server side - you use the tunnel
initiated by the client to both send and receive messages. This is similar
to jetty - a client requests some path on your server (e.g.
myserver.example.com/abc/def), you create a jetty server there and anything
for that URL goes to your bean at the end. The important thing here is that
whatever your bean returns goes back, but HTTP protocol is stateless and
closes the tunnel. In FIX it's very similar - you just continue using the
same tunnel. In both cases, the client is the only initiator - with jetty,
you don't say "connect to client", you just say "return the data to the
client using the already established tunnel".
What I don't understand is: when you say
from(quickfixserver).to(quickfixclient), you actually say - receive from
quickfixserver and send to quickfixclient. You configure quickfixserver as
acceptor and quickfixclient as initiator. Making quickfixserver an acceptor
is OK, however quickfixserver cannot be an initiator - on the server side,
you cannot initiate any connections - you just use the tunnel initiated by
the client to send FIX messages back.
Is there an example of something like the above?
Let me give you an example of what is needed:
- Say you have a client
- Client initiates the connection to server at some IP:port
- Server accepts the connection, thus creating a tunnel they will use going
forward
- Client can send messages and server can accept them (I have this part
working)
- After the connection is established, server sends a FIX message (e.g. a
test request or any other type) each 10 seconds to the client using the
established tunnel
- Server does not know anything about the client, specifically there is no
IP:port on the client side that server can even try to connect (for
simplicity, let's assume the client is behind a very restrictive firewall
that only allows client to initiate traffic)
- The question is - how do I reuse the tunnel I made above for this purpose?
How would the above be configured? I looked at all the examples, however
none of them were clear enough to me to make the above - any help would be
appreciated.
Thanks!
--
View this message in context:
http://old.nabble.com/Quickfix-send-receive-messages-in-both-directions-tp27855316p27999544.html
Sent from the Camel - Users mailing list archive at Nabble.com.
