/** * 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); }