Example usage for io.netty.channel.socket DatagramPacket DatagramPacket

List of usage examples for io.netty.channel.socket DatagramPacket DatagramPacket

  1. HOME
  2. Java
  3. io.netty
  4. io.netty.channel.socket.*
  5. DatagramPacket
  6. DatagramPacket

Introduction

In this page you can find the example usage for io.netty.channel.socket DatagramPacket DatagramPacket.

Prototype

public DatagramPacket(ByteBuf data, InetSocketAddress recipient)

Source Link

Document

Create a new instance with the specified packet data and recipient address.

Usage

From source file:io.haze.transport.udp.UDPEncoder.java

License:Apache License

/**
 * Encode a {@link MessageContext} into a {@link ByteBuf}.
 *
 * @param context The channel handler context.
 * @param message The input message./*from   www.j  a v  a 2  s . c o m*/
 * @param buffer  The output buffer.
 */
@Override
public void encode(ChannelHandlerContext context, MessageContext message, ByteBuf buffer) throws Exception {
    ByteBuf messageBuffer = ((BufferMessage) message.getMessage()).getBuffer();
    int count = messageBuffer.readableBytes() / SAFE_PACKET_SIZE
            + ((messageBuffer.readableBytes() % SAFE_PACKET_SIZE == 0) ? 0 : 1);
    State state = (State) message.getTransportClient().getState(State.class);

    if (state == null) {
        state = new State();
    }

    try {
        int endPacketId = state.packetId - 1 + count;
        int startPacketId = state.packetId;

        while (messageBuffer.readableBytes() > 0) {
            int capacity = Math.min(SAFE_PACKET_SIZE, messageBuffer.readableBytes() + HEADERS_BYTE_SIZE);
            ByteBuf packetBuffer = Unpooled.buffer(capacity, capacity);

            // write flags, current packet id, start packet id, end packet id, payload length
            packetBuffer.writeByte(0);
            packetBuffer.writeShort(state.packetId++);
            packetBuffer.writeShort(startPacketId);
            packetBuffer.writeShort(endPacketId);
            packetBuffer.writeShort((short) (capacity - HEADERS_BYTE_SIZE));

            // read one packet worth of data from buffer and handle the packet
            messageBuffer.readBytes(packetBuffer, capacity - HEADERS_BYTE_SIZE);

            handlePacket((UDPTransportClient) message.getTransportClient(), state.packetId,
                    new DatagramPacket(packetBuffer, message.getTransportClient().getAddress()));
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    } finally {
        message.getTransportClient().setState(state.getClass(), state);
    }
}

From source file:io.hekate.cluster.seed.multicast.MulticastSeedNodeProvider.java

License:Apache License

@Override
public void startDiscovery(String cluster, InetSocketAddress address) throws HekateException {
    log.info("Starting seed nodes discovery [cluster={}, {}]", cluster, ToString.formatProperties(this));

    SeedNode thisNode = new SeedNode(address, cluster);

    try {//from www . jav  a  2s  .c o  m
        NetworkInterface nif = selectMulticastInterface(address);

        try {
            synchronized (mux) {
                if (isRegistered()) {
                    throw new IllegalStateException(
                            "Multicast seed node provider is already registered with another address "
                                    + "[existing=" + localNode + ']');
                }

                ByteBuf discoveryMsg = prepareDiscovery(thisNode);

                ByteBuf seedNodeInfoBytes = prepareSeedNodeInfo(thisNode);

                localNode = thisNode;

                seedNodes = new HashSet<>();

                eventLoop = new NioEventLoopGroup(1, new HekateThreadFactory("SeedNodeMulticast"));

                // Prepare common bootstrap options.
                Bootstrap bootstrap = new Bootstrap();

                bootstrap.option(ChannelOption.SO_REUSEADDR, true);
                bootstrap.option(ChannelOption.IP_MULTICAST_TTL, ttl);
                bootstrap.option(ChannelOption.IP_MULTICAST_IF, nif);

                if (loopBackDisabled) {
                    bootstrap.option(ChannelOption.IP_MULTICAST_LOOP_DISABLED, true);

                    if (DEBUG) {
                        log.debug("Setting {} option to true", ChannelOption.IP_MULTICAST_LOOP_DISABLED);
                    }
                }

                bootstrap.group(eventLoop);
                bootstrap.channelFactory(() -> new NioDatagramChannel(ipVer));

                // Create a sender channel (not joined to a multicast group).
                bootstrap.localAddress(0);
                bootstrap.handler(createSenderHandler(thisNode));

                ChannelFuture senderBind = bootstrap.bind();

                DatagramChannel localSender = (DatagramChannel) senderBind.channel();

                sender = localSender;

                senderBind.get();

                // Create a listener channel and join to a multicast group.
                bootstrap.localAddress(group.getPort());

                bootstrap.handler(createListenerHandler(thisNode, seedNodeInfoBytes));

                ChannelFuture listenerBind = bootstrap.bind();

                listener = (DatagramChannel) listenerBind.channel();

                listenerBind.get();

                log.info("Joining to a multicast group " + "[address={}, port={}, interface={}, ttl={}]",
                        AddressUtils.host(group), group.getPort(), nif.getName(), ttl);

                listener.joinGroup(group, nif).get();

                // Create a periodic task for discovery messages sending.
                discoveryFuture = eventLoop.scheduleWithFixedDelay(() -> {
                    if (DEBUG) {
                        log.debug("Sending discovery message [from={}]", thisNode);
                    }

                    DatagramPacket discovery = new DatagramPacket(discoveryMsg.copy(), group);

                    localSender.writeAndFlush(discovery);
                }, 0, interval, TimeUnit.MILLISECONDS);
            }
        } catch (ExecutionException e) {
            cleanup();

            throw new HekateException(
                    "Failed to start a multicast seed nodes discovery [node=" + thisNode + ']', e.getCause());
        }

        log.info("Will wait for seed nodes [timeout={}(ms)]", waitTime);

        Thread.sleep(waitTime);
    } catch (InterruptedException e) {
        cleanup();

        Thread.currentThread().interrupt();

        throw new HekateException(
                "Thread was interrupted while awaiting for multicast discovery [node=" + thisNode + ']', e);
    }

    log.info("Done waiting for seed nodes.");
}

From source file:io.hekate.cluster.seed.multicast.MulticastSeedNodeProvider.java

License:Apache License

private SimpleChannelInboundHandler<DatagramPacket> createListenerHandler(SeedNode thisNode,
        ByteBuf seedNodeInfo) {// w ww . j av  a  2  s.  co  m
    return new SimpleChannelInboundHandler<DatagramPacket>() {
        @Override
        public void channelRead0(ChannelHandlerContext ctx, DatagramPacket msg) throws Exception {
            ByteBuf buf = msg.content();

            if (buf.readableBytes() > 4 && buf.readInt() == Utils.MAGIC_BYTES) {
                MessageTYpe msgType = MessageTYpe.values()[buf.readByte()];

                if (msgType == MessageTYpe.DISCOVERY) {
                    String cluster = decodeUtf(buf);
                    InetSocketAddress address = decodeAddress(buf);

                    if (thisNode.cluster().equals(cluster) && !address.equals(thisNode.address())) {
                        onDiscoveryMessage(address);

                        DatagramPacket response = new DatagramPacket(seedNodeInfo.copy(), msg.sender());

                        ctx.writeAndFlush(response);
                    }
                }
            }
        }
    };
}

From source file:io.jsync.datagram.impl.DefaultDatagramSocket.java

License:Open Source License

@Override
@SuppressWarnings("unchecked")
public DatagramSocket send(Buffer packet, String host, int port, Handler<AsyncResult<DatagramSocket>> handler) {
    configurable = false;/*from   w  w w.  j  av  a  2 s .c o  m*/
    ChannelFuture future = channel()
            .writeAndFlush(new DatagramPacket(packet.getByteBuf(), new InetSocketAddress(host, port)));
    addListener(future, handler);
    return this;
}

From source file:io.reactivex.netty.examples.java.HelloUdpServer.java

License:Apache License

public static void main(String[] args) {
    RxNetty.createUdpServer(PORT, new ConnectionHandler<DatagramPacket, DatagramPacket>() {
        @Override/*w ww  .j  ava  2 s  .com*/
        public Observable<Void> handle(
                final ObservableConnection<DatagramPacket, DatagramPacket> newConnection) {
            return newConnection.getInput().flatMap(new Func1<DatagramPacket, Observable<Void>>() {
                @Override
                public Observable<Void> call(DatagramPacket received) {
                    InetSocketAddress sender = received.sender();
                    System.out.println("Received datagram. Sender: " + sender + ", data: "
                            + received.content().toString(Charset.defaultCharset()));
                    ByteBuf data = newConnection.getChannelHandlerContext().alloc()
                            .buffer(WELCOME_MSG_BYTES.length);
                    data.writeBytes(WELCOME_MSG_BYTES);
                    return newConnection.writeAndFlush(new DatagramPacket(data, sender));
                }
            });
        }
    }).startAndWait();
}

From source file:io.reactivex.netty.examples.udp.HelloUdpServer.java

License:Apache License

public UdpServer<DatagramPacket, DatagramPacket> createServer() {
    UdpServer<DatagramPacket, DatagramPacket> server = RxNetty.createUdpServer(port,
            new ConnectionHandler<DatagramPacket, DatagramPacket>() {
                @Override//from  w w  w.ja  v a2 s  .  co  m
                public Observable<Void> handle(
                        final ObservableConnection<DatagramPacket, DatagramPacket> newConnection) {
                    return newConnection.getInput().flatMap(new Func1<DatagramPacket, Observable<Void>>() {
                        @Override
                        public Observable<Void> call(DatagramPacket received) {
                            InetSocketAddress sender = received.sender();
                            System.out.println("Received datagram. Sender: " + sender + ", data: "
                                    + received.content().toString(Charset.defaultCharset()));
                            ByteBuf data = newConnection.getChannelHandlerContext().alloc()
                                    .buffer(WELCOME_MSG_BYTES.length);
                            data.writeBytes(WELCOME_MSG_BYTES);
                            return newConnection.writeAndFlush(new DatagramPacket(data, sender));
                        }
                    });
                }
            });
    System.out.println("UDP hello server started...");
    return server;
}

From source file:io.reactivex.netty.protocol.udp.client.UdpClientConnection.java

License:Apache License

@Override
public void writeBytes(byte[] msg) {
    ByteBuf data = getChannelHandlerContext().alloc().buffer(msg.length);
    data.writeBytes(msg);/*from   w ww  .j  av  a2s  .  c  o m*/
    writeOnChannel(new DatagramPacket(data, receiverAddress));
}

From source file:io.vertx.core.datagram.impl.DatagramSocketImpl.java

License:Open Source License

private void doSend(Buffer packet, InetSocketAddress addr, Handler<AsyncResult<DatagramSocket>> handler) {
    ChannelFuture future = channel().writeAndFlush(new DatagramPacket(packet.getByteBuf(), addr));
    addListener(future, handler);//from  w  w w . j  a  va 2 s.  c  om
}

From source file:ipmi.test.qotm.QuoteOfTheMomentClient.java

License:Apache License

public static void main(String[] args) throws Exception {
    System.out.println("QuoteOfTheMomentClient");
    EventLoopGroup group = new NioEventLoopGroup();
    try {//  w ww.j a v  a2s.c o m
        Bootstrap b = new Bootstrap();
        b.group(group).channel(NioDatagramChannel.class)
                //.option(ChannelOption.SO_BROADCAST, true)
                .handler(new QuoteOfTheMomentClientHandler());

        Channel ch = b.bind(0).sync().channel();

        // Broadcast the QOTM request to port 8080.
        ch.writeAndFlush(new DatagramPacket(Unpooled.copiedBuffer("QOTM?", CharsetUtil.UTF_8),
                SocketUtils.socketAddress("192.168.0.78", PORT))).sync();

        // QuoteOfTheMomentClientHandler will close the DatagramChannel when a
        // response is received.  If the channel is not closed within 5 seconds,
        // print an error message and quit.
        if (!ch.closeFuture().await(5000)) {
            System.err.println("QOTM request timed out.");
        }
    } finally {
        group.shutdownGracefully();
    }
}

From source file:ipmi.test.qotm.QuoteOfTheMomentServerHandler.java

License:Apache License

@Override
public void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) throws Exception {
    System.err.println(packet);//from w w w .  j  a v a2  s . c  om
    //if ("QOTM?".equals(packet.content().toString(CharsetUtil.UTF_8))) {
    ctx.write(new DatagramPacket(Unpooled.copiedBuffer("QOTM: " + nextQuote(), CharsetUtil.UTF_8),
            packet.sender()));
    //}
}