public void sendReconnectProcess(String processName, String hostName, int port, boolean managementSubsystemEndpoint, byte[] asAuthKey) { synchronized (lock) { ManagedProcess process = processes.get(processName); if (process == null) { ROOT_LOGGER.attemptToReconnectNonExistentProcess(processName); // ignore return; } process.reconnect(hostName, port, managementSubsystemEndpoint, asAuthKey); } }
public void startProcess(final String processName) { synchronized (lock) { if (shutdown) { return; } final Map<String, ManagedProcess> processes = this.processes; final ManagedProcess process = processes.get(processName); if (process == null) { ROOT_LOGGER.attemptToStartNonExistentProcess(processName); // ignore return; } process.start(); } }
public void stopProcess(final String processName) { synchronized (lock) { final Map<String, ManagedProcess> processes = this.processes; final ManagedProcess process = processes.get(processName); if (process == null) { ROOT_LOGGER.attemptToStopNonExistentProcess(processName); // ignore return; } process.stop(); } }
public void stop() { synchronized (lock) { if (state != State.STARTED) { log.debugf("Attempted to stop already-stopping or down process '%s'", processName); return; } log.stoppingProcess(processName); stopRequested = true; StreamUtils.safeClose(stdin); state = State.STOPPING; } }
log.startingProcess(processName); log.debugf("Process name='%s' command='%s' workingDirectory='%s'", processName, command, workingDirectory); final ProcessBuilder builder = new ProcessBuilder(command); builder.environment().putAll(env); e.printStackTrace(); processController.operationFailed(processName, ProcessMessageHandler.OperationType.START); log.failedToStartProcess(processName); return; ok = true; } catch (Exception e) { log.failedToSendAuthKey(processName, e);
operationType = ProcessMessageHandler.OperationType.SEND_STDIN; processName = readUTFZBytes(dataStream); SERVER_LOGGER.tracef("Received send_stdin for process %s", processName); processController.sendStdin(processName, dataStream); } else { SERVER_LOGGER.tracef("Ignoring send_stdin message from untrusted source"); SERVER_LOGGER.tracef("Received add_process for process %s", processName); processController.addProcess(processName, authKey, Arrays.asList(command), env, workingDirectory, false, false); } else { SERVER_LOGGER.tracef("Ignoring add_process message from untrusted source"); processName = readUTFZBytes(dataStream); processController.startProcess(processName); SERVER_LOGGER.tracef("Received start_process for process %s", processName); } else { SERVER_LOGGER.tracef("Ignoring start_process message from untrusted source"); SERVER_LOGGER.tracef("Ignoring stop_process message from untrusted source"); processController.removeProcess(processName); } else { SERVER_LOGGER.tracef("Ignoring remove_process message from untrusted source"); processController.sendInventory(); } else { SERVER_LOGGER.tracef("Ignoring request_process_inventory message from untrusted source"); processController.sendReconnectProcess(processName, hostName, port, managementSubsystemEndpoint, asAuthKey);
void respawn() { synchronized (lock) { if (state != State.DOWN) { log.debugf("Attempted to respawn already-running process '%s'", processName); return; } doStart(true); } }
public void sendStdin(final InputStream msg) throws IOException { assert holdsLock(lock); // Call under lock try { StreamUtils.copyStream(msg, stdin); stdin.flush(); } catch (IOException e) { log.failedToSendDataBytes(e, processName); throw e; } }
public void removeProcess(final String processName) { synchronized (lock) { final Map<String, ManagedProcess> processes = this.processes; final ManagedProcess process = processes.get(processName); if (process == null) { ROOT_LOGGER.attemptToRemoveNonExistentProcess(processName); // ignore return; } boolean removed = processes.remove(processName) != null; processesByKey.remove(new Key(process.getAuthKey())); if(removed) { processRemoved(processName); } lock.notifyAll(); } }
public void reconnect(String hostName, int port, boolean managementSubsystemEndpoint, byte[] asAuthKey) { assert holdsLock(lock); // Call under lock try { StreamUtils.writeUTFZBytes(stdin, hostName); StreamUtils.writeInt(stdin, port); StreamUtils.writeBoolean(stdin, managementSubsystemEndpoint); stdin.write(asAuthKey); stdin.flush(); } catch (IOException e) { if(state == State.STARTED) { // Only log in case the process is still running log.failedToSendReconnect(e, processName); } } }
public void addProcess(final String processName, final byte[] authKey, final List<String> command, final Map<String, String> env, final String workingDirectory, final boolean isPrivileged, final boolean respawn) { for (String s : command) { if (s == null) { throw MESSAGES.nullCommandComponent(); } } synchronized (lock) { if (shutdown) { return; } final Map<String, ManagedProcess> processes = this.processes; if (processes.containsKey(processName)) { ROOT_LOGGER.duplicateProcessName(processName); // ignore return; } final ManagedProcess process = new ManagedProcess(processName, command, env, workingDirectory, lock, this, authKey, isPrivileged, respawn); processes.put(processName, process); processesByKey.put(new Key(authKey), process); processAdded(processName); } }
public void start() { synchronized (lock) { if (state != State.DOWN) { log.debugf("Attempted to start already-running process '%s'", processName); return; } resetRespawnCount(); doStart(false); } }