import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
public void destroy() {
    log.info("Destroying " + command);
    if (this.maybeRunningProcess.isPresent()) {
        final NuProcess runningProcess = this.maybeRunningProcess.get();

        runningProcess.destroy(false);

        try {
            runningProcess.waitFor(3, TimeUnit.SECONDS);

            if (runningProcess.isRunning())
                runningProcess.destroy(true);
        } catch (InterruptedException e) {
            runningProcess.destroy(true);
        }
    }
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
/** Gets the native process identifier for the given process instance. */
@Nullable
public Long getPid(Object process) {
  if (process instanceof NuProcess) {
    return (long) ((NuProcess) process).getPID();
  } else if (process instanceof Process) {
    // Until we switch to JDK9, we will have to go with this per-platform workaround.
    // In JDK9, `Process` has `getPid()` method that does exactly what we need here.
    // http://download.java.net/java/jdk9/docs/api/java/lang/Process.html#getPid--
    Long pid = jdk9ProcessId(process);
    if (pid == null) {
      pid = unixLikeProcessId(process);
    }
    if (pid == null) {
      pid = windowsProcessId(process);
    }
    return pid;
  } else {
    throw new IllegalArgumentException("Unknown process class: " + process.getClass().toString());
  }
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
public void send(String stdin) {
    if (this.maybeRunningProcess.isPresent()) {
        final NuProcess runningProcess = this.maybeRunningProcess.get();

        final ByteBuffer buffer = ByteBuffer.wrap((stdin + "\n").getBytes());

        runningProcess.writeStdin(buffer);
    }
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
ChildProcess(
        final NuProcess process,
        final ProcessSettings settings) {

    m_process = process;
    m_settings = settings;
    m_stdinClosed = new AtomicBoolean(false);

    // Handle write in callback
    if (settings.getWantWrite()) {
        m_process.wantWrite();
    }
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public void onPreStart(final NuProcess nuProcess) {
    this.process = new DefaultReactiveProcess(nuProcess, exitCode);
    Observable.Operator<ProcessOutput<T>, T> combineWithProcess = combineWith(process);

    // subscribe to stdout
    if (stdoutObserver != null) {
        Observable<T> out;
        Observable.Operator<T, ByteBuffer> outDecoder = decoder.create();
        if (outDecoder == null) {
            out = (Observable<T>) this.stdout; // T must be ByteBuffer
        } else {
            out = stdout.lift(outDecoder);
        }
        out.lift(combineWithProcess).subscribe(stdoutObserver);
    }

    // subscribe to stderr
    if (stderrObserver != null) {
        Observable<T> err;
        Observable.Operator<T, ByteBuffer> errDecoder = decoder.create();
        if (errDecoder == null) {
            err = (Observable<T>) this.stderr; // T must be ByteBuffer
        } else {
            err = stderr.lift(errDecoder);
        }
        err.lift(combineWithProcess).subscribe(stderrObserver);
    }
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Benchmark
public void cat() throws Exception {
    NuProcessBuilder builder = new NuProcessBuilder("cat", TEST_FILE);
    builder.setProcessListener(new NuAbstractProcessHandler() {

        private final CRC32 crc32 = new CRC32();

        @Override
        public void onExit(int statusCode) {
            long crc = crc32.getValue();
            if (crc != TEST_CRC32) {
                System.err.println("Incorrect CRC32 checksum (" + crc + "); file corruption?");
            }
        }

        @Override
        public void onStdout(ByteBuffer buffer, boolean closed) {
            // the contents of the file are run through CRC32 just to "do" something with them
            // note that update(ByteBuffer) requires Java 8. it's been selected because it doesn't
            // inflate the measured allocation rate by allocating buffers internally
            crc32.update(buffer);
        }
    });

    NuProcess process = builder.start();

    int exitCode = process.waitFor(5L, TimeUnit.MINUTES);
    if (exitCode == Integer.MIN_VALUE) {
        process.destroy(false);

        throw new AssertionError(process + " took longer than 5 minutes to complete");
    }
    if (exitCode != 0) {
        throw new AssertionError(process + " failed (Exit code: " + exitCode + ")");
    }
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
private void execute()
{
    NuProcessBuilder pb = new NuProcessBuilder(Arrays.asList("ssh", host));
    ProcessHandler processHandler = new ProcessHandler();
    pb.setProcessListener(processHandler);
    NuProcess np = pb.start();

    processHandler.write("cd");
    processHandler.write("ls -l");
    processHandler.write("exit");

    processHandler.awaitDisconnection();
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public NuProcess createProcess(List<String> commands, String[] env, NuProcessHandler processListener, Path cwd)
{
   LinuxProcess process = new LinuxProcess(processListener);
   synchronized (LinProcessFactory.class) {
      process.start(commands, env, cwd);
   }
   return process;
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public NuProcess createProcess(List<String> commands, String[] env, NuProcessHandler processListener, Path cwd)
{
   WindowsProcess process = new WindowsProcess(processListener);
   process.start(commands, env, cwd);
   return process;
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public NuProcess createProcess(List<String> commands, String[] env, NuProcessHandler processListener, Path cwd)
{
   OsxProcess process = new OsxProcess(processListener);
   process.start(commands, env, cwd);
   return process;
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
/** @return whether the process has finished executing or not. */
public boolean hasProcessFinished(Object process) {
  if (process instanceof NuProcess) {
    return !((NuProcess) process).isRunning();
  } else if (process instanceof Process) {
    try {
      ((Process) process).exitValue();
      return true;
    } catch (IllegalThreadStateException e) {
      return false;
    }
  } else {
    throw new IllegalArgumentException("Unknown process class: " + process.getClass().toString());
  }
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
/**
 * Launches a process and asynchronously sends notifications to {@code listener} on a background
 * thread when the process starts, has I/O, or exits.
 */
public LaunchedProcess launchProcess(ProcessExecutorParams params, final ProcessListener listener)
    throws IOException {
  LOG.debug("Launching process with params %s", params);

  ListeningProcessHandler processHandler = new ListeningProcessHandler(listener, params);

  // Unlike with Java's ProcessBuilder, we don't need special param escaping for Win32 platforms.
  NuProcessBuilder processBuilder = new NuProcessBuilder(processHandler, params.getCommand());
  if (params.getEnvironment().isPresent()) {
    processBuilder.environment().clear();
    processBuilder.environment().putAll(params.getEnvironment().get());
  }
  if (params.getDirectory().isPresent()) {
    processBuilder.setCwd(params.getDirectory().get());
  }

  NuProcess process = BgProcessKiller.startProcess(processBuilder);
  if (process == null) {
    throw new IOException(String.format("Could not start process with params %s", params));
  }
  LOG.debug("Successfully launched process %s", process);

  // This should be set by onPreStart().
  Preconditions.checkState(processHandler.process != null);
  processRegistry.registerProcess(processHandler.process.nuProcess, params, ImmutableMap.of());
  return processHandler.process;
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
void verifyExternalProcessInfo(long pid, NuProcess process, ProcessExecutorParams params)
    throws Exception {
  ProcessInfo info = processesInfo.get(pid);
  assertThat(info, CoreMatchers.instanceOf(ExternalProcessInfo.class));
  assertEquals(pid, ((ExternalProcessInfo) info).pid);
  assertSame(process, ((ExternalProcessInfo) info).process);
  assertEquals(params, ((ExternalProcessInfo) info).params);
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Override
public void onPreStart(final NuProcess process) {
    m_handler.onPreStart(new ChildProcess(process, m_settings));
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Override
public void onStart(final NuProcess process) {
    m_handler.onStart(new ChildProcess(process, m_settings));
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
public DefaultReactiveProcess(
        NuProcess process,
        Observable<Integer> exitCode) {
    this.process = process;
    this.exitCode = exitCode;
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Override
public void onStart(final NuProcess nuProcess) {
    // do nothing
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Override
public void onStart(final NuProcess nuProcess)
{
    this.nuProcess = nuProcess;
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Override
public void onStart(NuProcess nuProcess)
{
    this.nuProcess = nuProcess;
}
 

import com.zaxxer.nuprocess.NuProcess; //导入依赖的package包/类
@Override
public boolean process()
{
   int stdinFd = Integer.MIN_VALUE;
   int stdoutFd = Integer.MIN_VALUE;
   int stderrFd = Integer.MIN_VALUE;
   LinuxProcess linuxProcess = null;
   try {
      int nev = LibEpoll.epoll_wait(epoll, triggeredEvent.getPointer(), 1, DEADPOOL_POLL_INTERVAL);
      if (nev == -1) {
         throw new RuntimeException("Error waiting for epoll");
      }

      if (nev == 0) {
         return false;
      }

      EpollEvent epEvent = triggeredEvent;
      int ident = epEvent.getFileDescriptor();
      int events = epEvent.getEvents();

      linuxProcess = fildesToProcessMap.get(ident);
      if (linuxProcess == null) {
         return true;
      }

      stdinFd = linuxProcess.getStdin().acquire();
      stdoutFd = linuxProcess.getStdout().acquire();
      stderrFd = linuxProcess.getStderr().acquire();

      if ((events & LibEpoll.EPOLLIN) != 0) { // stdout/stderr data available to read
         if (ident == stdoutFd) {
            linuxProcess.readStdout(NuProcess.BUFFER_CAPACITY, stdoutFd);
         }
         else if (ident == stderrFd) {
            linuxProcess.readStderr(NuProcess.BUFFER_CAPACITY, stderrFd);
         }
      }
      else if ((events & LibEpoll.EPOLLOUT) != 0) { // Room in stdin pipe available to write
         if (stdinFd != -1) {
            if (linuxProcess.writeStdin(NuProcess.BUFFER_CAPACITY, stdinFd)) {
               epEvent.setEvents(LibEpoll.EPOLLOUT | LibEpoll.EPOLLONESHOT | LibEpoll.EPOLLRDHUP | LibEpoll.EPOLLHUP);
               LibEpoll.epoll_ctl(epoll, LibEpoll.EPOLL_CTL_MOD, ident, epEvent.getPointer());
            }
         }
      }

      if ((events & LibEpoll.EPOLLHUP) != 0 || (events & LibEpoll.EPOLLRDHUP) != 0 || (events & LibEpoll.EPOLLERR) != 0) {
         LibEpoll.epoll_ctl(epoll, LibEpoll.EPOLL_CTL_DEL, ident, null);
         if (ident == stdoutFd) {
            linuxProcess.readStdout(-1, stdoutFd);
         }
         else if (ident == stderrFd) {
            linuxProcess.readStderr(-1, stderrFd);
         }
         else if (ident == stdinFd) {
            linuxProcess.closeStdin(true);
         }
      }

      if (linuxProcess.isSoftExit()) {
         cleanupProcess(linuxProcess, stdinFd, stdoutFd, stderrFd);
      }

      return true;
   }
   finally {
      if (linuxProcess != null) {
         if (stdinFd != Integer.MIN_VALUE) {
            linuxProcess.getStdin().release();
         }
         if (stdoutFd != Integer.MIN_VALUE) {
            linuxProcess.getStdout().release();
         }
         if (stderrFd != Integer.MIN_VALUE) {
            linuxProcess.getStderr().release();
         }
      }
      checkDeadPool();
   }
}