// ========================================================================
// Copyright 2006-20078 Mort Bay Consulting Pty. Ltd.
// ------------------------------------------------------------------------
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================
package org.mortbay.cometd.client;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ConcurrentHashMap;
import javax.servlet.http.Cookie;
import org.cometd.Bayeux;
import org.cometd.Client;
import org.cometd.ClientListener;
import org.cometd.Extension;
import org.cometd.Message;
import org.cometd.MessageListener;
import org.cometd.RemoveListener;
import org.mortbay.cometd.MessageImpl;
import org.mortbay.cometd.MessagePool;
import org.mortbay.component.AbstractLifeCycle;
import org.mortbay.io.Buffer;
import org.mortbay.io.ByteArrayBuffer;
import org.mortbay.jetty.HttpHeaders;
import org.mortbay.jetty.HttpSchemes;
import org.mortbay.jetty.HttpURI;
import org.mortbay.jetty.client.Address;
import org.mortbay.jetty.client.ContentExchange;
import org.mortbay.jetty.client.HttpClient;
import org.mortbay.jetty.client.HttpExchange;
import org.mortbay.log.Log;
import org.mortbay.util.ArrayQueue;
import org.mortbay.util.LazyList;
import org.mortbay.util.QuotedStringTokenizer;
import org.mortbay.util.ajax.JSON;
/* ------------------------------------------------------------ */
/**
* Bayeux protocol Client.
* <p>
* Implements a Bayeux Ajax Push client as part of the cometd project.
*
* @see http://cometd.com
* @author gregw
*
*/
public class BayeuxClient extends AbstractLifeCycle implements Client
{
protected HttpClient _httpClient;
protected MessagePool _msgPool = new MessagePool();
private Queue<Message> _inQ = new ArrayQueue<Message>(); // queue of incoming messages
private Queue<Message> _outQ = new ArrayQueue<Message>(); // queue of outgoing messages
protected Address _cometdAddress;
private Exchange _pull;
private Exchange _push;
private String _path = "/cometd";
private boolean _initialized = false;
private boolean _disconnecting = false;
private boolean _handshook = false;
private String _clientId;
private org.cometd.Listener _listener;
private List<RemoveListener> _rListeners;
private List<MessageListener> _mListeners;
private int _batch;
private boolean _formEncoded;
private Map<String, Cookie> _cookies = new ConcurrentHashMap<String, Cookie>();
private Advice _advice;
private Timer _timer;
private int _backoffInterval = 1000;
private int _backoffMaxRetries = 60; // equivalent to 60 seconds
private Buffer _scheme;
protected Extension[] _extensions;
/* ------------------------------------------------------------ */
public BayeuxClient(HttpClient client, String url)
{
this(client,url,null);
}
/* ------------------------------------------------------------ */
public BayeuxClient(HttpClient client, String url, Timer timer)
{
HttpURI uri = new HttpURI(url);
_httpClient = client;
_cometdAddress = new Address(uri.getHost(),uri.getPort());
_path=uri.getPath();
_timer = timer;
if (_timer == null)
_timer = new Timer("DefaultBayeuxClientTimer",true);
_scheme = (HttpSchemes.HTTPS.equals(uri.getScheme()))?HttpSchemes.HTTPS_BUFFER:HttpSchemes.HTTP_BUFFER;
}
/* ------------------------------------------------------------ */
public BayeuxClient(HttpClient client, Address address, String path, Timer timer)
{
_httpClient = client;
_cometdAddress = address;
_path = path;
_timer = timer;
if (_timer == null)
_timer = new Timer("DefaultBayeuxClientTimer",true);
}
/* ------------------------------------------------------------ */
public BayeuxClient(HttpClient client, Address address, String uri)
{
this(client,address,uri,null);
}
/* ------------------------------------------------------------ */
public void addExtension(Extension ext)
{
_extensions = (Extension[])LazyList.addToArray(_extensions,ext,Extension.class);
}
/* ------------------------------------------------------------ */
Extension[] getExtensions()
{
return _extensions;
}
/* ------------------------------------------------------------ */
/**
* If unable to connect/handshake etc, even if following the interval in the
* advice, wait for this interval and try again, up to a maximum of
* _backoffRetries
*
* @param interval
*/
public void setBackOffInterval(int interval)
{
_backoffInterval = interval;
}
/* ------------------------------------------------------------ */
public int getBackoffInterval()
{
return _backoffInterval;
}
/* ------------------------------------------------------------ */
public void setBackoffMaxRetries(int retries)
{
_backoffMaxRetries = retries;
}
/* ------------------------------------------------------------ */
public int getBackoffMaxRetries()
{
return _backoffMaxRetries;
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc) Returns the clientId
*
* @see dojox.cometd.Client#getId()
*/
public String getId()
{
return _clientId;
}
/* ------------------------------------------------------------ */
protected void doStart() throws Exception
{
super.doStart();
synchronized (_outQ)
{
if (!_initialized && _pull == null)
{
_pull = new Handshake();
send((Exchange)_pull,false);
}
}
}
/* ------------------------------------------------------------ */
protected void doStop() throws Exception
{
remove(); // disconnect
super.doStop();
_pull = null;
_push = null;
}
/* ------------------------------------------------------------ */
public boolean isPolling()
{
synchronized (_outQ)
{
return isRunning() && (_pull != null);
}
}
/* ------------------------------------------------------------ */
/**
* (non-Javadoc)
*/
public void deliver(Client from, Message message)
{
if (!isRunning())
throw new IllegalStateException("Not running");
synchronized (_inQ)
{
if (_mListeners == null)
_inQ.add(message);
else
{
for (MessageListener l : _mListeners)
l.deliver(from,this,message);
}
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#deliver(dojox.cometd.Client, java.lang.String,
* java.lang.Object, java.lang.String)
*/
public void deliver(Client from, String toChannel, Object data, String id)
{
if (!isRunning())
throw new IllegalStateException("Not running");
Message message = new MessageImpl();
message.put(Bayeux.CHANNEL_FIELD,toChannel);
message.put(Bayeux.DATA_FIELD,data);
if (id != null)
message.put(Bayeux.ID_FIELD,id);
synchronized (_inQ)
{
if (_mListeners == null)
_inQ.add(message);
else
{
for (MessageListener l : _mListeners)
l.deliver(from,this,message);
}
}
}
/* ------------------------------------------------------------ */
/**
* @deprecated
*/
public org.cometd.Listener getListener()
{
synchronized (_inQ)
{
return _listener;
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#hasMessages()
*/
public boolean hasMessages()
{
synchronized (_inQ)
{
return _inQ.size() > 0;
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#isLocal()
*/
public boolean isLocal()
{
return false;
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#subscribe(java.lang.String)
*/
private void publish(Message msg)
{
if (!isRunning())
throw new IllegalStateException("Not running");
synchronized (_outQ)
{
_outQ.add(msg);
if (_batch == 0 && _initialized && _push == null)
{
_push = new Publish();
try
{
send(_push);
}
catch (Exception e)
{
metaPublishFail(e,((Publish)_push).getOutboundMessages());
}
}
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#publish(java.lang.String, java.lang.Object,
* java.lang.String)
*/
public void publish(String toChannel, Object data, String msgId)
{
if (!isRunning())
throw new IllegalStateException("Not running");
Message msg = new MessageImpl();
msg.put(Bayeux.CHANNEL_FIELD,toChannel);
msg.put(Bayeux.DATA_FIELD,data);
if (msgId != null)
msg.put(Bayeux.ID_FIELD,msgId);
publish(msg);
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#subscribe(java.lang.String)
*/
public void subscribe(String toChannel)
{
if (!isRunning())
throw new IllegalStateException("Not running");
Message msg = new MessageImpl();
msg.put(Bayeux.CHANNEL_FIELD,Bayeux.META_SUBSCRIBE);
msg.put(Bayeux.SUBSCRIPTION_FIELD,toChannel);
publish(msg);
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#unsubscribe(java.lang.String)
*/
public void unsubscribe(String toChannel)
{
if (!isRunning())
throw new IllegalStateException("Not running");
Message msg = new MessageImpl();
msg.put(Bayeux.CHANNEL_FIELD,Bayeux.META_UNSUBSCRIBE);
msg.put(Bayeux.SUBSCRIPTION_FIELD,toChannel);
publish(msg);
}
/* ------------------------------------------------------------ */
/**
* Disconnect this client.
* @deprecated use {@link #disconnect()}
*/
public void remove()
{
disconnect();
}
/* ------------------------------------------------------------ */
/**
* Disconnect this client.
*/
public void disconnect()
{
if (isStopped())
throw new IllegalStateException("Not running");
Message msg = new MessageImpl();
msg.put(Bayeux.CHANNEL_FIELD,Bayeux.META_DISCONNECT);
synchronized (_outQ)
{
_outQ.add(msg);
_disconnecting = true;
if (_batch == 0 && _initialized && _push == null)
{
_push = new Publish();
try
{
send(_push);
}
catch (IOException e)
{
Log.warn(e);
send(_push,true);
}
}
_initialized = false;
}
}
/* ------------------------------------------------------------ */
/**
* @deprecated
*/
public void setListener(org.cometd.Listener listener)
{
synchronized (_inQ)
{
if (_listener != null)
removeListener(_listener);
_listener = listener;
if (_listener != null)
addListener(_listener);
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc) Removes all available messages from the inbound queue. If a
* listener is set then messages are not queued.
*
* @see dojox.cometd.Client#takeMessages()
*/
public List<Message> takeMessages()
{
synchronized (_inQ)
{
LinkedList<Message> list = new LinkedList<Message>(_inQ);
_inQ.clear();
return list;
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#endBatch()
*/
public void endBatch()
{
if (!isRunning())
throw new IllegalStateException("Not running");
synchronized (_outQ)
{
if (--_batch <= 0)
{
_batch = 0;
if ((_initialized || _disconnecting) && _push == null && _outQ.size() > 0)
{
_push = new Publish();
try
{
send(_push);
}
catch (IOException e)
{
metaPublishFail(e,((Publish)_push).getOutboundMessages());
}
}
}
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see dojox.cometd.Client#startBatch()
*/
public void startBatch()
{
if (!isRunning())
throw new IllegalStateException("Not running");
synchronized (_outQ)
{
_batch++;
}
}
/* ------------------------------------------------------------ */
/**
* Customize an Exchange. Called when an exchange is about to be sent to
* allow Cookies and Credentials to be customized. Default implementation
* sets any cookies
*/
protected void customize(HttpExchange exchange)
{
StringBuilder buf = null;
for (Cookie cookie : _cookies.values())
{
if (buf == null)
buf = new StringBuilder();
else
buf.append("; ");
buf.append(cookie.getName()); // TODO quotes
buf.append("=");
buf.append(cookie.getValue()); // TODO quotes
}
if (buf != null)
exchange.addRequestHeader(HttpHeaders.COOKIE,buf.toString());
if (_scheme!=null)
exchange.setScheme(_scheme);
}
/* ------------------------------------------------------------ */
public void setCookie(Cookie cookie)
{
_cookies.put(cookie.getName(),cookie);
}
/* ------------------------------------------------------------ */
/**
* The base class for all bayeux exchanges.
*/
protected class Exchange extends ContentExchange
{
Message[] _responses;
int _connectFailures;
int _backoffRetries = 0;
String _jsonOut;
/* ------------------------------------------------------------ */
Exchange(String info)
{
setMethod("POST");
setScheme(HttpSchemes.HTTP_BUFFER);
setAddress(_cometdAddress);
setURI(_path + "/" + info);
setRequestContentType(_formEncoded?"application/x-www-form-urlencoded;charset=utf-8":"text/json;charset=utf-8");
}
/* ------------------------------------------------------------ */
public int getBackoffRetries()
{
return _backoffRetries;
}
/* ------------------------------------------------------------ */
public void incBackoffRetries()
{
++_backoffRetries;
}
/* ------------------------------------------------------------ */
protected void setMessage(String message)
{
message=extendOut(message);
setJsonOut(message);
}
/* ------------------------------------------------------------ */
protected void setMessages(Queue<Message> messages)
{
for (Message msg : messages)
{
msg.put(Bayeux.CLIENT_FIELD,_clientId);
extendOut(msg);
}
setJsonOut(JSON.toString(messages));
}
/* ------------------------------------------------------------ */
protected void setJsonOut(String json)
{
try
{
_jsonOut = json;
if (_formEncoded)
setRequestContent(new ByteArrayBuffer("message=" + URLEncoder.encode(_jsonOut,"utf-8")));
else
setRequestContent(new ByteArrayBuffer(_jsonOut,"utf-8"));
}
catch (Exception e)
{
Log.warn(e);
setRequestContent(new ByteArrayBuffer(_jsonOut));
}
}
/* ------------------------------------------------------------ */
protected void onResponseStatus(Buffer version, int status, Buffer reason) throws IOException
{
super.onResponseStatus(version,status,reason);
}
/* ------------------------------------------------------------ */
protected void onResponseHeader(Buffer name, Buffer value) throws IOException
{
super.onResponseHeader(name,value);
if (!isRunning())
return;
if (HttpHeaders.CACHE.getOrdinal(name) == HttpHeaders.SET_COOKIE_ORDINAL)
{
String cname = null;
String cvalue = null;
QuotedStringTokenizer tok = new QuotedStringTokenizer(value.toString(),"=;",false,false);
tok.setSingle(false);
if (tok.hasMoreElements())
cname = tok.nextToken();
if (tok.hasMoreElements())
cvalue = tok.nextToken();
Cookie cookie = new Cookie(cname,cvalue);
while (tok.hasMoreTokens())
{
String token = tok.nextToken();
if ("Version".equalsIgnoreCase(token))
cookie.setVersion(Integer.parseInt(tok.nextToken()));
else if ("Comment".equalsIgnoreCase(token))
cookie.setComment(tok.nextToken());
else if ("Path".equalsIgnoreCase(token))
cookie.setPath(tok.nextToken());
else if ("Domain".equalsIgnoreCase(token))
cookie.setDomain(tok.nextToken());
else if ("Expires".equalsIgnoreCase(token))
{
tok.nextToken();
// TODO
}
else if ("Max-Age".equalsIgnoreCase(token))
{
tok.nextToken();
// TODO
}
else if ("Secure".equalsIgnoreCase(token))
cookie.setSecure(true);
}
BayeuxClient.this.setCookie(cookie);
}
}
/* ------------------------------------------------------------ */
protected void onResponseComplete() throws IOException
{
if (!isRunning())
return;
super.onResponseComplete();
if (getResponseStatus() == 200)
{
String content = getResponseContent();
// TODO
if (content == null || content.length() == 0)
throw new IllegalStateException();
_responses = _msgPool.parse(content);
if (_responses!=null)
for (int i=0;i<_responses.length;i++)
extendIn(_responses[i]);
}
}
/* ------------------------------------------------------------ */
protected void resend(boolean backoff)
{
if (!isRunning())
return;
setJsonOut(_jsonOut);
if (!send(this,backoff))
Log.warn("Retries exhausted"); // giving up
}
/* ------------------------------------------------------------ */
protected void recycle()
{
if (_responses!=null)
for (Message msg:_responses)
if (msg instanceof MessageImpl)
((MessageImpl)msg).decRef();
_responses=null;
}
}
/* ------------------------------------------------------------ */
/**
* The Bayeux handshake exchange. Negotiates a client Id and initializes the
* protocol.
*
*/
protected class Handshake extends Exchange
{
public final static String __HANDSHAKE = "[{" + "\"channel\":\"/meta/handshake\"," + "\"version\":\"0.9\"," + "\"minimumVersion\":\"0.9\"" + "}]";
Handshake()
{
super("handshake");
setMessage(__HANDSHAKE);
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see
* org.mortbay.cometd.client.BayeuxClient.Exchange#onResponseComplete()
*/
protected void onResponseComplete() throws IOException
{
super.onResponseComplete();
if (!isRunning())
return;
if (getResponseStatus() == 200 && _responses != null && _responses.length > 0)
{
Message response = _responses[0];
Boolean successful = (Boolean)response.get(Bayeux.SUCCESSFUL_FIELD);
// Get advice if there is any
Map adviceField = (Map)response.get(Bayeux.ADVICE_FIELD);
if (adviceField != null)
_advice = new Advice(adviceField);
if (successful != null && successful.booleanValue())
{
metaHandshake(true,_handshook,response);
_handshook = true;
if (Log.isDebugEnabled())
Log.debug("Successful handshake, sending connect");
_clientId = (String)response.get(Bayeux.CLIENT_FIELD);
_pull = new Connect();
send(_pull,false);
}
else
{
metaHandshake(false,false,response);
_handshook = false;
if (_advice != null && _advice.isReconnectNone())
throw new IOException("Handshake failed with advice reconnect=none :" + _responses[0]);
else if (_advice != null && _advice.isReconnectHandshake())
{
_pull = new Handshake();
if (!send(_pull,true))
throw new IOException("Handshake, retries exhausted");
}
else
// assume retry = reconnect?
{
_pull = new Connect();
if (!send(_pull,true))
throw new IOException("Connect after handshake, retries exhausted");
}
}
}
else
{
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("status",new Integer(getResponseStatus()));
error.put("content",getResponseContent());
metaHandshake(false,false,error);
resend(true);
}
recycle();
}
/* ------------------------------------------------------------ */
protected void onExpire()
{
// super.onExpire();
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("failure","expired");
metaHandshake(false,false,error);
resend(true);
}
/* ------------------------------------------------------------ */
protected void onConnectionFailed(Throwable ex)
{
// super.onConnectionFailed(ex);
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("failure",ex.toString());
error.put("exception",ex);
metaHandshake(false,false,error);
resend(true);
}
/* ------------------------------------------------------------ */
protected void onException(Throwable ex)
{
// super.onException(ex);
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("failure",ex.toString());
error.put("exception",ex);
metaHandshake(false,false,error);
resend(true);
}
}
/* ------------------------------------------------------------ */
/**
* The Bayeux Connect exchange. Connect exchanges implement the long poll
* for Bayeux.
*/
protected class Connect extends Exchange
{
String _connectString;
Connect()
{
super("connect");
_connectString = "{" + "\"channel\":\"/meta/connect\"," + "\"clientId\":\"" + _clientId + "\"," + "\"connectionType\":\"long-polling\"" + "}";
setMessage(_connectString);
}
protected void onResponseComplete() throws IOException
{
super.onResponseComplete();
if (!isRunning())
return;
if (getResponseStatus() == 200 && _responses != null && _responses.length > 0)
{
try
{
startBatch();
for (int i = 0; i < _responses.length; i++)
{
Message msg = _responses[i];
// get advice if there is any
Map adviceField = (Map)msg.get(Bayeux.ADVICE_FIELD);
if (adviceField != null)
_advice = new Advice(adviceField);
if (Bayeux.META_CONNECT.equals(msg.get(Bayeux.CHANNEL_FIELD)))
{
Boolean successful = (Boolean)msg.get(Bayeux.SUCCESSFUL_FIELD);
if (successful != null && successful.booleanValue())
{
if (!isInitialized())
{
setInitialized(true);
synchronized (_outQ)
{
if (_outQ.size() > 0)
{
_push = new Publish();
send(_push);
}
}
}
// send a Connect (ie longpoll) possibly with
// delay according to interval advice
metaConnect(true,msg);
_pull = new Connect();
send(_pull,false);
}
else
{
// received a failure to our connect message,
// check the advice to see what to do:
// reconnect: none = hard error
// reconnect: handshake = send a handshake
// message
// reconnect: retry = send another connect,
// possibly using interval
setInitialized(false);
metaConnect(false,msg);
if (_advice != null && _advice.isReconnectNone())
throw new IOException("Connect failed, advice reconnect=none");
else if (_advice != null && _advice.isReconnectHandshake())
{
if (Log.isDebugEnabled())
Log.debug("connect received success=false, advice is to rehandshake");
_pull = new Handshake();
send(_pull,true);
}
else
// assume retry = reconnect
{
if (Log.isDebugEnabled())
Log.debug("Assuming retry=reconnect");
resend(true);
}
}
}
deliver(null,msg);
}
}
finally
{
endBatch();
}
}
else
{
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("status",getResponseStatus());
error.put("content",getResponseContent());
metaConnect(false,error);
resend(true);
}
recycle();
}
/* ------------------------------------------------------------ */
protected void onExpire()
{
// super.onExpire();
setInitialized(false);
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("failure","expired");
metaConnect(false,error);
resend(true);
}
/* ------------------------------------------------------------ */
protected void onConnectionFailed(Throwable ex)
{
// super.onConnectionFailed(ex);
setInitialized(false);
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("failure",ex.toString());
error.put("exception",ex);
metaConnect(false,error);
resend(true);
}
/* ------------------------------------------------------------ */
protected void onException(Throwable ex)
{
// super.onException(ex);
setInitialized(false);
Message error=_msgPool.newMessage();
error.put(Bayeux.SUCCESSFUL_FIELD,Boolean.FALSE);
error.put("failure",ex.toString());
error.put("exception",ex);
metaConnect(false,error);
resend(true);
}
}
/* ------------------------------------------------------------ */
/**
* Publish message exchange. Sends messages to bayeux server and handles any
* messages received as a result.
*/
protected class Publish extends Exchange
{
Publish()
{
super("publish");
synchronized (_outQ)
{
if (_outQ.size() == 0)
return;
setMessages(_outQ);
_outQ.clear();
}
}
protected Message[] getOutboundMessages()
{
try
{
return _msgPool.parse(_jsonOut);
}
catch (IOException e)
{
Log.warn("Error converting outbound messages");
if (Log.isDebugEnabled())
Log.debug(e);
return null;
}
}
/* ------------------------------------------------------------ */
/*
* (non-Javadoc)
*
* @see
* org.mortbay.cometd.client.BayeuxClient.Exchange#onResponseComplete()
*/
protected void onResponseComplete() throws IOException
{
if (!isRunning())
return;
super.onResponseComplete();
try
{
synchronized (_outQ)
{
startBatch();
_push = null;
}
if (getResponseStatus() == 200 && _responses != null && _responses.length > 0)
{
for (int i = 0; i < _responses.length; i++)
{
Message msg = _responses[i];
deliver(null,msg);
}
}
else
{
Log.warn("Publish, error=" + getResponseStatus());
}
}
finally
{
endBatch();
}
recycle();
}
/* ------------------------------------------------------------ */
protected void onExpire()
{
super.onExpire();
metaPublishFail(null,this.getOutboundMessages());
}
/* ------------------------------------------------------------ */
protected void onConnectionFailed(Throwable ex)
{
super.onConnectionFailed(ex);
metaPublishFail(ex,this.getOutboundMessages());
}
/* ------------------------------------------------------------ */
protected void onException(Throwable ex)
{
super.onException(ex);
metaPublishFail(ex,this.getOutboundMessages());
}
}
/* ------------------------------------------------------------ */
public void addListener(ClientListener listener)
{
synchronized (_inQ)
{
boolean added=false;
if (listener instanceof MessageListener)
{
added=true;
if (_mListeners == null)
_mListeners = new ArrayList<MessageListener>();
_mListeners.add((MessageListener)listener);
}
if (listener instanceof RemoveListener)
{
added=true;
if (_rListeners == null)
_rListeners = new ArrayList<RemoveListener>();
_rListeners.add((RemoveListener)listener);
}
if (!added)
throw new IllegalArgumentException();
}
}
/* ------------------------------------------------------------ */
public void removeListener(ClientListener listener)
{
synchronized (_inQ)
{
if (listener instanceof MessageListener)
{
if (_mListeners != null)
_mListeners.remove((MessageListener)listener);
}
if (listener instanceof RemoveListener)
{
if (_rListeners != null)
_rListeners.remove((RemoveListener)listener);
}
}
}
/* ------------------------------------------------------------ */
public int getMaxQueue()
{
return -1;
}
/* ------------------------------------------------------------ */
public Queue<Message> getQueue()
{
return _inQ;
}
/* ------------------------------------------------------------ */
public void setMaxQueue(int max)
{
if (max != -1)
throw new UnsupportedOperationException();
}
/* ------------------------------------------------------------ */
/**
* Send the exchange, possibly using a backoff.
*
* @param exchange
* @param backoff
* if true, use backoff algorithm to send
* @return
*/
protected boolean send(final Exchange exchange, final boolean backoff)
{
long interval = (_advice != null?_advice.getInterval():0);
if (backoff)
{
int retries = exchange.getBackoffRetries();
if (Log.isDebugEnabled())
Log.debug("Send with backoff, retries=" + retries + " for " + exchange);
if (retries >= _backoffMaxRetries)
return false;
exchange.incBackoffRetries();
interval += (retries * _backoffInterval);
}
if (interval > 0)
{
TimerTask task = new TimerTask()
{
public void run()
{
try
{
send(exchange);
}
catch (IOException e)
{
Log.warn("Delayed send, retry: ",e);
send(exchange,true);
}
}
};
if (Log.isDebugEnabled())
Log.debug("Delay " + interval + " send of " + exchange);
_timer.schedule(task,interval);
}
else
{
try
{
send(exchange);
}
catch (IOException e)
{
Log.warn("Send, retry on fail: ",e);
return send(exchange,true);
}
}
return true;
}
/* ------------------------------------------------------------ */
/**
* Send the exchange.
*
* @param exchange
* @throws IOException
*/
protected void send(HttpExchange exchange) throws IOException
{
exchange.reset(); // ensure at start state
customize(exchange);
if (Log.isDebugEnabled())
Log.debug("Send: using any connection=" + exchange);
_httpClient.send(exchange); // use any connection
}
/* ------------------------------------------------------------ */
/**
* False when we have received a success=false message in response to a
* Connect, or we have had an exception when sending or receiving a Connect.
*
* True when handshake and then connect has happened.
*
* @param b
*/
protected void setInitialized(boolean b)
{
_initialized = b;
}
/* ------------------------------------------------------------ */
protected boolean isInitialized()
{
return _initialized;
}
/* ------------------------------------------------------------ */
/**
* Called with the results of a /meta/connect message
* @param success connect was returned with this status
*/
protected void metaConnect(boolean success, Message message)
{
if (!success)
Log.warn(this.toString()+" "+message.toString());
}
/* ------------------------------------------------------------ */
/**
* Called with the results of a /meta/handshake message
* @param success connect was returned with this status
* @param reestablish the client was previously connected.
*/
protected void metaHandshake(boolean success, boolean reestablish, Message message)
{
if (!success)
Log.warn(this.toString()+" "+message.toString());
}
/* ------------------------------------------------------------ */
/**
* Called with the results of a failed publish
*/
protected void metaPublishFail(Throwable e, Message[] messages)
{
Log.warn(this.toString(),e);
}
/* ------------------------------------------------------------ */
/** Called to extend outbound string messages.
* Some messages are sent as preformatted JSON strings (eg handshake
* and connect messages). This extendOut method is a variation of the
* {@link #extendOut(Message)} method to efficiently cater for these
* preformatted strings.
* <p>
* This method calls the {@link Extension}s added by {@link #addExtension(Extension)}
*
* @param msg
* @return the extended message
*/
protected String extendOut(String msg)
{
if (_extensions==null)
return msg;
try
{
Message[] messages = _msgPool.parse(msg);
for (int i=0; i<messages.length; i++)
extendOut(messages[i]);
if (messages.length==1 && msg.charAt(0)=='{')
return _msgPool.getMsgJSON().toJSON(messages[0]);
return _msgPool.getMsgJSON().toJSON(messages);
}
catch(IOException e)
{
Log.warn(e);
return msg;
}
}
/* ------------------------------------------------------------ */
/** Called to extend outbound messages
* <p>
* This method calls the {@link Extension}s added by {@link #addExtension(Extension)}
*
*/
protected void extendOut(Message message)
{
if (_extensions!=null)
{
Message m = message;
if (m.getChannel().startsWith(Bayeux.META_SLASH))
for (int i=0;m!=null && i<_extensions.length;i++)
m=_extensions[i].sendMeta(this,m);
else
for (int i=0;m!=null && i<_extensions.length;i++)
m=_extensions[i].send(this,m);
if (message!=m)
{
message.clear();
if (m!=null)
for (Map.Entry<String,Object> entry:m.entrySet())
message.put(entry.getKey(),entry.getValue());
}
}
}
/* ------------------------------------------------------------ */
/** Called to extend inbound messages
* <p>
* This method calls the {@link Extension}s added by {@link #addExtension(Extension)}
*
*/
protected void extendIn(Message message)
{
if (_extensions!=null)
{
Message m = message;
if (m.getChannel().startsWith(Bayeux.META_SLASH))
for (int i=_extensions.length;m!=null && i-->0;)
m=_extensions[i].rcvMeta(this,m);
else
for (int i=_extensions.length;m!=null && i-->0;)
m=_extensions[i].rcv(this,m);
if (message!=m)
{
message.clear();
if (m!=null)
for (Map.Entry<String,Object> entry:m.entrySet())
message.put(entry.getKey(),entry.getValue());
}
}
}
}