Java Code Examples for java.nio.channels.DatagramChannel#send()

public static void main(String[] args) throws IOException
{
    ByteBuffer data = ByteBuffer.wrap("TESTING DATA".getBytes());
    DatagramChannel dgChannel = DatagramChannel.open();

    for(int i = 0; i < targets.length; i++){
        data.rewind();
        SocketAddress sa = new InetSocketAddress(targets[i], port);
        System.out.println("-------------\nDG_Sending data:" +
                           "\n    remaining:" + data.remaining() +
                           "\n     position:" + data.position() +
                           "\n        limit:" + data.limit() +
                           "\n     capacity:" + data.capacity() +
                           " bytes on DG channel to " + sa);
        try {
            int n = dgChannel.send(data, sa);
            System.out.println("DG_Sent " + n + " bytes");
        } catch (IOException e) {
            //This regression test is to check vm crash only, so ioe is OK.
            e.printStackTrace();
        }
    }
    dgChannel.close();
}
 

public void test_bounded_harmony6493() throws IOException {
    DatagramChannel server = DatagramChannel.open();
    InetSocketAddress addr = new InetSocketAddress("localhost", 0);
    server.socket().bind(addr);
    SocketAddress boundedAddress = server.socket().getLocalSocketAddress();

    DatagramChannel client = DatagramChannel.open();
    ByteBuffer sent = ByteBuffer.allocate(1024);
    sent.put("test".getBytes());
    sent.flip();
    client.send(sent, boundedAddress);
    assertTrue(client.socket().isBound());

    server.close();
    client.close();
}
 

public static void main(String[] args) throws IOException
{
    ByteBuffer data = ByteBuffer.wrap("TESTING DATA".getBytes());
    DatagramChannel dgChannel = DatagramChannel.open();

    for(int i = 0; i < targets.length; i++){
        data.rewind();
        SocketAddress sa = new InetSocketAddress(targets[i], port);
        System.out.println("-------------\nDG_Sending data:" +
                           "\n    remaining:" + data.remaining() +
                           "\n     position:" + data.position() +
                           "\n        limit:" + data.limit() +
                           "\n     capacity:" + data.capacity() +
                           " bytes on DG channel to " + sa);
        try {
            int n = dgChannel.send(data, sa);
            System.out.println("DG_Sent " + n + " bytes");
        } catch (IOException e) {
            //This regression test is to check vm crash only, so ioe is OK.
            e.printStackTrace();
        }
    }
    dgChannel.close();
}
 

@Test
public void testSend() throws Exception {
    String host = "239.239.239.99";//多播地址
    int port = 9999;
    InetAddress group = InetAddress.getByName(host);
    String message = "test-multicastSocket";

    DatagramChannel channel = DatagramChannel.open(StandardProtocolFamily.INET);
    channel.configureBlocking(true);
    channel.bind(new InetSocketAddress(port));
    channel.join(group, Utils.getLocalNetworkInterface());

    InetSocketAddress sender = new InetSocketAddress("239.239.239.99", 4000);
    channel.send(ByteBuffer.wrap(message.getBytes()), sender);

    channel.close();
}
 

public static void main(String[] args) throws IOException
{
    ByteBuffer data = ByteBuffer.wrap("TESTING DATA".getBytes());
    DatagramChannel dgChannel = DatagramChannel.open();

    for(int i = 0; i < targets.length; i++){
        data.rewind();
        SocketAddress sa = new InetSocketAddress(targets[i], port);
        System.out.println("-------------\nDG_Sending data:" +
                           "\n    remaining:" + data.remaining() +
                           "\n     position:" + data.position() +
                           "\n        limit:" + data.limit() +
                           "\n     capacity:" + data.capacity() +
                           " bytes on DG channel to " + sa);
        try {
            int n = dgChannel.send(data, sa);
            System.out.println("DG_Sent " + n + " bytes");
        } catch (IOException e) {
            //This regression test is to check vm crash only, so ioe is OK.
            e.printStackTrace();
        }
    }
    dgChannel.close();
}
 

