Avoid using the concrete class like StreamTaskListener for a contract.

git-svn-id: https://hudson.dev.java.net/svn/hudson/trunk/hudson/main@17807 71c3de6d-444a-0410-be80-ed276b4c234a

core/src/main/java/hudson/os/windows/ManagedWindowsServiceLauncher.java

@@ -26,9 +26,9 @@ package hudson.os.windows;
 import hudson.lifecycle.WindowsSlaveInstaller;
 import hudson.model.Descriptor;
 import hudson.model.Hudson;
+import hudson.model.TaskListener;
 import hudson.slaves.ComputerLauncher;
 import hudson.slaves.SlaveComputer;
-import hudson.util.StreamTaskListener;
 import hudson.util.Secret;
 import hudson.util.jna.DotNet;
 import hudson.remoting.Channel;
@@ -96,7 +96,7 @@ public class ManagedWindowsServiceLauncher extends ComputerLauncher {
         return new NtlmPasswordAuthentication(auth.getDomain(), auth.getUserName(), auth.getPassword());
     }
 
-    public void launch(final SlaveComputer computer, final StreamTaskListener listener) throws IOException, InterruptedException {
+    public void launch(final SlaveComputer computer, final TaskListener listener) throws IOException, InterruptedException {
         try {
             PrintStream logger = listener.getLogger();
 
@@ -205,7 +205,7 @@ public class ManagedWindowsServiceLauncher extends ComputerLauncher {
     }
 
     @Override
-    public void afterDisconnect(SlaveComputer computer, StreamTaskListener listener) {
+    public void afterDisconnect(SlaveComputer computer, TaskListener listener) {
         try {
             JIDefaultAuthInfoImpl auth = createAuth();
             JISession session = JISession.createSession(auth);

core/src/main/java/hudson/slaves/CommandLauncher.java

@@ -27,10 +27,10 @@ import hudson.EnvVars;
 import hudson.Util;
 import hudson.Extension;
 import hudson.model.Descriptor;
+import hudson.model.TaskListener;
 import hudson.remoting.Channel;
 import hudson.util.ProcessTreeKiller;
 import hudson.util.StreamCopyThread;
-import hudson.util.StreamTaskListener;
 import hudson.util.FormValidation;
 
 import java.io.IOException;
@@ -82,7 +82,7 @@ public class CommandLauncher extends ComputerLauncher {
     }
 
     @Override
-    public void launch(SlaveComputer computer, final StreamTaskListener listener) {
+    public void launch(SlaveComputer computer, final TaskListener listener) {
         EnvVars _cookie = null;
         Process _proc = null;
         try {

core/src/main/java/hudson/slaves/ComputerLauncher.java

@@ -29,6 +29,7 @@ import hudson.model.Computer;
 import hudson.model.Describable;
 import hudson.model.Descriptor;
 import hudson.model.Hudson;
+import hudson.model.TaskListener;
 import hudson.remoting.Channel.Listener;
 import hudson.util.DescriptorList;
 import hudson.util.StreamTaskListener;
@@ -85,20 +86,52 @@ public abstract class ComputerLauncher implements Describable<ComputerLauncher>,
      *      a failure and the stack trace is reported into the listener. This handling is just so that the implementation
      *      of this method doesn't have to dilligently catch those exceptions.
      */
-    public abstract void launch(SlaveComputer computer, StreamTaskListener listener) throws IOException , InterruptedException;
+    public void launch(SlaveComputer computer, TaskListener listener) throws IOException , InterruptedException {
+        launch(computer,cast(listener));
+    }
+
+    /**
+     * @deprecated as of 1.304
+     *  Use {@link #launch(SlaveComputer, TaskListener)}
+     */
+    public void launch(SlaveComputer computer, StreamTaskListener listener) throws IOException , InterruptedException {
+        throw new UnsupportedOperationException(getClass()+" must implement the launch method");
+    }
 
     /**
      * Allows the {@link ComputerLauncher} to tidy-up after a disconnect.
      */
+    public void afterDisconnect(SlaveComputer computer, TaskListener listener) {
+        afterDisconnect(computer,cast(listener));
+    }
+
+    /**
+     * @deprecated as of 1.304
+     *  Use {@link #afterDisconnect(SlaveComputer, TaskListener)}
+     */
     public void afterDisconnect(SlaveComputer computer, StreamTaskListener listener) {
     }
 
     /**
      * Allows the {@link ComputerLauncher} to prepare for a disconnect.
      */
+    public void beforeDisconnect(SlaveComputer computer, TaskListener listener) {
+        beforeDisconnect(computer,cast(listener));
+    }
+
+    /**
+     * @deprecated as of 1.304
+     *  Use {@link #beforeDisconnect(SlaveComputer, TaskListener)} 
+     */
     public void beforeDisconnect(SlaveComputer computer, StreamTaskListener listener) {
     }
 
+    private StreamTaskListener cast(TaskListener listener) {
+        if (listener instanceof StreamTaskListener)
+            return (StreamTaskListener) listener;
+        return new StreamTaskListener(listener.getLogger());
+    }
+
     public Descriptor<ComputerLauncher> getDescriptor() {
         return (Descriptor<ComputerLauncher>)Hudson.getInstance().getDescriptor(getClass());
     }

core/src/main/java/hudson/slaves/ComputerLauncherFilter.java

@@ -23,9 +23,9 @@
  */
 package hudson.slaves;
 
-import hudson.util.StreamTaskListener;
 import hudson.model.Descriptor;
 import hudson.model.Node;
+import hudson.model.TaskListener;
 
 import java.io.IOException;
 
@@ -57,15 +57,15 @@ public abstract class ComputerLauncherFilter extends ComputerLauncher {
         return core.isLaunchSupported();
     }
 
-    public void launch(SlaveComputer computer, StreamTaskListener listener) throws IOException, InterruptedException {
+    public void launch(SlaveComputer computer, TaskListener listener) throws IOException, InterruptedException {
         core.launch(computer, listener);
     }
 
-    public void afterDisconnect(SlaveComputer computer, StreamTaskListener listener) {
+    public void afterDisconnect(SlaveComputer computer, TaskListener listener) {
         core.afterDisconnect(computer, listener);
     }
 
-    public void beforeDisconnect(SlaveComputer computer, StreamTaskListener listener) {
+    public void beforeDisconnect(SlaveComputer computer, TaskListener listener) {
         core.beforeDisconnect(computer, listener);
     }
 

core/src/main/java/hudson/slaves/JNLPLauncher.java

@@ -24,7 +24,7 @@
 package hudson.slaves;
 
 import hudson.model.Descriptor;
-import hudson.util.StreamTaskListener;
+import hudson.model.TaskListener;
 import hudson.Util;
 import hudson.Extension;
 import org.kohsuke.stapler.DataBoundConstructor;
@@ -70,7 +70,7 @@ public class JNLPLauncher extends ComputerLauncher {
         return false;
     }
 
-    public void launch(SlaveComputer computer, StreamTaskListener listener) {
+    public void launch(SlaveComputer computer, TaskListener listener) {
         // do nothing as we cannot self start
     }
 

core/src/main/java/hudson/slaves/SlaveComputer.java

@@ -164,7 +164,7 @@ public class SlaveComputer extends Computer {
             public Object call() throws Exception {
                 // do this on another thread so that the lengthy launch operation
                 // (which is typical) won't block UI thread.
-                StreamTaskListener listener = new StreamTaskListener(openLogFile());
+                TaskListener listener = new StreamTaskListener(openLogFile());
                 try {
                     launcher.launch(SlaveComputer.this, listener);
                     return null;
@@ -267,19 +267,20 @@ public class SlaveComputer extends Computer {
         if(this.channel!=null)
             throw new IllegalStateException("Already connected");
 
+        PrintWriter log = new PrintWriter(launchLog,true);
+        final TaskListener taskListener = new StreamTaskListener(log);
+
         Channel channel = new Channel(nodeName,threadPoolForRemoting, Channel.Mode.NEGOTIATE,
             in,out, launchLog);
         channel.addListener(new Channel.Listener() {
             public void onClosed(Channel c,IOException cause) {
                 SlaveComputer.this.channel = null;
+                launcher.afterDisconnect(SlaveComputer.this, taskListener);
             }
         });
         if(listener!=null)
             channel.addListener(listener);
 
-        PrintWriter log = new PrintWriter(launchLog,true);
-        TaskListener taskListener = new StreamTaskListener(log);
-
         boolean _isUnix = channel.call(new DetectOS());
         log.println(_isUnix? hudson.model.Messages.Slave_UnixSlave():hudson.model.Messages.Slave_WindowsSlave());
 
@@ -349,7 +350,7 @@ public class SlaveComputer extends Computer {
             public void run() {
                 // do this on another thread so that any lengthy disconnect operation
                 // (which could be typical) won't block UI thread.
-                StreamTaskListener listener = new StreamTaskListener(openLogFile());
+                TaskListener listener = new StreamTaskListener(openLogFile());
                 launcher.beforeDisconnect(SlaveComputer.this, listener);
                 closeChannel();
                 launcher.afterDisconnect(SlaveComputer.this, listener);