Raise Errors from StreamingCallbacks.

src/main/java/org/jenkinsci/plugins/p4/client/AbstractStreamingCallback.java

@@ -0,0 +1,66 @@
+package org.jenkinsci.plugins.p4.client;
+
+import com.perforce.p4java.exception.P4JavaException;
+import com.perforce.p4java.impl.mapbased.server.Server;
+import com.perforce.p4java.server.IServer;
+import com.perforce.p4java.server.callback.IStreamingCallback;
+import hudson.model.TaskListener;
+
+import java.util.Map;
+
+public abstract class AbstractStreamingCallback implements IStreamingCallback {
+
+	private boolean done = false;
+	private boolean fail = false;
+	private P4JavaException exception = null;
+
+	private final Server server;
+	private final Validate validate;
+
+	public AbstractStreamingCallback(IServer iserver, TaskListener listener) {
+		this.server = (Server) iserver;
+		this.validate = new Validate(listener);
+	}
+
+	@Override
+	public boolean startResults(int key) throws P4JavaException {
+		return true;
+	}
+
+	@Override
+	public boolean endResults(int key) throws P4JavaException {
+		done = true;
+		return true;
+	}
+
+	@Override
+	public abstract boolean handleResult(Map<String, Object> map, int key) throws P4JavaException;
+
+	public boolean isDone() {
+		return done;
+	}
+
+	public boolean isFail() {
+		return fail;
+	}
+
+	public void setFail() {
+		fail = true;
+	}
+
+	public P4JavaException getException() {
+		return exception;
+	}
+
+	public void setException(P4JavaException exception) {
+		this.exception = exception;
+	}
+
+	public Server getServer() {
+		return server;
+	}
+
+	public Validate getValidate() {
+		return validate;
+	}
+}

src/main/java/org/jenkinsci/plugins/p4/client/ClientHelper.java

@@ -285,7 +285,7 @@ private void syncFiles(String revisions, Populate populate) throws Exception {
 			}
 
 			if (callback.isFail()) {
-				throw new P4JavaException("Sync failed in streaming callback.");
+				throw new P4JavaException(callback.getException());
 			}
 		}
 	}

src/main/java/org/jenkinsci/plugins/p4/client/ReconcileStreamingCallback.java

@@ -1,56 +1,33 @@
 package org.jenkinsci.plugins.p4.client;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-
 import com.perforce.p4java.core.file.IFileSpec;
 import com.perforce.p4java.exception.P4JavaException;
-import com.perforce.p4java.impl.mapbased.server.Server;
+import com.perforce.p4java.impl.mapbased.server.cmd.ResultListBuilder;
 import com.perforce.p4java.server.IServer;
-import com.perforce.p4java.server.callback.IStreamingCallback;
-
 import hudson.model.TaskListener;
 