/** This method is thread safe. */
public int send (Connection connection, Object object, SocketAddress address) throws IOException {
	DatagramChannel datagramChannel = this.datagramChannel;
	if (datagramChannel == null) throw new SocketException("Connection is closed.");
	synchronized (writeLock) {
		try {
			try {
				serialization.write(connection, writeBuffer, object);
			} catch (Exception ex) {
				throw new KryoNetException("Error serializing object of type: " + object.getClass().getName(), ex);
			}
			writeBuffer.flip();
			int length = writeBuffer.limit();
			datagramChannel.send(writeBuffer, address);

			lastCommunicationTime = System.currentTimeMillis();

			boolean wasFullWrite = !writeBuffer.hasRemaining();
			return wasFullWrite ? length : -1;
		} finally {
			writeBuffer.clear();
		}
	}
}
 

public static void main(String[] args) throws IOException
{
    ByteBuffer data = ByteBuffer.wrap("TESTING DATA".getBytes());
    DatagramChannel dgChannel = DatagramChannel.open();

    for(int i = 0; i < targets.length; i++){
        data.rewind();
        SocketAddress sa = new InetSocketAddress(targets[i], port);
        System.out.println("-------------\nDG_Sending data:" +
                           "\n    remaining:" + data.remaining() +
                           "\n     position:" + data.position() +
                           "\n        limit:" + data.limit() +
                           "\n     capacity:" + data.capacity() +
                           " bytes on DG channel to " + sa);
        try {
            int n = dgChannel.send(data, sa);
            System.out.println("DG_Sent " + n + " bytes");
        } catch (IOException e) {
            //This regression test is to check vm crash only, so ioe is OK.
            e.printStackTrace();
        }
    }
    dgChannel.close();
}
 

public long transferTo(DatagramChannel ch, SocketAddress raddr) throws IOException {
    int send = 0;
    for (ByteBuffer buf: buffers) {
        if (buf.hasRemaining()) {
            int w = ch.send(buf, raddr);
            if (w == 0) {
                break;
            } else {
                send += w;
            }
        }
    }
    written += send;

    return send;
}
 

public static void handleRead(SelectionKey key, ByteBuffer readBuffer) throws IOException {

        // Log.i("UdpForwarder", "Handling Read");
        DatagramChannel channel = (DatagramChannel) key.channel();
        ClientRecord clientRecord = (ClientRecord) key.attachment();

        // Ensure the buffer is empty
        readBuffer.clear();

        // Receive the data
        channel.receive(readBuffer);

        // Get read to wrte, then send
        readBuffer.flip();
        channel.send(readBuffer, clientRecord.toAddress);

        // If there is anything remaining in the buffer
        if (readBuffer.remaining() > 0) {
            clientRecord.writeBuffer.put(readBuffer);
            key.interestOps(SelectionKey.OP_WRITE);
        }

//        ClientRecord clientRecord = (ClientRecord) key.attachment();
//        clientRecord.buffer.clear();    // Prepare buffer for receiving
//        clientRecord.clientAddress = channel.receive(clientRecord.buffer);
//
//        if (clientRecord.clientAddress != null) {  // Did we receive something?
//            // Register write with the selector
//            key.interestOps(SelectionKey.OP_WRITE);
//        }
    }
 

static void wakeupWhenBound(final DatagramChannel dc) {
    Runnable wakeupTask = new Runnable() {
        public void run() {
            try {
                // poll for local address
                InetSocketAddress local;
                do {
                    Thread.sleep(50);
                    local = (InetSocketAddress)dc.getLocalAddress();
                } while (local == null);

                // send message to channel to wakeup receiver
                DatagramChannel sender = DatagramChannel.open();
                try {
                    ByteBuffer bb = ByteBuffer.wrap("hello".getBytes());
                    InetAddress lh = InetAddress.getLocalHost();
                    SocketAddress target =
                        new InetSocketAddress(lh, local.getPort());
                    sender.send(bb, target);
                } finally {
                    sender.close();
                }

            } catch (Exception x) {
                x.printStackTrace();
            }
        }};
    new Thread(wakeupTask).start();
}
 

