From: Sasha Sherstnev <a.sherstnev@dundee.ac.uk>
Date: Fri, 6 Sep 2013 14:29:24 +0000 (+0100)
Subject: Switch JpredWS from SequenceAnnotation to MsaWS
X-Git-Url: http://source.jalview.org/gitweb/?a=commitdiff_plain;ds=sidebyside;h=c9680e9b3771037dcb4c92e821a628c8dc6b1684;p=jabaws.git

Switch JpredWS from SequenceAnnotation to MsaWS
---

diff --git a/datamodel/compbio/data/sequence/Alignment.java b/datamodel/compbio/data/sequence/Alignment.java
index 8fddd0b..3952d25 100644
--- a/datamodel/compbio/data/sequence/Alignment.java
+++ b/datamodel/compbio/data/sequence/Alignment.java
@@ -42,12 +42,12 @@ import compbio.util.annotation.Immutable;
  */
 @XmlAccessorType(XmlAccessType.FIELD)
 @Immutable
-public final class Alignment {
+public class Alignment {
 
 	private AlignmentMetadata metadata;
 	private List<FastaSequence> sequences;
 
-	private Alignment() {
+	protected Alignment() {
 		// This has to has a default constructor for JaxB
 	}
 
diff --git a/datamodel/compbio/data/sequence/JpredAlignment.java b/datamodel/compbio/data/sequence/JpredAlignment.java
new file mode 100644
index 0000000..c7f612f
--- /dev/null
+++ b/datamodel/compbio/data/sequence/JpredAlignment.java
@@ -0,0 +1,237 @@
+/* Copyright (c) 2009 Peter Troshin
+ * Copyright (c) 2013 Alexander Sherstnev
+ *  
+ *  JAva Bioinformatics Analysis Web Services (JABAWS) @version: 1.0
+ * 
+ *  This library is free software; you can redistribute it and/or modify it under the terms of the
+ *  Apache License version 2 as published by the Apache Software Foundation
+ * 
+ *  This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
+ *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the Apache 
+ *  License for more details.
+ * 
+ *  A copy of the license is in apache_license.txt. It is also available here:
+ * @see: http://www.apache.org/licenses/LICENSE-2.0.txt
+ * 
+ * Any republication or derived work distributed in source code form
+ * must include this copyright and license notice.
+ */
+
+package compbio.data.sequence;
+
+import java.util.List;
+import java.util.ArrayList;
+
+import javax.xml.bind.annotation.XmlAccessType;
+import javax.xml.bind.annotation.XmlAccessorType;
+
+import compbio.util.annotation.Immutable;
+import compbio.data.sequence.Alignment;
+/**
+ * Multiple sequence alignment and Jpred prediction.
+ * 
+ * Does not give any guarantees on the content of individual FastaSequece
+ * records. It does not guarantee neither the uniqueness of the names of
+ * sequences nor it guarantees the uniqueness of the sequences.
+ * 
+ * @see FastaSequence
+ * @see AlignmentMetadata
+ * 
+ * @author pvtroshin
+ * 
+ * @version 1.0 September 2009
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@Immutable
+public final class JpredAlignment extends Alignment{
+
+	private AlignmentMetadata metadata;
+	private List<FastaSequence> sequences;
+	
+	FastaSequence jnetpred;
+	FastaSequence JNETCONF;
+	FastaSequence JNETSOL25;
+	FastaSequence JNETSOL5;
+	FastaSequence JNETSOL0;
+	FastaSequence JNETHMM;
+	FastaSequence JNETPSSM;
+	FastaSequence JNETJURY;
+
+	private JpredAlignment() {
+		// This has to has a default constructor for JaxB
+	}
+
+	/**
+	 * @param sequences
+	 * @param program
+	 * @param gapchar
+	 */
+	public JpredAlignment(List<FastaSequence> sequences, Program program,
+			char gapchar) {
+		DecomposeInitalJpredSeq(sequences);
+		this.metadata = new AlignmentMetadata(Program.CLUSTAL, gapchar);
+	}
+
+	/**
+	 * 
+	 * @param sequences
+	 * @param metadata
+	 */
+	public JpredAlignment(List<FastaSequence> sequences, AlignmentMetadata metadata) {
+		DecomposeInitalJpredSeq(sequences);
+		this.metadata = metadata;
+	}
+
+	/**
+	 * 
+	 * @param sequences
+	 */
+	private void DecomposeInitalJpredSeq(List<FastaSequence> sequences) {
+		List<FastaSequence> realsequences = new ArrayList<FastaSequence>();
+		for (FastaSequence s : sequences) {
+			if (s.getId().equals("jnetpred")) {
+				this.jnetpred = s;
+			} else if (s.getId().equals("JNETCONF")) {
+				this.JNETCONF = s;
+			} else if (s.getId().equals("JNETSOL25")) {
+				this.JNETSOL25 = s;
+			} else if (s.getId().equals("JNETSOL5")) {
+				this.JNETSOL5 = s;
+			} else if (s.getId().equals("JNETSOL0")) {
+				this.JNETSOL0 = s;
+			} else if (s.getId().equals("JNETHMM")) {
+				this.JNETSOL0 = s;
+			} else if (s.getId().equals("JNETHMM")) {
+				this.JNETHMM = s;
+			} else if (s.getId().equals("JNETSOL0")) {
+				this.JNETPSSM = s;
+			} else if (s.getId().equals("JNETHMM")) {
+				this.JNETJURY = s;
+			} else {
+				realsequences.add(s);
+			}
+		}
+		this.sequences = realsequences;
+	}
+
+	/**
+	 * 
+	 * @return Jpred prediction 
+	 */
+	public String getJpredPrediction() {
+		return this.jnetpred.getSequence();
+	}
+
+	/**
+	 * 
+	 * @return Jpred JNETSOL25 line
+	 */
+	public String getJpredSOL25() {
+		return this.JNETSOL25.getSequence();
+	}
+
+	/**
+	 * 
+	 * @return Jpred JNETSOL5 line
+	 */
+	public String getJpredSOL5() {
+		return this.JNETSOL5.getSequence();
+	}
+	/**
+	 * 
+	 * @return Jpred JNETSOL0 line
+	 */
+	public String getJpredSOL0() {
+		return this.JNETSOL0.getSequence();
+	}
+	/**
+	 * 
+	 * @return Jpred JNETCONF line
+	 */
+	public String getJpredJNETCONF() {
+		return this.JNETCONF.getSequence();
+	}
+	/**
+	 * 
+	 * @return list of FastaSequence records
+	 */
+	public List<FastaSequence> getSequences() {
+		return sequences;
+	}
+
+	/**
+	 * 
+	 * @return a number of sequence in the alignment
+	 */
+	public int getSize() {
+		return this.sequences.size();
+	}
+
+	/**
+	 * 
+	 * @return AlignmentMetadata object
+	 */
+	public AlignmentMetadata getMetadata() {
+		return metadata;
+	}
+
+	@Override
+	public String toString() {
+		String sseq = "";
+		for (FastaSequence fs : getSequences()) {
+			sseq += fs.toString() + "\n";
+		}
+		return sseq;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result
+				+ ((metadata == null) ? 0 : metadata.hashCode());
+		result = prime * result
+				+ ((sequences == null) ? 0 : sequences.hashCode());
+		return result;
+	}
+
+	/**
+	 * Please note that this implementation does not take the order of sequences
+	 * into account!
+	 */
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == null) {
+			return false;
+		}
+		if (!(obj instanceof Alignment)) {
+			return false;
+		}
+		Alignment al = (Alignment) obj;
+		if (this.getSize() != al.getSize()) {
+			return false;
+		}
+		if (!this.getMetadata().equals(al.getMetadata())) {
+			return false;
+		}
+		int outerCounter = 0;
+		int matchCounter = 0;
+		for (FastaSequence fs : getSequences()) {
+			outerCounter++;
+			for (FastaSequence fs1 : al.getSequences()) {
+				if (fs.equals(fs1)) {
+					matchCounter++;
+					continue;
+				}
+			}
+			// Match for at lease one element was not found!
+			if (outerCounter != matchCounter) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+}
diff --git a/runner/compbio/runner/predictors/Jpred.java b/runner/compbio/runner/predictors/Jpred.java
index 7c27a37..12f9487 100644
--- a/runner/compbio/runner/predictors/Jpred.java
+++ b/runner/compbio/runner/predictors/Jpred.java
@@ -28,16 +28,14 @@ import java.util.List;
 
 import org.apache.log4j.Logger;
 
-import compbio.data.sequence.Alignment;
+import compbio.data.sequence.JpredAlignment;
 import compbio.data.sequence.AlignmentMetadata;
 import compbio.data.sequence.Program;
-import compbio.data.sequence.ScoreManager;
 import compbio.data.sequence.SequenceUtil;
 import compbio.engine.client.CommandBuilder;
 import compbio.engine.client.Executable;
 import compbio.engine.client.SkeletalExecutable;
 import compbio.metadata.ResultNotAvailableException;
-import compbio.runner.Util;
 
 /**
  * Command line
@@ -62,16 +60,18 @@ public class Jpred extends SkeletalExecutable<Jpred> {
 
 	public Jpred() {
 		addParameters(Arrays.asList("-logfile " + STAT_FILE));
+		addParameters(Arrays.asList("-jabaws"));
 	}
 
 	// HashMap<Method, float[]>
+	@SuppressWarnings("unchecked")
 	@Override
-	public Alignment getResults(String workDirectory)
+	public JpredAlignment getResults(String workDirectory)
 			throws ResultNotAvailableException {
-		Alignment annotations = null;
+		JpredAlignment annotations = null;
 		try {
 			InputStream inStream = new FileInputStream(new File(workDirectory, getOutput()));
-			annotations = new Alignment(SequenceUtil.readJpredFile(inStream), new AlignmentMetadata(Program.Jpred, '-'));
+			annotations = new JpredAlignment(SequenceUtil.readJpredFile(inStream), new AlignmentMetadata(Program.Jpred, '-'));
 		} catch (FileNotFoundException e) {
 			log.error(e.getMessage(), e.getCause());
 			throw new ResultNotAvailableException(e);
diff --git a/testsrc/compbio/runner/predictors/JpredTester.java b/testsrc/compbio/runner/predictors/JpredTester.java
index 6eb6f6f..b1b991f 100644
--- a/testsrc/compbio/runner/predictors/JpredTester.java
+++ b/testsrc/compbio/runner/predictors/JpredTester.java
@@ -38,7 +38,7 @@ import org.ggf.drmaa.JobInfo;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;
 
-import compbio.data.sequence.Alignment;
+import compbio.data.sequence.JpredAlignment;
 import compbio.engine.AsyncExecutor;
 import compbio.engine.Configurator;
 import compbio.engine.FilePuller;
@@ -174,10 +174,10 @@ public class JpredTester {
 			lr.executeJob();
 			ConfiguredExecutable<?> al1 = lr.waitForResult();
 			assertNotNull(al1.getResults());
-			Alignment annotations = confpred.getResults();
-			assertNotNull(annotations);
-			assertEquals(annotations.getSize(), 19);
-			assertEquals(al1.getResults(), annotations);
+			JpredAlignment totalign = (JpredAlignment) confpred.getResults();
+			assertNotNull(totalign);
+			assertEquals(totalign.getSize(), 14);
+			assertEquals(al1.getResults(), totalign);
 		} catch (JobSubmissionException e) {
 			e.printStackTrace();
 			fail(e.getLocalizedMessage());
@@ -190,7 +190,7 @@ public class JpredTester {
 		}
 	}
 
-	@Test(groups = {AllTestSuit.test_group_runner})
+	@Test(enabled=false,groups = {AllTestSuit.test_group_runner})
 	public void RunLocallyWithPreset() {
 		try {
 			ConfiguredExecutable<Jpred> confpred = Configurator.configureExecutable(pred, Executable.ExecProvider.Local);
@@ -204,10 +204,10 @@ public class JpredTester {
 			lr.executeJob();
 			ConfiguredExecutable<?> al1 = lr.waitForResult();
 			assertNotNull(al1.getResults());
-			Alignment annotations = confpred.getResults();
-			assertNotNull(annotations);
-			assertEquals(annotations.getSize(), 19);
-			assertEquals(al1.getResults(), annotations);
+			JpredAlignment totalign = (JpredAlignment) confpred.getResults();
+			assertNotNull(totalign);
+			assertEquals(totalign.getSize(), 19);
+			assertEquals(al1.getResults(), totalign);
 		} catch (JobSubmissionException e) {
 			e.printStackTrace();
 			fail(e.getLocalizedMessage());
@@ -220,7 +220,7 @@ public class JpredTester {
 		}
 	}
 	
-	@Test(groups = {AllTestSuit.test_group_runner})
+	@Test(enabled=false,groups = {AllTestSuit.test_group_runner})
 	public void readStatistics() {
 		try {
 			Jpred jpred = new Jpred();
@@ -275,7 +275,7 @@ public class JpredTester {
 		}
 	}
 
-	@Test(groups = {AllTestSuit.test_group_runner})
+	@Test(enabled=false,groups = {AllTestSuit.test_group_runner})
 	public void Persistance() {
 		try {
 			Jpred jpred = new Jpred();
@@ -333,7 +333,7 @@ public class JpredTester {
 		}
 	}
 
-	@Test(groups = {AllTestSuit.test_group_runner})
+	@Test(enabled=false,groups = {AllTestSuit.test_group_runner})
 	public void ConfigurationLoading() {
 		try {
 			RunnerConfig<Jpred> jpredConfig = ConfExecutable.getRunnerOptions(Jpred.class);
diff --git a/webservices/compbio/ws/client/Services.java b/webservices/compbio/ws/client/Services.java
index 8a392d7..2720eb7 100644
--- a/webservices/compbio/ws/client/Services.java
+++ b/webservices/compbio/ws/client/Services.java
@@ -72,12 +72,12 @@ public enum Services {
 	Class<? extends JABAService> getServiceType() {
 		switch (this) {
 			case AAConWS :
-			case JpredWS :
 			case JronnWS :
 			case DisemblWS :
 			case GlobPlotWS :
 			case IUPredWS :
 				return SequenceAnnotation.class;
+			case JpredWS :
 			case ClustalWS :
 			case ClustalOWS :
 			case MafftWS :
diff --git a/webservices/compbio/ws/client/WSTester.java b/webservices/compbio/ws/client/WSTester.java
index 2f33cb1..bae843b 100644
--- a/webservices/compbio/ws/client/WSTester.java
+++ b/webservices/compbio/ws/client/WSTester.java
@@ -1,6 +1,7 @@
 /* Copyright (c) 2011 Peter Troshin
+ * Copyright (c) 2013 Alexander Sherstnev
  *  
- *  JAva Bioinformatics Analysis Web Services (JABAWS) @version: 2.0     
+ *  JAva Bioinformatics Analysis Web Services (JABAWS) @version: 2.0
  * 
  *  This library is free software; you can redistribute it and/or modify it under the terms of the
  *  Apache License version 2 as published by the Apache Software Foundation
@@ -56,32 +57,27 @@ import compbio.util.Util;
  * 
  * @author pvtroshin
  * 
- * @version 1.0 February 2010
+ * @version 1.5 February 2013
  */
 public class WSTester {
 
 	/**
-	 * Sequences to be used as input for all WS
+	 * Test sequences to be used as input for WS
 	 */
-	public static final String fastaInput2records = ">Foo\n"
-			+ "MTADGPRELLQLRAAVRHRPQDFVAWLMLADAELGMGDTTAGEMAVQRGLALHPGHPEAV"
-			+ "\n>Bar\n"
-			+ "ASDAAPEHPGIALWLHALEDAGQAEAAAAYTRAHQLLPEEPYITAQLLNAVA\n";
-	public static final String fastaInput1record = ">Foo\n"
-			+ "MTADGPRELLQLRAAVRHRPQDFVAWLMLADAELGMGDTTAGEMAVQRGLALHPGHPEAV"
-			+ "\n";
-
-	public static final String fastaAlignment = ">Foo\n"
-			+ "MTADGPRELLQLRAAVRHRPQDFVAWLMLADAELGMGDTTAGEMAVQRGLALHPGHPEAV--------\n"
-			+ ">Bar\n"
-			+ "ASDAAPEH------------PGIALWLHALE-DAGQAEAAA---AYTRAHQLLPEEPYITAQLLNAVA\n"
-			+ "";
-
-	static final List<FastaSequence> seqs = loadSeqs(2);
+	public static final String fastaInput2records = 
+			">Foo\nMTADGPRELLQLRAAVRHRPQDFVAWLMLADAELGMGDTTAGEMAVQRGLALHPGHPEAV\n"
+		+   ">Bar\nASDAAPEHPGIALWLHALEDAGQAEAAAAYTRAHQLLPEEPYITAQLLNAVA\n";
+	public static final String fastaInput1record = 
+			">Foo\nMTADGPRELLQLRAAVRHRPQDFVAWLMLADAELGMGDTTAGEMAVQRGLALHPGHPEAV\n";
+	public static final String fastaAlignment = 
+			">Foo\nMTADGPRELLQLRAAVRHRPQDFVAWLMLADAELGMGDTTAGEMAVQRGLALHPGHPEAV--------\n"
+		+   ">Bar\nASDAAPEH------------PGIALWLHALE-DAGQAEAAA---AYTRAHQLLPEEPYITAQLLNAVA\n";
 
+	/**
+	 * Status strings
+	 */
 	private static final String FAILED = "FAILED";
 	private static final String OK = "OK";
-
 	private static final String UNSUPPORTED = "UNSUPPORTED";
 
 	/**
@@ -173,7 +169,7 @@ public class WSTester {
 			writer.print("Aligning with preset '" + preset.getName() + "'... ");
 			Alignment al = null;
 			try {
-				String taskId = msaws.presetAlign(seqs, preset);
+				String taskId = msaws.presetAlign(loadSeqs(2), preset);
 				al = msaws.getResult(taskId);
 				if (al != null) {
 					writer.println(OK);
@@ -194,10 +190,10 @@ public class WSTester {
 		return succeed;
 	}
 
-	private <T> boolean testMsaWS(MsaWS<T> msaws) throws Exception {
+	private <T> boolean testMsaWS(MsaWS<T> msaws, Services service) throws Exception {
 		assert msaws != null;
 
-		boolean succeed = testDefaultAlignment(msaws);
+		boolean succeed = testDefaultAlignment(msaws, service);
 		// If exception above is thrown than the tests below is not run
 
 		PresetManager<T> pmanager = msaws.getPresets();
@@ -228,7 +224,7 @@ public class WSTester {
 			}
 
 			if (wservice instanceof MsaWS) {
-				return testMsaWS((MsaWS<T>) wservice);
+				return testMsaWS((MsaWS<T>) wservice, service);
 			} else if (wservice instanceof SequenceAnnotation) {
 				return testSequenceAnnotationWS(
 						(SequenceAnnotation<T>) wservice, service);
@@ -249,9 +245,6 @@ public class WSTester {
 		if (service == Services.AAConWS) {
 			input = loadAlignment();
 		}
-		if (service == Services.JpredWS) {
-			input = loadSeqs(1);
-		}
 		boolean success = testDefaultAnalyse(input, wservice, null, null);
 
 		PresetManager<T> presetman = wservice.getPresets();
@@ -343,12 +336,17 @@ public class WSTester {
 	 * @param msaws
 	 * @throws UnsupportedRuntimeException
 	 */
-	private <T> boolean testDefaultAlignment(MsaWS<T> msaws) throws Exception {
+	private <T> boolean testDefaultAlignment(MsaWS<T> msaws, Services service) throws Exception {
 		writer.print("Testing alignment with default parameters:");
 		Alignment al = null;
 		boolean succeed = false;
+		String taskId;
 
-		String taskId = msaws.align(seqs);
+		if (service == Services.JpredWS) {
+			taskId = msaws.align(loadSeqs(1));
+		} else {
+			taskId = msaws.align(loadSeqs(2));
+		}
 		writer.print("\nQuerying job status...");
 		JobStatus status = msaws.getJobStatus(taskId);
 		while (status != JobStatus.FINISHED) {
diff --git a/webservices/compbio/ws/server/JpredWS.java b/webservices/compbio/ws/server/JpredWS.java
index b0aa158..eebc96f 100644
--- a/webservices/compbio/ws/server/JpredWS.java
+++ b/webservices/compbio/ws/server/JpredWS.java
@@ -1,8 +1,6 @@
 /* Copyright (c) 2011 Peter Troshin
- * Copyright (c) 2013 Alexander Sherstnev
  *  
- *  JAva Bioinformatics Analysis Web Services (JABAWS)
- *  @version: 2.5     
+ *  JAva Bioinformatics Analysis Web Services (JABAWS) @version: 2.0     
  * 
  *  This library is free software; you can redistribute it and/or modify it under the terms of the
  *  Apache License version 2 as published by the Apache Software Foundation
@@ -17,6 +15,7 @@
  * Any republication or derived work distributed in source code form
  * must include this copyright and license notice.
  */
+
 package compbio.ws.server;
 
 import java.io.File;
@@ -27,61 +26,145 @@ import javax.jws.WebService;
 import org.apache.log4j.Logger;
 
 import compbio.data.msa.JABAService;
-import compbio.data.msa.SequenceAnnotation;
+import compbio.data.msa.MsaWS;
+import compbio.data.sequence.Alignment;
 import compbio.data.sequence.FastaSequence;
+import compbio.engine.AsyncExecutor;
 import compbio.engine.Configurator;
 import compbio.engine.client.ConfiguredExecutable;
+import compbio.engine.client.Executable;
+import compbio.engine.client.SkeletalExecutable;
 import compbio.metadata.ChunkHolder;
+import compbio.metadata.JobStatus;
 import compbio.metadata.JobSubmissionException;
-import compbio.metadata.LimitExceededException;
+import compbio.metadata.Limit;
+import compbio.metadata.LimitsManager;
 import compbio.metadata.Option;
 import compbio.metadata.Preset;
-import compbio.metadata.UnsupportedRuntimeException;
+import compbio.metadata.PresetManager;
+import compbio.metadata.ResultNotAvailableException;
+import compbio.metadata.RunnerConfig;
 import compbio.metadata.WrongParameterException;
+import compbio.runner.Util;
 import compbio.runner.predictors.Jpred;
 
-@WebService(endpointInterface = "compbio.data.msa.SequenceAnnotation", targetNamespace = JABAService.V2_SERVICE_NAMESPACE, serviceName = "JpredWS")
-public class JpredWS extends SequenceAnnotationService<Jpred>
-		implements SequenceAnnotation<Jpred> {
+@WebService(endpointInterface = "compbio.data.msa.MsaWS", targetNamespace = JABAService.V2_SERVICE_NAMESPACE, serviceName = "JpredWS")
+public class JpredWS implements MsaWS<Jpred> {
 
 	private static Logger log = Logger.getLogger(JpredWS.class);
 
-	public JpredWS() {
-		super(new Jpred(), log);
+	private static final RunnerConfig<Jpred> jpredOptions = Util.getSupportedOptions(Jpred.class);
+
+	private static final PresetManager<Jpred> jpredPresets = Util.getPresets(Jpred.class);
+
+	private static final LimitsManager<Jpred> limitMan = compbio.engine.client.Util.getLimits(new Jpred().getType());
+
+	@Override
+	public String align(List<FastaSequence> sequences)
+			throws JobSubmissionException {
+
+		WSUtil.validateFastaInput(sequences);
+		ConfiguredExecutable<Jpred> confClust = init(sequences);
+		return WSUtil.align(sequences, confClust, log, "align", getLimit(""));
+	}
+
+	ConfiguredExecutable<Jpred> init(List<FastaSequence> dataSet)
+			throws JobSubmissionException {
+		Jpred jpred = new Jpred();
+		jpred.setInput(SkeletalExecutable.INPUT);
+		jpred.setOutput(SkeletalExecutable.OUTPUT);
+		jpred.setError(SkeletalExecutable.ERROR);
+		ConfiguredExecutable<Jpred> confClust = Configurator.configureExecutable(jpred, dataSet);
+		// Set the number of threads for the cluster execution from conf file
+		if (confClust.getExecProvider() == Executable.ExecProvider.Cluster) {
+			int clusterCpuNum = SkeletalExecutable.getClusterCpuNum(jpred.getType());
+			if (clusterCpuNum != 0) {
+				jpred.setNCore(clusterCpuNum);
+			}
+		}
+		return confClust;
 	}
 
 	@Override
-	public String analize(List<FastaSequence> sequences)
-			throws UnsupportedRuntimeException, LimitExceededException, JobSubmissionException {
-		WSUtil.validateJpredInput(sequences);
-		ConfiguredExecutable<Jpred> confpred = init(sequences);
-
-		// set default conservation method to fastest - SHENKIN
-		// TODO: This violates encapsulation, should be moved to the runners
-		// level.
-		//confpred.addParameters(Arrays.asList("-m=SHENKIN"));
-		return WSUtil.analize(sequences, confpred, log, "JpredWS analize", getLimit(""));
+	public String presetAlign(List<FastaSequence> sequences,
+			Preset<Jpred> preset) throws JobSubmissionException,
+			WrongParameterException {
+		WSUtil.validateFastaInput(sequences);
+		if (preset == null) {
+			throw new WrongParameterException("Preset must be provided!");
+		}
+		Limit<Jpred> limit = getLimit(preset.getName());
+		ConfiguredExecutable<Jpred> confClust = init(sequences);
+		confClust.addParameters(preset.getOptions());
+		return WSUtil.align(sequences, confClust, log, "presetAlign", limit);
 	}
 
 	@Override
-	public String customAnalize(List<FastaSequence> sequences, List<Option<Jpred>> options) 
-					throws UnsupportedRuntimeException, LimitExceededException, JobSubmissionException, WrongParameterException {
-		WSUtil.validateJpredInput(sequences);
-		return super.customAnalize(sequences, options);
+	public String customAlign(List<FastaSequence> sequences,
+			List<Option<Jpred>> options) throws JobSubmissionException,
+			WrongParameterException {
+		WSUtil.validateFastaInput(sequences);
+		ConfiguredExecutable<Jpred> confClust = init(sequences);
+		List<String> params = WSUtil.getCommands(options, Jpred.KEY_VALUE_SEPARATOR);
+		confClust.addParameters(params);
+		log.info("Setting parameters: " + params);
+		return WSUtil.align(sequences, confClust, log, "customAlign", getLimit(""));
+	}
+
+	@Override
+	public RunnerConfig<Jpred> getRunnerOptions() {
+		return jpredOptions;
+	}
+
+	@SuppressWarnings("unchecked")
+	@Override
+	public Alignment getResult(String jobId) throws ResultNotAvailableException {
+		WSUtil.validateJobId(jobId);
+		AsyncExecutor asyncEngine = Configurator.getAsyncEngine(jobId);
+		ConfiguredExecutable<Jpred> jpred = (ConfiguredExecutable<Jpred>) asyncEngine.getResults(jobId);
+		return jpred.getResults();
+	}
+
+	@Override
+	public Limit<Jpred> getLimit(String presetName) {
+		if (limitMan == null) {
+			// No limit is configured
+			return null;
+		}
+		Limit<Jpred> limit = limitMan.getLimitByName(presetName);
+		return limit;
+	}
+
+	@Override
+	public LimitsManager<Jpred> getLimits() {
+		return limitMan;
+	}
+
+	@Override
+	public boolean cancelJob(String jobId) {
+		WSUtil.validateJobId(jobId);
+		boolean result = WSUtil.cancelJob(jobId);
+		return result;
+	}
+
+	@Override
+	public JobStatus getJobStatus(String jobId) {
+		WSUtil.validateJobId(jobId);
+		JobStatus status = WSUtil.getJobStatus(jobId);
+		return status;
 	}
 
 	@Override
-	public String presetAnalize(List<FastaSequence> sequences, Preset<Jpred> preset)
-			throws UnsupportedRuntimeException, LimitExceededException, JobSubmissionException, WrongParameterException {
-		WSUtil.validateJpredInput(sequences);
-		return super.presetAnalize(sequences, preset);
+	public PresetManager<Jpred> getPresets() {
+		return jpredPresets;
 	}
 
 	@Override
 	public ChunkHolder pullExecStatistics(String jobId, long position) {
 		WSUtil.validateJobId(jobId);
 		String file = Configurator.getWorkDirectory(jobId) + File.separator + Jpred.getStatFile();
-		return WSUtil.pullFile(file, position);
+		ChunkHolder cholder = WSUtil.pullFile(file, position);
+		return cholder;
 	}
 
 }