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

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

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

Introduction

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

Prototype

ByteBuf content();

Source Link

Document

Return the data which is held by this ByteBufHolder .

Usage

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

License:Apache License

/**
 * Decode a {@link DatagramPacket} into a {@link MessageContext}.
 *
 * @param context  The channel handler context.
 * @param packet   The datagram packet.//  w w  w.  j a  va 2 s. co m
 * @param messages The output messages.
 *
 * @throws Exception If an error has occurred.
 */
@Override
public void decode(ChannelHandlerContext context, DatagramPacket packet, List<Object> messages)
        throws Exception {
    UDPTransportClient client = null;

    if (!server.isAddressRegistered(packet.sender())) {
        client = (UDPTransportClient) server.registerAddress(packet.sender())
                .setAccessTime(System.currentTimeMillis()).setChannel((DatagramChannel) context.channel())
                .setMessageFormat(server.getDefaultMessageFormat());
    } else {
        client = (UDPTransportClient) server.getTransportClient(packet.sender())
                .setAccessTime(System.currentTimeMillis());
    }

    byte flags = packet.content().readByte();

    if ((flags & ACK_BIT) == ACK_BIT) {
        // ack packet
        encoder.handleAckPacket(client, packet);
    } else {
        // standard data packet
        handlePacket(client, packet, messages);
    }
}

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

License:Apache License

private SimpleChannelInboundHandler<DatagramPacket> createSenderHandler(SeedNode thisNode) {
    return new SimpleChannelInboundHandler<DatagramPacket>() {
        @Override//w  w  w .j  a v  a2s  . c o  m
        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.SEED_NODE_INFO) {
                    String cluster = decodeUtf(buf);

                    InetSocketAddress address = decodeAddress(buf);

                    SeedNode otherNode = new SeedNode(address, cluster);

                    if (!thisNode.equals(otherNode)) {
                        if (DEBUG) {
                            log.debug("Received seed node info message [node={}]", otherNode);
                        }

                        boolean discovered = false;

                        synchronized (mux) {
                            if (isRegistered()) {
                                if (!seedNodes.contains(otherNode)) {
                                    discovered = true;

                                    seedNodes.add(otherNode);
                                }
                            }
                        }

                        if (discovered) {
                            log.info("Seed node discovered [address={}]", otherNode.address());
                        }
                    }
                }
            }
        }
    };
}

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

License:Apache License

private SimpleChannelInboundHandler<DatagramPacket> createListenerHandler(SeedNode thisNode,
        ByteBuf seedNodeInfo) {/*w ww . j  ava  2  s . c  om*/
    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.DatagramServerHandler.java

License:Open Source License

@Override
protected Object safeObject(Object msg, ByteBufAllocator allocator) throws Exception {
    if (msg instanceof DatagramPacket) {
        DatagramPacket packet = (DatagramPacket) msg;
        ByteBuf content = packet.content();
        if (content.isDirect()) {
            content = safeBuffer(content, allocator);
        }//from w w  w .java 2 s.  com
        return new DefaultDatagramPacket(packet.sender(), new Buffer(content));
    }
    return msg;
}

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

License:Apache License

public static void main(String[] args) {
    RxNetty.createUdpClient("localhost", HelloUdpServer.PORT).connect().flatMap(
            new Func1<ObservableConnection<DatagramPacket, DatagramPacket>, Observable<DatagramPacket>>() {
                @Override/*from  w  w w  .j  av  a  2 s .  co m*/
                public Observable<DatagramPacket> call(
                        ObservableConnection<DatagramPacket, DatagramPacket> connection) {
                    connection.writeStringAndFlush("Is there anybody out there?");
                    return connection.getInput();
                }
            }).toBlockingObservable().forEach(new Action1<DatagramPacket>() {
                @Override
                public void call(DatagramPacket datagramPacket) {
                    System.out.println("Received a new message: "
                            + datagramPacket.content().toString(Charset.defaultCharset()));
                }
            });
}

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 w w .  j av a 2s.  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));
                }
            });
        }
    }).startAndWait();
}

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

License:Apache License

public String sendHello() {
    String content = RxNetty.createUdpClient("localhost", port).connect().flatMap(
            new Func1<ObservableConnection<DatagramPacket, DatagramPacket>, Observable<DatagramPacket>>() {
                @Override/*from   w w  w  .  j a  v  a 2s . c o m*/
                public Observable<DatagramPacket> call(
                        ObservableConnection<DatagramPacket, DatagramPacket> connection) {
                    connection.writeStringAndFlush("Is there anybody out there?");
                    return connection.getInput();
                }
            }).take(1).map(new Func1<DatagramPacket, String>() {
                @Override
                public String call(DatagramPacket datagramPacket) {
                    return datagramPacket.content().toString(Charset.defaultCharset());
                }
            }).toBlocking().first();
    System.out.println("Received: " + content);
    return content;
}

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   ww  w  . java 2  s.  c  o  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:me.melchor9000.net.UDPSocket.java

License:Open Source License

public Packet receiveFrom(ByteBuf data, int bytes) throws Throwable {
    checkSocketCreated("receiveFrom");
    if (canReadDirectly) {
        if (receivedPackets.peek().content().readableBytes() > bytes)
            throw new NotEnoughSpaceForPacketException("Cannot write the message into the ByteBuf",
                    receivedPackets.peek().content().readableBytes(), receivedPackets.peek().sender());
        DatagramPacket packet = receivedPackets.poll();
        int bytes2 = packet.content().writableBytes();
        packet.content().writeBytes(data, packet.content().writableBytes());
        canReadDirectly = false;//from ww w . jav a  2s .c  o m
        packet.release();
        return new Packet(data, packet.sender(), bytes2);
    } else {
        return receiveAsyncFrom(data, bytes).sync().getValueNow();
    }
}

From source file:net.marfgamer.jraknet.client.RakNetClientHandler.java

License:Open Source License

@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    if (msg instanceof DatagramPacket) {
        // Get packet and sender data
        DatagramPacket datagram = (DatagramPacket) msg;
        InetSocketAddress sender = datagram.sender();
        RakNetPacket packet = new RakNetPacket(datagram);

        // If an exception happens it's because of this address
        this.causeAddress = sender;

        // Handle the packet and release the buffer
        client.handleMessage(packet, sender);
        datagram.content().readerIndex(0); // Reset position
        RakNetLogger.debug(loggerName, "Sent packet to client and reset Datagram buffer read position");
        client.getListener().handleNettyMessage(datagram.content(), sender);
        datagram.content().release(); // No longer needed
        RakNetLogger.debug(loggerName, "Sent Datagram buffer to client and released it");

        // No exceptions occurred, release the suspect
        this.causeAddress = null;
    }//from w w w  . j a  va 2s .  c  o  m
}