-public class ReconcileStreamingCallback implements IStreamingCallback {
-
-	private boolean done = false;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 
-	private final Server server;
-	private final Validate validate;
+public class ReconcileStreamingCallback extends AbstractStreamingCallback {
 
 	public ReconcileStreamingCallback(IServer iserver, TaskListener listener) {
-		this.server = (Server) iserver;
-		this.validate = new Validate(listener);
-	}
-
-	@Override
-	public boolean startResults(int key) throws P4JavaException {
-		return true;
-	}
-
-	@Override
-	public boolean endResults(int key) throws P4JavaException {
-		done = true;
-		return true;
+		super(iserver, listener);
 	}
 
 	@Override
 	public boolean handleResult(Map<String, Object> map, int key) throws P4JavaException {
 		List<IFileSpec> specList = new ArrayList<IFileSpec>();
-		specList.add(server.handleFileReturn(map));
+		specList.add(ResultListBuilder.handleFileReturn(map, getServer()));
 
 		try {
-			validate.check(specList, "also opened by", "no file(s) to reconcile", "must sync/resolve",
+			getValidate().check(specList, "also opened by", "no file(s) to reconcile", "must sync/resolve",
 					"exclusive file already opened", "cannot submit from stream", "instead of", "empty, assuming text");
 		} catch (Exception e) {
 			// re-throw exception as AbortException is only used if !quiet
 			throw new P4JavaException(e);
 		}
 		return true;
 	}
-
-	public boolean isDone() {
-		return done;
-	}
 }

src/main/java/org/jenkinsci/plugins/p4/client/SubmitStreamingCallback.java

@@ -1,36 +1,18 @@
 package org.jenkinsci.plugins.p4.client;
 
 import com.perforce.p4java.exception.P4JavaException;
-import com.perforce.p4java.impl.mapbased.server.Server;
 import com.perforce.p4java.server.IServer;
-import com.perforce.p4java.server.callback.IStreamingCallback;
 import hudson.model.TaskListener;
 
 import java.util.Map;
 
-public class SubmitStreamingCallback implements IStreamingCallback {
-
-	private boolean done = false;
-	private long change = 0;
-
-	private final Server server;
-	private final Validate validate;
+public class SubmitStreamingCallback extends AbstractStreamingCallback {
 
 	public SubmitStreamingCallback(IServer iserver, TaskListener listener) {
-		this.server = (Server) iserver;
-		this.validate = new Validate(listener);
-	}
-
-	@Override
-	public boolean startResults(int key) throws P4JavaException {
-		return true;
+		super(iserver, listener);
 	}
 
-	@Override
-	public boolean endResults(int key) throws P4JavaException {
-		done = true;
-		return true;
-	}
+	private long change = 0;
 
 	@Override
 	public boolean handleResult(Map<String, Object> map, int id) throws P4JavaException {
@@ -45,12 +27,7 @@ public boolean handleResult(Map<String, Object> map, int id) throws P4JavaExcept
 		return true;
 	}
 
-	public boolean isDone() {
-		return done;
-	}
-
 	public long getChange() {
 		return change;
 	}
-
 }

src/main/java/org/jenkinsci/plugins/p4/client/SyncStreamingCallback.java

@@ -2,63 +2,38 @@
 
 import com.perforce.p4java.core.file.IFileSpec;
 import com.perforce.p4java.exception.P4JavaException;
-import com.perforce.p4java.impl.mapbased.server.Server;
+import com.perforce.p4java.impl.mapbased.server.cmd.ResultListBuilder;
 import com.perforce.p4java.server.IServer;
-import com.perforce.p4java.server.callback.IStreamingCallback;
 import hudson.model.TaskListener;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
-public class SyncStreamingCallback implements IStreamingCallback {
-
-	private boolean done = false;
-	private boolean fail = false;
-
-	private final Server server;
-	private final Validate validate;
+public class SyncStreamingCallback extends AbstractStreamingCallback {
 
 	public SyncStreamingCallback(IServer iserver, TaskListener listener) {
-		this.server = (Server) iserver;
-		this.validate = new Validate(listener);
-	}
-
-	@Override
-	public boolean startResults(int key) throws P4JavaException {
-		return true;
-	}
-
-	@Override
-	public boolean endResults(int key) throws P4JavaException {
-		done = true;
-		return true;
+		super(iserver, listener);
 	}
 
 	@Override
 	public boolean handleResult(Map<String, Object> map, int key) throws P4JavaException {
 		List<IFileSpec> specList = new ArrayList<IFileSpec>();
-		specList.add(server.handleFileReturn(map));
+		specList.add(ResultListBuilder.handleFileReturn(map, getServer()));
 
 		try {
-			validate.check(specList, "file(s) up-to-date.",
+			getValidate().check(specList, "file(s) up-to-date.",
 					"file does not exist",
 					"no file(s) as of that date",
 					"no such file(s)",
 					"Unexpected argument syntax - @");
 		} catch (Exception e) {
-			fail = true;
+			setFail();
+			P4JavaException exception = new P4JavaException(e);
+			setException(exception);
 			// re-throw exception as AbortException is only used if !quiet
-			throw new P4JavaException(e);
+			throw exception;
 		}
 		return true;
 	}
-
-	public boolean isDone() {
-		return done;
-	}
-
-	public boolean isFail() {
-		return fail;
-	}
 }