void isReadable(SelectionKey k) {
EventableChannel ec = (EventableChannel) k.attachment();
long b = ec.getBinding();
if (ec.isWatchOnly()) {
if (ec.isNotifyReadable()) eventCallback(b, EM_CONNECTION_NOTIFY_READABLE, null);
} else {
myReadBuffer.clear();
try {
ec.readInboundData(myReadBuffer);
myReadBuffer.flip();
if (myReadBuffer.limit() > 0) {
if (ProxyConnections != null) {
EventableChannel target = ProxyConnections.get(b);
if (target != null) {
ByteBuffer myWriteBuffer = ByteBuffer.allocate(myReadBuffer.limit());
myWriteBuffer.put(myReadBuffer);
myWriteBuffer.flip();
target.scheduleOutboundData(myWriteBuffer);
} else {
eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
}
} else {
eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
}
}
} catch (IOException e) {
UnboundConnections.add(b);
}
}
}
/**
* sends data from buffer.
*
* <p>precondition: sendbb is in put mode post condition: sendbb is in put mode
*/
private void sendFromBuffer() {
aa(this, isSender(), "nonsender can't write");
aa(this, isConnected() || isClosurePending(), "needs to be established can't write");
// switch sendbb to get mode
sendbb.flip();
p(this, 3, "Sending from buffer. bb flipped.");
int payloadLength = Math.min(Transport.MAX_PAYLOAD_SIZE, sendbb.limit());
p(this, 4, "Max Payload size: " + Transport.MAX_PAYLOAD_SIZE);
p(this, 4, "payloadlen: " + payloadLength);
dumpState(4);
if (roomForPacket(payloadLength) && payloadLength > 0) {
byte[] payload = new byte[payloadLength];
sendbb.get(payload);
Transport t = makeTransport(Transport.DATA, seqNum, payload);
tcpMan.sendData(this.tsid, t);
p(this, 3, "Write: converting to packet: " + TCPManager.bytesToString(payload));
// only increment the seqNum if a packet is sent
seqNum += payloadLength;
}
// switch back to put mode
sendbb.compact();
dumpState(4);
if (isClosurePending() && sendbb.position() == 0) release();
}
public static void main(String args[]) {
try {
aServer asr = new aServer();
// file channel.
FileInputStream is = new FileInputStream("");
is.read();
FileChannel cha = is.getChannel();
ByteBuffer bf = ByteBuffer.allocate(1024);
bf.flip();
cha.read(bf);
// Path Paths
Path pth = Paths.get("", "");
// Files some static operation.
Files.newByteChannel(pth);
Files.copy(pth, pth);
// file attribute, other different class for dos and posix system.
BasicFileAttributes bas = Files.readAttributes(pth, BasicFileAttributes.class);
bas.size();
} catch (Exception e) {
System.err.println(e);
}
System.out.println("hello ");
}
static byte[] encode(char[] cc, Charset cs, boolean testDirect, Time t) throws Exception {
ByteBuffer bbf;
CharBuffer cbf;
CharsetEncoder enc = cs.newEncoder();
String csn = cs.name();
if (testDirect) {
bbf = ByteBuffer.allocateDirect(cc.length * 4);
cbf = ByteBuffer.allocateDirect(cc.length * 2).asCharBuffer();
cbf.put(cc).flip();
} else {
bbf = ByteBuffer.allocate(cc.length * 4);
cbf = CharBuffer.wrap(cc);
}
CoderResult cr = null;
long t1 = System.nanoTime() / 1000;
for (int i = 0; i < iteration; i++) {
cbf.rewind();
bbf.clear();
enc.reset();
cr = enc.encode(cbf, bbf, true);
}
long t2 = System.nanoTime() / 1000;
t.t = (t2 - t1) / iteration;
if (cr != CoderResult.UNDERFLOW) {
System.out.println("ENC-----------------");
int pos = cbf.position();
System.out.printf(" cr=%s, cbf.pos=%d, cc[pos]=%x%n", cr.toString(), pos, cc[pos] & 0xffff);
throw new RuntimeException("Encoding err: " + csn);
}
byte[] bb = new byte[bbf.position()];
bbf.flip();
bbf.get(bb);
return bb;
}
private void recv(SocketChannel sc, ClientInfo ci) throws IOException {
ci.channel.read(ci.inBuf);
ByteBuffer tmpBuf = ci.inBuf.duplicate();
tmpBuf.flip();
int bytesProcessed = 0;
boolean doneLoop = false;
while (!doneLoop) {
byte b;
try {
b = tmpBuf.get();
} catch (BufferUnderflowException bue) {
// Processed all data in buffer
ci.inBuf.clear();
doneLoop = true;
break;
}
switch (b) {
case TypeServerConstants.WELCOME:
bytesProcessed++;
break;
case TypeServerConstants.GET_STRING_REQUEST:
bytesProcessed++;
if (ci.outputPending) {
// Client is backed up. We can't append to
// the byte buffer because it's in the wrong
// state. We could allocate another buffer
// here and change our send method to know
// about multiple buffers, but we'll just
// assume that the client is dead
break;
}
ci.outBuf.put(TypeServerConstants.GET_STRING_RESPONSE);
ByteBuffer strBuf = encoder.encode(testString);
ci.outBuf.putShort((short) strBuf.remaining());
ci.outBuf.put(strBuf);
ci.outBuf.flip();
send(sc, ci);
break;
case TypeServerConstants.GET_STRING_RESPONSE:
int startPos = tmpBuf.position();
try {
int nBytes = tmpBuf.getInt();
byte[] buf = new byte[nBytes];
tmpBuf.get(buf);
bytesProcessed += buf.length + 5;
String s = new String(buf);
// Send the string to the GUI
break;
} catch (BufferUnderflowException bue) {
// Processed all available data
ci.inBuf.position(ci.inBuf.position() + bytesProcessed);
doneLoop = true;
}
break;
}
}
}
public static void runTests() {
try {
// SHA1 sha1Jmule = new SHA1();
MessageDigest sha1Sun = MessageDigest.getInstance("SHA-1");
SHA1 sha1Gudy = new SHA1();
// SHA1Az shaGudyResume = new SHA1Az();
ByteBuffer buffer = ByteBuffer.allocate(1024 * 1024);
File dir = new File(dirname);
File[] files = dir.listFiles();
for (int i = 0; i < files.length; i++) {
FileChannel fc = new RandomAccessFile(files[i], "r").getChannel();
System.out.println("Testing " + files[i].getName() + " ...");
while (fc.position() < fc.size()) {
fc.read(buffer);
buffer.flip();
byte[] raw = new byte[buffer.limit()];
System.arraycopy(buffer.array(), 0, raw, 0, raw.length);
sha1Gudy.update(buffer);
sha1Gudy.saveState();
ByteBuffer bb = ByteBuffer.wrap(new byte[56081]);
sha1Gudy.digest(bb);
sha1Gudy.restoreState();
sha1Sun.update(raw);
buffer.clear();
}
byte[] sun = sha1Sun.digest();
sha1Sun.reset();
byte[] gudy = sha1Gudy.digest();
sha1Gudy.reset();
if (Arrays.equals(sun, gudy)) {
System.out.println(" SHA1-Gudy: OK");
} else {
System.out.println(" SHA1-Gudy: FAILED");
}
buffer.clear();
fc.close();
System.out.println();
}
} catch (Throwable e) {
Debug.printStackTrace(e);
}
}
/**
* Read from the socket up to len bytes into the buffer buf starting at position pos.
*
* @param buf byte[] the buffer
* @param pos int starting position in buffer
* @param len int number of bytes to read
* @return int on success, the number of bytes read, which may be smaller than len; on failure, -1
*/
public int read(byte[] buf, int pos, int len) {
aa(this, isReceiver(), "nonreceiver socket reading");
aa(this, state == State.ESTABLISHED, "attempting to read from closed socket");
recvbb.flip();
int bytesCopied = Math.min(recvbb.limit(), len);
recvbb.get(buf, pos, bytesCopied);
recvbb.compact();
return bytesCopied;
}
void isReadable(SelectionKey k) {
EventableChannel ec = (EventableChannel) k.attachment();
long b = ec.getBinding();
if (ec.isWatchOnly()) {
if (ec.isNotifyReadable()) eventCallback(b, EM_CONNECTION_NOTIFY_READABLE, null);
} else {
myReadBuffer.clear();
try {
ec.readInboundData(myReadBuffer);
myReadBuffer.flip();
if (myReadBuffer.limit() > 0) eventCallback(b, EM_CONNECTION_READ, myReadBuffer);
} catch (IOException e) {
UnboundConnections.add(b);
}
}
}
public void resendMessage(Message message, IP remoteAddress, int remotePort) throws IOException {
if (remoteAddress == null) remoteAddress = IP.getLocalHost();
message.setSentStamp(getConvertedTime(remoteAddress, remotePort));
message.setMessageServer(this);
try {
sendBuffer.clear();
sendBuffer.put(extractor.convertMessage(message));
sendBuffer.flip();
channel.send(sendBuffer, new InetSocketAddress(remoteAddress.toString(), remotePort));
message.setRemoteAddress(remoteAddress);
message.setRemotePort(remotePort);
messageSent(message);
} catch (IllegalAccessException exc) {
throw new RuntimeException(exc);
} catch (IllegalArgumentException exc) {
throw new RuntimeException(exc);
} catch (InvocationTargetException exc) {
throw new RuntimeException(exc);
}
}
private void dispatchMessage(
TcpAddress incomingAddress, ByteBuffer byteBuffer, long bytesRead) {
byteBuffer.flip();
if (logger.isDebugEnabled()) {
logger.debug(
"Received message from "
+ incomingAddress
+ " with length "
+ bytesRead
+ ": "
+ new OctetString(byteBuffer.array(), 0, (int) bytesRead).toHexString());
}
ByteBuffer bis;
if (isAsyncMsgProcessingSupported()) {
byte[] bytes = new byte[(int) bytesRead];
System.arraycopy(byteBuffer.array(), 0, bytes, 0, (int) bytesRead);
bis = ByteBuffer.wrap(bytes);
} else {
bis = ByteBuffer.wrap(byteBuffer.array(), 0, (int) bytesRead);
}
fireProcessMessage(incomingAddress, bis);
}
/**
* Decode file charset.
*
* @param f File to process.
* @return File charset.
* @throws IOException in case of error.
*/
public static Charset decode(File f) throws IOException {
SortedMap<String, Charset> charsets = Charset.availableCharsets();
String[] firstCharsets = {
Charset.defaultCharset().name(), "US-ASCII", "UTF-8", "UTF-16BE", "UTF-16LE"
};
Collection<Charset> orderedCharsets = U.newLinkedHashSet(charsets.size());
for (String c : firstCharsets)
if (charsets.containsKey(c)) orderedCharsets.add(charsets.get(c));
orderedCharsets.addAll(charsets.values());
try (RandomAccessFile raf = new RandomAccessFile(f, "r")) {
FileChannel ch = raf.getChannel();
ByteBuffer buf = ByteBuffer.allocate(4096);
ch.read(buf);
buf.flip();
for (Charset charset : orderedCharsets) {
CharsetDecoder decoder = charset.newDecoder();
decoder.reset();
try {
decoder.decode(buf);
return charset;
} catch (CharacterCodingException ignored) {
}
}
}
return Charset.defaultCharset();
}
/** {@inheritDoc} */
@Override
public ByteBuffer encode(GridNioSession ses, GridClientMessage msg)
throws IOException, GridException {
assert msg != null;
if (msg instanceof GridTcpRestPacket) return encodeMemcache((GridTcpRestPacket) msg);
else if (msg == PING_MESSAGE) return ByteBuffer.wrap(PING_PACKET);
else {
byte[] data = marshaller.marshal(msg);
assert data.length > 0;
ByteBuffer res = ByteBuffer.allocate(data.length + 5);
res.put(GRIDGAIN_REQ_FLAG);
res.put(U.intToBytes(data.length));
res.put(data);
res.flip();
return res;
}
}
private synchronized DBMessage go(DBMessage msg, ByteDecoder decoder) throws IOException {
if (_sock == null) _open();
{
ByteBuffer out = msg.prepare();
while (out.remaining() > 0) _sock.write(out);
}
if (_pool != null) _pool._everWorked = true;
if (decoder == null) return null;
ByteBuffer response = decoder._buf;
if (response.position() != 0) throw new IllegalArgumentException();
int read = 0;
while (read < DBMessage.HEADER_LENGTH) read += _read(response);
int len = response.getInt(0);
if (len <= DBMessage.HEADER_LENGTH)
throw new IllegalArgumentException("db sent invalid length: " + len);
if (len > response.capacity())
throw new IllegalArgumentException(
"db message size is too big (" + len + ") " + "max is (" + response.capacity() + ")");
response.limit(len);
while (read < len) read += _read(response);
if (read != len) throw new RuntimeException("something is wrong");
response.flip();
return new DBMessage(response);
}
private void go() throws IOException {
// Create a new selector
Selector selector = Selector.open();
// Open a listener on each port, and register each one
// with the selector
for (int i = 0; i < ports.length; ++i) {
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.configureBlocking(false);
ServerSocket ss = ssc.socket();
InetSocketAddress address = new InetSocketAddress(ports[i]);
ss.bind(address);
SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Going to listen on " + ports[i]);
}
while (true) {
int num = selector.select();
Set selectedKeys = selector.selectedKeys();
Iterator it = selectedKeys.iterator();
while (it.hasNext()) {
SelectionKey key = (SelectionKey) it.next();
if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
// Accept the new connection
ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
SocketChannel sc = ssc.accept();
sc.configureBlocking(false);
// Add the new connection to the selector
SelectionKey newKey = sc.register(selector, SelectionKey.OP_READ);
it.remove();
System.out.println("Got connection from " + sc);
} else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
// Read the data
SocketChannel sc = (SocketChannel) key.channel();
// Echo data
int bytesEchoed = 0;
while (true) {
echoBuffer.clear();
int r = sc.read(echoBuffer);
if (r <= 0) {
break;
}
echoBuffer.flip();
sc.write(echoBuffer);
bytesEchoed += r;
}
System.out.println("Echoed " + bytesEchoed + " from " + sc);
it.remove();
}
}
// System.out.println( "going to clear" );
// selectedKeys.clear();
// System.out.println( "cleared" );
}
}
private void readMessage(SelectionKey sk, SocketChannel readChannel, TcpAddress incomingAddress)
throws IOException {
// note that socket has been used
SocketEntry entry = (SocketEntry) sockets.get(incomingAddress);
if (entry != null) {
entry.used();
ByteBuffer readBuffer = entry.getReadBuffer();
if (readBuffer != null) {
readChannel.read(readBuffer);
if (readBuffer.hasRemaining()) {
readChannel.register(selector, SelectionKey.OP_READ, entry);
} else {
dispatchMessage(incomingAddress, readBuffer, readBuffer.capacity());
}
return;
}
}
ByteBuffer byteBuffer = ByteBuffer.wrap(buf);
byteBuffer.limit(messageLengthDecoder.getMinHeaderLength());
long bytesRead = readChannel.read(byteBuffer);
if (logger.isDebugEnabled()) {
logger.debug("Reading header " + bytesRead + " bytes from " + incomingAddress);
}
MessageLength messageLength = new MessageLength(0, Integer.MIN_VALUE);
if (bytesRead == messageLengthDecoder.getMinHeaderLength()) {
messageLength = messageLengthDecoder.getMessageLength(ByteBuffer.wrap(buf));
if (logger.isDebugEnabled()) {
logger.debug("Message length is " + messageLength);
}
if ((messageLength.getMessageLength() > getMaxInboundMessageSize())
|| (messageLength.getMessageLength() <= 0)) {
logger.error(
"Received message length "
+ messageLength
+ " is greater than inboundBufferSize "
+ getMaxInboundMessageSize());
synchronized (entry) {
entry.getSocket().close();
logger.info("Socket to " + entry.getPeerAddress() + " closed due to an error");
}
} else {
byteBuffer.limit(messageLength.getMessageLength());
bytesRead += readChannel.read(byteBuffer);
if (bytesRead == messageLength.getMessageLength()) {
dispatchMessage(incomingAddress, byteBuffer, bytesRead);
} else {
byte[] message = new byte[byteBuffer.limit()];
byteBuffer.flip();
byteBuffer.get(message, 0, byteBuffer.limit() - byteBuffer.remaining());
entry.setReadBuffer(ByteBuffer.wrap(message));
}
readChannel.register(selector, SelectionKey.OP_READ, entry);
}
} else if (bytesRead < 0) {
logger.debug("Socket closed remotely");
sk.cancel();
readChannel.close();
TransportStateEvent e =
new TransportStateEvent(
DefaultTcpTransportMapping.this,
incomingAddress,
TransportStateEvent.STATE_DISCONNECTED_REMOTELY,
null);
fireConnectionStateChanged(e);
}
}