static void wakeupWhenBound(final DatagramChannel dc) {
    Runnable wakeupTask = new Runnable() {
        public void run() {
            try {
                // poll for local address
                InetSocketAddress local;
                do {
                    Thread.sleep(50);
                    local = (InetSocketAddress)dc.getLocalAddress();
                } while (local == null);

                // send message to channel to wakeup receiver
                DatagramChannel sender = DatagramChannel.open();
                try {
                    ByteBuffer bb = ByteBuffer.wrap("hello".getBytes());
                    InetAddress lh = InetAddress.getLocalHost();
                    SocketAddress target =
                        new InetSocketAddress(lh, local.getPort());
                    sender.send(bb, target);
                } finally {
                    sender.close();
                }

            } catch (Exception x) {
                x.printStackTrace();
            }
        }};
    new Thread(wakeupTask).start();
}
 

/**
 * send a reply-acknowledgement (6,2,3), sends it doing a busy write, the ACK is so small
 * that it should always go to the buffer
 * @param key
 * @param channel
 */
protected void sendAck(SelectionKey key, WritableByteChannel channel, byte[] command, SocketAddress udpaddr) {
    try {

        ByteBuffer buf = ByteBuffer.wrap(command);
        int total = 0;
        if (channel instanceof DatagramChannel) {
            DatagramChannel dchannel = (DatagramChannel)channel;
            //were using a shared channel, document says its thread safe
            //TODO check optimization, one channel per thread?
            while ( total < command.length ) {
                total += dchannel.send(buf, udpaddr);
            }
        } else {
            while ( total < command.length ) {
                total += channel.write(buf);
            }
        }
        if (log.isTraceEnabled()) {
            log.trace("ACK sent to " +
                    ( (channel instanceof SocketChannel) ?
                      ((SocketChannel)channel).socket().getInetAddress() :
                      ((DatagramChannel)channel).socket().getInetAddress()));
        }
    } catch ( java.io.IOException x ) {
        log.warn("Unable to send ACK back through channel, channel disconnected?: "+x.getMessage());
    }
}
 

static void wakeupWhenBound(final DatagramChannel dc) {
    Runnable wakeupTask = new Runnable() {
        public void run() {
            try {
                // poll for local address
                InetSocketAddress local;
                do {
                    Thread.sleep(50);
                    local = (InetSocketAddress)dc.getLocalAddress();
                } while (local == null);

                // send message to channel to wakeup receiver
                DatagramChannel sender = DatagramChannel.open();
                try {
                    ByteBuffer bb = ByteBuffer.wrap("hello".getBytes());
                    InetAddress lh = InetAddress.getLocalHost();
                    SocketAddress target =
                        new InetSocketAddress(lh, local.getPort());
                    sender.send(bb, target);
                } finally {
                    sender.close();
                }

            } catch (Exception x) {
                x.printStackTrace();
            }
        }};
    new Thread(wakeupTask).start();
}
 

static void wakeupWhenBound(final DatagramChannel dc) {
    Runnable wakeupTask = new Runnable() {
        public void run() {
            try {
                // poll for local address
                InetSocketAddress local;
                do {
                    Thread.sleep(50);
                    local = (InetSocketAddress)dc.getLocalAddress();
                } while (local == null);

                // send message to channel to wakeup receiver
                DatagramChannel sender = DatagramChannel.open();
                try {
                    ByteBuffer bb = ByteBuffer.wrap("hello".getBytes());
                    InetAddress lh = InetAddress.getLocalHost();
                    SocketAddress target =
                        new InetSocketAddress(lh, local.getPort());
                    sender.send(bb, target);
                } finally {
                    sender.close();
                }

            } catch (Exception x) {
                x.printStackTrace();
            }
        }};
    new Thread(wakeupTask).start();
}
 

@Override
public synchronized void send() throws IOException {
	try {
		bufferWriter.flush();
		final byte[] bytes = buffer.toByteArray();
		final ByteBuffer byteBuffer = ByteBuffer.wrap(bytes);
		final DatagramChannel channel = createDatagramChannel();
		try {
			final int nbSentBytes = channel.send(byteBuffer, address);
			if (bytes.length != nbSentBytes) {
				final String msg = String.format(
						"Could not send entirely data to StatsD host %s:%d. Only sent %d bytes out of %d bytes",
						address.getHostName(), address.getPort(), nbSentBytes, bytes.length);
				LOG.warn(msg, new IOException(msg));
			}
		} finally {
			channel.close();
		}
	} catch (final ConnectException e) {
		throw new IOException("Error connecting to StatsD at " + address.getHostName() + ':'
				+ address.getPort(), e);
	} finally {
		// finally to be sure to not keep too much data in buffer
		// including when the socket can't connect
		buffer.reset();
	}
}
 

