queue_poll.cpp

ncbi源码

/*
 * ===========================================================================
 * PRODUCTION $Log: queue_poll.cpp,v $
 * PRODUCTION Revision 1000.3  2004/06/01 18:27:26  gouriano
 * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.9
 * PRODUCTION
 * ===========================================================================
 */

/*  $Id: queue_poll.cpp,v 1000.3 2004/06/01 18:27:26 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 Description:
 *   Queueing and Polling code for blast_client.
 *
 */

// Local
#include <ncbi_pch.hpp>
#include "queue_poll.hpp"

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

// Objects
#include <objects/blast/blast__.hpp>
#include <objects/blast/blastclient.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 namespace ncbi::objects;

typedef list< CRef<CBlast4_error> > TErrorList;


/////////////////////////////////////////////////////////////////////////////
//
//  Helper Functions
//

#define BLAST4_POLL_DELAY_SEC 15
#define BLAST4_IGNORE_ERRS    5

static inline bool
s_IsAmino(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;
}

//#include <unistd.h>

class some_kind_of_nothing : public CEofException {
};

static CRef<CBlast4_reply>
s_Submit(CRef<CBlast4_request_body> body, bool echo = true)
{
    static int errors_ignored = 0;
    
    // Create the request; optionally echo it

    CRef<CBlast4_request> request(new CBlast4_request);
    request->SetBody(*body);
    
    if (echo) {
        s_Output(NcbiCout, request);
    }
    
    // submit to server, get reply; optionally echo it
    
    CRef<CBlast4_reply> reply(new CBlast4_reply);
    
    try {
        //throw some_kind_of_nothing();
        CBlast4Client().Ask(*request, *reply);
    }
    catch(CEofException & e) {
        if (errors_ignored >= BLAST4_IGNORE_ERRS) {
            ERR_POST(Error << "Unexpected EOF when contacting netblast server"
                     " - unable to complete request.");
#if defined(NCBI_OS_UNIX)
            // Use _exit() avoid coredump.
            _exit(-1);
#else
            exit(-1);
#endif
        } else {
            errors_ignored ++;
//             ERR_POST(Error << "Unexpected EOF when contacting netblast server"
//                      " ::: ignoring (" << errors_ignored << "/" << BLAST4_IGNORE_ERRS << ").");
            
            CRef<CBlast4_reply> empty_result;
            return empty_result;
        }
    }
    
    if (echo) {
        s_Output(NcbiCout, reply);
    }
    
    return reply;
}

class CSearchParamBuilder : public COptionWalker
{
public:
    CSearchParamBuilder(list< CRef<CBlast4_parameter> > & algo,
                        list< CRef<CBlast4_parameter> > & prog)
        : m_Algo(algo),
          m_Prog(prog)
    {}
    
    template <class T>
    void Same(T          & valobj,
              CUserOpt,
              CNetName     nb_name,
              CArgKey,
              COptDesc,
              EListPick    lp)
    {
        if (EListAlgo == lp) {
            s_SetpOpt(m_Algo, nb_name, valobj);
        } else if (EListProg == lp) {
            s_SetpOpt(m_Prog, nb_name, valobj);
        }
    }
    
    template <class T>
    void Local(T &,
               CUserOpt,
               CArgKey,
               COptDesc)
    { }
    
    template <class T> void Remote(T & valobj, CNetName net_name, EListPick lp)
    {
        if (EListAlgo == lp) {
            s_SetpOpt(m_Algo, net_name, valobj);
        } else if (EListProg == lp) {
            s_SetpOpt(m_Prog, net_name, valobj);
        }
    }
    
    bool NeedRemote(void) { return true; }
    
private:
    list< CRef<CBlast4_parameter> > & m_Algo;
    list< CRef<CBlast4_parameter> > & m_Prog;
};

static void
s_SetSearchParams(CNetblastSearchOpts             & opts,
                  list< CRef<CBlast4_parameter> > & algo,
                  list< CRef<CBlast4_parameter> > & prog)
{
    CSearchParamBuilder spb(algo, prog);
    
    opts.Apply(spb);
}

// Stolen from: CRemoteBlast::SetQueries(CRef<objects::CBioseq_set> bioseqs)

bool s_SetQueries(CRef<CBlast4_queue_search_request> qsr,
                  CRef<CBioseq_set>                  bioseqs)
{
    if (bioseqs.Empty()) {
        return false;
    }
    
    CRef<CBlast4_queries> queries_p(new CBlast4_queries);
    queries_p->SetBioseq_set(*bioseqs);