I'm trying to send a file, a client requested from the server, from the server to the client.
The Client specefies the file in the FileRequestProtocol, sends it to the server, the server adds the file size to file FileRequestProtocol and returns it to the client.
The client adds a new FileChunkReqWriteHandler with the correct file size to its pipeline.
The server creates a new ChunkedFileServerHandler with the context and the desired file and tries to send it, but the FileChunkReqWriteHandler never reads byte from the channel.
What am I doing wrong here?
Log
INFO ProtocolHeadHandler:48 - Client send ProtocolHead [version=1, jobType=FILEREQUEST]
INFO ProtocolHeadServerHandler:36 - Server receive ProtocolHead [version=1, jobType=FILEREQUEST]
INFO ProtocolHeadHandler:57 - Client ProtocolHead equals, Send Protocol FileRequestProtocol [filePath=test.jpg, fileSize=0]
INFO FileRequestServerHandler:42 - Server new FileRequest FileRequestProtocol [filePath=test.jpg, fileSize=0]
INFO FileRequestHandler:41 - Client receives FileRequestProtocol [filePath=test.jpg, fileSize=174878]
INFO ChunkedFileServerHandler:39 - New ChunkedFileServerHandler
INFO FileChunkReqWriteHandler:20 - New ChunkedFile Handler FileRequestProtocol [filePath=test.jpg, fileSize=174878]
Client
FileRequestHandler.java
public class FileRequestHandler extends
SimpleChannelInboundHandler<FileRequestProtocol> {
private Logger logger = Logger.getLogger(this.getClass());
public FileRequestHandler() {
}
@Override
public void channelRead0(ChannelHandlerContext ctx, FileRequestProtocol msg) {
logger.info("Client receives " + msg);
ReferenceCountUtil.release(msg);
ctx.channel().pipeline().addLast(new FileChunkReqWriteHandler(msg));
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) {
logger.info("Client read complete");
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
ctx.close();
}
}
FileChunkReqWriteHandler.java
public class FileChunkReqWriteHandler extends SimpleChannelInboundHandler<ChunkedFile> {
FileRequestProtocol fileRequestProtocol;
private Logger logger = Logger.getLogger(this.getClass());
public FileChunkReqWriteHandler(FileRequestProtocol msg) {
this.fileRequestProtocol = msg;
logger.info("New ChunkedFile Handler " + msg);
}
@Override
public void channelActive(ChannelHandlerContext ctx) {
logger.info("in channel active method");
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
if (ctx.channel().isActive()) {
ctx.writeAndFlush("ERR: " +
cause.getClass().getSimpleName() + ": " +
cause.getMessage() + '
').addListener(ChannelFutureListener.CLOSE);
}
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, ChunkedFile msg)
throws Exception {
logger.info("in channelRead0");
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
logger.info("channelRead");
ByteBuf buf = (ByteBuf) msg;
byte[] bytes = new byte[buf.readableBytes()];
buf.readBytes(bytes);
if(buf.readableBytes() >= this.fileRequestProtocol.getFileSize())
{
logger.info("received all data");
}
}
}
Server
FileRequestServerHandler.java
public class FileRequestServerHandler extends
SimpleChannelInboundHandler<FileRequestProtocol> {
private File f;
private Logger logger = Logger.getLogger(this.getClass());
@Override
public void channelRead0(ChannelHandlerContext ctx, FileRequestProtocol fileRequest) {
logger.info("Server new FileRequest " + fileRequest);
f = new File(fileRequest.getFilePath());
fileRequest.setFileSize(f.length());
ctx.writeAndFlush(fileRequest);
new ChunkedFileServerHandler(ctx,f);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) {
logger.info("Server read complete");
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
ctx.close();
}
}
ChunkedFileServerHandler.java
public class ChunkedFileServerHandler extends ChunkedWriteHandler {
private Logger logger = Logger.getLogger(this.getClass());
private File file;
public ChunkedFileServerHandler(ChannelHandlerContext ctx, File file) {
this.file = file;
logger.info("New ChunkedFileServerHandler");
ChunkedFile chunkedFile;
try {
chunkedFile = new ChunkedFile(this.file);
ctx.writeAndFlush(chunkedFile);
ctx.close();
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
super.channelActive(ctx);
logger.info("FILE WRITE GETS ACTIVE");
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
ctx.close();
}
}
Update
public class ServerInitializer extends ChannelInitializer<SocketChannel> {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline p = ch.pipeline();
p.addLast("encoder", new ObjectEncoder());
p.addLast("decoder",
new ObjectDecoder(ClassResolvers.cacheDisabled(null)));
p.addLast("protocolhead", new ProtocolHeadServerHandler());
p.addLast("filerequestserverhandler", new FileRequestServerHandler());
p.addLast("chunkedfileserver", new ChunkedFileServerHandler());
}
}
Server StartUp
public void startUp()
{
bossGroup = new NioEventLoopGroup(1);
workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ServerInitializer());
// Bind and start to accept incoming connections.
b.bind(this.port).sync().channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
