uidserver.UIDServerHandler.java Source code

Introduction

Here is the source code for uidserver.UIDServerHandler.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package uidserver;

/**
 *
 * @author ghfan
 */

/*
 * Copyright 2012 The Netty Project
 *
 * The Netty Project licenses this file to you 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.
 */
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.ssl.SslHandler;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.GlobalEventExecutor;
import java.io.File;
import java.io.IOException;

import java.net.InetAddress;
import java.nio.file.Files;
import java.nio.file.StandardOpenOption;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Handles a server-side channel.
 */
public class UIDServerHandler extends SimpleChannelInboundHandler<String> {

    static final ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    File logFile = null;

    @Override
    public void channelActive(final ChannelHandlerContext ctx) {
        // Once session is secured, send a greeting and register the channel to the global channel
        // list so the channel received the messages from others.
        ctx.pipeline().get(SslHandler.class).handshakeFuture()
                .addListener(new GenericFutureListener<Future<Channel>>() {
                    @Override
                    public void operationComplete(Future<Channel> future) throws Exception {
                        ctx.writeAndFlush("Welcome to " + InetAddress.getLocalHost().getHostName()
                                + " for unit id service!\n");
                        ctx.writeAndFlush("Your session is protected by "
                                + ctx.pipeline().get(SslHandler.class).engine().getSession().getCipherSuite()
                                + " cipher suite.\n");

                        channels.add(ctx.channel());
                        System.out.println("New Client " + ctx.channel().remoteAddress().toString() + " connected");
                        if (logFile != null) {
                            System.out.println("file already existing");
                        } else {
                            String remoteAdd = ctx.channel().remoteAddress().toString();
                            remoteAdd = remoteAdd.replace(':', '_');
                            remoteAdd = remoteAdd.replace('.', '_');
                            remoteAdd = remoteAdd.substring(1, remoteAdd.length());

                            logFile = new File(Config.logPath.getAbsolutePath() + "/" + remoteAdd + "/"
                                    + LocalDateTime.now().format(DateTimeFormatter.ofPattern("uuuuMMddhhmmss"))
                                    + ".log");
                            //                            System.out.println("Create log file: " + logFile.getAbsolutePath());

                            if (!logFile.exists()) {
                                try {
                                    if (!logFile.getParentFile().exists()) {
                                        logFile.getParentFile().mkdirs();
                                    }
                                    if (!logFile.createNewFile()) {
                                        logFile = null;
                                        System.out
                                                .println("Failed to create log file: " + logFile.getAbsolutePath());
                                    } else {
                                        System.out.println(
                                                "Succesfully to create log file: " + logFile.getAbsolutePath());
                                    }
                                } catch (Exception e) {
                                    e.printStackTrace();
                                    logFile = null;
                                }
                            }
                        }
                    }
                });
    }

    @Override
    public void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        // Send the received message to all channels but the current one.
        //        for (Channel c: channels) {
        //            if (c != ctx.channel()) {
        //                c.writeAndFlush("[" + ctx.channel().remoteAddress() + "] " + msg + '\n');
        //            } else {
        //                c.writeAndFlush("[you] " + msg + '\n');
        //            }
        //        }
        String content = "";
        if ("bye".equals(msg.toLowerCase())) {
            logFile = null;
            ctx.close();
            System.out.println("Client connection closed: ");
            content = "Client Msg|" + msg + "\n";
            content += "Connection closed";

        } else {
            String unitID = UIDGenerator.selectNext();
            String localTime = LocalDateTime.now().toString();
            ctx.writeAndFlush(unitID + '\n');
            content = "Time|" + localTime + "|Client Msg|" + msg + "|UID|" + unitID;
        }
        content += "\n";
        writeLog(content);

    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();
        logFile = null;
        ctx.close();
    }

    public void writeLog(String content) {
        if (logFile != null && logFile.exists()) {
            try {
                Files.write(logFile.toPath(), content.getBytes(), StandardOpenOption.APPEND);
            } catch (IOException ex) {
                Logger.getLogger(UIDServerHandler.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}