[JENKINS-36871] Make all the rest of the javadoc work on Java 8's str…

…ict validation
jenkinsci · Aug 3, 2016 · aae74ae · aae74ae
1 parent fc646c3
commit aae74ae
Show file tree

Hide file tree

Showing 14 changed files with 26 additions and 24 deletions.
diff --git a/src/main/java/hudson/remoting/Asynchronous.java b/src/main/java/hudson/remoting/Asynchronous.java
@@ -31,7 +31,7 @@
  * // this method actually gets executed. For example, if you invoke two async
  * // calls, they may execute in the reverse order.
  * foo.zot();
- *
+ * </pre>
  *
  * @see Channel#callAsync(Callable)
  * @author Kohsuke Kawaguchi

diff --git a/src/main/java/hudson/remoting/Base64.java b/src/main/java/hudson/remoting/Base64.java
@@ -27,8 +27,6 @@
  * data. You need the data that you will encode/decode
  * already on a byte arrray.
  *
- * @xerces.internal
- *
  * @author Jeffrey Rodriguez
  * @author Sandy Gao
  * @version $Id: Base64.java,v 1.4 2007/07/19 04:38:32 ofung Exp $

diff --git a/src/main/java/hudson/remoting/CallableFilter.java b/src/main/java/hudson/remoting/CallableFilter.java
@@ -1,5 +1,7 @@
 package hudson.remoting;
 
