/// <summary>
/// CreateJob() to get job id and control id and Submit job
/// using input sequence with job id and control id
/// </summary>
/// <param name="sequence">input sequences</param>
/// <param name="parameters">input params</param>
/// <returns>result params with job id and control id</returns>
public ServiceParameters SubmitRequest(IList <ISequence> sequence, ClustalWParameters parameters)
{
ServiceParameters result = new ServiceParameters();
if (null == sequence)
{
throw new ArgumentNullException("Sequence");
}
if (null == parameters)
{
throw new ArgumentNullException("Parameters");
}
// ClusterOption = biosim cbsum1 cbsum2k8 cbsusrv05 cbsum2 or Auto
string[] output = _baseClient.CreateJob(tAppId.P_CLUSTALW, "test_BioHPC_Job", "1", parameters.Values[ClustalWParameters.Email].ToString(),
string.Empty, parameters.Values[ClustalWParameters.ClusterOption].ToString());
if (!output[0].Contains(ERROR))
{
result.JobId = output[1];
result.Parameters.Add(CONTROLID, output[2]);
AppInputData inputData = _baseClient.InitializeApplicationParams(tAppId.P_CLUSTALW, "test_BioHPC_Job");
StringBuilder inputSequence = new StringBuilder();
foreach (ISequence seq in sequence)
{
inputSequence.AppendLine(FastAFormatter.FormatString(seq));
}
inputData.clustalw.inputsource = QuerySrcType.paste;
inputData.clustalw.inputstring = inputSequence.ToString();
inputData.clustalw.isDNA = false;
inputData.clustalw.action = (ClwActions)Enum.Parse(typeof(ClwActions),
parameters.Values[ClustalWParameters.ActionAlign].ToString());
inputData.clustalw.email_notify = true;
_baseClient.SubmitJob(result.JobId, result.Parameters[CONTROLID].ToString(), inputData);
result.Parameters.Add(SUBMISSONRESULT, SUCCESS);
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
// Start the BackGroundThread to check the status of job
_workerThread = new BackgroundWorker();
_workerThread.WorkerSupportsCancellation = true;
_workerThread.DoWork += new DoWorkEventHandler(ProcessRequestThread);
_workerThread.RunWorkerCompleted += new RunWorkerCompletedEventHandler(CompletedRequestThread);
_workerThread.RunWorkerAsync(result);
}
}
else
{
result.Parameters.Add(SUBMISSONRESULT, output[0]);
}
return(result);
}
/// <summary>
/// Check the currently set parameters for validity
/// </summary>
/// <param name="parameters">Blast input parameters</param>
/// <param name="pars">BLAST parameters in the BioHPC service format</param>
/// <returns>Validation result</returns>
private ParameterValidationResult ValidateParameters(BlastParameters parameters, AppInputData pars)
{
ParameterValidationResult result = new ParameterValidationResult();
result.IsValid = true;
// Make sure e-mail address is configured
if (string.IsNullOrEmpty(Configuration.EmailAddress))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETEREMAILREQUIRED;
}
// check required BLAST parameters
if (!parameters.Settings.ContainsKey(PARAMETERPROGRAM))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERPROGRAMREQUIRED;
}
else
{
string prgm = parameters.Settings[PARAMETERPROGRAM].ToLower();
if (Helper.StringHasMatch(prgm, Enum.GetNames(typeof(BLASTprogram))))
{
pars.blast.program = (BLASTprogram)Enum.Parse(typeof(BLASTprogram), prgm);
}
else
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERPROGRAMREQUIRED;
}
}
if (!parameters.Settings.ContainsKey(PARAMETERDATABASE))
{
result.IsValid = false;
result.ValidationErrors += Resources.PARAMETERDATABASEREQUIRED;
}
else
{
string dbname = parameters.Settings[PARAMETERDATABASE];
if (IsProgramDna(pars.blast.program))
{
if (IsDbstringDNA(dbname))
{
pars.blast.database.database = dbname;
}
else
{
result.IsValid = false;
result.ValidationErrors += Resources.BIOHPCNODNADB;
}
}
else
{
if (IsDbstringProt(dbname))
{
pars.blast.database.database = dbname;
}
else
{
result.IsValid = false;
result.ValidationErrors += Resources.BIOHPCNOPROTDB;
}
}
}
// Allowed parameters
if (parameters.Settings.ContainsKey(PARAMETERFILTER))
{
// If the supplied filter parameter makes sense, use it; otherwise the default will be used.
string fltr = parameters.Settings[PARAMETERFILTER];
if (Helper.StringHasMatch(fltr, Enum.GetNames(typeof(LowCompFilter))))
{
pars.blast.options.lcompfilter = (LowCompFilter)Enum.Parse(typeof(LowCompFilter), fltr);
}
}
if (parameters.Settings.ContainsKey(PARAMETERALIGNMENTS))
{
pars.blast.options.maxtargets = int.Parse(parameters.Settings[PARAMETERALIGNMENTS], CultureInfo.InvariantCulture);
}
if (parameters.Settings.ContainsKey(PARAMETERMATRIXNAME))
{
// If the supplied matrix parameter makes sense, use it; otherwise the default will be used.
string mtrx = parameters.Settings[PARAMETERMATRIXNAME].ToUpper(CultureInfo.InvariantCulture);
if (Helper.StringHasMatch(mtrx, Enum.GetNames(typeof(MBF.Web.BioHPC.Matrix))))
{
pars.blast.options.matrix = (MBF.Web.BioHPC.Matrix)Enum.Parse(typeof(MBF.Web.BioHPC.Matrix), mtrx);
}
}
if (parameters.Settings.ContainsKey(PARAMETEREXPECT))
{
pars.blast.options.ecut = double.Parse(parameters.Settings[PARAMETEREXPECT], CultureInfo.InvariantCulture);
}
if (parameters.Settings.ContainsKey(PARAMETERMINQUERYLENGTH))
{
pars.blast.options.minquerylength = int.Parse(parameters.Settings[PARAMETERMINQUERYLENGTH], CultureInfo.InvariantCulture);
}
if (parameters.Settings.ContainsKey(PARAMETEREMAILNOTIFY))
{
pars.blast.runparams.email_notify = parameters.Settings[PARAMETEREMAILNOTIFY] == "yes";
}
// Any other unknown parameters
foreach (KeyValuePair <string, string> parameter in parameters.Settings)
{
switch (parameter.Key)
{
// These are either handled above, or allowed
case PARAMETERDATABASE:
case PARAMETERPROGRAM:
case PARAMETERFORMATTYPE:
case PARAMETERFILTER:
case PARAMETERALIGNMENTS:
case PARAMETERMATRIXNAME:
case PARAMETEREXPECT:
case PARAMETERMINQUERYLENGTH:
case PARAMETEREMAILNOTIFY:
case PARAMETERJOBNAME:
break;
default:
result.IsValid = false;
result.ValidationErrors += string.Format(
CultureInfo.InvariantCulture,
Resources.PARAMETRUNKNOWNBIOHPC,
parameter.Key);
break;
}
}
if (result.IsValid)
{
result.ParametersObject = pars;
}
return(result);
}
/// <summary>
/// Submit the search request with the user supplied configuration parameters and sequence list.
/// Implementation should make use of the MBF.IO formatters to convert the sequence into
/// the web interface compliant sequence format
/// </summary>
/// <remarks>An exception is thrown if the request does not succeed.</remarks>
/// <param name="sequences">List of sequence to search with</param>
/// <param name="parameters">Blast input parameters</param>
/// <returns>Unique Search ID generated by MBF</returns>
public string SubmitRequest(IList <ISequence> sequences, BlastParameters parameters)
{
if (sequences == null)
{
throw new Exception(Resources.BIOHPCNOSEQUENCE);
}
string requestIdentifier;
// Start of BioHPC-specific code
// we are submitting BLAST and give the job a name
tAppId appID = tAppId.P_BLAST;
string jobname = BlastParameters.Parameters["JobName"].DefaultValue;
if (parameters.Settings.ContainsKey(PARAMETERJOBNAME))
{
if (!String.IsNullOrEmpty(parameters.Settings[PARAMETERJOBNAME]))
{
jobname = parameters.Settings[PARAMETERJOBNAME];
}
}
// initialize input parameters with defaults
AppInputData pars = _blastClient.InitializeApplicationParams(appID, jobname);
// Retrieve database names for easy access by parameter validator
dnaDatabases = GetServiceMetadata(MetadataDatabasesDna);
protDatabases = GetServiceMetadata(MetadataDatabasesProt);
// Validate the parameter
ParameterValidationResult valid = ValidateParameters(parameters, pars);
if (!valid.IsValid)
{
throw new Exception(valid.ValidationErrors);
}
// ValidateParameters updated some of the entries in pars and put them
// into its ParametersObject - we need to fetch the updated pars
pars = valid.ParametersObject as AppInputData;
// Set some remaining parameters...
pars.blast.querysource = QuerySrcType.paste;
// We request XML as format, since this is what we can parse...
pars.blast.options.format = OutputFormat.XML;
// Query sequence should be in full Fasta format.
// We concatenate all the sequences from the list into a single string.
pars.blast.query = String.Empty;
foreach (ISequence auxseq in sequences)
{
pars.blast.query += ">" + auxseq.DisplayID + "\n" + auxseq.ToString() + "\n";
}
pars.blast.query = pars.blast.query.Substring(0, pars.blast.query.Length - 1); // remobe trailing newline...
// Run parameters and query string are ready. Submit the job to server:
// Create a new BLAST job.
string jobid = String.Empty;
string cntrl = String.Empty;
try
{
string pswd = String.Empty;
try
{
pswd = Configuration.Password;
}
catch
{
}
string[] outtab = _blastClient.CreateJob(appID, jobname, "1", Configuration.EmailAddress, pswd, "Auto");
if (outtab[0].IndexOf(MsgError, StringComparison.Ordinal) != -1)
{
throw new Exception(String.Format(CultureInfo.InvariantCulture, Resources.BIOHPCJOBNOTCREATED, outtab[0]));
}
jobid = outtab[1];
cntrl = outtab[2];
requestIdentifier = jobid + "_" + cntrl;
}
catch
{
throw new Exception(Resources.BIOHPCSERVERABSENT);
}
// Finally, we can submit the job
try
{
string result = _blastClient.SubmitJob(jobid, cntrl, pars);
if (result.IndexOf(MsgError, StringComparison.Ordinal) != -1)
{
throw new Exception(String.Format(CultureInfo.InvariantCulture, Resources.BIOHPCJOBNOTSUBMITTED, jobid, result));
}
}
catch
{
throw new Exception(Resources.BIOHPCSERVERABSENT);
}
// end of BioHPC-specific code
// Only if the event is registered, invoke the thread
if (null != RequestCompleted)
{
// ThreadParameter wants a single sequence - nor sure what this is for.
// We'll give it the first sequence from the list, i.e., sequence[0]
ThreadParameter threadParameter = new ThreadParameter(
requestIdentifier,
sequences[0],
parameters);
// Start the BackGroundThread to check the status of job
_workerThread = new BackgroundWorker();
_workerThread.WorkerSupportsCancellation = true;
_workerThread.DoWork += new DoWorkEventHandler(ProcessRequestThread);
_workerThread.RunWorkerCompleted += new RunWorkerCompletedEventHandler(CompletedRequestThread);
_workerThread.RunWorkerAsync(threadParameter);
}
return(requestIdentifier);
}