From 4877fffa0a591bdb6fe21af6192986b74102d17d Mon Sep 17 00:00:00 2001 From: Jestan Nirojan Date: Sun, 10 May 2015 16:21:52 +0530 Subject: [PATCH] SCTP echo client/server multi-homing examples Motivation: There are no Netty SCTP examples on multi-homing. Modifications: - Added new example classes based on echo client/server example Result: Better documentation --- .../SctpMultiHomingEchoClient.java | 87 +++++++++++++++++++ .../SctpMultiHomingEchoServer.java | 83 ++++++++++++++++++ 2 files changed, 170 insertions(+) create mode 100644 example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoClient.java create mode 100644 example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoServer.java diff --git a/example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoClient.java b/example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoClient.java new file mode 100644 index 0000000000..c3d681b7e9 --- /dev/null +++ b/example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoClient.java @@ -0,0 +1,87 @@ +/* + * Copyright 2015 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. + */ +package io.netty.example.sctp.multihoming; + +import io.netty.bootstrap.Bootstrap; +import io.netty.channel.ChannelFuture; +import io.netty.channel.ChannelInitializer; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.sctp.SctpChannel; +import io.netty.channel.sctp.SctpChannelOption; +import io.netty.channel.sctp.nio.NioSctpChannel; +import io.netty.example.sctp.SctpEchoClientHandler; + +import java.net.InetAddress; +import java.net.InetSocketAddress; + +/** + * SCTP Echo Client with multi-homing support. + */ +public final class SctpMultiHomingEchoClient { + + private static final String CLIENT_PRIMARY_HOST = System.getProperty("host.primary", "127.0.0.1"); + private static final String CLIENT_SECONDARY_HOST = System.getProperty("host.secondary", "127.0.0.2"); + + private static final int CLIENT_PORT = Integer.parseInt(System.getProperty("port.local", "8008")); + + private static final String SERVER_REMOTE_HOST = System.getProperty("host.remote", "127.0.0.1"); + private static final int SERVER_REMOTE_PORT = Integer.parseInt(System.getProperty("port.remote", "8007")); + + public static void main(String[] args) throws Exception { + // Configure the client. + EventLoopGroup group = new NioEventLoopGroup(); + try { + Bootstrap b = new Bootstrap(); + b.group(group) + .channel(NioSctpChannel.class) + .option(SctpChannelOption.SCTP_NODELAY, true) + .handler(new ChannelInitializer() { + @Override + public void initChannel(SctpChannel ch) throws Exception { + ch.pipeline().addLast( +// new LoggingHandler(LogLevel.INFO), + new SctpEchoClientHandler()); + } + }); + + InetSocketAddress localAddress = new InetSocketAddress(CLIENT_PRIMARY_HOST, CLIENT_PORT); + InetAddress localSecondaryAddress = InetAddress.getByName(CLIENT_SECONDARY_HOST); + + InetSocketAddress remoteAddress = new InetSocketAddress(SERVER_REMOTE_HOST, SERVER_REMOTE_PORT); + + // Bind the client channel. + ChannelFuture bindFuture = b.bind(localAddress).sync(); + + // Get the underlying sctp channel + SctpChannel channel = (SctpChannel) bindFuture.channel(); + + // Bind the secondary address. + // Please note that, bindAddress in the client channel should be done before connecting if you have not + // enable Dynamic Address Configuration. See net.sctp.addip_enable kernel param + channel.bindAddress(localSecondaryAddress).sync(); + + // Finish connect + ChannelFuture connectFuture = channel.connect(remoteAddress).sync(); + + // Wait until the connection is closed. + connectFuture.channel().closeFuture().sync(); + } finally { + // Shut down the event loop to terminate all threads. + group.shutdownGracefully(); + } + } +} diff --git a/example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoServer.java b/example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoServer.java new file mode 100644 index 0000000000..99faea25b4 --- /dev/null +++ b/example/src/main/java/io/netty/example/sctp/multihoming/SctpMultiHomingEchoServer.java @@ -0,0 +1,83 @@ +/* + * Copyright 2015 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. + */ +package io.netty.example.sctp.multihoming; + +import io.netty.bootstrap.ServerBootstrap; +import io.netty.channel.ChannelFuture; +import io.netty.channel.ChannelInitializer; +import io.netty.channel.ChannelOption; +import io.netty.channel.EventLoopGroup; +import io.netty.channel.nio.NioEventLoopGroup; +import io.netty.channel.sctp.SctpChannel; +import io.netty.channel.sctp.SctpServerChannel; +import io.netty.channel.sctp.nio.NioSctpServerChannel; +import io.netty.example.sctp.SctpEchoServerHandler; +import io.netty.handler.logging.LogLevel; +import io.netty.handler.logging.LoggingHandler; + +import java.net.InetAddress; +import java.net.InetSocketAddress; + +/** + * SCTP Echo Server with multi-homing support. + */ +public final class SctpMultiHomingEchoServer { + + private static final String SERVER_PRIMARY_HOST = System.getProperty("host.primary", "127.0.0.1"); + private static final String SERVER_SECONDARY_HOST = System.getProperty("host.secondary", "127.0.0.2"); + + private static final int SERVER_PORT = Integer.parseInt(System.getProperty("port", "8007")); + + public static void main(String[] args) throws Exception { + // Configure the server. + EventLoopGroup bossGroup = new NioEventLoopGroup(1); + EventLoopGroup workerGroup = new NioEventLoopGroup(); + try { + ServerBootstrap b = new ServerBootstrap(); + b.group(bossGroup, workerGroup) + .channel(NioSctpServerChannel.class) + .option(ChannelOption.SO_BACKLOG, 100) + .handler(new LoggingHandler(LogLevel.INFO)) + .childHandler(new ChannelInitializer() { + @Override + public void initChannel(SctpChannel ch) throws Exception { + ch.pipeline().addLast( +// new LoggingHandler(LogLevel.INFO), + new SctpEchoServerHandler()); + } + }); + + InetSocketAddress localAddress = new InetSocketAddress(SERVER_PRIMARY_HOST, SERVER_PORT); + InetAddress localSecondaryAddress = InetAddress.getByName(SERVER_SECONDARY_HOST); + + // Bind the server to primary address. + ChannelFuture bindFuture = b.bind(localAddress).sync(); + + //Get the underlying sctp channel + SctpServerChannel channel = (SctpServerChannel) bindFuture.channel(); + + //Bind the secondary address + ChannelFuture connectFuture = channel.bindAddress(localSecondaryAddress).sync(); + + // Wait until the connection is closed. + connectFuture.channel().closeFuture().sync(); + } finally { + // Shut down all event loops to terminate all threads. + bossGroup.shutdownGracefully(); + workerGroup.shutdownGracefully(); + } + } +}