com.liferay.sync.engine.lan.server.file.LanFileServerInitializer.java Source code

Introduction

Here is the source code for com.liferay.sync.engine.lan.server.file.LanFileServerInitializer.java

Source

/**
 * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 */

package com.liferay.sync.engine.lan.server.file;

import com.liferay.sync.engine.lan.util.LanClientUtil;
import com.liferay.sync.engine.lan.util.LanPEMParserUtil;
import com.liferay.sync.engine.model.SyncAccount;
import com.liferay.sync.engine.service.SyncAccountService;

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.ssl.ClientAuth;
import io.netty.handler.ssl.SniHandler;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.SslProvider;
import io.netty.handler.stream.ChunkedWriteHandler;
import io.netty.util.DomainNameMapping;
import io.netty.util.DomainNameMappingBuilder;

import java.security.cert.X509Certificate;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Dennis Ju
 */
public class LanFileServerInitializer extends ChannelInitializer<SocketChannel> {

    public LanFileServerInitializer(SyncTrafficShapingHandler syncTrafficShapingHandler) {

        _syncTrafficShapingHandler = syncTrafficShapingHandler;

        updateDomainNameMapping();
    }

    @Override
    public void initChannel(SocketChannel socketChannel) {
        ChannelPipeline channelPipeline = socketChannel.pipeline();

        if (_domainNameMapping != null) {
            channelPipeline.addLast(new SniHandler(_domainNameMapping));
        }

        channelPipeline.addLast(new HttpServerCodec());
        channelPipeline.addLast(new HttpObjectAggregator(65536));
        channelPipeline.addLast(_syncTrafficShapingHandler);
        channelPipeline.addLast(new ChunkedWriteHandler());
        channelPipeline.addLast(new LanFileServerHandler(_syncTrafficShapingHandler));
    }

    public void updateDomainNameMapping() {
        DomainNameMappingBuilder<SslContext> domainNameMappingBuilder = null;

        for (SyncAccount syncAccount : SyncAccountService.findAll()) {
            if (!syncAccount.isActive() || !syncAccount.isLanEnabled()) {
                continue;
            }

            SslContext sslContext = null;

            try {
                X509Certificate x509Certificate = LanPEMParserUtil
                        .parseX509Certificate(syncAccount.getLanCertificate());

                SslContextBuilder sslContextBuilder = SslContextBuilder
                        .forServer(LanPEMParserUtil.parsePrivateKey(syncAccount.getLanKey()), x509Certificate);

                sslContextBuilder.clientAuth(ClientAuth.REQUIRE);
                sslContextBuilder.sslProvider(SslProvider.JDK);
                sslContextBuilder.trustManager(x509Certificate);

                sslContext = sslContextBuilder.build();
            } catch (Exception e) {
                _logger.error(e.getMessage(), e);

                continue;
            }

            if (domainNameMappingBuilder == null) {
                domainNameMappingBuilder = new DomainNameMappingBuilder<>(sslContext);
            }

            domainNameMappingBuilder.add(LanClientUtil.getSNIHostname(syncAccount.getLanServerUuid()), sslContext);
        }

        if (domainNameMappingBuilder == null) {
            return;
        }

        _domainNameMapping = domainNameMappingBuilder.build();
    }

    private static final Logger _logger = LoggerFactory.getLogger(LanFileServerInitializer.class);

    private DomainNameMapping<SslContext> _domainNameMapping;
    private final SyncTrafficShapingHandler _syncTrafficShapingHandler;

}