@Override
public void run(Timeout timeout) throws Exception {
if (timeout.isCancelled()) {
return;
}
if (!ctx.getChannel().isOpen()) {
return;
}
State state = (State) ctx.getAttachment();
long currentTime = System.currentTimeMillis();
long nextDelay = timeoutMillis - (currentTime - state.lastReadTime);
if (nextDelay <= 0) {
// Read timed out - set a new timeout and notify the callback.
state.timeout = timer.newTimeout(this, timeoutMillis, TimeUnit.MILLISECONDS);
try {
// FIXME This should be called from an I/O thread.
// To be fixed in Netty 4.
readTimedOut(ctx);
} catch (Throwable t) {
fireExceptionCaught(ctx, t);
}
} else {
// Read occurred before the timeout - set a new timeout with shorter delay.
state.timeout = timer.newTimeout(this, nextDelay, TimeUnit.MILLISECONDS);
}
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
if (LOG.isTraceEnabled()) {
LOG.trace("Channel closed: {}", ctx.getChannel());
}
Exchange exchange = getExchange(ctx);
AsyncCallback callback = getAsyncCallback(ctx);
// remove state
producer.removeState(ctx.getChannel());
// to keep track of open sockets
producer.getAllChannels().remove(ctx.getChannel());
if (producer.getConfiguration().isSync() && !messageReceived && !exceptionHandled) {
// To avoid call the callback.done twice
exceptionHandled = true;
// session was closed but no message received. This could be because the remote server had an
// internal error
// and could not return a response. We should count down to stop waiting for a response
if (LOG.isDebugEnabled()) {
LOG.debug(
"Channel closed but no message received from address: {}",
producer.getConfiguration().getAddress());
}
exchange.setException(
new CamelExchangeException(
"No response received from remote server: "
+ producer.getConfiguration().getAddress(),
exchange));
// signal callback
callback.done(false);
}
}
@Override
public void incomingMessage(ChannelHandlerContext ctx, MessageEvent event) throws Exception {
if (event.getMessage() instanceof MappingHttpRequest) {
MappingHttpRequest httpRequest = (MappingHttpRequest) event.getMessage();
if (httpRequest.getMessage() instanceof WalrusRequestType) {
WalrusRequestType request = (WalrusRequestType) httpRequest.getMessage();
BucketLogData logData = request.getLogData();
if (logData != null) {
long currentTime = System.currentTimeMillis();
logData.setTotalTime(currentTime);
logData.setTurnAroundTime(currentTime);
logData.setUri(httpRequest.getUri());
String referrer = httpRequest.getHeader(HttpHeaders.Names.REFERER);
if (referrer != null) logData.setReferrer(referrer);
String userAgent = httpRequest.getHeader(HttpHeaders.Names.USER_AGENT);
if (userAgent != null) logData.setUserAgent(userAgent);
logData.setTimestamp(
String.format("[%1$td/%1$tb/%1$tY:%1$tH:%1$tM:%1$tS %1$tz]", Calendar.getInstance()));
User user = Contexts.lookup(httpRequest.getCorrelationId()).getUser();
if (user != null) logData.setAccessorId(user.getUserId());
if (request.getBucket() != null) logData.setBucketName(request.getBucket());
if (request.getKey() != null) logData.setKey(request.getKey());
if (ctx.getChannel().getRemoteAddress() instanceof InetSocketAddress) {
InetSocketAddress sockAddress = (InetSocketAddress) ctx.getChannel().getRemoteAddress();
logData.setSourceAddress(sockAddress.getAddress().getHostAddress());
}
}
}
}
}
/**
* Starts an SSL / TLS handshake for the specified channel.
*
* @return a {@link ChannelFuture} which is notified when the handshake succeeds or fails.
*/
public ChannelFuture handshake() {
if (handshaken && !isEnableRenegotiation()) {
throw new IllegalStateException("renegotiation disabled");
}
ChannelHandlerContext ctx = this.ctx;
Channel channel = ctx.getChannel();
ChannelFuture handshakeFuture;
synchronized (handshakeLock) {
if (handshaking) {
return this.handshakeFuture;
} else {
handshaking = true;
try {
engine.beginHandshake();
runDelegatedTasks();
handshakeFuture = this.handshakeFuture = future(channel);
} catch (SSLException e) {
handshakeFuture = this.handshakeFuture = failedFuture(channel, e);
}
}
}
try {
wrapNonAppData(ctx, channel);
} catch (SSLException e) {
handshakeFuture.setFailure(e);
}
return handshakeFuture;
}
protected void increaseCounter(Runnable task) {
if (!shouldCount(task)) {
return;
}
Settings settings = this.settings;
long maxChannelMemorySize = settings.maxChannelMemorySize;
int increment = settings.objectSizeEstimator.estimateSize(task);
if (task instanceof ChannelEventRunnable) {
ChannelEventRunnable eventTask = (ChannelEventRunnable) task;
eventTask.estimatedSize = increment;
Channel channel = eventTask.getEvent().getChannel();
long channelCounter = getChannelCounter(channel).addAndGet(increment);
// System.out.println("IC: " + channelCounter + ", " + increment);
if (maxChannelMemorySize != 0 && channelCounter >= maxChannelMemorySize && channel.isOpen()) {
if (channel.isReadable()) {
// System.out.println("UNREADABLE");
ChannelHandlerContext ctx = eventTask.getContext();
if (ctx.getHandler() instanceof ExecutionHandler) {
// readSuspended = true;
ctx.setAttachment(Boolean.TRUE);
}
channel.setReadable(false);
}
}
} else {
((MemoryAwareRunnable) task).estimatedSize = increment;
}
if (totalLimiter != null) {
totalLimiter.increase(increment);
}
}
private boolean handleRevision1Response(ChannelHandlerContext ctx, int payloadLength)
throws Exception {
int code = buffered.readInt();
int descriptionLength = buffered.readInt();
byte[] descBytes = new byte[descriptionLength];
buffered.readBytes(descBytes, 0, descBytes.length);
String description = new String(descBytes, StandardCharsets.UTF_8);
logger.debug(
"Decoded payload with length:[{}], code:[{}], descriptionLength:[{}], description:[{}] on connection [{}]",
payloadLength,
code,
descriptionLength,
description,
ctx.getChannel().getLocalAddress());
if (200 <= code && code <= 299) {
logger.info(
"Connected to Found Elasticsearch: [{}]: [{}] on connection [{}]",
code,
description,
ctx.getChannel().getLocalAddress());
return true;
} else {
logger.error(
"Unable to connect to Found Elasticsearch: [{}]: [{}] on connection [{}]",
code,
description,
ctx.getChannel().getLocalAddress());
return false;
}
}
@Override
@SuppressWarnings("unchecked")
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
S serverChannel = (S) ctx.getAttachment();
T childChannel = createChildChannel(serverChannel, e.getChannel());
fireChannelOpen(childChannel);
ChannelAddress localAddress = serverChannel.getLocalAddress();
childChannel.setLocalAddress(localAddress);
childChannel.setBound();
fireChannelBound(childChannel, localAddress);
ctx.setAttachment(childChannel);
ctx.sendUpstream(e);
// TODO: fire CONNECTED_BARRIER event to next pipeline
// then fire CONNECTED event when future completes successfully
ChannelAddress remoteAddress = localAddress.newEphemeralAddress();
childChannel.setRemoteAddress(remoteAddress);
childChannel.setConnected();
fireChannelConnected(childChannel, remoteAddress);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
getLogger(ctx.getChannel()).debug("Error while processing imap request", e.getCause());
if (e.getCause() instanceof TooLongFrameException) {
// Max line length exceeded
// See RFC 2683 section 3.2.1
//
// "For its part, a server should allow for a command line of at
// least
// 8000 octets. This provides plenty of leeway for accepting
// reasonable
// length commands from clients. The server should send a BAD
// response
// to a command that does not end within the server's maximum
// accepted
// command length."
//
// See also JAMES-1190
ImapResponseComposer composer = (ImapResponseComposer) ctx.getAttachment();
composer.untaggedResponse(
ImapConstants.BAD + " failed. Maximum command line length exceeded");
} else {
// logout on error not sure if that is the best way to handle it
final ImapSession imapSession = (ImapSession) attributes.get(ctx.getChannel());
if (imapSession != null) imapSession.logout();
// Make sure we close the channel after all the buffers were flushed out
Channel channel = ctx.getChannel();
if (channel.isConnected()) {
channel.write(ChannelBuffers.EMPTY_BUFFER).addListener(ChannelFutureListener.CLOSE);
}
}
}
private void cleanup(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
try {
ChannelBuffer cumulation = this.cumulation;
if (cumulation == null) {
return;
} else {
this.cumulation = null;
}
if (cumulation.readable()) {
// Make sure all frames are read before notifying a closed
// channel.
callDecode(ctx, ctx.getChannel(), cumulation, null);
}
// Call decodeLast() finally. Please note that decodeLast() is
// called even if there's nothing more to read from the buffer to
// notify a user that the connection was closed explicitly.
Object partialFrame = decodeLast(ctx, ctx.getChannel(), cumulation);
if (partialFrame != null) {
Channels.fireMessageReceived(ctx, partialFrame, null);
}
} finally {
ctx.sendUpstream(e);
}
}
/**
* Detects if we're connecting to a Found Elasticsearch cluster (using pre-configured host
* suffixes) and adds a SSL handler at the beginning of the pipeline if we're connecting to a
* SSL-endpoint (using a list of pre-configured ports).
*/
@Override
public void connectRequested(final ChannelHandlerContext ctx, final ChannelStateEvent e)
throws Exception {
if (e.getValue() instanceof InetSocketAddress) {
InetSocketAddress inetSocketAddress = (InetSocketAddress) e.getValue();
for (String suffix : hostSuffixes) {
isFoundCluster = isFoundCluster || inetSocketAddress.getHostString().endsWith(suffix);
}
if (isFoundCluster) {
for (int sslPort : sslPorts) {
if (inetSocketAddress.getPort() == sslPort) {
logger.debug(
"Enabling SSL on transport layer with unsafeAllowSelfSigned=[{}].",
unsafeAllowSelfSigned);
FoundSSLHandler handler =
FoundSSLUtils.getSSLHandler(unsafeAllowSelfSigned, inetSocketAddress);
ctx.getPipeline().addFirst("ssl", handler);
break;
}
}
} else {
ctx.getPipeline().remove(this);
}
}
super.connectRequested(ctx, e);
}
@Override
public void handleUpstream(final ChannelHandlerContext ctx, final ChannelEvent e)
throws Exception {
final MappingHttpRequest request = MappingHttpMessage.extractMessage(e);
final BaseMessage msg = BaseMessage.extractMessage(e);
if (msg != null) {
try {
final Class<? extends ComponentId> compClass = ComponentMessages.lookup(msg);
ComponentId compId = ComponentIds.lookup(compClass);
if (compId.isAlwaysLocal() || Topology.isEnabledLocally(compClass)) {
ctx.sendUpstream(e);
} else {
Handlers.sendRedirect(ctx, e, compClass, request);
}
} catch (final NoSuchElementException ex) {
LOG.warn(
"Failed to find reverse component mapping for message type: " + msg.getClass());
ctx.sendUpstream(e);
} catch (final Exception ex) {
Logs.extreme().error(ex, ex);
ctx.sendUpstream(e);
}
} else {
ctx.sendUpstream(e);
}
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
throws Exception {
Session session = new Session(ctx.getChannel());
netHandler.onConnected(session);
ctx.setAttachment(session);
}
@Override
protected Object decode(
ChannelHandlerContext context, Channel channel, ChannelBuffer buffer, VoidEnum state)
throws Exception {
int opcode = buffer.readUnsignedByte();
MessageCodec<?> codec = CodecLookupService.find(opcode);
if (codec == null) {
OpenClassic.getLogger()
.warning(
"Invalid packet ID "
+ opcode
+ "! (previous ID = "
+ this.previousOpcode
+ ") Disconnecting user...");
if (context.getAttachment() instanceof ServerSession) {
((ServerSession) context.getAttachment()).disconnect("Invalid packet ID " + opcode + "!");
} else {
channel.disconnect();
}
return null;
}
this.previousOpcode = opcode;
return codec.decode(buffer);
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent event) throws Exception {
if (event.getMessage() instanceof MappingHttpRequest) {
MappingHttpRequest httpRequest = (MappingHttpRequest) event.getMessage();
if (httpRequest.getMessage() instanceof ObjectStorageDataRequestType) {
if (httpRequest.isChunked()) {
// Chunked request, and beginning, setup map etc.
initializeNewPut(ctx, (ObjectStorageDataRequestType) httpRequest.getMessage());
}
}
} else if (event.getMessage() instanceof HttpChunk) {
// Add the chunk to the current streams channel buffer.
HttpChunk chunk = (HttpChunk) event.getMessage();
appendChunk(chunk.getContent(), ctx.getChannel());
if (chunk.isLast()) {
// Remove from the map
Logs.extreme()
.debug(
"Removing data map due to last chunk processed event for channel: "
+ ctx.getChannel().getId());
dataMap.remove(ctx.getChannel());
}
}
// Always pass it on
ctx.sendUpstream(event);
}
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
context.getWorkers().put(ctx.getChannel(), new MasterWorkerHolder(ctx.getChannel()));
Channel channel = ctx.getChannel();
SocketAddress addr = channel.getRemoteAddress();
SocketLog.info("worker connected , :" + addr.toString());
super.channelConnected(ctx, e);
}
@Override
public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
super.channelDisconnected(ctx, e);
if (!ctx.getChannel().isConnected()) {
tryToFinishOffChannel(ctx.getChannel());
}
}
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
logger.error(
"something goes wrong with channel:{}, exception={}",
ctx.getChannel(),
ExceptionUtils.getStackTrace(e.getCause()));
ctx.getChannel().close();
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent me) throws Exception {
if (!(me.getMessage() instanceof HttpRequest)) {
ctx.sendUpstream(me);
return;
}
HttpRequest request = (HttpRequest) me.getMessage();
Object response;
// Look up resource
String path = request.getUri();
String host = request.getHeader("host");
log.debug("Received request for path:" + path);
boolean showHtml = false;
if (path.endsWith("?html")) {
showHtml = true;
path = path.replace("?html", "");
}
for (String service : resources.keySet()) {
log.debug("Available Service: " + service);
}
Model model = resources.get(path);
if (model != null) {
if (request.getMethod() == HttpMethod.GET) {
if (showHtml) {
String html = HtmlCreator.createModelPage(model, new URI(path), host);
response = ChannelBuffers.wrappedBuffer(html.getBytes(Charset.forName("UTF-8")));
log.debug("Returned html page for resource: " + path);
} else {
response = new SelfDescription(model, new URI(request.getUri()));
log.debug("Resource found: " + path);
}
} else {
response =
new DefaultHttpResponse(
request.getProtocolVersion(), HttpResponseStatus.METHOD_NOT_ALLOWED);
log.debug("Method not allowed: " + request.getMethod());
}
} else {
response =
HttpResponseFactory.createHttpResponse(
request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND);
log.debug("Resource not found: " + path);
}
// Send response
ChannelFuture future = Channels.write(ctx.getChannel(), response);
future.addListener(ChannelFutureListener.CLOSE);
}
@Override
public void channelBound(final ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
ImapSession imapsession =
new NettyImapSession(
ctx.getChannel(), logger, context, enabledCipherSuites, compress, plainAuthDisallowed);
attributes.set(ctx.getChannel(), imapsession);
super.channelBound(ctx, e);
}
@BeforeMethod
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
handler = new SyslogTCPFramingRouterHandler(2048, Delimiters.lineDelimiter());
when(context.getPipeline()).thenReturn(pipeline);
when(context.getName()).thenReturn("current");
}
private void receivedConnect(NetData.JoinMessage message) {
logger.info("Received Start Join");
NetClient client = new NetClient(channelHandlerContext.getChannel(), networkSystem, identity);
client.setPreferredName(message.getName());
client.setColor(new Color(message.getColor().getRgba()));
client.setViewDistanceMode(ViewDistance.forIndex(message.getViewDistanceLevel()));
channelHandlerContext.getPipeline().remove(this);
serverHandler.connectionComplete(client);
}
private void handleInitialize(ChannelHandlerContext ctx, MappingHttpRequest request)
throws IOException, SocketException {
InetSocketAddress addr = (InetSocketAddress) ctx.getChannel().getRemoteAddress();
LOG.info(LogUtil.subheader("Using " + addr.getHostName() + " as the database address."));
Component.db.setHostAddress(addr.getHostName());
Component.db.markEnabled();
Component.dns.setHostAddress(addr.getHostName());
Component.eucalyptus.setHostAddress(addr.getHostName());
Component.cluster.setHostAddress(addr.getHostName());
Component.jetty.setHostAddress(addr.getHostName());
HeartbeatType msg = (HeartbeatType) request.getMessage();
LOG.info(LogUtil.header("Got heartbeat event: " + LogUtil.dumpObject(msg)));
for (HeartbeatComponentType component : msg.getComponents()) {
LOG.info(LogUtil.subheader("Registering local component: " + LogUtil.dumpObject(component)));
System.setProperty("euca." + component.getComponent() + ".name", component.getName());
Component.valueOf(component.getComponent()).markLocal();
// FIXME: this is needed because we can't dynamically change the mule config, so we need to
// disable at init time and hup when a new component is loaded.
initializedComponents.add(component.getComponent());
}
// FIXME: this is needed because we can't dynamically change the mule config, so we need to
// disable at init time and hup when a new component is loaded.
if (!initializedComponents.contains(Component.storage.name())) {
Component.storage.markDisabled();
}
// FIXME: this is needed because we can't dynamically change the mule config, so we need to
// disable at init time and hup when a new component is loaded.
if (!initializedComponents.contains(Component.walrus.name())) {
Component.walrus.markDisabled();
}
System.setProperty("euca.db.password", Hashes.getHexSignature());
System.setProperty("euca.db.url", Component.db.getUri().toASCIIString());
boolean foundDb = false;
try {
foundDb = NetworkUtil.testReachability(addr.getHostName());
LOG.debug("Initializing SSL just in case: " + SslSetup.class);
foundDb = true;
} catch (Throwable e) {
foundDb = false;
}
if (foundDb) {
HttpResponse response =
new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.OK);
ChannelFuture writeFuture = ctx.getChannel().write(response);
writeFuture.addListener(ChannelFutureListener.CLOSE);
initialized = true;
if (this.channel != null) {
this.channel.close();
}
} else {
HttpResponse response =
new DefaultHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NOT_ACCEPTABLE);
ChannelFuture writeFuture = ctx.getChannel().write(response);
writeFuture.addListener(ChannelFutureListener.CLOSE);
}
}
/** Invoked when a connection is closed */
@Override
public final void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) {
GameSession session = (GameSession) ctx.getAttachment();
if (session != null) {
synchronized (LogicService.getWorkerThread()) {
World.getSingleton().unregisterPlayer(session.getPlayer());
}
}
ctx.getChannel().close();
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
super.channelClosed(ctx, e);
if (!ctx.getChannel().isOpen()) {
tryToFinishOffChannel(ctx.getChannel());
}
channelGroup.remove(e.getChannel());
}
/* (non-Javadoc)
* @see org.jboss.netty.channel.ChannelFutureListener#operationComplete(org.jboss.netty.channel.ChannelFuture)
*/
@Override
public void operationComplete(ChannelFuture future) throws Exception {
if (upstreamContext != null && bgpEvent != null) {
upstreamContext.sendUpstream(
new UpstreamMessageEvent(
upstreamContext.getChannel(),
bgpEvent,
upstreamContext.getChannel().getRemoteAddress()));
}
}
/**
* Sends an SSL {@code close_notify} message to the specified channel and destroys the underlying
* {@link SSLEngine}.
*/
public ChannelFuture close() {
ChannelHandlerContext ctx = this.ctx;
Channel channel = ctx.getChannel();
try {
engine.closeOutbound();
return wrapNonAppData(ctx, channel);
} catch (SSLException e) {
return failedFuture(channel, e);
}
}
@Override
public void channelOpen(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
// add bind handler to pipeline
String baseName = ctx.getName();
String name = format("%s:socket", baseName);
ctx.getPipeline().addAfter(baseName, name, bindHandler);
// propagate channel open event
super.channelOpen(ctx, e);
}
@Override
public void handleUpstream(final ChannelHandlerContext ctx, final ChannelEvent e)
throws Exception {
if (!Bootstrap.isFinished()) {
// TODO:GRZE: do nothing for the moment, not envouh info here.
// throw new ServiceNotReadyException( "System has not yet completed booting." );
ctx.sendUpstream(e);
} else {
ctx.sendUpstream(e);
}
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
ChannelBuffer buffer = (ChannelBuffer) e.getMessage();
Route route = app.getRouter().parseRoute(getUtf(buffer));
byte[] data = new byte[buffer.readableBytes()];
buffer.readBytes(data);
LocalSession localSession = sessions.getSession(ctx.getChannel().getId()).getLocalSession();
byte[] response = server.handle(route, localSession, data);
if (response != null) {
ctx.getChannel().write(response);
}
}
@Override
public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent ce) throws Exception {
if (!(ce instanceof MessageEvent)) {
ctx.sendUpstream(ce);
return;
}
MessageEvent e = (MessageEvent) ce;
RedisConnection conn = (RedisConnection) e.getChannel().getAttachment();
ChannelBuffer cb = (ChannelBuffer) e.getMessage();
conn.replyFromBackend(cb.copy());
ctx.sendUpstream(ce);
}
