Java NotYetConnectedException类代码示例

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
public void sendNetworkEvent(BaseEvent event) throws IOException {
    if (this.getStatus() == Node.CLOSE) {
        return;
    }
    if (writeTarget == null) {
        throw new NotYetConnectedException();
    }
    if (this.status != Node.HANDSHAKE && !isHandShakeMessage(event)) {
        throw new NotYetConnectedException();
    }
    lock.lock();
    try {
        byte[] data = event.serialize();
        NulsMessage message = new NulsMessage(magicNumber, data);
        this.writeTarget.write(message.serialize());
    } finally {
        lock.unlock();
    }
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
private BroadcastResult broadcastToGroup(NulsMessage message, String groupName, String excludeNodeId) {
    List<Node> broadNodes = nodesManager.getGroupAvailableNodes(groupName, excludeNodeId);
    if (broadNodes.size() <= 1) {
        return new BroadcastResult(false, "no node can be broadcast");
    }

    int successCount = 0;
    for (Node node : broadNodes) {
        try {
            node.sendMessage(message);
            successCount++;
        } catch (NotYetConnectedException | IOException e) {
            Log.warn("broadcast message error ， maybe the node closed ! node ip :{}, {}", node.getIp(), e.getMessage());
        }
    }

    if (successCount == 0) {
        new BroadcastResult(false, "broadcast fail", broadNodes);
    }
    Log.debug("成功广播给{}个节点，消息{}", successCount, message);
    return new BroadcastResult(true, "OK");
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
/**
 * Sends the given message to the peer. Due to the asynchronousness of network programming, there is no guarantee
 * the peer will have received it. Throws NotYetConnectedException if we are not yet connected to the remote peer.
 * TODO: Maybe use something other than the unchecked NotYetConnectedException here
 */
public void sendMessage(Message message) throws NotYetConnectedException {
    lock.lock();
    try {
        if (writeTarget == null)
            throw new NotYetConnectedException();
    } finally {
        lock.unlock();
    }
    // TODO: Some round-tripping could be avoided here
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    try {
        serializer.serialize(message, out);
        writeTarget.writeBytes(out.toByteArray());
    } catch (IOException e) {
        exceptionCaught(e);
    }
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
public void invokeMethod(String method, Object paramsObject,
                         @Nullable PendingRequestCallback callback)
    throws NotYetConnectedException {
  Util.throwIfNull(method);

  Long requestId = (callback != null) ? preparePendingRequest(callback) : null;

  // magic, can basically convert anything for some amount of runtime overhead...
  JSONObject params = mObjectMapper.convertValue(paramsObject, JSONObject.class);

  JsonRpcRequest message = new JsonRpcRequest(requestId, method, params);
  String requestString;
  JSONObject jsonObject = mObjectMapper.convertValue(message, JSONObject.class);
  requestString = jsonObject.toString();
  mPeer.sendText(requestString);
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
public void invokeMethod(String method, Object paramsObject,
    @Nullable PendingRequestCallback callback)
    throws NotYetConnectedException {
  Util.throwIfNull(method);

  Long requestId = (callback != null) ? preparePendingRequest(callback) : null;

  // magic, can basically convert anything for some amount of runtime overhead...
  JSONObject params = mObjectMapper.convertValue(paramsObject, JSONObject.class);

  JsonRpcRequest message = new JsonRpcRequest(requestId, method, params);
  String requestString;
  JSONObject jsonObject = mObjectMapper.convertValue(message, JSONObject.class);
  requestString = jsonObject.toString();
  mPeer.sendText(requestString);
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
public long write (ByteBuffer[] srcs, int offset, int length)
  throws IOException
{
  if (!isConnected())
    throw new NotYetConnectedException();

  if ((offset < 0)
      || (offset > srcs.length)
      || (length < 0)
      || (length > (srcs.length - offset)))
    throw new IndexOutOfBoundsException();

  /* We are connected, meaning we will write these bytes to
   * the host we connected to, so we don't need to explicitly
   * give the host. */
  return channel.writeGathering(srcs, offset, length);
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) throws Exception {
    Throwable cause = e.getCause();

    // do not print exception if it is BindException.
    // we are trying to search available port below 1024. It is not good to
    // print a flood
    // of error logs during the searching.
    if (cause instanceof java.net.BindException) {
        return;
    }

    LOG.error("Exception on connection to " + getRemoteAddress(), e.getCause());

    // close the channel unless we are connecting and it is
    // NotYetConnectedException
    if (!((cause instanceof NotYetConnectedException)
            && _connection.getConnectionState().equals(Connection.State.CONNECTING))) {
        ctx.getChannel().close();
    }
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
@Override
protected void doWriteFileRegion(FileRegion region) throws Exception {
    OutputStream os = this.os;
    if (os == null) {
        throw new NotYetConnectedException();
    }
    if (outChannel == null) {
        outChannel = Channels.newChannel(os);
    }

    long written = 0;
    for (;;) {
        long localWritten = region.transferTo(outChannel, written);
        if (localWritten == -1) {
            checkEOF(region);
            return;
        }
        written += localWritten;

        if (written >= region.count()) {
            return;
        }
    }
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
@TestTargetNew(
    level = TestLevel.PARTIAL_COMPLETE,
    notes = "Doesn't verify all exceptions according to specification.",
    method = "write",
    args = {java.nio.ByteBuffer[].class}
)
public void testWriteByteBufferArray_Block() throws IOException {
    ByteBuffer[] writeBuf = new ByteBuffer[2];
    writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
    writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
    InetSocketAddress ipAddr = localAddr1;
    try {
        this.channel1.write(writeBuf);
        fail("Should throw NotYetConnectedException.");
    } catch (NotYetConnectedException e) {
        // correct
    }
    this.channel1.connect(ipAddr);
    assertTrue(this.channel1.isConnected());
    assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf));
    // cannot be buffered again!
    assertEquals(0, this.channel1.write(writeBuf));
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationSelf",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "NotYetConnectedException",
        args = {}
    )
})
public void testSerializationSelf() throws Exception {

    SerializationTest.verifySelf(new NotYetConnectedException());
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
/**
 * @tests serialization/deserialization compatibility with RI.
 */
@TestTargets({
    @TestTargetNew(
        level = TestLevel.COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "!SerializationGolden",
        args = {}
    ),
    @TestTargetNew(
        level = TestLevel.PARTIAL_COMPLETE,
        notes = "Verifies serialization/deserialization compatibility.",
        method = "NotYetConnectedException",
        args = {}
    )
})
public void testSerializationCompatibility() throws Exception {

    SerializationTest.verifyGolden(this, new NotYetConnectedException());
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
public void testOpen() throws IOException {
    java.nio.ByteBuffer[] buf = new java.nio.ByteBuffer[1];
    buf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
    MockSocketChannel testMSChannel = new MockSocketChannel(null);
    MockSocketChannel testMSChannelnotnull = new MockSocketChannel(
            SelectorProvider.provider());
    SocketChannel testSChannel = MockSocketChannel.open();
    assertTrue(testSChannel.isOpen());
    assertNull(testMSChannel.provider());
    assertNotNull(testSChannel.provider());
    assertEquals(SelectorProvider.provider(), testSChannel.provider());
    assertNotNull(testMSChannelnotnull.provider());
    assertEquals(this.channel1.provider(), testMSChannelnotnull.provider());
    try {
        this.channel1.write(buf);
        fail("Should throw NotYetConnectedException");
    } catch (NotYetConnectedException e) {
        // correct
    }
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
/**
 * Sends <var>text</var> to server
 *
 * @param text
 *            String to send to server
 */
@JavascriptInterface
public void send(final String text) {
	new Thread(new Runnable() {
		@Override
		public void run() {
			if (instance.readyState == WEBSOCKET_STATE_OPEN) {
				try {
					instance._send(text);
				} catch (Exception e) {
					instance.onError(e);
				}
			} else {
				instance.onError(new NotYetConnectedException());
			}
		}
	}).start();
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
/**
 * Sends the given message to the peer. Due to the asynchronousness of network programming,
 * there is no guarantee
 * the peer will have received it. Throws NotYetConnectedException if we are not yet
 * connected to the remote peer.
 * TODO: Maybe use something other than the unchecked NotYetConnectedException here
 */
public void sendMessage(Message message) throws NotYetConnectedException {
    lock.lock();
    try {
        if (writeTarget == null) {
            throw new NotYetConnectedException();
        }
    } finally {
        lock.unlock();
    }
    // TODO: Some round-tripping could be avoided here
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    try {
        serializer.serialize(message, out);
        writeTarget.writeBytes(out.toByteArray());
    } catch (IOException e) {
        exceptionCaught(e);
    }
}
 

import java.nio.channels.NotYetConnectedException; //导入依赖的package包/类
public void testWriteByteBufferArrayIntInt_Block() throws IOException {
    ByteBuffer[] writeBuf = new ByteBuffer[2];
    writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
    writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
    InetSocketAddress ipAddr = localAddr1; 
    try {
        this.channel1.write(writeBuf, 0, 2);
        fail("Should throw NotYetConnectedException.");
    } catch (NotYetConnectedException e) {
        // correct
    }
    this.channel1.connect(ipAddr); 
    assertTrue(this.channel1.isConnected());
    assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
    // cannot be buffered again!
    assertEquals(0, this.channel1.write(writeBuf, 0, 1));

}