public static void main(String[] args) {
if (args.length != 1) {
System.out.println("\nbad args");
System.out.println(
"usage:java hw3.java TEMPLETON_STARTING_VALUE SIKORSKI_STARTING_VALUE CR89_STARTING_VALUE\n");
} else {
try {
Client client1 =
new Client(
"TEMPLETON",
MONITOR_NAME,
MONITOR_PORT,
HOST_NAME,
44444,
Integer.parseInt(args[0]),
Integer.parseInt(args[1]),
Integer.parseInt(args[2]));
client1.start();
Server server1 = new Server("TEMPLETON", MONITOR_PORT, 44444);
server1.start();
Client client2 =
new Client(
"SIKORSKI",
MONITOR_NAME,
MONITOR_PORT,
HOST_NAME,
44445,
Integer.parseInt(args[0]),
Integer.parseInt(args[1]),
Integer.parseInt(args[2]));
client2.start();
Server server2 = new Server("SIKORSKI", MONITOR_PORT, 44445);
server2.start();
Client client3 =
new Client(
"CR89",
MONITOR_NAME,
MONITOR_PORT,
HOST_NAME,
44446,
Integer.parseInt(args[0]),
Integer.parseInt(args[1]),
Integer.parseInt(args[2]));
client3.start();
Server server3 = new Server("CR89", MONITOR_PORT, 44446);
server3.start();
} catch (Exception e) {
e.printStackTrace();
}
}
}
@Test(timeout = 90000)
public void testRPCInterruptedSimple() throws IOException {
final Configuration conf = new Configuration();
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.setSecretManager(null)
.build();
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();
}
}
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);
}
}
}
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();
}
@Override
public void run() {
ConnectivityManager connMgr =
(ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
if ((networkInfo == null)
|| (!networkInfo.isConnected())
|| (networkInfo.getType() != ConnectivityManager.TYPE_WIFI)) {
bundle.putInt(
Constants.SERVER_THREAD_STATUS, Constants.SERVER_THREAD_STATUS_WIFI_NOT_CONNECTED);
msg.setData(bundle);
MainActivity.this.serverThreadMessageHandler.sendMessage(msg);
return;
}
WifiManager wifiManager = (WifiManager) getSystemService(Context.WIFI_SERVICE);
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
int ipAddress = wifiInfo.getIpAddress();
String ip =
(ipAddress & 0xff)
+ "."
+ (ipAddress >> 8 & 0xff)
+ "."
+ (ipAddress >> 16 & 0xff)
+ "."
+ (ipAddress >> 24 & 0xff);
try {
serverSocket = new ServerSocket(Constants.SERVER_PORT);
bundle.putInt(Constants.SERVER_THREAD_STATUS, Constants.SERVER_THREAD_STATUS_LISTENING);
bundle.putString(Constants.IP_ADDRESS, ip);
msg.setData(bundle);
MainActivity.this.serverThreadMessageHandler.sendMessage(msg);
} catch (Exception e) {
bundle.putInt(Constants.SERVER_THREAD_STATUS, Constants.SERVER_THREAD_STATUS_INIT_FAILED);
msg.setData(bundle);
MainActivity.this.serverThreadMessageHandler.sendMessage(msg);
return;
}
Socket clientSocket;
while (true) {
try {
clientSocket = serverSocket.accept();
String hostAddress = clientSocket.getInetAddress().getHostAddress();
boolean inClients = false;
for (Client client : clients)
if (client.host.equals(hostAddress)) {
inClients = true;
break;
}
if (!inClients) {
Client newClient = new Client(hostAddress);
clients.add(newClient);
newClient.connect();
}
Server server = new Server(clientSocket, hostAddress);
servers.add(server);
server.start();
} catch (Exception e) {
}
}
}
public void run() {
ServerSocket mainSocket = null;
try {
mainSocket = new ServerSocket(wyldConfig.getPort());
} catch (IOException e) {
Misc.println(Messages.PORT_IN_USE.getDesc());
}
Misc.println(
"[Socket] Listening on port " + wyldConfig.getPort() + " for incoming connections.");
while (true) {
Socket connectionSocket = null;
try {
connectionSocket = mainSocket.accept();
} catch (IOException e) {
Misc.servere(e.toString());
}
try {
Server thread = new Server(connectionSocket, i, irc);
thread.start();
irc.clients.add(thread);
} catch (java.lang.NullPointerException e) {
e.printStackTrace();
}
i++;
}
}
@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);
}
}
@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);
}
}
}
@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 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);
}
/** Model startuje i uruchamia wszystkie potrzebne moduły. */
public void load() {
if (self == null) {
outQueue.add(new ProgramClosingEvent());
throw new NullPointerException("Self contact nie może być null!");
}
server.start();
multicast.start();
sender.start();
}
protected static void start(final Server s) {
try {
s.start();
} catch (Exception ex) {
ex.printStackTrace();
System.exit(-1);
} finally {
System.out.println("done!");
}
}
public static void main(String[] args) {
try {
Server s = new Server();
s.start();
} catch (Exception ex) {
ex.printStackTrace();
System.exit(-1);
} finally {
System.out.println("done!");
}
}
@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");
}
}
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 testErrorClient() throws Exception {
// start server
Server server = new TestServer(1, false);
InetSocketAddress addr = NetUtils.getConnectAddress(server);
server.start();
// start client
Client client = new Client(LongErrorWritable.class, conf);
try {
client.call(new LongErrorWritable(RANDOM.nextLong()), addr, null, null);
fail("Expected an exception to have been thrown");
} catch (IOException e) {
// check error
Throwable cause = e.getCause();
assertTrue(cause instanceof IOException);
assertEquals(LongErrorWritable.ERR_MSG, cause.getMessage());
}
}
public static void main(String[] args) {
FileSendTest test = new FileSendTest();
JFileChooser jfc = new JFileChooser();
jfc.setAcceptAllFileFilterUsed(true);
jfc.showOpenDialog(null);
Socket socket = null;
FileInputStream in = null;
CheckedOutputStream cout = null;
try {
File file = jfc.getSelectedFile();
if (file.canRead()) {
test.setFILE_NAME(file.getName());
Server s = new Server(test);
s.start();
socket = new Socket("127.0.0.1", Server.PORT);
cout = new CheckedOutputStream(socket.getOutputStream(), new CRC32());
in = new FileInputStream(file);
byte[] buffer = new byte[Server.BUFFER_SIZE];
System.out.println(Calendar.getInstance().getTimeInMillis());
while ((in.read(buffer)) != -1) {
cout.write(buffer);
}
cout.close();
in.close();
System.out.println(Calendar.getInstance().getTimeInMillis());
System.out.println("Client CRC: " + Long.toHexString(cout.getChecksum().getValue()));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
System.out.println("Clien Out...");
try {
if (cout != null) {
cout.close();
}
if (socket != null) {
socket.close();
}
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
@Test
public void testBPubSub() throws InterruptedException {
String topic = "test";
// Start pubsub server
Server server =
new Server("127.0.0.1", Settings.CLIENT_SUBSCRIBE_PORT, Settings.CLIENT_PUBLISH_PORT);
server.start();
// Create publisher and subscriber
Publisher publisher = new Publisher("127.0.0.1", Settings.CLIENT_PUBLISH_PORT);
Subscriber subscriber = new Subscriber("127.0.0.1", Settings.CLIENT_SUBSCRIBE_PORT);
// Subscribe to test topic
TestPubSubCallback cb = new TestPubSubCallback();
subscriber.subscribe(topic, cb);
Thread.sleep(1000);
// Publish a message
System.out.println("Publisher publishing " + "hello" + " on topic " + topic);
publisher.publish(topic, PubSubProtos.StringMessage.newBuilder().setMessage("hello").build());
cb.awaitMessage("hello");
// Publish a message
System.out.println("Publisher publishing " + "hello" + " on topic " + "badtest");
publisher.publish(
"badtest", PubSubProtos.StringMessage.newBuilder().setMessage("hello").build());
cb.awaitNoMessage("hello");
// Publish a message
System.out.println("Publisher publishing " + "hello2" + " on topic " + topic);
publisher.publish(topic, PubSubProtos.StringMessage.newBuilder().setMessage("hello2").build());
cb.awaitMessage("hello2");
// Unsubscribe
subscriber.unsubscribe(topic, cb);
Thread.sleep(1000);
// Publish a message
System.out.println("Publisher publishing " + "hello2" + " on topic " + topic);
publisher.publish(topic, PubSubProtos.StringMessage.newBuilder().setMessage("hello2").build());
cb.awaitNoMessage("hello2");
}
/**
* {@inheritDoc}
*
* @see
* com.continuent.tungsten.replicator.plugin.ReplicatorPlugin#prepare(com.continuent.tungsten.replicator.plugin.PluginContext)
*/
public synchronized void prepare(PluginContext context)
throws ReplicatorException, InterruptedException {
// Prepare database connection.
if (url != null && url.trim().length() > 0) {
logger.info("Preparing SQL catalog tables");
ReplicatorRuntime runtime = (ReplicatorRuntime) context;
String metadataSchema = context.getReplicatorSchemaName();
catalog = new CatalogManager(runtime);
catalog.connect(url, user, password, metadataSchema, vendor);
catalog.prepareSchema();
} else logger.info("SQL catalog tables are disabled");
// Configure and prepare the log.
diskLog = new DiskLog();
diskLog.setDoChecksum(doChecksum);
diskLog.setEventSerializerClass(eventSerializer);
diskLog.setLogDir(logDir);
diskLog.setLogFileSize(logFileSize);
diskLog.setLogFileRetainMillis(logFileRetainMillis);
diskLog.setLogConnectionTimeoutMillis(logConnectionTimeout * 1000);
diskLog.setBufferSize(bufferSize);
diskLog.setFsyncOnFlush(fsyncOnFlush);
if (fsyncOnFlush) {
// Only used with fsync.
diskLog.setFlushIntervalMillis(flushIntervalMillis);
}
diskLog.setReadOnly(readOnly);
diskLog.prepare();
logger.info("Log preparation is complete");
// Start server for THL connections.
if (context.isRemoteService() == false) {
try {
server = new Server(context, sequencer, this);
server.start();
} catch (IOException e) {
throw new ReplicatorException("Unable to start THL server", e);
}
}
}
/*
* To run as a console application just open a console window and:
* > java Server
* > java Server portNumber
* If the port number is not specified 1500 is used
*/
public static void main(String[] args) {
// start server on port 1500 unless a PortNumber is specified
int portNumber = 1500;
switch (args.length) {
case 1:
try {
portNumber = Integer.parseInt(args[0]);
} catch (Exception e) {
System.out.println("Port yang diisikan invalid.");
System.out.println("Usage is: > java Server [portNumber]");
return;
}
case 0:
break;
default:
System.out.println("Usage is: > java Server [portNumber]");
return;
}
// create a server object and start it
Server server = new Server(portNumber);
server.start();
}
@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 synchronized Server startListening(ServerConnectListener listener) throws IOException {
if (serverRunning.getAndSet(true)) throw new IOException("This node is already listening!");
final Server server = new Server(descriptor.getServerSocket(), listener);
server.start();
return server;
}
@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();
}
}
public static void main(String[] args) throws UnknownHostException, IOException {
int portNumber = Integer.parseInt(args[0]); // get port number from program parameters
Server server = new Server(portNumber);
server.start();
}
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);
}
}
@Test(timeout = 30000)
public void testRPCInterrupted() throws IOException, InterruptedException {
final Configuration conf = new Configuration();
Server server =
new RPC.Builder(conf)
.setProtocol(TestProtocol.class)
.setInstance(new TestImpl())
.setBindAddress(ADDRESS)
.setPort(0)
.setNumHandlers(5)
.setVerbose(true)
.setSecretManager(null)
.build();
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);
}
static {
server = new Server(RpcUtil.getRpcPort(), 8);
server.start();
}
