Mirrors/criu
1
0
Fork 0
mirror of https://github.com/checkpoint-restore/criu.git synced 2026-01-23 02:14:37 +00:00
Code Issues Projects Releases Wiki Activity

Add Socket-based Java Functional Tests

Browse source 
Signed-off-by: Nidhi Gupta <itsnidhi16@gmail.com>
This commit is contained in:
Nidhi Gupta 2019-12-08 10:14:40 +05:30 • committed by Andrei Vagin
parent 8b5dea33f6
commit 1e9ff2aa03
21 changed files with 2424 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

11
test/javaTests/README.md
View file

@ -30,7 +30,16 @@ Here we test the File-Based Java APIs by checkpointing the application in the fo
## Memory mapping Java APIs
Here we test the Memory Mapping APIs by checkpointing the application in following scenario and verifying the contents after restore:
- Memory-mapping a file and writing its content to another file. (MemoryMappings.java)
- Memory-mapping a file and writing its content to another file. (MemoryMappings.java)
## Socket-based Java APIs
Here we test the Socket-based API's by checkpointing the application in the following scenario and verifying the state after restore:
- Checkpointing the server process in the middle of data transfer. (Sockets.java)
- Checkpointing the server process after it has bound to a port but is not listening for client connections. (SocketListen.java)
- Checkpointing the server process while it is listening for client connections, and no client has connected yet. (SocketConnect.java)
- Checkpointing the server process when it has multiple clients in multiple states connected to it. (SocketMultiple.java)
- Checkpointing the client process in the middle of data transfer. (SocketsData.java)
### Prerequisites for running the tests:
- Maven

1
test/javaTests/src/org/criu/java/tests/CheckpointRestore.java
View file

@ -154,6 +154,7 @@ public class CheckpointRestore {
*/
while (Helper.STATE_INIT == currentState) {
currentState = mappedByteBuffer.getChar(Helper.MAPPED_INDEX);
Thread.sleep(100);
}
/*

2
test/javaTests/src/org/criu/java/tests/Helper.java
View file

@ -30,7 +30,7 @@ class Helper {
* the pid to the pidFile.
*
* @param testName Name of the java test
* @param pid Pid of the java test process
* @param pid Pid of the java test process
* @param logger
* @return 0 or 1 denoting whether the function was successful or not.
* @throws IOException

100
test/javaTests/src/org/criu/java/tests/SocketHelper.java Normal file
View file

@ -0,0 +1,100 @@
package org.criu.java.tests;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.MappedByteBuffer;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.SimpleFormatter;
class SocketHelper {
static char STATE_LISTEN = 'S';
static char STATE_SUCCESS = 'Z';
static String IP_ADDRESS = "127.0.0.1";
/**
* Creates a new log file, for the logger to log in.
*
* @param testName Name of the server or client program
* @param parentTestName Name of the test
* @param logger
* @throws IOException
*/
static void init(String testName, String parentTestName, Logger logger) throws IOException {
FileHandler handler = new FileHandler(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/" + testName + ".log", false);
handler.setFormatter(new SimpleFormatter());
handler.setLevel(Level.FINE);
logger.addHandler(handler);
logger.setLevel(Level.FINE);
}
/**
* Writes pid of the process to be checkpointed in the file
*
* @param parentTestName Name of the test
* @param pid Pid of the process to be checkpointed
* @throws IOException
*/
static void writePid(String parentTestName, String pid) throws IOException {
File pidfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/" + parentTestName + Helper.PID_APPEND);
BufferedWriter pidwriter = new BufferedWriter(new FileWriter(pidfile));
/*
* Overwriting pid to be checkpointed
*/
pidwriter.write(pid + "\n");
pidwriter.close();
}
/**
* Waits for the MappedByteBuffer to change state from STATE_CHECKPOINT to STATE_RESTORE
*
* @param socketMappedBuffer MappedByteBuffer between the client, server and the controller process.
* @param logger
*/
static void socketWaitForRestore(MappedByteBuffer socketMappedBuffer, Logger logger) {
while (Helper.STATE_CHECKPOINT == socketMappedBuffer.getChar(Helper.MAPPED_INDEX)) {
;
}
if (Helper.STATE_RESTORE != socketMappedBuffer.getChar(Helper.MAPPED_INDEX)) {
logger.log(Level.SEVERE, "Server socket was not in expected restore state " + socketMappedBuffer.getChar(Helper.MAPPED_INDEX));
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
} else {
logger.log(Level.INFO, "Restored!!!");
}
}
/**
* Puts the MappedByteBuffer to Helper.STATE_CHECKPOINT and waits for CheckpointRestore.java to change its state to Helper.STATE_RESTORE
*
* @param b MappedByteBuffer between the controller process and CheckpointRestore.java
* @param logger Logger to log the messages
* @param p1 Process object for the client process
* @param p2 Process object for the server process
*/
static void checkpointAndWait(MappedByteBuffer b, Logger logger, Process p1, Process p2) {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_CHECKPOINT);
char c = b.getChar(Helper.MAPPED_INDEX);
while (Helper.STATE_CHECKPOINT == c) {
c = b.getChar(Helper.MAPPED_INDEX);
}
if (Helper.STATE_TERMINATE == c) {
logger.log(Level.SEVERE, "Error during checkpoint-restore, Test terminated");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
p1.destroy();
p2.destroy();
System.exit(1);
}
if (Helper.STATE_RESTORE != c) {
logger.log(Level.SEVERE, "Error: Test state is not the expected Restored state");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
p1.destroy();
p2.destroy();
System.exit(1);
}
}
}

141
test/javaTests/src/org/criu/java/tests/Sockets.java Normal file
View file