+import org.jenkinsci.remoting.CallableDecorator;
+
 /**
  * Decorator on {@code Callable.call()} to filter the execution.
  *

diff --git a/src/main/java/hudson/remoting/Channel.java b/src/main/java/hudson/remoting/Channel.java
@@ -643,8 +643,6 @@ public <T> T export(Class<T> type, T instance) {
 
     /**
      * Increase reference count so much to effectively prevent de-allocation.
-     *
-     * @see ExportTable.Entry#pin()
      */
     public void pin(Object instance) {
         exportedObjects.pin(instance);
@@ -1065,8 +1063,8 @@ public synchronized void join(long timeout) throws InterruptedException {
     /**
      * Notifies the remote peer that we are closing down.
      *
-     * Execution of this command also triggers the {@link SynchronousCommandTransport.ReaderThread} to shut down
-     * and quit. The {@link CloseCommand} is always the last command to be sent on
+     * Execution of this command also triggers the {@code SynchronousCommandTransport.ReaderThread} to shut down
+     * and quit. The {@code CloseCommand} is always the last command to be sent on
      * {@link ObjectOutputStream}, and it's the last command to be read.
      */
     private static final class CloseCommand extends Command {

diff --git a/src/main/java/hudson/remoting/ClassFilter.java b/src/main/java/hudson/remoting/ClassFilter.java
@@ -23,7 +23,7 @@
  */
 public abstract class ClassFilter {
     /**
-     * Property to set to <b>override<b> the blacklist used by {{@link #DEFAULT} with a different set.
+     * Property to set to <b>override</b> the blacklist used by {{@link #DEFAULT} with a different set.
      * The location should point to a a file containing regular expressions (one per line) of classes to blacklist.
      * If this property is set but the file can not be read the default blacklist will be used.
      * @since 2.53.2

diff --git a/src/main/java/hudson/remoting/CommandTransport.java b/src/main/java/hudson/remoting/CommandTransport.java
@@ -108,7 +108,7 @@ static interface CommandReceiver {
      * 
      * <h2>Closing the read pump</h2>
      * <p>
-     * {@link Channel} implements {@linkplain Channel.CloseCommand its own "end of command stream" marker}, and
+     * {@link Channel} implements {@code Channel.CloseCommand} its own "end of command stream" marker, and
      * therefore under the orderly shutdown scenario, it doesn't rely on the transport to provide EOF-like
      * marker. Instead, {@link Channel} will call your {@link #closeRead()} (from the same thread
      * that invoked {@link CommandReceiver#handle(Command)}) to indicate that it is done with the reading.

diff --git a/src/main/java/hudson/remoting/FastPipedInputStream.java b/src/main/java/hudson/remoting/FastPipedInputStream.java
@@ -32,7 +32,7 @@
  * synchronization with its counterpart {@link FastPipedOutputStream}.
  *
  * @author WD
- * @link http://developer.java.sun.com/developer/bugParade/bugs/4404700.html
+ * @see <a href="http://developer.java.sun.com/developer/bugParade/bugs/4404700.html">4404700</a>
  * @see FastPipedOutputStream
  */
 public class FastPipedInputStream extends InputStream {

diff --git a/src/main/java/hudson/remoting/FastPipedOutputStream.java b/src/main/java/hudson/remoting/FastPipedOutputStream.java
@@ -33,7 +33,7 @@
  * synchronization with its counterpart {@link FastPipedInputStream}.
  *
  * @author WD
- * @link http://developer.java.sun.com/developer/bugParade/bugs/4404700.html
+ * @see <a href="http://developer.java.sun.com/developer/bugParade/bugs/4404700.html">4404700</a>
  * @see FastPipedOutputStream
  */
 public class FastPipedOutputStream extends OutputStream implements ErrorPropagatingOutputStream {

diff --git a/src/main/java/hudson/remoting/RemoteClassLoader.java b/src/main/java/hudson/remoting/RemoteClassLoader.java
@@ -582,7 +582,7 @@ public static class ClassFile2 extends ResourceFile {
          *
          * This information is crucial in determining which classloaders are to cache
          * the prefetch information. Imagine classloader X requests fetch3("Foo"),
-         * which returns 2 <tt>ClassFile2<tt> instances:
+         * which returns 2 {@code ClassFile2} instances:
          *
          * <ol>
          *     <li>ClassFile2 #1: image of "Foo" is here and load this from classloader Y

diff --git a/src/main/java/org/jenkinsci/remoting/CallableDecorator.java b/src/main/java/org/jenkinsci/remoting/CallableDecorator.java
@@ -1,6 +1,7 @@
 package org.jenkinsci.remoting;
 
 import hudson.remoting.Callable;
+import hudson.remoting.Channel;
 
 /**
  * Decorator on {@code Callable.call()} to filter the execution.

diff --git a/src/main/java/org/jenkinsci/remoting/Role.java b/src/main/java/org/jenkinsci/remoting/Role.java
@@ -27,17 +27,17 @@
  * </pre>
  *
  * <p>
- * Then the callables that are meant to be run on the server would return {@code CLIENT} from
- * {@link RoleSensitive#getRecipients()}:
+ * Then the callables that are meant to be run on the client would check {@code CLIENT} from
+ * {@link RoleSensitive#checkRoles(RoleChecker)}:
  *
  * <pre>
  * // from the server
- * channelToClient.call(new Callable&lt;Void,IOException>() {
+ * channelToClient.call(new Callable&lt;Void,IOException&gt;() {
  *     Void call() {
  *         ...
  *     }
- *     Collection&lt;Role> getRecipients() {
- *          return Collections.singleton(MyProtocol.CLIENT);
+ *     void checkRoles(RoleChecker checker) {
+ *          checker.check(this,MyProtocol.CLIENT);
  *     }
  * });
  * </pre>

diff --git a/src/main/java/org/jenkinsci/remoting/RoleSensitive.java b/src/main/java/org/jenkinsci/remoting/RoleSensitive.java
@@ -24,8 +24,8 @@ public interface RoleSensitive {
      * If you have a Jenkins {@link Callable} or {@code FileCallable}, use the standard abstract base classes instead,
      * such as {@code MasterToSlaveCallable}, {@code MasterToSlaveFileCallable}, {@code NotReallyRoleSensitiveCallable}, etc.
      * See <a href="https://wiki.jenkins-ci.org/display/JENKINS/Slave+To+Master+Access+Control/#SlaveToMasterAccessControl-I%27maplugindeveloper.WhatshouldIdo%3F">this document</a> for details.
-     * @return
-     *      If the method returns normally, the check has passed.
+     * <p>
+     * If the method returns normally, the check has passed.
      *
      * @throws SecurityException
      *      If there's a mismatch in the expected roles and the actual roles that should prevent

diff --git a/src/main/java/org/jenkinsci/remoting/engine/JnlpProtocol3Handler.java b/src/main/java/org/jenkinsci/remoting/engine/JnlpProtocol3Handler.java
@@ -79,6 +79,7 @@
  *
  * <p>The following goes over the handshake in more detail:
  * <pre>
+ * {@code
  * Client                                                                Master
  *           handshake ciphers = createFrom(slave name, slave secret)
  *
@@ -110,7 +111,8 @@
  *
  *              channel ciphers = createFrom(AES key, IvSpec)
  *           channel = channelBuilder.createWith(channel ciphers)
- * </pre>
+ * }
+ *  </pre>
  *
  * <p>The entire process assumes the slave secret has not been leaked
  * beforehand and the slave obtains it in a secure manner.

diff --git a/src/main/java/org/jenkinsci/remoting/util/SettableFuture.java b/src/main/java/org/jenkinsci/remoting/util/SettableFuture.java
@@ -113,7 +113,7 @@ private SettableFuture() {
      * Completes the future with the supplied value.
      *
      * @param value the value (may be {@code null}.
-     * @return {@code true} if the future is now completed, {@false} if the future has already been completed.
+     * @return {@code true} if the future is now completed, {@code false} if the future has already been completed.
      */
     public boolean set(@Nullable V value) {
         boolean result;
@@ -137,7 +137,7 @@ public boolean set(@Nullable V value) {
      * Completes the future with the supplied exception.
      *
      * @param throwable the exception.
-     * @return {@code true} if the future is now completed, {@false} if the future has already been completed.
+     * @return {@code true} if the future is now completed, {@code false} if the future has already been completed.
      */
     public boolean setException(@Nonnull Throwable throwable) {
         verifyNonnull(throwable);
@@ -165,7 +165,7 @@ public boolean setException(@Nonnull Throwable throwable) {
      * Completes the future by cancellation.
      *
      * @param mayInterruptIfRunning ignored.
-     * @return {@code true} if the future is now cancelled, {@false} if the future has already been completed.
+     * @return {@code true} if the future is now cancelled, {@code false} if the future has already been completed.
      */
     @Override
     public boolean cancel(boolean mayInterruptIfRunning) {
@@ -229,7 +229,8 @@ public V get() throws InterruptedException, ExecutionException {
      * {@inheritDoc}
      */
     @Override
-    public V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+    public V get(long timeout, @Nonnull TimeUnit unit)
+            throws InterruptedException, ExecutionException, TimeoutException {
         long timeoutNanos = unit.toNanos(timeout);
         long start = System.nanoTime();
         synchronized (lock) {