Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* ************************************************************************
  #
  #  DivConq
  #
  #  http://divconq.com/
  #
  #  Copyright:
  #    Copyright 2014 eTimeline, LLC. All rights reserved.
  #
 #  License:
 #    See the license.txt file in the project's top-level directory for details.
 #
 #  Authors:
 #    * Andy White
 #
 ************************************************************************ */
 package divconq.ctp.net;
 
 
 
 public class CtpHandler extends ChannelInboundHandlerAdapter implements ICtpChannel {
 	protected CtpAdapter adapter = null;
 	protected ChannelHandlerContext chan = null;
 	protected boolean serverMode = true;
 	
 	protected ByteBuf remnant = null;
 	protected boolean readRequested = true;		// initially expects a read
 	protected ReentrantLock readLock = new ReentrantLock();
 	
 	public CtpHandler(CtpAdapter tunnelboolean serverMode) {
 		this. = tunnel;
 		this. = serverMode;
 	}
 
 	public void debug(String msg) {
 		..println("Ctp " + (this. ? "Server" : "Client") + " - " + msg);
 	}
 	
 	public void channelInactive(ChannelHandlerContext ctxthrows Exception {
 		this..close();
 	}
 	
     @Override
     public void handlerAdded(ChannelHandlerContext ctx) {
 		this.debug("Handler added");		
 		this. = ctx;
     	this..setChannel(this);
     }
     
 	public void read() {
 		this..lock();
 		
 		if ()
 			..println("Start Server requested read!");
 		
 		this. = false;		// meaning read is covered until further notice
 		
 		try {
 			ByteBuf rem = this.;
 			
         	//CtpHandler.this.debug("checking remnant: " + rem);
 
 			// if there are any unread bytes from the last read, check to see if we can collect a command
 	        if (rem != null) {
 	        	//CtpHandler.this.debug("checking bytes: " + rem.readableBytes());
 				
 	        	//System.out.println("Remnant ref cnt 1: " + rem.refCnt() + " for server: " + CtpHandler.this.serverMode);
 	        	
 				boolean ready = false;
 				
 				try {
 					ready = this..decode(rem);
 				} 
 				catch (Exception x) {
 					// TODO error and close!!
 					..println("Error decoding message: " + x);
 					return;
 				}
 				
 	        	//System.out.println("Remnant ref cnt 2: " + rem.refCnt());
 				
 				// if there are any unread bytes here we need to store them and combine with the next read
 				if (!rem.isReadable()) {
 					this. = null;		
 					rem.release();
 				}
	        	//System.out.println("Remnant ref cnt 3: " + rem.refCnt());
				if (!ready) {
					this. = true;
					this..read();
				}
				else
	        }
			else {
				this. = true;
				this..read();
			}
	        
				..println("End Server requested read!");
		}
		finally {
		}
	}
	public void send(ByteBuf bufChannelFutureListener listener) {
		try {
			if (this. != null) {
				ChannelFuture future = this..writeAndFlush(buf);
				if (listener != null)
					future.addListener(listener);
			}
		}
		catch (Exception x) {
			Logger.error("Error writing Ctp buffer: " + x);
			this.close();
		}
	}
	public void close() {
		try {
			if (this. != null)
				this..close().await(2000);
		catch (InterruptedException x) {
			// ignore 
		}
		finally {
			this. = null;
		}
	}
    
	public void channelRead(ChannelHandlerContext ctxObject msgthrows Exception {
		try {
			ByteBuf buf = (ByteBufmsg;
				..println("Server got network read 1: " + buf.readableBytes());
			ByteBuf rem = this.;
			// if there are any unread bytes from the last read, combine with this read 
			this. = buf;
			// TODO there are maybe better ways to do this - a queue of buffers?
			if (rem != null) {
				if (rem.isReadable())  {			
					buf.release();
				}
				rem.release();
			}
				..println("Server got network read 2: " + this..readableBytes());
			if (!this.)
				return;
			if (this..readableBytes() > 256 * 1024)
				..println("CTP Buffer getting too large - possible issue!!!! " + this..readableBytes());
			// read with the updated buffer
			this.read();
		}
		finally {
		}
	}
	public void channelReadComplete(ChannelHandlerContext ctxthrows Exception {
        //ctx.flush();
		//System.out.println("read complete");
		//this.debug("Read Complete");
	}
    @Override
    public void exceptionCaught(ChannelHandlerContext ctxThrowable cause) {
    	this.debug("Exception");
        cause.printStackTrace();
        ctx.close();
    }
    
    @Override
    public void userEventTriggered(ChannelHandlerContext ctxObject evt)
    		throws Exception {
    	
    	// on success the request first read
    	if (evt == .) {
        	// make sure auto read is off
    		ctx.channel().config().setAutoRead(false);
    		
    		this.debug("SSL passed");
    		// do initial read, this is fine - just be sure streaming will work by not always reading
    		ctx.read();
    	}
    }
New to GrepCode? Check out our FAQ X