@Test(timeout = 90000)
public void testRPCInterruptedSimple() throws Exception {
final Configuration conf = new Configuration();
Server server =
RPC.getServer(TestProtocol.class, new TestImpl(), ADDRESS, 0, 5, true, conf, null);
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
final TestProtocol proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
// Connect to the server
proxy.ping();
// Interrupt self, try another call
Thread.currentThread().interrupt();
try {
proxy.ping();
fail("Interruption did not cause IPC to fail");
} catch (IOException ioe) {
if (!ioe.toString().contains("InterruptedException")) {
throw ioe;
}
// clear interrupt status for future tests
Thread.interrupted();
} finally {
server.stop();
}
}
@Test
public void testConnectionPing() throws Exception {
Configuration conf = new Configuration();
int pingInterval = 50;
conf.setBoolean(CommonConfigurationKeys.IPC_CLIENT_PING_KEY, true);
conf.setInt(CommonConfigurationKeys.IPC_PING_INTERVAL_KEY, pingInterval);
final Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.build();
server.start();
final TestProtocol proxy =
RPC.getProxy(TestProtocol.class, TestProtocol.versionID, server.getListenerAddress(), conf);
try {
// this call will throw exception if server couldn't decode the ping
proxy.sleep(pingInterval * 4);
} finally {
if (proxy != null) RPC.stopProxy(proxy);
server.stop();
}
}
public void testSerial(
int handlerCount, boolean handlerSleep, int clientCount, int callerCount, int callCount)
throws Exception {
Server server = new TestServer(handlerCount, handlerSleep);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
server.start();
Client[] clients = new Client[clientCount];
for (int i = 0; i < clientCount; i++) {
clients[i] = new Client(LongWritable.class, conf);
}
SerialCaller[] callers = new SerialCaller[callerCount];
for (int i = 0; i < callerCount; i++) {
callers[i] = new SerialCaller(clients[i % clientCount], addr, callCount);
callers[i].start();
}
for (int i = 0; i < callerCount; i++) {
callers[i].join();
assertFalse(callers[i].failed);
}
for (int i = 0; i < clientCount; i++) {
clients[i].stop();
}
server.stop();
}
@Test
public void testProxyAddress() throws IOException {
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.build();
TestProtocol proxy = null;
try {
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
// create a client
proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
assertEquals(addr, RPC.getServerAddress(proxy));
} finally {
server.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
}
}
private void doRPCs(Configuration conf, boolean expectFailure) throws Exception {
SecurityUtil.setPolicy(new ConfiguredPolicy(conf, new TestPolicyProvider()));
Server server = RPC.getServer(new TestImpl(), ADDRESS, 0, 5, true, conf);
TestProtocol proxy = null;
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
try {
proxy = (TestProtocol) RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
if (expectFailure) {
fail("Expect RPC.getProxy to fail with AuthorizationException!");
}
} catch (RemoteException e) {
if (expectFailure) {
assertTrue(e.unwrapRemoteException() instanceof AuthorizationException);
} else {
throw e;
}
} finally {
server.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
}
}
/** Test that server.stop() properly stops all threads */
@Test
public void testStopsAllThreads() throws IOException, InterruptedException {
int threadsBefore = countThreads("Server$Listener$Reader");
assertEquals("Expect no Reader threads running before test", 0, threadsBefore);
final Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.build();
server.start();
try {
// Wait for at least one reader thread to start
int threadsRunning = 0;
long totalSleepTime = 0;
do {
totalSleepTime += 10;
Thread.sleep(10);
threadsRunning = countThreads("Server$Listener$Reader");
} while (threadsRunning == 0 && totalSleepTime < 5000);
// Validate that at least one thread started (we didn't timeout)
threadsRunning = countThreads("Server$Listener$Reader");
assertTrue(threadsRunning > 0);
} finally {
server.stop();
}
int threadsAfter = countThreads("Server$Listener$Reader");
assertEquals("Expect no Reader threads left running after test", 0, threadsAfter);
}
@Test
public void testConfRpc() throws IOException {
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(1)
.setVerbose(false)
.build();
// Just one handler
int confQ =
conf.getInt(
CommonConfigurationKeys.IPC_SERVER_HANDLER_QUEUE_SIZE_KEY,
CommonConfigurationKeys.IPC_SERVER_HANDLER_QUEUE_SIZE_DEFAULT);
assertEquals(confQ, server.getMaxQueueSize());
int confReaders =
conf.getInt(
CommonConfigurationKeys.IPC_SERVER_RPC_READ_THREADS_KEY,
CommonConfigurationKeys.IPC_SERVER_RPC_READ_THREADS_DEFAULT);
assertEquals(confReaders, server.getNumReaders());
server.stop();
server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(1)
.setnumReaders(3)
.setQueueSizePerHandler(200)
.setVerbose(false)
.build();
assertEquals(3, server.getNumReaders());
assertEquals(200, server.getMaxQueueSize());
server.stop();
}
public void windowClosing(WindowEvent e) {
if (server != null) {
try {
server.stop();
} catch (Exception eClose) {
}
server = null;
}
dispose();
System.exit(0);
}
@Test
public void session() throws Exception {
Client c = new Client();
Server<Object> s = new Server<Object>(TEST_AUTHENTICATOR, TEST_MANAGER);
assertEquals(TEST_AUTHENTICATOR, s.getAuthenticator());
try {
c.assertValidSession();
fail();
} catch (I18NException ex) {
assertEquals(Messages.NOT_LOGGED_IN, ex.getI18NBoundMessage());
}
c.login(TEST_USER, TEST_PASSWORD);
SessionId id = c.getSessionId();
assertNotNull(id);
assertEquals(id, c.getContext().getSessionId());
assertEquals(TEST_USER, TEST_MANAGER.get(id).getUser());
try {
c.login(TEST_USER, TEST_PASSWORD);
fail();
} catch (I18NException ex) {
assertEquals(Messages.ALREADY_LOGGED_IN, ex.getI18NBoundMessage());
}
assertEquals(id, c.getSessionId());
assertEquals(TEST_USER, TEST_MANAGER.get(id).getUser());
c.logout();
assertNull(c.getSessionId());
assertNull(c.getContext().getSessionId());
assertNull(TEST_MANAGER.get(id));
try {
c.login(TEST_USER_D, TEST_PASSWORD);
fail();
} catch (RemoteException ex) {
assertEquals(Messages.BAD_CREDENTIALS, ((I18NException) ex.getCause()).getI18NBoundMessage());
}
assertNull(c.getSessionId());
c.logout();
s.stop();
try {
c.login(TEST_USER, TEST_PASSWORD);
fail();
} catch (WebServiceException ex) {
// Desired.
}
}
@Test
public void testSlowRpc() throws IOException {
System.out.println("Testing Slow RPC");
// create a server with two handlers
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(2)
.setVerbose(false)
.build();
TestProtocol proxy = null;
try {
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
// create a client
proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
SlowRPC slowrpc = new SlowRPC(proxy);
Thread thread = new Thread(slowrpc, "SlowRPC");
thread.start(); // send a slow RPC, which won't return until two fast pings
assertTrue("Slow RPC should not have finished1.", !slowrpc.isDone());
proxy.slowPing(false); // first fast ping
// verify that the first RPC is still stuck
assertTrue("Slow RPC should not have finished2.", !slowrpc.isDone());
proxy.slowPing(false); // second fast ping
// Now the slow ping should be able to be executed
while (!slowrpc.isDone()) {
System.out.println("Waiting for slow RPC to get done.");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
}
}
} finally {
server.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
System.out.println("Down slow rpc testing");
}
}
/*
* If the user click the X button to close the application
* I need to close the connection with the server to free the port
*/
public void windowClosing(WindowEvent e) {
// if my Server exist
if (server != null) {
try {
server.stop(); // ask the server to close the conection
} catch (Exception eClose) {
}
server = null;
}
// dispose the frame
dispose();
System.exit(0);
}
private void doRPCs(Configuration conf, boolean expectFailure) throws IOException {
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.build();
server.refreshServiceAcl(conf, new TestPolicyProvider());
TestProtocol proxy = null;
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
try {
proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
if (expectFailure) {
fail("Expect RPC.getProxy to fail with AuthorizationException!");
}
} catch (RemoteException e) {
if (expectFailure) {
assertTrue(e.unwrapRemoteException() instanceof AuthorizationException);
} else {
throw e;
}
} finally {
server.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
MetricsRecordBuilder rb = getMetrics(server.rpcMetrics.name());
if (expectFailure) {
assertCounter("RpcAuthorizationFailures", 1, rb);
} else {
assertCounter("RpcAuthorizationSuccesses", 1, rb);
}
// since we don't have authentication turned ON, we should see
// 0 for the authentication successes and 0 for failure
assertCounter("RpcAuthenticationFailures", 0, rb);
assertCounter("RpcAuthenticationSuccesses", 0, rb);
}
}
public void actionPerformed(ActionEvent e) {
// if running we have to stop
if (server != null) {
server.stop();
server = null;
tPortNumber.setEditable(true);
stopStart.setText("Start");
return;
}
// OK start the server
int port;
try {
port = Integer.parseInt(tPortNumber.getText().trim());
} catch (Exception er) {
appendEvent("Invalid port number");
return;
}
// ceate a new Server
server = new Server(port, this);
// and start it as a thread
new ServerRunning().start();
stopStart.setText("Stop");
tPortNumber.setEditable(false);
}
@Test
public void testServerAddress() throws IOException {
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.build();
InetSocketAddress bindAddr = null;
try {
bindAddr = NetUtils.getConnectAddress(server);
} finally {
server.stop();
}
assertEquals(bindAddr.getAddress(), InetAddress.getLocalHost());
}
public void actionPerformed(ActionEvent e) {
if (server != null) {
server.stop();
server = null;
tPortNumber.setEditable(true);
stopStart.setText("Start");
return;
}
int port;
try {
port = Integer.parseInt(tPortNumber.getText().trim());
} catch (Exception er) {
appendEvent("Invalid port number.");
return;
}
server = new Server(port, this);
new ServerRunning().start();
stopStart.setText("Stop");
tPortNumber.setEditable(false);
}
/**
* {@inheritDoc}
*
* @see
* com.continuent.tungsten.replicator.plugin.ReplicatorPlugin#release(com.continuent.tungsten.replicator.plugin.PluginContext)
*/
public synchronized void release(PluginContext context)
throws InterruptedException, ReplicatorException {
// Cancel server.
if (server != null) {
try {
server.stop();
} catch (InterruptedException e) {
logger.warn("Server stop operation was unexpectedly interrupted", e);
} finally {
server = null;
}
}
if (catalog != null) {
catalog.close();
catalog = null;
}
if (diskLog != null) {
diskLog.release();
diskLog = null;
}
}
@Test
public void testRpcMetrics() throws Exception {
Configuration configuration = new Configuration();
final int interval = 1;
configuration.setBoolean(CommonConfigurationKeys.RPC_METRICS_QUANTILE_ENABLE, true);
configuration.set(CommonConfigurationKeys.RPC_METRICS_PERCENTILES_INTERVALS_KEY, "" + interval);
final Server server =
new RPC.Builder(configuration)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.build();
server.start();
final TestProtocol proxy =
RPC.getProxy(
TestProtocol.class, TestProtocol.versionID, server.getListenerAddress(), configuration);
try {
for (int i = 0; i < 1000; i++) {
proxy.ping();
proxy.echo("" + i);
}
MetricsRecordBuilder rpcMetrics = getMetrics(server.getRpcMetrics().name());
assertTrue(
"Expected non-zero rpc queue time", getLongCounter("RpcQueueTimeNumOps", rpcMetrics) > 0);
assertTrue(
"Expected non-zero rpc processing time",
getLongCounter("RpcProcessingTimeNumOps", rpcMetrics) > 0);
MetricsAsserts.assertQuantileGauges("RpcQueueTime" + interval + "s", rpcMetrics);
MetricsAsserts.assertQuantileGauges("RpcProcessingTime" + interval + "s", rpcMetrics);
} finally {
if (proxy != null) {
RPC.stopProxy(proxy);
}
server.stop();
}
}
@Test
public void testErrorMsgForInsecureClient() throws IOException {
Configuration serverConf = new Configuration(conf);
SecurityUtil.setAuthenticationMethod(AuthenticationMethod.KERBEROS, serverConf);
UserGroupInformation.setConfiguration(serverConf);
final Server server =
new RPC.Builder(serverConf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.build();
server.start();
UserGroupInformation.setConfiguration(conf);
boolean succeeded = false;
final InetSocketAddress addr = NetUtils.getConnectAddress(server);
TestProtocol proxy = null;
try {
proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.echo("");
} catch (RemoteException e) {
LOG.info("LOGGING MESSAGE: " + e.getLocalizedMessage());
assertTrue(e.unwrapRemoteException() instanceof AccessControlException);
succeeded = true;
} finally {
server.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
}
assertTrue(succeeded);
conf.setInt(CommonConfigurationKeys.IPC_SERVER_RPC_READ_THREADS_KEY, 2);
UserGroupInformation.setConfiguration(serverConf);
final Server multiServer =
new RPC.Builder(serverConf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.build();
multiServer.start();
succeeded = false;
final InetSocketAddress mulitServerAddr = NetUtils.getConnectAddress(multiServer);
proxy = null;
try {
UserGroupInformation.setConfiguration(conf);
proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, mulitServerAddr, conf);
proxy.echo("");
} catch (RemoteException e) {
LOG.info("LOGGING MESSAGE: " + e.getLocalizedMessage());
assertTrue(e.unwrapRemoteException() instanceof AccessControlException);
succeeded = true;
} finally {
multiServer.stop();
if (proxy != null) {
RPC.stopProxy(proxy);
}
}
assertTrue(succeeded);
}
private void testCallsInternal(Configuration conf) throws IOException {
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.build();
TestProtocol proxy = null;
try {
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
proxy = RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
String stringResult = proxy.echo("foo");
assertEquals(stringResult, "foo");
stringResult = proxy.echo((String) null);
assertEquals(stringResult, null);
// Check rpcMetrics
MetricsRecordBuilder rb = getMetrics(server.rpcMetrics.name());
assertCounter("RpcProcessingTimeNumOps", 3L, rb);
assertCounterGt("SentBytes", 0L, rb);
assertCounterGt("ReceivedBytes", 0L, rb);
// Number of calls to echo method should be 2
rb = getMetrics(server.rpcDetailedMetrics.name());
assertCounter("EchoNumOps", 2L, rb);
// Number of calls to ping method should be 1
assertCounter("PingNumOps", 1L, rb);
String[] stringResults = proxy.echo(new String[] {"foo", "bar"});
assertTrue(Arrays.equals(stringResults, new String[] {"foo", "bar"}));
stringResults = proxy.echo((String[]) null);
assertTrue(Arrays.equals(stringResults, null));
UTF8 utf8Result = (UTF8) proxy.echo(new UTF8("hello world"));
assertEquals(utf8Result, new UTF8("hello world"));
utf8Result = (UTF8) proxy.echo((UTF8) null);
assertEquals(utf8Result, null);
int intResult = proxy.add(1, 2);
assertEquals(intResult, 3);
intResult = proxy.add(new int[] {1, 2});
assertEquals(intResult, 3);
// Test protobufs
EnumDescriptorProto sendProto = EnumDescriptorProto.newBuilder().setName("test").build();
EnumDescriptorProto retProto = proxy.exchangeProto(sendProto);
assertEquals(sendProto, retProto);
assertNotSame(sendProto, retProto);
boolean caught = false;
try {
proxy.error();
} catch (IOException e) {
if (LOG.isDebugEnabled()) {
LOG.debug("Caught " + e);
}
caught = true;
}
assertTrue(caught);
proxy.testServerGet();
// create multiple threads and make them do large data transfers
System.out.println("Starting multi-threaded RPC test...");
server.setSocketSendBufSize(1024);
Thread threadId[] = new Thread[numThreads];
for (int i = 0; i < numThreads; i++) {
Transactions trans = new Transactions(proxy, datasize);
threadId[i] = new Thread(trans, "TransactionThread-" + i);
threadId[i].start();
}
// wait for all transactions to get over
System.out.println("Waiting for all threads to finish RPCs...");
for (int i = 0; i < numThreads; i++) {
try {
threadId[i].join();
} catch (InterruptedException e) {
i--; // retry
}
}
} finally {
server.stop();
if (proxy != null) RPC.stopProxy(proxy);
}
}
public void actionPerformed(ActionEvent e) {
String NameItem = (((JMenuItem) e.getSource()).getText());
if (NameItem == "Load File") {
// all files disabled
fc.setAcceptAllFileFilterUsed(false);
// only XML files
FileNameExtensionFilter xmlfilter =
new FileNameExtensionFilter("xml files (*.xml)", "xml");
fc.setFileFilter(xmlfilter);
// Set Directory!!
fc.setCurrentDirectory(new java.io.File("data"));
// Open XML
fc.setDialogTitle("Open XML");
int returnVal = fc.showOpenDialog(null);
if (returnVal == JFileChooser.APPROVE_OPTION) {
File file = fc.getSelectedFile();
String FileLocation = file.getPath();
textArea.setText("");
// textArea.setText(FileLocation + "\n" + "\n");
// Parse XML
xmlParser parser = new xmlParser();
final ContainerSetXml containers;
try {
long time = System.nanoTime();
containers = parser.parse(FileLocation);
System.out.println(
"It took" + (System.nanoTime() - time) + "ns to parse the xml file");
// new Thread for display next container after some time
Thread t =
new Thread() {
public void run() {
for (ContainerXml c : containers.containers) {
DateFormat dateFormat = new SimpleDateFormat(" HH:mm:ss");
Calendar now = Calendar.getInstance();
String Time = "[" + dateFormat.format(now.getTime()) + "]";
textArea.append(Time + " " + c.id + " " + c.ownerName + "\n");
textArea.setCaretPosition(textArea.getDocument().getLength());
try {
sleep(150); // milliseconds
} catch (InterruptedException ex) {
}
}
}
};
t.start(); // call back run()
} catch (Exception ex) {
System.out.println(ex);
}
}
} else if (NameItem == "Start server") {
// server.start() launches server.run() in a new thread
// Meaning server.start won't freeze the gui anymore
server.start(6666);
} else if (NameItem == "Login to ftp") {
FtpLoginView ftpLoginView = new FtpLoginView(server);
ftpLoginView.display();
String name = ftpLoginView.name;
String password = ftpLoginView.name;
// server.login() is called in ftpLoginView
} else if (NameItem == "About") {
JOptionPane.showMessageDialog(
null,
"Mede mogelijk gemaakt door Groep 5!",
"About",
JOptionPane.INFORMATION_MESSAGE);
} else if (NameItem == "Help") {
JOptionPane.showMessageDialog(
null, "Moet nog ingevuld worden!", "Help", JOptionPane.INFORMATION_MESSAGE);
} else if (NameItem == "Quit") {
System.exit(0);
} else if (NameItem == "Restart server") {
server.restart(6666);
} else if (NameItem == "Stop server") {
server.stop();
}
}
public static void main(String[] args) throws Exception {
int timeout = (int) Duration.ONE_HOUR.getMilliseconds();
Server server = new Server();
SocketConnector connector = new SocketConnector();
// Set some timeout options to make debugging easier.
connector.setMaxIdleTime(timeout);
connector.setSoLingerTime(-1);
connector.setPort(8080);
server.addConnector(connector);
Resource keystore = Resource.newClassPathResource("/keystore");
if (keystore != null && keystore.exists()) {
// if a keystore for a SSL certificate is available, start a SSL
// connector on port 8443.
// By default, the quickstart comes with a Apache Wicket Quickstart
// Certificate that expires about half way september 2021. Do not
// use this certificate anywhere important as the passwords are
// available in the source.
connector.setConfidentialPort(8443);
SslContextFactory factory = new SslContextFactory();
factory.setKeyStoreResource(keystore);
factory.setKeyStorePassword("wicket");
factory.setTrustStoreResource(keystore);
factory.setKeyManagerPassword("wicket");
SslSocketConnector sslConnector = new SslSocketConnector(factory);
sslConnector.setMaxIdleTime(timeout);
sslConnector.setPort(8443);
sslConnector.setAcceptors(4);
server.addConnector(sslConnector);
System.out.println("SSL access to the quickstart has been enabled on port 8443");
System.out.println("You can access the application using SSL on https://localhost:8443");
System.out.println();
}
WebAppContext bb = new WebAppContext();
bb.setServer(server);
bb.setContextPath("/");
bb.setWar("src/main/webapp");
// START JMX SERVER
// MBeanServer mBeanServer = ManagementFactory.getPlatformMBeanServer();
// MBeanContainer mBeanContainer = new MBeanContainer(mBeanServer);
// server.getContainer().addEventListener(mBeanContainer);
// mBeanContainer.start();
server.setHandler(bb);
try {
System.out.println(">>> STARTING EMBEDDED JETTY SERVER, PRESS ANY KEY TO STOP");
server.start();
System.in.read();
System.out.println(">>> STOPPING EMBEDDED JETTY SERVER");
server.stop();
server.join();
} catch (Exception e) {
e.printStackTrace();
System.exit(1);
}
}
@Override
protected void doExecute() throws MojoExecutionException, MojoFailureException {
final Log log = getLog();
final File deploymentFile = file();
// The deployment must exist before we do anything
if (!deploymentFile.exists()) {
throw new MojoExecutionException(
String.format(
"The deployment '%s' could not be found.", deploymentFile.getAbsolutePath()));
}
// Validate the environment
final Path jbossHome = extractIfRequired(deploymentFile.getParentFile().toPath());
if (!Files.isDirectory(jbossHome)) {
throw new MojoExecutionException(
String.format("JBOSS_HOME '%s' is not a valid directory.", jbossHome));
}
final StandaloneCommandBuilder commandBuilder =
StandaloneCommandBuilder.of(jbossHome)
.setJavaHome(javaHome)
.addModuleDirs(modulesPath.getModulePaths());
// Set the JVM options
if (javaOpts != null) {
commandBuilder.setJavaOptions(javaOpts);
} else if (jvmArgs != null) {
commandBuilder.setJavaOptions(jvmArgs.split("\\s+"));
}
if (serverConfig != null) {
commandBuilder.setServerConfiguration(serverConfig);
}
if (propertiesFile != null) {
commandBuilder.setPropertiesFile(propertiesFile);
}
if (serverArgs != null) {
commandBuilder.addServerArguments(serverArgs);
}
// Check for management overrides
final ModelControllerClientConfiguration clientConfiguration = getClientConfiguration();
final String host = clientConfiguration.getHost();
final int port = clientConfiguration.getPort();
if (host != null) {
commandBuilder.setBindAddressHint("management", host);
}
if (port > 0) {
commandBuilder.addServerArguments("-Djboss.management.http.port=" + port);
}
// Print some server information
log.info(String.format("JAVA_HOME=%s", commandBuilder.getJavaHome()));
log.info(String.format("JBOSS_HOME=%s%n", commandBuilder.getWildFlyHome()));
Server server = null;
try (final ManagementClient client = createClient()) {
// Create the server
server = Server.create(commandBuilder, client);
// Start the server
log.info("Server is starting up. Press CTRL + C to stop the server.");
server.start(startupTimeout);
// Deploy the application
server.checkServerState();
if (server.isRunning()) {
log.info(String.format("Deploying application '%s'%n", deploymentFile.getName()));
final Deployment deployment =
StandaloneDeployment.create(client, deploymentFile, name, getType(), null, null);
switch (executeDeployment(client, deployment, jbossHome)) {
case REQUIRES_RESTART:
{
client.execute(ServerOperations.createOperation(ServerOperations.RELOAD));
break;
}
case SUCCESS:
break;
}
} else {
throw new DeploymentFailureException("Cannot deploy to a server that is not running.");
}
while (server.isRunning()) {
TimeUnit.SECONDS.sleep(1L);
}
} catch (Exception e) {
throw new MojoExecutionException("The server failed to start", e);
} finally {
if (server != null) server.stop();
}
}
@Test(timeout = 30000)
public void testRPCInterrupted() throws IOException, InterruptedException {
final Configuration conf = new Configuration();
Server server =
RPC.getServer(TestProtocol.class, new TestImpl(), ADDRESS, 0, 5, true, conf, null);
server.start();
int numConcurrentRPC = 200;
InetSocketAddress addr = NetUtils.getConnectAddress(server);
final CyclicBarrier barrier = new CyclicBarrier(numConcurrentRPC);
final CountDownLatch latch = new CountDownLatch(numConcurrentRPC);
final AtomicBoolean leaderRunning = new AtomicBoolean(true);
final AtomicReference<Throwable> error = new AtomicReference<Throwable>();
Thread leaderThread = null;
for (int i = 0; i < numConcurrentRPC; i++) {
final int num = i;
final TestProtocol proxy =
RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
Thread rpcThread =
new Thread(
new Runnable() {
@Override
public void run() {
try {
barrier.await();
while (num == 0 || leaderRunning.get()) {
proxy.slowPing(false);
}
proxy.slowPing(false);
} catch (Exception e) {
if (num == 0) {
leaderRunning.set(false);
} else {
error.set(e);
}
LOG.error(e);
} finally {
latch.countDown();
}
}
});
rpcThread.start();
if (leaderThread == null) {
leaderThread = rpcThread;
}
}
// let threads get past the barrier
Thread.sleep(1000);
// stop a single thread
while (leaderRunning.get()) {
leaderThread.interrupt();
}
latch.await();
// should not cause any other thread to get an error
assertTrue("rpc got exception " + error.get(), error.get() == null);
server.stop();
}
public void run(int selfId) {
long initTime, lastRoundTime;
BufferedWriter out = null;
if (selfId != 0) // The node is a peer
{
try {
if (OUTPUT) {
out = new BufferedWriter(new FileWriter(selfId + "_nbDeletedUpdates.txt"));
out.write(peer.selfId + " " + RTE + " " + UPDATES_PER_ROUND + "\n");
}
long currentTimeMillis = System.currentTimeMillis();
long nextMinuteMillis = (1 + currentTimeMillis / 60000) * (60000);
try {
sleepAtLeast(nextMinuteMillis - currentTimeMillis);
} catch (InterruptedException e) {
}
System.out.println("Session starts NOW");
// Count new rounds until time limit
initTime = System.currentTimeMillis() / 1000;
while (System.currentTimeMillis() / 1000 - initTime < SESSION_DURATION) {
// If the duration of one round passed, treat a new round
lastRoundTime = System.currentTimeMillis() / 1000;
// Trigger periodical messages of peer
peer.newRound();
// Wait until the end of round
while (System.currentTimeMillis() / 1000 - lastRoundTime < ROUND_DURATION)
peer.treatInMessage();
// End of round: increase the round ID, update the log, and consume received updates
int[] results = peer.endOfRound();
if (OUTPUT)
out.write(
peer.getRoundId()
+ " "
+ results[0]
+ " "
+ results[1]
+ "\n"); // roundId, nodeStatus, nbDeletedUpdates
}
if (OUTPUT) out.close();
peer.sender.mustStop = true;
peer.receiver.mustStop = true;
if (OUTPUT) {
try {
peer.outLog.close();
} catch (IOException e1) {
e1.printStackTrace();
}
}
} catch (IOException e) {
e.printStackTrace();
}
} else // The node is the broadcaster
{
long currentTimeMillis = System.currentTimeMillis();
long nextMinuteMillis = (1 + currentTimeMillis / 60000) * (60000);
try {
sleepAtLeast(nextMinuteMillis - currentTimeMillis);
} catch (InterruptedException e) {
}
System.out.println("Session starts NOW");
// Count new rounds until time limit
initTime = System.currentTimeMillis() / 1000;
// If the duration of one round passed, treat a new round
while (System.currentTimeMillis() / 1000 - initTime < SESSION_DURATION) {
lastRoundTime = System.currentTimeMillis() / 1000;
// Trigger periodical messages of peer
server.newRound();
// Wait until the end of round
while (System.currentTimeMillis() / 1000 - lastRoundTime < ROUND_DURATION)
server.treatInMessage();
}
server.stop();
int nbrServeRounds =
server.getNbServeRounds()
- RTE; // The subtraction is related to the final rounds, for which updates cannot
// expire
if (OUTPUT) {
try {
out = new BufferedWriter(new FileWriter("0_nbrSentUpdates.txt"));
out.write(nbrServeRounds + "\n");
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public void testCalls() throws Exception {
Server server = RPC.getServer(new TestImpl(), ADDRESS, 0, conf);
TestProtocol proxy = null;
try {
server.start();
InetSocketAddress addr = NetUtils.getConnectAddress(server);
proxy = (TestProtocol) RPC.getProxy(TestProtocol.class, TestProtocol.versionID, addr, conf);
proxy.ping();
String stringResult = proxy.echo("foo");
assertEquals(stringResult, "foo");
stringResult = proxy.echo((String) null);
assertEquals(stringResult, null);
String[] stringResults = proxy.echo(new String[] {"foo", "bar"});
assertTrue(Arrays.equals(stringResults, new String[] {"foo", "bar"}));
stringResults = proxy.echo((String[]) null);
assertTrue(Arrays.equals(stringResults, null));
UTF8 utf8Result = (UTF8) proxy.echo(new UTF8("hello world"));
assertEquals(utf8Result, new UTF8("hello world"));
utf8Result = (UTF8) proxy.echo((UTF8) null);
assertEquals(utf8Result, null);
int intResult = proxy.add(1, 2);
assertEquals(intResult, 3);
intResult = proxy.add(new int[] {1, 2});
assertEquals(intResult, 3);
boolean caught = false;
try {
proxy.error();
} catch (IOException e) {
LOG.debug("Caught " + e);
caught = true;
}
assertTrue(caught);
proxy.testServerGet();
// create multiple threads and make them do large data transfers
System.out.println("Starting multi-threaded RPC test...");
server.setSocketSendBufSize(1024);
Thread threadId[] = new Thread[numThreads];
for (int i = 0; i < numThreads; i++) {
Transactions trans = new Transactions(proxy, datasize);
threadId[i] = new Thread(trans, "TransactionThread-" + i);
threadId[i].start();
}
// wait for all transactions to get over
System.out.println("Waiting for all threads to finish RPCs...");
for (int i = 0; i < numThreads; i++) {
try {
threadId[i].join();
} catch (InterruptedException e) {
i--; // retry
}
}
// try some multi-calls
Method echo = TestProtocol.class.getMethod("echo", new Class[] {String.class});
String[] strings =
(String[])
RPC.call(
echo, new String[][] {{"a"}, {"b"}}, new InetSocketAddress[] {addr, addr}, conf);
assertTrue(Arrays.equals(strings, new String[] {"a", "b"}));
Method ping = TestProtocol.class.getMethod("ping", new Class[] {});
Object[] voids =
(Object[])
RPC.call(ping, new Object[][] {{}, {}}, new InetSocketAddress[] {addr, addr}, conf);
assertEquals(voids, null);
} finally {
server.stop();
if (proxy != null) RPC.stopProxy(proxy);
}
}