/**
* Appends the given number of entries in the given term on the server. Must be run on server's
* ThreadContext.
*/
protected void append(int entries, long term) throws Throwable {
for (int i = 0; i < entries; i++) {
try (TestEntry entry = serverState.getLog().create(TestEntry.class)) {
entry.setTerm(term).setTombstone(false);
serverState.getLog().append(entry);
}
}
}
/*
* Creates a HttpContext at the given address. If there is already a server
* it uses that server to create a context. Otherwise, it creates a new
* HTTP server. This sever is added to servers Map.
*/
/*package*/ HttpContext createContext(String address) {
try {
HttpServer server;
ServerState state;
URL url = new URL(address);
int port = url.getPort();
if (port == -1) {
port = url.getDefaultPort();
}
InetSocketAddress inetAddress = new InetSocketAddress(url.getHost(), port);
synchronized (servers) {
state = servers.get(inetAddress);
if (state == null) {
logger.fine("Creating new HTTP Server at " + inetAddress);
// Creates server with default socket backlog
server = HttpServer.create(inetAddress, 0);
server.setExecutor(Executors.newCachedThreadPool());
String path = url.toURI().getPath();
logger.fine("Creating HTTP Context at = " + path);
HttpContext context = server.createContext(path);
server.start();
// we have to get actual inetAddress from server, which can differ from the original in
// some cases.
// e.g. A port number of zero will let the system pick up an ephemeral port in a bind
// operation,
// or IP: 0.0.0.0 - which is used to monitor network traffic from any valid IP address
inetAddress = server.getAddress();
logger.fine("HTTP server started = " + inetAddress);
state = new ServerState(server, path);
servers.put(inetAddress, state);
return context;
}
}
server = state.getServer();
if (state.getPaths().contains(url.getPath())) {
String err =
"Context with URL path "
+ url.getPath()
+ " already exists on the server "
+ server.getAddress();
logger.fine(err);
throw new IllegalArgumentException(err);
}
logger.fine("Creating HTTP Context at = " + url.getPath());
HttpContext context = server.createContext(url.getPath());
state.oneMoreContext(url.getPath());
return context;
} catch (Exception e) {
throw new ServerRtException("server.rt.err", e);
}
}
@Test
public void testUpdateServerState() throws Exception {
final MultiDomainServerState state = new MultiDomainServerState();
final ServerState ss1 = new ServerState();
assertTrue(ss1.update(csn3));
final ServerState ss2 = new ServerState();
assertTrue(ss2.update(csn2));
state.update(dn1, ss1);
state.update(dn2, ss2);
final String expected = "o=test1:" + csn3 + ";o=test2:" + csn2 + ";";
assertEquals(state.toString(), expected);
}
public List<ServerState> getServerStates() throws Exception {
List<ServerState> serverStates = new ArrayList<ServerState>();
for (ProxyInfo proxy : AppserverProxyServlet.getProxies()) {
AppserverDeploymentable deployer = proxy.getDeployer();
ServerState serverState = new ServerState();
serverState.setServerName(deployer.getServerName());
serverState.setState(proxy.isAlive() ? "ALIVE" : "NOT ALIVE");
serverState.setDeployState("UNKNOWN");
serverState.setUrl(proxy.getUrl());
serverStates.add(serverState);
}
return serverStates;
}
/** Creates and returns the given number of entries in the given term. */
protected List<TestEntry> entries(int entries, long term) {
List<TestEntry> result = new ArrayList<>();
for (int i = 0; i < entries; i++) {
try (TestEntry entry = serverState.getLog().create(TestEntry.class)) {
result.add(entry.setTerm(term).setTombstone(false));
}
}
return result;
}
public Server(File systemDir, boolean cachesInMemory) {
Utils.setSystemRoot(systemDir);
final ExecutorService threadPool = Executors.newCachedThreadPool();
myScheduler =
ConcurrencyUtil.newSingleScheduledThreadExecutor(
"Client activity checker", Thread.MIN_PRIORITY);
myBuildsExecutor = Executors.newFixedThreadPool(MAX_SIMULTANEOUS_BUILD_SESSIONS);
myChannelFactory = new NioServerSocketChannelFactory(threadPool, threadPool, 1);
final ChannelRegistrar channelRegistrar = new ChannelRegistrar();
myMessageHandler =
new ServerMessageHandler(
this,
new AsyncTaskExecutor() {
@Override
public void submit(final Runnable runnable) {
myBuildsExecutor.submit(
new Runnable() {
@Override
public void run() {
try {
runnable.run();
} finally {
Thread.interrupted(); // clear interrupted status before returning to pull
}
}
});
}
});
myPipelineFactory =
new ChannelPipelineFactory() {
public ChannelPipeline getPipeline() throws Exception {
return Channels.pipeline(
channelRegistrar,
new ProtobufVarint32FrameDecoder(),
new ProtobufDecoder(JpsRemoteProto.Message.getDefaultInstance()),
new ProtobufVarint32LengthFieldPrepender(),
new ProtobufEncoder(),
myMessageHandler);
}
};
ServerState.getInstance().setKeepTempCachesInMemory(cachesInMemory);
Runtime.getRuntime()
.addShutdownHook(
new Thread("Shutdown hook thread") {
public void run() {
try {
myMessageHandler.cancelAllBuildsAndClearState();
} finally {
Server.this.stop();
}
}
});
}
@Override
public void execute() {
MenuFrame.client.addActionListener(
(ActionEvent ae) -> {
// System.out.println(ae);
exitCode = CLIENT_CODE;
changeState(ClientState.instance());
});
MenuFrame.server.addActionListener(
(ActionEvent ae) -> {
// System.out.println(ae);
exitCode = SERVER_CODE;
changeState(ServerState.instance());
});
}
@Override
public Entity createPlayer(UUID id) {
Entity entity = new Player(id);
Box box = new Box(0.1f, 1f, 0.1f);
Geometry geometry = new Geometry("geometry", box);
entity.attachChild(geometry);
CapsuleCollisionShape ccs = new CapsuleCollisionShape(0.25f, 1f);
CharacterControl characterControl = new CharacterControl(ccs, 1f);
geometry.addControl(characterControl);
getPhysicsSpace().add(characterControl);
serverState.addEntity(entity);
return entity;
}
/*
* Removes a context. If the server doesn't have anymore contexts, it
* would stop the server and server is removed from servers Map.
*/
/*package*/ void removeContext(HttpContext context) {
InetSocketAddress inetAddress = context.getServer().getAddress();
synchronized (servers) {
ServerState state = servers.get(inetAddress);
int instances = state.noOfContexts();
if (instances < 2) {
((ExecutorService) state.getServer().getExecutor()).shutdown();
state.getServer().stop(0);
servers.remove(inetAddress);
} else {
state.getServer().removeContext(context);
state.oneLessContext(context.getPath());
}
}
}
private boolean isServerRunning() throws IOException {
ModelNodeResult result = ops.readAttribute(Address.root(), Constants.SERVER_STATE);
result.assertDefinedValue();
return ServerState.isRunning(result.stringValue());
}
@Override
public Entity removePlayer(UUID id) {
Entity entity = serverState.removeEntity(id);
getPhysicsSpace().remove(entity.getChild("geometry").getControl(CharacterControl.class));
return entity;
}
/** Gets the entry at the given index. */
protected <T extends Entry> T get(long index) throws Throwable {
return serverState.getLog().get(index);
}
