queue_poll.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: queue_poll.cpp,v $
 * PRODUCTION Revision 1000.2  2004/06/01 18:06:48  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.6
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: queue_poll.cpp,v 1000.2 2004/06/01 18:06:48 gouriano Exp $
 * ===========================================================================
 *
 *                            PUBLIC DOMAIN NOTICE
 *               National Center for Biotechnology Information
 *
 *  This software/database is a "United States Government Work" under the
 *  terms of the United States Copyright Act.  It was written as part of
 *  the author's official duties as a United States Government employee and
 *  thus cannot be copyrighted.  This software/database is freely available
 *  to the public for use. The National Library of Medicine and the U.S.
 *  Government have not placed any restriction on its use or reproduction.
 *
 *  Although all reasonable efforts have been taken to ensure the accuracy
 *  and reliability of the software and data, the NLM and the U.S.
 *  Government do not and cannot warrant the performance or results that
 *  may be obtained by using this software or data. The NLM and the U.S.
 *  Government disclaim all warranties, express or implied, including
 *  warranties of performance, merchantability or fitness for any particular
 *  purpose.
 *
 *  Please cite the author in any work or product based on this material.
 *
 * ===========================================================================
 *
 * Author:  Kevin Bealer
 *
 */

/** @file queue_poll.cpp
 * Queueing and Polling code for remote_blast.
 */

static char const rcsid[] = 
    "$Id: queue_poll.cpp,v 1000.2 2004/06/01 18:06:48 gouriano Exp $";

#include <ncbi_pch.hpp>
#include <sys/time.h>
#include <unistd.h>

// CRemoteBlast
#include <algo/blast/api/remote_blast.hpp>

// Local
#include "queue_poll.hpp"

// Corelib
#include <corelib/ncbi_system.hpp>

// Objects
#include <objects/blast/Blast4_subject.hpp>
#include <objects/blast/Blast4_queue_search_reques.hpp>
#include <objects/blast/Blast4_parameter.hpp>
#include <objects/blast/Blast4_parameters.hpp>
#include <objects/blast/Blast4_value.hpp>
#include <objects/blast/blastclient.hpp>
#include <objects/blast/Blast4_queue_search_reply.hpp>
#include <objects/blast/Blas_get_searc_resul_reque.hpp>
#include <objects/blast/Blas_get_searc_resul_reply.hpp>
#include <objects/blast/Blast4_error.hpp>
#include <objects/blast/Blast4_error_code.hpp>
#include <objects/seqalign/Seq_align_set.hpp>

// Object Manager
#include <objmgr/object_manager.hpp>
#include <objmgr/scope.hpp>
#include <objtools/data_loaders/genbank/gbloader.hpp>

// Objtools
#include <objtools/readers/fasta.hpp>

// Use _exit() if available.
#if defined(NCBI_OS_UNIX)
#include <unistd.h>
#endif

USING_NCBI_SCOPE;
USING_SCOPE(blast);
USING_SCOPE(objects);

typedef list< CRef<CBlast4_error> > TErrorList;


//--------------------------------------------------------------------
//  Helper Functions
//--------------------------------------------------------------------

#define BLAST4_POLL_DELAY_SEC 15
#define BLAST4_IGNORE_ERRS    5

static inline bool
s_QueryIsAmino(const string & program)
{
    // Should the FASTA be NUC or PROT data?
        
    return (program == "blastp")  ||  (program == "tblastn");
}

void
s_Setp(list<CRef<CBlast4_parameter> >& l, string n, CRef<CBlast4_cutoff> x)
{
    CRef<CBlast4_value> v(new CBlast4_value);
    v->SetCutoff(*x);

    CRef<CBlast4_parameter> p(new CBlast4_parameter);
    p->SetName(n);
    p->SetValue(*v);

    l.push_back(p);
}

void
s_Setp(list<CRef<CBlast4_parameter> >& l, string n, const string x)
{
    CRef<CBlast4_value> v(new CBlast4_value);
    v->SetString(x);

    CRef<CBlast4_parameter> p(new CBlast4_parameter);
    p->SetName(n);
    p->SetValue(*v);

    l.push_back(p);
}

void
s_Setp(list<CRef<CBlast4_parameter> >& l, string n, const int & x)
{
    CRef<CBlast4_value> v(new CBlast4_value);
    v->SetInteger(x);
    
    CRef<CBlast4_parameter> p(new CBlast4_parameter);
    p->SetName(n);
    p->SetValue(*v);
    
    l.push_back(p);
}