@ -0,0 +1,141 @@
package org.criu.java.tests;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class Sockets {
static String TESTNAME = "Sockets";
/**
* Runs the client and server process, checkpoints the server process while its in the middle of data transfer
*
* @param args Not used
*/
public static void main(String[] args) {
MappedByteBuffer b = null, socketMappedBuffer = null;
FileChannel channel;
String pid;
String port = "49200";
Logger logger = null;
try {
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
/*
* Mapped buffer 'b' to communicate between CheckpointRestore.java and this process.
*/
File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
pid = bean.getName();
Helper.init(TESTNAME, pid, logger);
logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
if (Helper.STATE_INIT != b.getChar(Helper.MAPPED_INDEX)) {
logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
logger.log(Level.INFO, "Creating socketBufferFile and setting the init value of buffer");
/*
* Socket Mapped Buffer to communicate between server process, client process and this process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/SocketsFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_INIT);
logger.log(Level.INFO, "Starting server and client process");
ProcessBuilder builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsServer", TESTNAME, port);
Process serverProcess = builder.start();
logger.log(Level.INFO, "Server process started");
builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsClient", TESTNAME, port);
Process clientProcess = builder.start();
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_LISTEN) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Killing the server and client process");
logger.log(Level.SEVERE, "Error took place in the client or server process; check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_CHECKPOINT) {
logger.log(Level.SEVERE, "Killing the server and client process");
logger.log(Level.SEVERE, "State is not the expected 'to be checkpointed' state");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
logger.log(Level.INFO, "Going to checkpoint server process");
SocketHelper.checkpointAndWait(b, logger, serverProcess, clientProcess);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_RESTORE);
logger.log(Level.INFO, "Process has been restored");
}
/*
* Loop while test is running.
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_FAIL && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_PASS) {
logger.log(Level.SEVERE, "Killing the server and client process");
logger.log(Level.SEVERE, "Received wrong message from the child process: not the expected finish message");
logger.log(Level.SEVERE, "Check their log files for more details");
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL) {
logger.log(Level.SEVERE, "Killing the server and client process");
logger.log(Level.SEVERE, "Error in the client or server process: check their log for details");
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
/*
* Client process puts socketMappedBuffer to Pass state if the test passed.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_PASS) {
logger.log(Level.INFO, Helper.PASS_MESSAGE);
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(0);
} catch (Exception e) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
e.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + e);
logger.log(Level.FINE, writer.toString());
}
if (b != null) {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(5);
}
}
}

133
test/javaTests/src/org/criu/java/tests/SocketsClient.java Normal file
View file

@ -0,0 +1,133 @@
package org.criu.java.tests;
import java.io.*;
import java.net.Socket;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsClient {
static String TESTNAME = "SocketsClient";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
Socket socket = null;
Logger logger = null;
String msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2",
readMssg, msg3 = "@Ft@rCPM$$g3", msg4 = "Aft@rCPM$$g4";
String parentTestName, portArg;
int port;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != SocketHelper.STATE_LISTEN) {
logger.log(Level.SEVERE, "Error: Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
logger.log(Level.INFO, "Client socket sending req to server at IP: 127.0.0.1 port:" + port);
/*
* Ensure client does not try to connect to port before server has bound itself.
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT) {
;
}
/*
* Socket Buffer should be put in SocketHelper.STATE_LISTEN state by server process, just before
* it starts listening for client connections.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != SocketHelper.STATE_LISTEN) {
logger.log(Level.SEVERE, "Error: Buffer does not contain the expected 'server bound to port and listening' state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
/*
* Ensure server has bound to port
*/
try {
Thread.sleep(10);
} catch (InterruptedException e) {
logger.log(Level.WARNING, "InterruptedException occurred!");
}
socket = new Socket(SocketHelper.IP_ADDRESS, port);
PrintStream out = new PrintStream(socket.getOutputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
logger.log(Level.INFO, "Sending message to server " + msg1);
out.println(msg1);
readMssg = br.readLine();
logger.log(Level.INFO, "Message received from server " + readMssg);
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "Error: wrong message received; message expected " + msg2);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
logger.log(Level.INFO, "Sending message to server " + msg3);
out.println(msg3);
readMssg = br.readLine();
logger.log(Level.INFO, "Message received from server " + readMssg);
if (!msg4.equals(readMssg)) {
logger.log(Level.SEVERE, "Error: wrong message received; message expected " + msg4);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
socket.close();
/*
* Wait for server process to end and then check whether it ended successfully or not
* If it has finished properly the socketMappedBuffer will contain SocketHelper.STATE_SUCCESS
*/
logger.log(Level.INFO, "Waiting for server process to end....");
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE) {
;
}
/*
* Check the server process has ended successfully, if it was a success put Mapped Buffer to pass state, else to failed state
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
logger.log(Level.INFO, "Test ends");
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
}
}
}

157
test/javaTests/src/org/criu/java/tests/SocketsConnect.java Normal file
View file

@ -0,0 +1,157 @@
package org.criu.java.tests;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsConnect {
static String TESTNAME = "SocketsConnect";
/**
* Runs the client and server process, checkpoints the server when its listening for incoming client connection requests on a port but no client has connected yet
*
* @param args Not used
*/
public static void main(String[] args) {
MappedByteBuffer b = null, socketMappedBuffer = null;
FileChannel channel;
String pid;
String port = "49200";
Logger logger = null;
try {
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
/*
* Mapped buffer 'b' to communicate between CheckpointRestore.java and this process.
*/
File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
pid = bean.getName();
Helper.init(TESTNAME, pid, logger);
logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
if (b.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
/*
* Socket Mapped Buffer to communicate between server process, client process and this process.
*/
logger.log(Level.INFO, "Creating socketbufferfile and setting the init value of buffer");
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/SocketsConnectFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
/*
* Set socketMappedBuffer to init state.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_INIT);
logger.log(Level.INFO, "Starting server and client process");
ProcessBuilder builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsConnectServer", TESTNAME, port);
Process serverProcess = builder.start();
builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsConnectClient", TESTNAME, port);
Process clientProcess = builder.start();
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Some error took place in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Exception occured in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_CHECKPOINT) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "State is not the expected 'to be checkpointed' state");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
logger.log(Level.INFO, "Going to checkpoint server process");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
logger.log(Level.WARNING, "Thread was interrupted");
}
SocketHelper.checkpointAndWait(b, logger, serverProcess, clientProcess);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_RESTORE);
logger.log(Level.INFO, "Process has been restored!");
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_LISTEN) {
;
}
char bufchar = socketMappedBuffer.getChar(Helper.MAPPED_INDEX);
if (bufchar != Helper.STATE_FAIL && bufchar != Helper.STATE_PASS && bufchar != SocketHelper.STATE_SUCCESS) {
logger.log(Level.SEVERE, "Received wrong message from the child process: not the expected finish message");
logger.log(Level.SEVERE, "Check their log files for more details");
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Error in the client or server process: check their log for details");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
;
}
/*
* Client process puts socketMappedBuffer to 'P'-Pass state if the test passed.
* Send pass message to Checkpoint-restore.java
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_PASS) {
logger.log(Level.INFO, Helper.PASS_MESSAGE);
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(0);
} catch (Exception e) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
e.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + e);
logger.log(Level.FINE, writer.toString());
}
if (b != null) {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(5);
}
}
}

130
test/javaTests/src/org/criu/java/tests/SocketsConnectClient.java Normal file
View file

@ -0,0 +1,130 @@
package org.criu.java.tests;
import java.io.*;
import java.net.Socket;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsConnectClient {
static String TESTNAME = "SocketsConnectClient";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
Socket socket = null;
String parentTestName, portArg;
int port;
Logger logger = null;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
String msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2",
readMssg, msg3 = "@Ft@rCPM$$g3", msg4 = "Aft@rCPM$$g4";
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsConnectFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_CHECKPOINT && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_RESTORE) {
logger.log(Level.SEVERE, "Error: Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
logger.log(Level.INFO, "Waiting for CR");
/*
* Wait for Checkpoint-Restore to occur
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_RESTORE) {
logger.log(Level.SEVERE, "Error:Buffer does not contain the expected restored state: " + socketMappedBuffer.getChar(Helper.MAPPED_INDEX));
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
logger.log(Level.INFO, "Restored");
logger.log(Level.INFO, "Client socket sending req to server at IP: 127.0.0.1 port:" + port);
/*
* Server should has have been listening for client connections when it was checkpointed, and it should continue to listen after restore.
*/
try {
socket = new Socket(SocketHelper.IP_ADDRESS, port);
} catch (Exception e) {
logger.log(Level.SEVERE, "Exception occured when connecting to port: " + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
PrintStream out = new PrintStream(socket.getOutputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
logger.log(Level.INFO, "Sending message to server " + msg1);
out.println(msg1);
readMssg = br.readLine();
logger.log(Level.INFO, "message received from server " + readMssg);
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received; Expected " + msg2);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
logger.log(Level.INFO, "Sending message to server " + msg3);
out.println(msg3);
readMssg = br.readLine();
logger.log(Level.INFO, "message received from server " + readMssg);
if (!msg4.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received; Expected " + msg4);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
socket.close();
/*
* Wait for server process to end.
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE) {
;
}
/*
* Check the server process has ended successfully, if it was a success put Mapped Buffer to pass state, else to failed state
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
}
}
}

151
test/javaTests/src/org/criu/java/tests/SocketsConnectServer.java Normal file
View file

@ -0,0 +1,151 @@
package org.criu.java.tests;
import java.io.*;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsConnectServer {
static String TESTNAME = "SocketsConnectServer";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
Socket socket = null;
String msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2", msg3 = "@Ft@rCPM$$g3",
msg4 = "Aft@rCPM$$g4", readMssg;
Logger logger = null;
String parentTestName, portArg;
int port;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsConnectFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
String pid = bean.getName();
SocketHelper.writePid(parentTestName, pid);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
logger.log(Level.INFO, "Server pid: " + pid);
logger.log(Level.INFO, "socket buffer connection opened");
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
ServerSocket ser = new ServerSocket(port);
logger.log(Level.INFO, "Server will be listening on Port: " + port);
/*
* Timeout after 7 sec if client does not connect
*/
try {
ser.setSoTimeout(7 * 1000);
} catch (SocketException e) {
logger.log(Level.SEVERE, "Cannot set timeout!");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
logger.log(Level.INFO, "Waiting for client to connect");
logger.log(Level.INFO, "Going to checkpoint");
try {
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
ser.close();
System.exit(1);
}
/*
* Checkpoint when server is listening for connections, and no client has connected to the server.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_CHECKPOINT);
socket = ser.accept();
SocketHelper.socketWaitForRestore(socketMappedBuffer, logger);
} catch (Exception e) {
logger.log(Level.SEVERE, "Timed out while waiting for client to connect\n" + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
if (!ser.isBound()) {
logger.log(Level.SEVERE, "Server is not bound to a port");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (ser.getLocalPort() != port) {
logger.log(Level.SEVERE, "Server is not listening on correct port");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintStream outstream = new PrintStream(socket.getOutputStream());
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 1: " + readMssg);
if (!msg1.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 1 received was wrong,received: " + readMssg + " expected: " + msg1);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
logger.log(Level.INFO, "Sending message: " + msg2);
outstream.println(msg2);
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 3: " + readMssg);
if (!msg3.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 3 received was wrong, received: " + readMssg + " expected: " + msg3);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
outstream.println(msg4);
logger.log(Level.INFO, "Sent message 4 " + msg4);
socket.close();
/*
* Put Socket-MappedBuffer to state SocketHelper.STATE_SUCCESS telling the server process has ended successfully.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
System.exit(1);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_SUCCESS);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occurred:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
}
}
}

156
test/javaTests/src/org/criu/java/tests/SocketsData.java Normal file
View file

@ -0,0 +1,156 @@
package org.criu.java.tests;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsData {
static String TESTNAME = "SocketsData";
/**
* Runs the server and client processes, checkpoints the client process when its in the middle of data transfer
*
* @param args Not used
*/
public static void main(String[] args) {
MappedByteBuffer b = null, socketMappedBuffer = null;
FileChannel channel;
String pid;
Logger logger = null;
String port = "49200";
try {
/*
* Mapped buffer 'b' to communicate between CheckpointRestore.java and this process.
*/
File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
pid = bean.getName();
Helper.init(TESTNAME, pid, logger);
logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
if (b.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
/*
* Socket Mapped Buffer to communicate between server process, client process and this process.
*/
logger.log(Level.INFO, "Creating socketbufferfile and setting the init value of buffer");
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/SocketsDataFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
/*
* Set socketMappedBuffer to init state.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_INIT);
logger.log(Level.INFO, "Starting server and client process");
ProcessBuilder builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsDataServer", TESTNAME, port);
Process serverProcess = builder.start();
builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsDataClient", TESTNAME, port);
Process clientProcess = builder.start();
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_LISTEN) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Some error took place in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Exception occured in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_CHECKPOINT) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "State is not the expected 'to be checkpointed' state");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
logger.log(Level.INFO, "Going to checkpoint client process");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
logger.log(Level.WARNING, "Thread was interrupted");
}
SocketHelper.checkpointAndWait(b, logger, serverProcess, clientProcess);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_RESTORE);
logger.log(Level.INFO, "Process has been restored!");
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE) {
;
}
char bufchar = socketMappedBuffer.getChar(Helper.MAPPED_INDEX);
if (bufchar != Helper.STATE_FAIL && bufchar != Helper.STATE_PASS && bufchar != SocketHelper.STATE_SUCCESS) {
logger.log(Level.SEVERE, "Received wrong message from the child process: not the expected finish message");
logger.log(Level.SEVERE, "Check their log files for more details");
serverProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Error in the client or server process: check their log for details");
serverProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
;
}
/*
* Client process puts socketMappedBuffer to STATE_PASS if the test passed.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_PASS) {
logger.log(Level.INFO, Helper.PASS_MESSAGE);
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
logger.log(Level.INFO, "Did not receive pass message from the client process");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
} catch (Exception e) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
e.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + e);
logger.log(Level.FINE, writer.toString());
}
if (b != null) {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(5);
}
}
}

141
test/javaTests/src/org/criu/java/tests/SocketsDataClient.java Normal file
View file

@ -0,0 +1,141 @@
package org.criu.java.tests;
import java.io.*;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.Socket;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsDataClient {
static String TESTNAME = "SocketsDataClient";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
Socket socket = null;
String parentTestName, portArg;
int port;
Logger logger = null;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
String msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2",
readMssg, msg3 = "@Ft@rCPM$$g3", msg4 = "Aft@rCPM$$g4";
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsDataFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
String pid = bean.getName();
logger.log(Level.INFO, "Client pid: " + pid);
SocketHelper.writePid(parentTestName, pid);
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != SocketHelper.STATE_LISTEN) {
logger.log(Level.SEVERE, "Error: Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT) {
;
}
/*
* Socket Mapped Buffer should be in 'Server listening for connections' state
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != SocketHelper.STATE_LISTEN) {
logger.log(Level.SEVERE, "socket-buffer not in expected state, current state: " + socketMappedBuffer.getChar(Helper.MAPPED_INDEX));
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
/*
* Server starts listening on port after putting the Mapped Buffer is in SocketHelper.STATE_LISTEN state
*/
logger.log(Level.INFO, "Client socket sending req to server at IP: 127.0.0.1 port:" + port);
try {
socket = new Socket(SocketHelper.IP_ADDRESS, port);
} catch (IOException e) {
logger.log(Level.SEVERE, "Exception occured when connecting to port: " + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
PrintStream out = new PrintStream(socket.getOutputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
logger.log(Level.INFO, "Sending message to server " + msg1);
out.println(msg1);
readMssg = br.readLine();
logger.log(Level.INFO, "message received from server " + readMssg);
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received; Expected " + msg2);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
/*
* Checkpoints and wait for Restore
*/
logger.log(Level.INFO, "Going to checkpoint");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_CHECKPOINT);
SocketHelper.socketWaitForRestore(socketMappedBuffer, logger);
logger.log(Level.INFO, "Sending message to server " + msg3);
out.println(msg3);
readMssg = br.readLine();
logger.log(Level.INFO, "message received from server " + readMssg);
if (!msg4.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received; Expected " + msg2);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
socket.close();
/*
* Wait for server process to end.
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE) {
;
}
/*
* Check the server process has ended successfully, if it was a success put Mapped Buffer to pass state, else to failed state
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
}
}
}

124
test/javaTests/src/org/criu/java/tests/SocketsDataServer.java Normal file
View file

@ -0,0 +1,124 @@
package org.criu.java.tests;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsDataServer {
static String TESTNAME = "SocketsDataServer";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
String parentTestName, portArg;
int port;
Socket socket = null;
Logger logger = null;
String msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2",
msg3 = "@Ft@rCPM$$g3", msg4 = "Aft@rCPM$$g4", readMssg;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsDataFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
logger.log(Level.INFO, "socket buffer connection opened");
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
ServerSocket ser = new ServerSocket(port);
logger.log(Level.INFO, "Server will be listening on Port " + port);
/*
* Wait for 7 seconds for client to connect, else throw a timeout exception
*/
try {
ser.setSoTimeout(7 * 1000);
} catch (SocketException e) {
logger.log(Level.SEVERE, "cannot set timeout");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
logger.log(Level.INFO, "Waiting for client to connect");
/*
* Put Socket Mapped Buffer to SocketHelper.STATE_LISTEN state - server has bound to port and
* begin listening for connections.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_LISTEN);
socket = ser.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintStream outstream = new PrintStream(socket.getOutputStream());
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 1: " + readMssg);
if (!msg1.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 1 received was wrong:rec " + readMssg + " expected: " + msg1);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
logger.log(Level.INFO, "Sending message: " + msg2);
outstream.println(msg2);
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 3: " + readMssg);
if (!msg3.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 3 received was wrong:rec " + readMssg + " expected: " + msg3);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
outstream.println(msg4);
logger.log(Level.INFO, "Sent message 4 " + msg4);
socket.close();
/*
* Put Socket-MappedBuffer to state SocketHelper.STATE_SUCCESS telling the server process has ended successfully.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
System.exit(1);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_SUCCESS);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occurred:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
}
}
}

153
test/javaTests/src/org/criu/java/tests/SocketsListen.java Normal file
View file

@ -0,0 +1,153 @@
package org.criu.java.tests;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsListen {
static String TESTNAME = "SocketsListen";
/**
* Runs the client and server process, checkpoints the server process when the server has bound to a port, but has not yet started listening
*
* @param args Not used
*/
public static void main(String[] args) {
MappedByteBuffer b = null, socketMappedBuffer = null;
FileChannel channel;
String pid;
String port = "49200";
Logger logger = null;
try {
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
/*
* Mapped buffer 'b' to communicate between CheckpointRestore.java and this process.
*/
File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
pid = bean.getName();
Helper.init(TESTNAME, pid, logger);
logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
if (b.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
logger.log(Level.INFO, "Creating socketbufferfile and setting the init value of buffer");
/*
* Socket Mapped Buffer to communicate between server process, client process and this process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/SocketsListenFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
/*
* Set socketMappedBuffer to init state.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_INIT);
logger.log(Level.INFO, "Starting server and client process");
ProcessBuilder builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsListenServer", TESTNAME, port);
Process serverProcess = builder.start();
builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsListenClient", TESTNAME, port);
Process clientProcess = builder.start();
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Some error took place in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Exception occured in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_CHECKPOINT) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "State is not the expected 'to be checkpointed' state");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
logger.log(Level.INFO, "Going to checkpoint server process");
SocketHelper.checkpointAndWait(b, logger, serverProcess, clientProcess);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_RESTORE);
logger.log(Level.INFO, "Process has been restored!");
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_LISTEN) {
;
}
char bufchar = socketMappedBuffer.getChar(Helper.MAPPED_INDEX);
if (bufchar != Helper.STATE_FAIL && bufchar != Helper.STATE_PASS && bufchar != SocketHelper.STATE_SUCCESS) {
logger.log(Level.SEVERE, "Received wrong message from the child process: not the expected finish message");
logger.log(Level.SEVERE, "Check their log files for more details");
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Error in the client or server process: check their log for details");
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
;
}
/*
* Client process puts socketMappedBuffer to Helper.STATE_PASS-Pass state if the test passed.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_PASS) {
logger.log(Level.INFO, Helper.PASS_MESSAGE);
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(0);
} catch (Exception e) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
e.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + e);
logger.log(Level.FINE, writer.toString());
}
if (b != null) {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(5);
}
}
}

136
test/javaTests/src/org/criu/java/tests/SocketsListenClient.java Normal file
View file

@ -0,0 +1,136 @@
package org.criu.java.tests;
import java.io.*;
import java.net.Socket;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsListenClient {
static String TESTNAME = "SocketsListenClient";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
Socket socket = null;
String parentTestName, portArg;
int port;
Logger logger = null;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
String msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2", readMssg,
msg3 = "@Ft@rCPM$$g3", msg4 = "Aft@rCPM$$g4";
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsListenFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_CHECKPOINT && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_RESTORE && socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != SocketHelper.STATE_LISTEN) {
logger.log(Level.SEVERE, "Error: Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
logger.log(Level.INFO, "Waiting for CR");
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
;
}
logger.log(Level.INFO, "Restored");
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != SocketHelper.STATE_LISTEN) {
logger.log(Level.SEVERE, "Buffer does not contain the expected 'server bound to port' state" + socketMappedBuffer.getChar(Helper.MAPPED_INDEX));
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
/*
* Make the thread sleep to ensure server is listening on the port for client connections.
*/
logger.log(Level.INFO, "Put thread to sleep");
try {
Thread.sleep(10);
} catch (InterruptedException e) {
logger.log(Level.WARNING, "Thread was interuptedp");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
logger.log(Level.INFO, "Client socket sending req to server at IP: 127.0.0.1 port:" + port);
try {
socket = new Socket(SocketHelper.IP_ADDRESS, port);
} catch (Exception e) {
logger.log(Level.SEVERE, "Exception occured when connecting to port: " + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
PrintStream out = new PrintStream(socket.getOutputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
logger.log(Level.INFO, "Sending message to server " + msg1);
out.println(msg1);
readMssg = br.readLine();
logger.log(Level.INFO, "message received from server " + readMssg);
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received; Expected " + msg2);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
logger.log(Level.INFO, "Sending message to server " + msg3);
out.println(msg3);
readMssg = br.readLine();
logger.log(Level.INFO, "message received from server " + readMssg);
if (!msg4.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received; Expected " + msg4);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
socket.close();
/*
* Wait for server process to end.
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_LISTEN) {
;
}
/*
* Check the server process has ended successfully, if it was a success put MappedBuffer to STATE_PASS, else to STATE_FAIL
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
}
}
}

160
test/javaTests/src/org/criu/java/tests/SocketsListenServer.java Normal file
View file

@ -0,0 +1,160 @@
package org.criu.java.tests;
import java.io.*;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsListenServer {
static String TESTNAME = "SocketsListenServer";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
String parentTestName, portArg;
int port;
Logger logger = null;
Socket socket = null;
String readMssg, msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2",
msg3 = "@Ft@rCPM$$g3", msg4 = "Aft@rCPM$$g4";
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsListenFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
String pid = bean.getName();
SocketHelper.writePid(parentTestName, pid);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
logger.log(Level.INFO, "Server pid: " + pid);
logger.log(Level.INFO, "socket buffer connection opened");
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
logger.log(Level.INFO, "Server will be listening on Port " + port);
ServerSocket ser = new ServerSocket(port);
/*
* Server has bound to a port but is not listening yet!
*/
logger.log(Level.INFO, "Going to checkpoint");
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
ser.close();
System.exit(1);
}
/*
* Checkpoint and wait for Restore.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_CHECKPOINT);
SocketHelper.socketWaitForRestore(socketMappedBuffer, logger);
if (!ser.isBound()) {
logger.log(Level.SEVERE, "Server is not bound to a port");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (ser.getLocalPort() != port) {
logger.log(Level.SEVERE, "SServer is not listening on correct port");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
/*
* Timeout after 5 sec if client does not connect
*/
try {
ser.setSoTimeout(5 * 1000);
} catch (SocketException e) {
logger.log(Level.SEVERE, "cannot set timeout");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
try {
logger.log(Level.INFO, "Waiting for client to connect");
/*
* Put Socket Mapped Buffer to SocketHelper.STATE_LISTEN state - server has bound to port and
* will begin listening for connections.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_LISTEN);
socket = ser.accept();
} catch (Exception e) {
logger.log(Level.SEVERE, "Timed out while waiting for client to connect\n" + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintStream outstream = new PrintStream(socket.getOutputStream());
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 1: " + readMssg);
if (!msg1.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 1 received was wrong:rec " + readMssg + " expected: " + msg1);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
logger.log(Level.INFO, "Sending message: " + msg2);
outstream.println(msg2);
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 3: " + readMssg);
if (!msg3.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 3 received was wrong:rec " + readMssg + " expected: " + msg3);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
outstream.println(msg4);
logger.log(Level.INFO, "Sending message: " + msg4);
/*
* Put Socket-MappedBuffer to state SocketHelper.STATE_SUCCESS telling the server process has ended successfully.
*/
socket.close();
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
System.exit(1);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_SUCCESS);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occurred:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
}
}
}

152
test/javaTests/src/org/criu/java/tests/SocketsMultiple.java Normal file
View file

@ -0,0 +1,152 @@
package org.criu.java.tests;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsMultiple {
static String TESTNAME = "SocketsMultiple";
/**
* Runs the Client and Server Processes, Multiple clients connect to server Process, checkpoints the server process
*
* @param args Not used
*/
public static void main(String[] args) {
MappedByteBuffer b = null, socketMappedBuffer = null;
FileChannel channel;
String pid;
String port = "49200";
Logger logger = null;
try {
/*
* Mapped buffer 'b' to communicate between CheckpointRestore.java and this process.
*/
File f = new File(Helper.MEMORY_MAPPED_FILE_NAME);
channel = FileChannel.open(f.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
b = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
pid = bean.getName();
Helper.init(TESTNAME, pid, logger);
logger.log(Level.INFO, "Test init done; pid written to pid file; beginning with test");
if (b.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Error: Error in memory mapping, test is not in init state");
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
/*
* Socket Mapped Buffer to communicate between server process, client process and this process.
*/
logger.log(Level.INFO, "Creating socketBufferFile and setting the init value of buffer");
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + TESTNAME + "/SocketsMultipleFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
/*
* Set socketMappedBuffer to init state.
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_INIT);
logger.log(Level.INFO, "Starting server and client process");
ProcessBuilder builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsMultipleServer", TESTNAME, port);
Process serverProcess = builder.start();
builder = new ProcessBuilder("java", "-cp", "target/classes", Helper.PACKAGE_NAME + "." + "SocketsMultipleClient", TESTNAME, port);
Process clientProcess = builder.start();
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_LISTEN) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Some error took place in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "Exception occured in the client or server process: check their log for details");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_CHECKPOINT) {
logger.log(Level.SEVERE, "Killing the server process and client process");
logger.log(Level.SEVERE, "State is not the expected 'to be checkpointed' state");
serverProcess.destroy();
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
logger.log(Level.INFO, "Going to checkpoint server process");
SocketHelper.checkpointAndWait(b, logger, serverProcess, clientProcess);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_RESTORE);
logger.log(Level.INFO, "Process has been restored!");
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE) {
;
}
char bufchar = socketMappedBuffer.getChar(Helper.MAPPED_INDEX);
if (bufchar != Helper.STATE_FAIL && bufchar != Helper.STATE_PASS && bufchar != SocketHelper.STATE_SUCCESS) {
logger.log(Level.SEVERE, "Received wrong message from the child process: not the expected finish message");
logger.log(Level.SEVERE, "Check their log files for more details");
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
logger.log(Level.SEVERE, "Error in the client or server process: check their log for details");
clientProcess.destroy();
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
;
}
/*
* Client process puts socketMappedBuffer to STATE_PASS state if the test passed.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_PASS) {
logger.log(Level.INFO, Helper.PASS_MESSAGE);
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(0);
} catch (Exception e) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
e.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + e);
logger.log(Level.FINE, writer.toString());
}
if (b != null) {
b.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
System.exit(5);
}
}
}

174
test/javaTests/src/org/criu/java/tests/SocketsMultipleClient.java Normal file
View file

@ -0,0 +1,174 @@
package org.criu.java.tests;
import java.io.*;
import java.net.Socket;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsMultipleClient {
static String TESTNAME = "SocketsMultipleClient";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
String msg1 = "Message1", msg2 = "Message2", readMssg;
Socket socket1 = null, socket2 = null, socket3 = null, socket4 = null;
String parentTestName, portArg;
int port;
Logger logger = null;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsMultipleFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != SocketHelper.STATE_LISTEN) {
logger.log(Level.SEVERE, "Error: Socket-buffer not in expected state");
}
try {
logger.log(Level.INFO, "client 1 connecting...");
socket1 = new Socket(SocketHelper.IP_ADDRESS, port);
} catch (Exception e) {
logger.log(Level.SEVERE, "Exception when client connects to server: " + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
logger.log(Level.INFO, "Client 1 connected to server successfully");
PrintStream out1 = new PrintStream(socket1.getOutputStream());
BufferedReader br1 = new BufferedReader(new InputStreamReader(socket1.getInputStream()));
logger.log(Level.INFO, "Got input and output streams for socket1");
try {
logger.log(Level.INFO, "client 2 connecting...");
socket2 = new Socket(SocketHelper.IP_ADDRESS, port);
} catch (Exception e) {
logger.log(Level.SEVERE, "Exception when client connects to server: " + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
logger.log(Level.INFO, "Client 2 connected to server successfully");
PrintStream out2 = new PrintStream(socket2.getOutputStream());
BufferedReader br2 = new BufferedReader(new InputStreamReader(socket2.getInputStream()));
logger.log(Level.INFO, "Got input and output streams for socket2");
try {
logger.log(Level.INFO, "client 3 connecting...");
socket3 = new Socket(SocketHelper.IP_ADDRESS, port);
} catch (Exception e) {
logger.log(Level.SEVERE, "Exception when client connects to server: " + e);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
logger.log(Level.INFO, "Client 3 connected to server successfully");
PrintStream out3 = new PrintStream(socket3.getOutputStream());
BufferedReader br3 = new BufferedReader(new InputStreamReader(socket3.getInputStream()));
logger.log(Level.INFO, "Got input and output streams for socket3");
out1.println(msg1);
readMssg = br1.readLine();
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received; Received: " + readMssg);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
socket1.close();
out2.println(msg1);
/*
* Wait for Checkpoint-Restore
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_INIT || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_LISTEN || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_CHECKPOINT) {
;
}
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_RESTORE) {
logger.log(Level.SEVERE, "Socket-mapped-buffer is not in restored state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
logger.log(Level.INFO, "Server is Restored!!");
out3.println(msg1);
readMssg = br2.readLine();
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received by client 2; Received: " + readMssg);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
readMssg = br3.readLine();
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received by client 3; Received: " + readMssg);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
socket2.close();
socket3.close();
try {
logger.log(Level.INFO, "client 4 connecting...");
socket4 = new Socket(SocketHelper.IP_ADDRESS, port);
} catch (Exception e) {
logger.log(Level.SEVERE, "Exception when client connects to server: " + e);
}
logger.log(Level.INFO, "Client 4 connected to server successfully");
PrintStream out4 = new PrintStream(socket4.getOutputStream());
BufferedReader br4 = new BufferedReader(new InputStreamReader(socket4.getInputStream()));
logger.log(Level.INFO, "Got input and output streams for socket4");
out4.println(msg1);
readMssg = br4.readLine();
if (!msg2.equals(readMssg)) {
logger.log(Level.SEVERE, "wrong message received by client 4; Received: " + readMssg);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
socket4.close();
/*
* Wait for server process to end.
*/
while (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_RESTORE) {
;
}
/*
* Check the server process has ended successfully, if it was a success put Mapped Buffer to STATE_PASS, else to STATE_FAIL
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == SocketHelper.STATE_SUCCESS) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_PASS);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occured:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
}
}
}

215
test/javaTests/src/org/criu/java/tests/SocketsMultipleServer.java Normal file
View file

@ -0,0 +1,215 @@
package org.criu.java.tests;
import java.io.*;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsMultipleServer {
static String TESTNAME = "SocketsMultipleServer";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
FileChannel channel;
String parentTestName, portArg;
int port;
Logger logger = null;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsMultipleFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
String pid = bean.getName();
SocketHelper.writePid(parentTestName, pid);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
logger.log(Level.INFO, "Server pid: " + pid);
logger.log(Level.INFO, "socket buffer connection opened");
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
System.exit(1);
}
/*
* The array indexes 3, 5, 7 and 9 will map the state of client 1, 2, 3 and 4.
* Set these array indexes to init state.
*/
socketMappedBuffer.putChar(3, Helper.STATE_INIT);
socketMappedBuffer.putChar(5, Helper.STATE_INIT);
socketMappedBuffer.putChar(7, Helper.STATE_INIT);
socketMappedBuffer.putChar(9, Helper.STATE_INIT);
ServerSocket ser = new ServerSocket(port);
logger.log(Level.INFO, "Server will be listening on Port " + port);
Socket[] sockets = new Socket[4];
/*
* Set the SocketMappedBuffer to S state-server will be listening for connections
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_LISTEN);
for (int i = 1; i <= 4; i++) {
sockets[i - 1] = ser.accept();
ServerThread serverThread = new ServerThread(sockets[i - 1], "ser-socket " + i, 2 * i + 1, logger, socketMappedBuffer);
serverThread.start();
if (i == 3) {
logger.log(Level.INFO, "Connected to client: 3");
/*
* Client 3 has connected, wait for thread 1 to finish and then checkpoint.
*/
while (socketMappedBuffer.getChar(3) != Helper.STATE_FAIL && socketMappedBuffer.getChar(3) != Helper.STATE_PASS) {
;
}
logger.log(Level.INFO, "Going to checkpoint");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_CHECKPOINT);
SocketHelper.socketWaitForRestore(socketMappedBuffer, logger);
}
}
/*
* Loop while any of the 4 thread is running
*/
while (socketMappedBuffer.getChar(3) == Helper.STATE_INIT || socketMappedBuffer.getChar(5) == Helper.STATE_INIT
|| socketMappedBuffer.getChar(7) == Helper.STATE_INIT || socketMappedBuffer.getChar(9) == Helper.STATE_INIT) {
;
}
/*
* Check Socket Mapped Buffer for a thread that failed
*/
for (int i = 1; i <= 4; i++) {
if (socketMappedBuffer.getChar(i * 2 + 1) == Helper.STATE_FAIL) {
logger.log(Level.SEVERE, "Error in thread connected to client " + i);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
}
/*
* Check the 1st Socket is closed
*/
if (!sockets[0].isClosed()) {
logger.log(Level.SEVERE, "socket 1 is not closed");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
logger.log(Level.INFO, "Socket 1 is in expected closed state: " + sockets[0].isClosed());
/*
* Check all threads are in expected pass state
*/
for (int i = 1; i <= 4; i++) {
if (socketMappedBuffer.getChar(i * 2 + 1) != Helper.STATE_PASS) {
logger.log(Level.SEVERE, "Unexpected State of buffer: " + socketMappedBuffer.getChar(i * 2 + 1) + ", client: " + i);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
}
logger.log(Level.INFO, "Done");
/*
* Put Socket-MappedBuffer to state SocketHelper.STATE_SUCCESS telling the server process has ended successfully.
*/
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
System.exit(1);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_SUCCESS);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occurred:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
}
}
}
class ServerThread extends Thread {
Socket socket = null;
String name;
int num;
MappedByteBuffer socketMappedBuffer;
Logger logger;
ServerThread(Socket socket, String name, int num, Logger logger, MappedByteBuffer socketMappedBuffer) {
this.socket = socket;
this.name = name;
this.logger = logger;
this.num = num;
this.socketMappedBuffer = socketMappedBuffer;
}
public void run() {
try {
String readMssg, msg1 = "Message1", msg2 = "Message2";
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintStream out = new PrintStream(socket.getOutputStream());
readMssg = br.readLine();
if (!msg1.equals(readMssg)) {
logger.log(Level.SEVERE, "Message read by thread " + name + " was not 'Message1', received Message: " + readMssg);
socket.close();
socketMappedBuffer.putChar(num, Helper.STATE_FAIL);
} else {
logger.log(Level.INFO, name + " received correct message");
out.println(msg2);
logger.log(Level.INFO, name + " has sent message");
socket.close();
socketMappedBuffer.putChar(num, Helper.STATE_PASS);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occurred in thread :" + name + " " + exception);
logger.log(Level.FINE, writer.toString());
}
try {
if (socket != null) {
socket.close();
}
} catch (IOException e) {
;
}
/*
* If exception occurs fail the thread
*/
socketMappedBuffer.putChar(num, Helper.STATE_FAIL);
}
}
}

142
test/javaTests/src/org/criu/java/tests/SocketsServer.java Normal file
View file

@ -0,0 +1,142 @@
package org.criu.java.tests;
import java.io.*;
import java.lang.management.ManagementFactory;
import java.lang.management.RuntimeMXBean;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.file.StandardOpenOption;
import java.util.logging.Level;
import java.util.logging.Logger;
class SocketsServer {
static String TESTNAME = "SocketsServer";
public static void main(String[] args) {
MappedByteBuffer socketMappedBuffer = null;
String msg1 = "Ch@ckM@$$@Ge!1", msg2 = "cH@C!m$SG!!2",
msg3 = "@Ft@rCPM$$g3", msg4 = "Aft@rCPM$$g4", readMssg;
FileChannel channel;
String parentTestName, portArg;
int port;
Logger logger = null;
try {
parentTestName = args[0];
portArg = args[1];
port = Integer.parseInt(portArg);
/*
* Socket Mapped Buffer to communicate between server process, client process and the calling parent process.
*/
File socketfile = new File(Helper.OUTPUT_FOLDER_NAME + "/" + parentTestName + "/SocketsFile");
channel = FileChannel.open(socketfile.toPath(), StandardOpenOption.READ, StandardOpenOption.WRITE, StandardOpenOption.CREATE);
socketMappedBuffer = channel.map(MapMode.READ_WRITE, 0, Helper.MAPPED_REGION_SIZE);
channel.close();
logger = Logger.getLogger(Helper.PACKAGE_NAME + "." + TESTNAME);
SocketHelper.init(TESTNAME, parentTestName, logger);
logger.log(Level.INFO, "Begin");
logger.log(Level.INFO, "Parent name: " + parentTestName);
RuntimeMXBean bean = ManagementFactory.getRuntimeMXBean();
String pid = bean.getName();
SocketHelper.writePid(parentTestName, pid);
logger.log(Level.INFO, "Socket buffer mapped");
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) != Helper.STATE_INIT) {
logger.log(Level.SEVERE, "Socket-buffer not in expected Init state");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
ServerSocket ser = new ServerSocket(port);
logger.log(Level.INFO, "Server will be listening on Port " + port);
/*
* Timeout after 5 second if client does not connect
*/
ser.setSoTimeout(5 * 1000);
logger.log(Level.INFO, "Waiting for client to connect");
Socket socket = null;
try {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_LISTEN);
socket = ser.accept();
} catch (Exception e) {
logger.log(Level.SEVERE, "Timed out while waiting for client to connect");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintStream outstream = new PrintStream(socket.getOutputStream());
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 1: " + readMssg);
if (!msg1.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 1 received was wrong:rec " + readMssg + " expected: " + msg1);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_END);
}
logger.log(Level.INFO, "Sending message: " + msg2);
outstream.println(msg2);
logger.log(Level.INFO, "Going to checkpoint");
/*
* Put socket Mapped Buffer to 'to be checkpointed' state and wait for restore
*/
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_CHECKPOINT);
SocketHelper.socketWaitForRestore(socketMappedBuffer, logger);
if (!ser.isBound()) {
logger.log(Level.SEVERE, "Server is not bound to a port");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
if (ser.getLocalPort() != port) {
logger.log(Level.SEVERE, "Server is not listening on correct port");
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
System.exit(1);
}
readMssg = br.readLine();
logger.log(Level.INFO, "Read message 3: " + readMssg);
if (!msg3.equals(readMssg)) {
logger.log(Level.SEVERE, "Message 3 received was wrong:rec " + readMssg + " expected: " + msg3);
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
socket.close();
System.exit(1);
}
outstream.println(msg4);
logger.log(Level.INFO, "Sent message 4 " + msg4);
/*
* Put Socket-MappedBuffer to state SocketHelper.STATE_SUCCESS telling the server process has ended successfully.
*/
socket.close();
if (socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_FAIL || socketMappedBuffer.getChar(Helper.MAPPED_INDEX) == Helper.STATE_END) {
System.exit(1);
} else {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, SocketHelper.STATE_SUCCESS);
}
} catch (Exception exception) {
if (null != logger) {
StringWriter writer = new StringWriter();
PrintWriter printWriter = new PrintWriter(writer);
exception.printStackTrace(printWriter);
logger.log(Level.SEVERE, "Exception occurred:" + exception);
logger.log(Level.FINE, writer.toString());
}
if (socketMappedBuffer != null) {
socketMappedBuffer.putChar(Helper.MAPPED_INDEX, Helper.STATE_FAIL);
}
}
}
}

46
test/javaTests/test.xml
View file

@ -40,4 +40,50 @@
</classes>
</test>
<test name = "test6-Sockets">
<parameter name="testname" value="Sockets"/>
<parameter name="checkpointOpt" value="--tcp-established"/>
<parameter name="restoreOpt" value="--tcp-established"/>
<classes>
<class name = "org.criu.java.tests.CheckpointRestore"/>
</classes>
</test>
<test name = "test7-SocketsListen">
<parameter name="testname" value="SocketsListen"/>
<parameter name="checkpointOpt" value="--tcp-established"/>
<parameter name="restoreOpt" value="--tcp-established"/>
<classes>
<class name = "org.criu.java.tests.CheckpointRestore"/>
</classes>
</test>
<test name = "test8-SocketsConnect">
<parameter name="testname" value="SocketsConnect"/>
<parameter name="checkpointOpt" value="--tcp-established"/>
<parameter name="restoreOpt" value="--tcp-established"/>
<classes>
<class name = "org.criu.java.tests.CheckpointRestore"/>
</classes>
</test>
<test name = "test9-SocketsMultiple">
<parameter name="testname" value="SocketsMultiple"/>
<parameter name="checkpointOpt" value="--tcp-established"/>
<parameter name="restoreOpt" value="--tcp-established"/>
<classes>
<class name = "org.criu.java.tests.CheckpointRestore"/>
</classes>
</test>
<test name = "test10-SocketsData">
<parameter name="testname" value="SocketsData"/>
<parameter name="checkpointOpt" value="--tcp-established"/>
<parameter name="restoreOpt" value="--tcp-established"/>
<classes>
<class name = "org.criu.java.tests.CheckpointRestore"/>
</classes>
</test>
</suite>