[JENKINS-41745] Non-Remoting-based CLI

cli/pom.xml

@@ -34,6 +34,10 @@
       <artifactId>commons-codec</artifactId>
       <version>1.4</version>
     </dependency>
+    <dependency>
+      <groupId>commons-io</groupId>
+      <artifactId>commons-io</artifactId>
+    </dependency>
     <dependency>
       <groupId>${project.groupId}</groupId>
       <artifactId>remoting</artifactId>
@@ -50,6 +54,16 @@
       <version>1.24</version>
     </dependency>
     <dependency>
+      <groupId>org.apache.sshd</groupId>
+      <artifactId>sshd-core</artifactId>
+      <optional>true</optional> <!-- do not expose to core -->
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-jdk14</artifactId>
+      <optional>true</optional> <!-- ditto -->
+    </dependency>
+    <dependency> <!-- TODO remove and replace PrivateKeyProvider with SecurityUtils.createFileKeyPairProvider() as in SshClient -->
       <groupId>org.jenkins-ci</groupId>
       <artifactId>trilead-ssh2</artifactId>
       <version>build214-jenkins-1</version>

cli/src/main/java/hudson/cli/CLIConnectionFactory.java

@@ -32,6 +32,7 @@ public CLIConnectionFactory url(String jenkins) throws MalformedURLException {
 
     /**
      * This {@link ExecutorService} is used to execute closures received from the server.
+     * Used only in Remoting mode.
      */
     public CLIConnectionFactory executorService(ExecutorService es) {
         this.exec = es;
@@ -59,15 +60,24 @@ public CLIConnectionFactory authorization(String value) {
 
     /**
      * Convenience method to call {@link #authorization} with the HTTP basic authentication.
+     * Currently unused.
      */
     public CLIConnectionFactory basicAuth(String username, String password) {
         return basicAuth(username+':'+password);
     }
 
+    /**
+     * Convenience method to call {@link #authorization} with the HTTP basic authentication.
+     * Cf. {@code BasicHeaderApiTokenAuthenticator}.
+     */
     public CLIConnectionFactory basicAuth(String userInfo) {
         return authorization("Basic " + new String(Base64.encodeBase64((userInfo).getBytes())));
     }
-
+
+    /**
+     * @deprecated Specific to Remoting-based protocol.
+     */
+    @Deprecated
     public CLI connect() throws IOException, InterruptedException {
         return new CLI(this);
     }

cli/src/main/java/hudson/cli/CliEntryPoint.java

@@ -34,7 +34,9 @@
  * Remotable interface for CLI entry point on the server side.
  *
  * @author Kohsuke Kawaguchi
+ * @deprecated Specific to Remoting-based protocol.
  */
+@Deprecated
 public interface CliEntryPoint {
     /**
      * Just like the static main method.

cli/src/main/java/hudson/cli/Connection.java

@@ -56,6 +56,9 @@
 import java.security.interfaces.RSAPublicKey;
 import java.security.spec.X509EncodedKeySpec;
 
+/**
+ * Used by Jenkins core only in deprecated Remoting-based CLI.
+ */
 public class Connection {
     public final InputStream in;
     public final OutputStream out;

cli/src/main/java/hudson/cli/DiagnosedStreamCorruptionException.java

@@ -0,0 +1,55 @@
+package hudson.cli;
+
+import java.io.PrintWriter;
+import java.io.StreamCorruptedException;
+import java.io.StringWriter;
+
+// TODO COPIED FROM hudson.remoting
+
+/**
+ * Signals a {@link StreamCorruptedException} with some additional diagnostic information.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+class DiagnosedStreamCorruptionException extends StreamCorruptedException {
+    private final Exception diagnoseFailure;
+    private final byte[] readBack;
+    private final byte[] readAhead;
+
+    DiagnosedStreamCorruptionException(Exception cause, Exception diagnoseFailure, byte[] readBack, byte[] readAhead) {
+        initCause(cause);
+        this.diagnoseFailure = diagnoseFailure;
+        this.readBack = readBack;
+        this.readAhead = readAhead;
+    }
+
+    public Exception getDiagnoseFailure() {
+        return diagnoseFailure;
+    }
+
+    public byte[] getReadBack() {
+        return readBack;
+    }
+
+    public byte[] getReadAhead() {
+        return readAhead;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder buf = new StringBuilder();
+        buf.append(super.toString()).append("\n");
+        buf.append("Read back: ").append(HexDump.toHex(readBack)).append('\n');
+        buf.append("Read ahead: ").append(HexDump.toHex(readAhead));
+        if (diagnoseFailure!=null) {
+            StringWriter w = new StringWriter();
+            PrintWriter p = new PrintWriter(w);
+            diagnoseFailure.printStackTrace(p);
+            p.flush();
+
+            buf.append("\nDiagnosis problem:\n    ");
+            buf.append(w.toString().trim().replace("\n","\n    "));
+        }
+        return buf.toString();
+    }
+}

cli/src/main/java/hudson/cli/FlightRecorderInputStream.java

@@ -0,0 +1,191 @@
+package hudson.cli;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+// TODO COPIED FROM hudson.remoting
+
+/**
+ * Filter input stream that records the content as it's read, so that it can be reported
+ * in case of a catastrophic stream corruption problem.
+ *
+ * @author Kohsuke Kawaguchi
+ */
+class FlightRecorderInputStream extends InputStream {
+
+    /**
+     * Size (in bytes) of the flight recorder ring buffer used for debugging remoting issues.
+     * @since 2.41
+     */
+    static final int BUFFER_SIZE = Integer.getInteger("hudson.remoting.FlightRecorderInputStream.BUFFER_SIZE", 1024 * 1024);
+
+    private final InputStream source;
+    private ByteArrayRingBuffer recorder = new ByteArrayRingBuffer(BUFFER_SIZE);
+
+    FlightRecorderInputStream(InputStream source) {
+        this.source = source;
+    }
+
+    /**
+     * Rewinds the record buffer and forget everything that was recorded.
+     */
+    public void clear() {
+        recorder = new ByteArrayRingBuffer(BUFFER_SIZE);
+    }
+
+    /**
+     * Gets the recorded content.
+     */
+    public byte[] getRecord() {
+        return recorder.toByteArray();
+    }
+
+    /**
+     * Creates a {@link DiagnosedStreamCorruptionException} based on the recorded content plus read ahead.
+     * The caller is responsible for throwing the exception.
+     */
+    public DiagnosedStreamCorruptionException analyzeCrash(Exception problem, String diagnosisName) {
+        final ByteArrayOutputStream readAhead = new ByteArrayOutputStream();
+        final IOException[] error = new IOException[1];
+
+        Thread diagnosisThread = new Thread(diagnosisName+" stream corruption diagnosis thread") {
+            public void run() {
+                int b;
+                try {
+                    // not all InputStream will look for the thread interrupt flag, so check that explicitly to be defensive
+                    while (!Thread.interrupted() && (b=source.read())!=-1) {
+                        readAhead.write(b);
+                    }
+                } catch (IOException e) {
+                    error[0] = e;
+                }
+            }
+        };
+
+        // wait up to 1 sec to grab as much data as possible
+        diagnosisThread.start();
+        try {
+            diagnosisThread.join(1000);
+        } catch (InterruptedException ignored) {
+            // we are only waiting for a fixed amount of time, so we'll pretend like we were in a busy loop
+            Thread.currentThread().interrupt();
+            // fall through
+        }
+
+        IOException diagnosisProblem = error[0]; // capture the error, if any, before we kill the thread
+        if (diagnosisThread.isAlive())
+            diagnosisThread.interrupt();    // if it's not dead, kill
+
+        return new DiagnosedStreamCorruptionException(problem,diagnosisProblem,getRecord(),readAhead.toByteArray());
+
+    }
+
+    @Override
+    public int read() throws IOException {
+        int i = source.read();
+        if (i>=0)
+            recorder.write(i);
+        return i;
+    }
+
+    @Override
+    public int read(byte[] b, int off, int len) throws IOException {
+        len = source.read(b, off, len);
+        if (len>0)
+            recorder.write(b,off,len);
+        return len;
+    }
+
+    /**
+     * To record the bytes we've skipped, convert the call to read.
+     */
+    @Override
+    public long skip(long n) throws IOException {
+        byte[] buf = new byte[(int)Math.min(n,64*1024)];
+        return read(buf,0,buf.length);
+    }
+
+    @Override
+    public int available() throws IOException {
+        return source.available();
+    }
+
+    @Override
+    public void close() throws IOException {
+        source.close();
+    }
+
+    @Override
+    public boolean markSupported() {
+        return false;
+    }
+
+    // http://stackoverflow.com/a/3651696/12916
+    private static class ByteArrayRingBuffer extends OutputStream {
+
+        byte[] data;
+
+        int capacity, pos = 0;
+
+        boolean filled = false;
+
+        public ByteArrayRingBuffer(int capacity) {
+            data = new byte[capacity];
+            this.capacity = capacity;
+        }
+
+        @Override
+        public synchronized void write(int b) {
+            if (pos == capacity) {
+                filled = true;
+                pos = 0;
+            }
+            data[pos++] = (byte) b;
+        }
+
+        public synchronized byte[] toByteArray() {
+            if (!filled) {
+                return Arrays.copyOf(data, pos);
+            }
+            byte[] ret = new byte[capacity];
+            System.arraycopy(data, pos, ret, 0, capacity - pos);
+            System.arraycopy(data, 0, ret, capacity - pos, pos);
+            return ret;
+        }
+
+        /** @author @roadrunner2 */
+        @Override public synchronized void write(byte[] buf, int off, int len) {
+            // no point in trying to copy more than capacity; this also simplifies logic below
+            if (len > capacity) {
+                off += (len - capacity);
+                len = capacity;
+            }
+
+            // copy to buffer, but no farther than the end
+            int num = Math.min(len, capacity - pos);
+            if (num > 0) {
+                System.arraycopy(buf, off, data, pos, num);
+                off += num;
+                len -= num;
+                pos += num;
+            }
+
+            // wrap around if necessary
+            if (pos == capacity) {
+                filled = true;
+                pos = 0;
+            }
+
+            // copy anything still left
+            if (len > 0) {
+                System.arraycopy(buf, off, data, pos, len);
+                pos += len;
+            }
+        }
+
+    }
+
+}

cli/src/main/java/hudson/cli/HexDump.java

@@ -0,0 +1,47 @@
+package hudson.cli;
+
+// TODO COPIED FROM hudson.remoting
+
+/**
+ * @author Kohsuke Kawaguchi
+ */
+class HexDump {
+    private static final String CODE = "0123456789abcdef";
+
+    public static String toHex(byte[] buf) {
+        return toHex(buf,0,buf.length);
+    }
+    public static String toHex(byte[] buf, int start, int len) {
+        StringBuilder r = new StringBuilder(len*2);
+        boolean inText = false;
+        for (int i=0; i<len; i++) {
+            byte b = buf[start+i];
+            if (b >= 0x20 && b <= 0x7e) {
+                if (!inText) {
+                    inText = true;
+                    r.append('\'');
+                }
+                r.append((char) b);
+            } else {
+                if (inText) {
+                    r.append("' ");
+                    inText = false;
+                }
+                r.append("0x");
+                r.append(CODE.charAt((b>>4)&15));
+                r.append(CODE.charAt(b&15));
+                if (i < len - 1) {
+                    if (b == 10) {
+                        r.append('\n');
+                    } else {
+                        r.append(' ');
+                    }
+                }
+            }
+        }
+        if (inText) {
+            r.append('\'');
+        }
+        return r.toString();
+    }
+}