static void wakeupWhenBound(final DatagramChannel dc) {
    Runnable wakeupTask = new Runnable() {
        public void run() {
            try {
                // poll for local address
                InetSocketAddress local;
                do {
                    Thread.sleep(50);
                    local = (InetSocketAddress)dc.getLocalAddress();
                } while (local == null);

                // send message to channel to wakeup receiver
                DatagramChannel sender = DatagramChannel.open();
                try {
                    ByteBuffer bb = ByteBuffer.wrap("hello".getBytes());
                    InetAddress lh = InetAddress.getLocalHost();
                    SocketAddress target =
                        new InetSocketAddress(lh, local.getPort());
                    sender.send(bb, target);
                } finally {
                    sender.close();
                }

            } catch (Exception x) {
                x.printStackTrace();
            }
        }};
    new Thread(wakeupTask).start();
}
 

static void wakeupWhenBound(final DatagramChannel dc) {
    Runnable wakeupTask = new Runnable() {
        public void run() {
            try {
                // poll for local address
                InetSocketAddress local;
                do {
                    Thread.sleep(50);
                    local = (InetSocketAddress)dc.getLocalAddress();
                } while (local == null);

                // send message to channel to wakeup receiver
                DatagramChannel sender = DatagramChannel.open();
                try {
                    ByteBuffer bb = ByteBuffer.wrap("hello".getBytes());
                    InetAddress lh = InetAddress.getLocalHost();
                    SocketAddress target =
                        new InetSocketAddress(lh, local.getPort());
                    sender.send(bb, target);
                } finally {
                    sender.close();
                }

            } catch (Exception x) {
                x.printStackTrace();
            }
        }};
    new Thread(wakeupTask).start();
}
 

@Test
public void test() throws Exception {
    CyclicBarrier barrier = new CyclicBarrier(2);

    DatagramBulkReflector reflector = new DatagramBulkReflector("REFLECTOR", REFLECTOR_ADDRESS, 1, barrier);
    reflector.open();

    barrier.await();
    Thread.sleep(1000);

    DatagramChannel channel = DatagramChannel.open();
    channel.configureBlocking(true);

    ByteBuffer bb = ByteBuffer.allocate(100);

    try {
        // sent
        bb.clear();
        bb.flip();
        int sent = channel.send(bb, CRUSHER_ADDRESS);
        Assert.assertEquals(0, sent);

        // check
        Thread.sleep(500);

        Assert.assertEquals(1, crusher.getClientTotalCount());

        RateMeters innerByteMeters = crusher.getInnerByteMeters();
        Assert.assertEquals(0, innerByteMeters.getReadMeter().getTotalCount());
        Assert.assertEquals(0, innerByteMeters.getSentMeter().getTotalCount());

        RateMeters innerPacketMeters = crusher.getInnerPacketMeters();
        Assert.assertEquals(1, innerPacketMeters.getReadMeter().getTotalCount());
        Assert.assertEquals(1, innerPacketMeters.getSentMeter().getTotalCount());

        // read
        bb.clear();
        InetSocketAddress address = (InetSocketAddress) channel.receive(bb);
        Assert.assertNotNull(address);
        Assert.assertEquals(CRUSHER_ADDRESS, address);
        Assert.assertEquals(0, bb.position());
    } finally {
        NioUtils.close(channel);
        NioUtils.close(reflector);
    }
}
 

@Override
public boolean onDiscoverHost (DatagramChannel datagramChannel, InetSocketAddress fromAddress, Serialization serialization)
	throws IOException {
	datagramChannel.send(emptyBuffer, fromAddress);
	return true;
}
 

public final long transferTo(DatagramChannel ch, SocketAddress raddr) throws IOException {
    return ch.send(buffer, raddr);
}