UscPluginTcp.java

/*
 * Copyright (c) 2015 Huawei, Inc and others.  All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
 * and is available at http://www.eclipse.org/legal/epl-v10.html
 */
package org.opendaylight.usc.plugin;

import io.netty.bootstrap.Bootstrap;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInboundHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOutboundHandler;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.local.LocalAddress;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;

import javax.net.ssl.SSLException;

import org.opendaylight.usc.manager.UscRouteBrokerService;
import org.opendaylight.usc.manager.api.UscConfigurationService;
import org.opendaylight.usc.manager.api.UscSecureService;
import org.opendaylight.usc.plugin.model.UscChannel.ChannelType;
import org.opendaylight.usc.plugin.model.UscDevice;
import org.opendaylight.usc.util.UscServiceUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * UscPlugin implemented for TCP traffic.
 */
public class UscPluginTcp extends UscPlugin {

    private static final Logger log = LoggerFactory
            .getLogger(UscPluginTcp.class);

    private final UscSecureService secureService;
    private final UscConfigurationService configService;
    private final EventLoopGroup agentGroup = new NioEventLoopGroup();
    private final Bootstrap agentBootstrap = new Bootstrap();
    private EventLoopGroup directGroup = null;
    private Bootstrap directBootstrap = null;

    /**
     * Constructs a new UscPluginTcp
     */
    public UscPluginTcp() {
        super(new LocalAddress("usc-local-server-tcp"));

        UscRouteBrokerService routeBroker = UscServiceUtils
                .getService(UscRouteBrokerService.class);
        if (routeBroker != null) {
            routeBroker.setConnetionManager(ChannelType.TCP,
                    super.getConnectionManager());
            routeBroker.setConnetionManager(ChannelType.TLS,
                    super.getConnectionManager());
        } else {
            log.error("UscRouteBrokerService is not found, failed to set connection manager for all TCP Channel!");
        }

        configService = UscServiceUtils
                .getService(UscConfigurationService.class);
        secureService = UscServiceUtils.getService(UscSecureService.class);
        agentBootstrap.group(agentGroup);
        agentBootstrap.channel(NioSocketChannel.class);
        agentBootstrap.handler(new ChannelInitializer<Channel>() {
            @Override
            public void initChannel(final Channel ch) throws Exception {
                if (secureService == null) {
                    log.error("UscSecureService is not initialized!");
                    return;
                }
                ChannelPipeline p = ch.pipeline();
                initAgentPipeline(p, secureService.getTcpClientHandler(ch));
            }
        });

        final ServerBootstrap callHomeServerTcpBootstrap = new ServerBootstrap();
        callHomeServerTcpBootstrap.group(agentGroup);
        callHomeServerTcpBootstrap.channel(NioServerSocketChannel.class);
        // callHomeServerTcpBootstrap.handler(new
        // LoggingHandler(LogLevel.TRACE));
        callHomeServerTcpBootstrap
                .childHandler(new ChannelInitializer<NioSocketChannel>() {

                    @Override
                    public void initChannel(final NioSocketChannel channel)
                            throws Exception {
                        if (secureService == null) {
                            log.error("UscSecureService is not initialized!");
                            return;
                        }
                        log.debug("Received call home TCP connection");

                        ChannelPipeline p = channel.pipeline();

                        addCallHomeConnection(channel.remoteAddress(), channel);

                        initAgentPipeline(p,
                                secureService.getTcpServerHandler(channel));
                    }
                });
        if (configService == null) {
            log.error("UscConfigurationService is not initialized!");
            return;
        }
        final ChannelFuture callHomeChannelTcpFuture = callHomeServerTcpBootstrap
                .bind(configService
                        .getConfigIntValue(UscConfigurationService.USC_PLUGIN_PORT));
        log.debug("callHomeChannelTcpFuture : " + callHomeChannelTcpFuture);
    }

    @Override
    protected ChannelOutboundHandler getFrameEncoder() {
        return UscFrameEncoderTcp.getInstance();
    }

    @Override
    protected ChannelInboundHandler getFrameDecoder() {
        // UscFrameDecoderTcp is NOT Sharable
        return new UscFrameDecoderTcp();
    }

    @Override
    public void close() {
        super.close();
        agentGroup.shutdownGracefully();
        if (directGroup != null)
            directGroup.shutdownGracefully();
    }

    @Override
    protected Channel connectToAgent(UscDevice device) throws Exception {
        if (configService == null) {
            log.error("UscConfigurationService is not initialized!");
            return null;
        }
        final int agentPort = configService
                .getConfigIntValue(UscConfigurationService.USC_AGENT_PORT);
        Channel channel = null;

        try {
            channel = agentBootstrap
                    .connect(device.getInetAddress(), agentPort).sync()
                    .channel();
        } catch (Exception e) {
            throw e;
        }

        return channel;
    }

    @Override
    protected Channel connectToDeviceDirectly(UscDevice device)
            throws Exception {
        Channel channel = null;

        if (directBootstrap == null) {
            directBootstrap = new Bootstrap();
            directGroup = new NioEventLoopGroup();

            directBootstrap.group(directGroup);
            directBootstrap.channel(NioSocketChannel.class);
            directBootstrap.handler(new ChannelInitializer<Channel>() {
                @Override
                public void initChannel(final Channel ch) throws Exception {
                    if (secureService == null) {
                        log.error("UscSecureService is not initialized!");
                        return;
                    }
                    ChannelPipeline p = ch.pipeline();
                    initDirectPipeline(p, secureService.getTcpClientHandler(ch));
                }
            });
        }

        try {
            channel = directBootstrap
                    .connect(device.getInetAddress(), device.getPort()).sync()
                    .channel();
        } catch (Exception e) {
            throw e;
        }

        return channel;
    }

    @Override
    protected ChannelType getChannelType() {
        return ChannelType.TLS;
    }

    /**
     * Returns the security handler for server-side use. Currently this is TLS.
     *
     * @param ch
     *            The physical channel that the traffic will be sent through.
     * @return The channel handler, or null if the security service was not
     *         properly initialized.
     * @throws SSLException
     */
    public static ChannelHandler getSecureServerHandler(Channel ch) throws SSLException {
        UscSecureService service = UscServiceUtils.getService(UscSecureService.class);
        if (service == null) {
            log.error("UscSecureService is not initialized!");
            return null;
        }
        return service.getTcpServerHandler(ch);
    }

    /**
     * Returns the security handler for client-side use. Currently this is TLS.
     *
     * @param ch
     *            The physical channel that the traffic will be sent through.
     * @return The channel handler, or null if the security service was not
     *         properly initialized.
     * @throws SSLException
     */
    public static ChannelHandler getSecureClientHandler(Channel ch) throws SSLException {
        UscSecureService service = UscServiceUtils.getService(UscSecureService.class);
        if (service == null) {
            log.error("UscSecureService is not initialized!");
            return null;
        }
        return service.getTcpClientHandler(ch);
    }

}