void
s_Setp(list<CRef<CBlast4_parameter> >& l, string n, const bool & x)
{
    CRef<CBlast4_value> v(new CBlast4_value);
    v->SetBoolean(x);
    
    CRef<CBlast4_parameter> p(new CBlast4_parameter);
    p->SetName(n);
    p->SetValue(*v);
    
    l.push_back(p);
}

void
s_Setp(list<CRef<CBlast4_parameter> >& l, string n, const double & x)
{
    CRef<CBlast4_value> v(new CBlast4_value);
    v->SetReal(x);
    
    CRef<CBlast4_parameter> p(new CBlast4_parameter);
    p->SetName(n);
    p->SetValue(*v);
    
    l.push_back(p);
}

template <class T1, class T2, class T3>
void
s_SetpOpt(T1 & params, T2 & name, T3 & object)
{
    if (object.Exists()) {
        s_Setp(params, name, object.GetValue());
    }
}

template <class T>
void
s_Output(CNcbiOstream & os, CRef<T> t)
{
    auto_ptr<CObjectOStream> x(CObjectOStream::Open(eSerial_AsnText, os));
    *x << *t;
    os.flush();
}


//--------------------------------------------------------------------
//  Queueing and Polling
//--------------------------------------------------------------------


static CRef<CBioseq_set>
s_SetupQuery(CNcbiIstream    & query_in,
             CRef<CScope>      scope,
             TReadFastaFlags   fasta_flags)
{
    CRef<CSeq_entry> seqentry = ReadFasta(query_in, fasta_flags, 0, 0);
    
    scope->AddTopLevelSeqEntry(*seqentry);
    
    CRef<CBioseq_set> seqset(new CBioseq_set);
    seqset->SetSeq_set().push_back(seqentry);
    
    return seqset;
}


class CSearchParamBuilder : public COptionWalker
{
public:
    template <class T>
    void Local(T &,
               CUserOpt,
               CArgKey,
               COptDesc)
    { }
    
    template <class ValueT, class MethodT, class OptsT>
    void Same(ValueT   & valobj,
               CUserOpt,
               MethodT    param,
               CArgKey,
               COptDesc,
               OptsT    & cboh)
    {
        if (valobj.Exists()) {
            param.Set(cboh, valobj.GetValue());
        }
    }
    
    template <class ValueT, class MethodT, class OptsT>
    void Remote(ValueT & valobj,
                MethodT param,
                OptsT & cboh)
    {
        if (valobj.Exists()) {
            param.Set(cboh, valobj.GetValue());
        }
    }
    
    bool NeedRemote(void) { return true; }
};


template<class T> void
s_SetSearchParams(CRef<CRemoteBlast>  & cb4o,
                  CNetblastSearchOpts & opts)
{
    CRef<T> cboh;
    
    cboh.Reset(new T(CBlastOptions::eRemote));
    cb4o.Reset(new CRemoteBlast(cboh));
    
    CSearchParamBuilder spb;
    
    opts.Apply(spb, cboh, cb4o);
}


static CRef<CRemoteBlast>
s_SetBlast4Params(string              & program,
                  string              & service,
                  string              & database,
                  CNetblastSearchOpts & opts,
                  CRef<CBioseq_set>     query,
                  string              & err)
{
    CRef<CRemoteBlast> cb4o;
    
    // NOTE: If adding new types here, add them also to the code in
    // search_opts.hpp that handles argument setting, i.e. the
    // OPT_HANDLER_SUPPORT_ALL() macro.
    
    if (program == "blastp" && service == "plain") {
        s_SetSearchParams<CBlastProteinOptionsHandle>(cb4o, opts);
    }
    else if (program  == "blastn" &&
             (service == "plain"  || service == "megablast")) {
        s_SetSearchParams<CBlastNucleotideOptionsHandle>(cb4o, opts);
    }
    else if (program == "tblastn" && service == "plain") {
        s_SetSearchParams<CTBlastnOptionsHandle>(cb4o, opts);
    }
    else if (program == "tblastx" && service == "plain") {
        s_SetSearchParams<CTBlastxOptionsHandle>(cb4o, opts);
    }
    else if (program == "blastx" && service == "plain") {
        s_SetSearchParams<CBlastxOptionsHandle>(cb4o, opts);
    }
    else if (program == "blastx" && service == "plain") {
        s_SetSearchParams<CBlastxOptionsHandle>(cb4o, opts);