Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
30 changes: 18 additions & 12 deletions src/main/java/org/scalasbt/ipcsocket/SocketChannels.java
Original file line number Diff line number Diff line change
Expand Up @@ -226,41 +226,47 @@ public SocketAddress getLocalAddress() {

@Override
public SocketAddress getRemoteAddress() {
return this.socket.getLocalSocketAddress();
return this.socket.getRemoteSocketAddress();
}

@Override
public final int write(ByteBuffer buffer) throws IOException {
byte[] bs = buffer.array();
byte[] bs = new byte[buffer.remaining()];
buffer.get(bs);
this.socket.getOutputStream().write(bs);
return bs.length;
}

@Override
public final long write(ByteBuffer buffers[], int offset, int length) throws IOException {
if (length == 0 || buffers.length == 0) {
return 0;
} else {

return write(buffers[offset]);
long total = 0;
for (int i = offset; i < offset + length; i++) {
total += write(buffers[i]);
}
return total;
}

@Override
public final int read(ByteBuffer buffer) throws IOException {
if (!buffer.hasRemaining()) {
return 0;
}
byte[] bs = new byte[buffer.remaining()];
int size = this.socket.getInputStream().read(bs);
buffer.put(bs, buffer.position(), size);
if (size > 0) {
buffer.put(bs, 0, size);
}
return size;
}

@Override
public final long read(ByteBuffer buffers[], int offset, int length) throws IOException {
if (length == 0 || buffers.length == 0) {
return 0;
} else {
return read(buffers[offset]);
for (int i = offset; i < offset + length; i++) {
if (buffers[i].hasRemaining()) {
return read(buffers[i]);
}
}
return 0;
}

@Override
Expand Down
109 changes: 109 additions & 0 deletions src/test/java/org/scalasbt/ipcsocket/ForwardingSocketChannelTest.java
Original file line number Diff line number Diff line change
@@ -0,0 +1,109 @@
package org.scalasbt.ipcsocket;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;
import org.junit.Test;
import static org.junit.Assert.*;

/** The channel that wraps our sockets must honour the ByteBuffer contract. */
public class ForwardingSocketChannelTest extends BaseSocketSetup {
interface ChannelTest {
void run(SocketChannel channel, Socket peer) throws IOException;
}

private void withChannel(ChannelTest test) throws IOException, InterruptedException {
withSocket(
sock -> {
ServerSocket serverSocket = newServerSocket(sock);
try {
SocketPair pair = SocketPair.connect(this, serverSocket, sock);
SocketChannel channel = SocketChannels.fromSocket(pair.client);
Socket peer = pair.peer;
try {
test.run(channel, peer);
} finally {
channel.close();
peer.close();
}
} finally {
serverSocket.close();
}
});
}

private static String readExactly(Socket peer, int n) throws IOException {
byte[] bs = new byte[n];
new DataInputStream(peer.getInputStream()).readFully(bs);
return new String(bs, StandardCharsets.UTF_8);
}

@Test(timeout = 10000)
public void readAtEndOfStreamReturnsMinusOne() throws IOException, InterruptedException {
// Windows named pipes report a closed peer as an IOException, not as end of stream
if (isWin) return;
withChannel(
(channel, peer) -> {
peer.close();
assertEquals(-1, channel.read(ByteBuffer.allocate(16)));
});
}

@Test(timeout = 10000)
public void readStoresAtBufferPosition() throws IOException, InterruptedException {
withChannel(
(channel, peer) -> {
peer.getOutputStream().write("abc".getBytes(StandardCharsets.UTF_8));
ByteBuffer buf = ByteBuffer.allocate(16);
buf.put((byte) 'x').put((byte) 'y');
int n = 0;
while (n < 3) n += channel.read(buf);
assertEquals(5, buf.position());
assertEquals("xyabc", new String(buf.array(), 0, 5, StandardCharsets.UTF_8));
});
}

@Test(timeout = 10000)
public void writeSendsOnlyRemainingBytes() throws IOException, InterruptedException {
withChannel(
(channel, peer) -> {
ByteBuffer buf = ByteBuffer.allocate(16);
buf.put("hi".getBytes(StandardCharsets.UTF_8)).flip();
while (buf.hasRemaining()) channel.write(buf);
ByteBuffer direct = ByteBuffer.allocateDirect(8);
direct.put((byte) '!').flip();
assertEquals(1, channel.write(direct));
assertFalse(direct.hasRemaining());
assertEquals("hi!", readExactly(peer, 3));
});
}

@Test(timeout = 10000)
public void gatheringWriteSendsAllBuffers() throws IOException, InterruptedException {
withChannel(
(channel, peer) -> {
ByteBuffer[] bufs = {
ByteBuffer.wrap("skip".getBytes(StandardCharsets.UTF_8)),
ByteBuffer.wrap("ab".getBytes(StandardCharsets.UTF_8)),
ByteBuffer.wrap("cd".getBytes(StandardCharsets.UTF_8))
};
assertEquals(4, channel.write(bufs, 1, 2));
assertEquals("abcd", readExactly(peer, 4));
});
}

@Test(timeout = 10000)
public void scatteringReadSkipsFullBuffers() throws IOException, InterruptedException {
withChannel(
(channel, peer) -> {
peer.getOutputStream().write("z".getBytes(StandardCharsets.UTF_8));
ByteBuffer[] bufs = {ByteBuffer.allocate(0), ByteBuffer.allocate(4)};
assertEquals(1, channel.read(bufs, 0, 2));
assertEquals('z', bufs[1].get(0));
});
}
}
56 changes: 56 additions & 0 deletions src/test/java/org/scalasbt/ipcsocket/SocketPair.java
Original file line number Diff line number Diff line change
@@ -0,0 +1,56 @@
package org.scalasbt.ipcsocket;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

/**
* A connected client and the server's socket for it. A named pipe instance only exists while the
* server is in accept(), so the client connects after accept() has started.
*/
final class SocketPair {
final Socket client;
final Socket peer;

private SocketPair(Socket client, Socket peer) {
this.client = client;
this.peer = peer;
}

static SocketPair connect(BaseSocketSetup setup, ServerSocket server, String name)
throws IOException {
CompletableFuture<Socket> accept =
CompletableFuture.supplyAsync(
() -> {
try {
return server.accept();
} catch (IOException e) {
throw new UncheckedIOException(e);
}
});
long deadline = System.currentTimeMillis() + 10000;
Socket client;
while (true) {
try {
client = setup.newClientSocket(name);
break;
} catch (IOException e) {
if (System.currentTimeMillis() > deadline) throw e;
try {
Thread.sleep(20);
} catch (InterruptedException ie) {
throw new IOException(ie);
}
}
}
try {
return new SocketPair(client, accept.get(10, TimeUnit.SECONDS));
} catch (Exception e) {
client.close();
throw new IOException(e);
}
}
}
Loading