dbclient_rs.h

Go to the documentation of this file.

 
/*    Copyright 2009 10gen Inc.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
 
#pragma once
 
#include <boost/shared_ptr.hpp>
#include <utility>
 
#include "mongo/client/dbclientinterface.h"
#include "mongo/client/export_macros.h"
#include "mongo/util/net/hostandport.h"
 
namespace mongo {
 
    class ReplicaSetMonitor;
    class TagSet;
    struct ReadPreferenceSetting;
    typedef boost::shared_ptr<ReplicaSetMonitor> ReplicaSetMonitorPtr;
 
    class MONGO_CLIENT_API DBClientReplicaSet : public DBClientBase {
    public:
        using DBClientBase::query;
        using DBClientBase::update;
        using DBClientBase::remove;
 
        DBClientReplicaSet( const std::string& name , const std::vector<HostAndPort>& servers, double so_timeout=0 );
        virtual ~DBClientReplicaSet();
 
        bool connect();
 
        virtual void logout(const std::string& dbname, BSONObj& info);
 
        // ----------- simple functions --------------
 
        virtual std::auto_ptr<DBClientCursor> query(const std::string &ns, Query query, int nToReturn = 0, int nToSkip = 0,
                                                    const BSONObj *fieldsToReturn = 0, int queryOptions = 0 , int batchSize = 0 );
 
        virtual BSONObj findOne(const std::string &ns, const Query& query, const BSONObj *fieldsToReturn = 0, int queryOptions = 0);
 
        virtual void insert( const std::string &ns , BSONObj obj , int flags=0, const WriteConcern* wc=NULL );
 
        virtual void insert( const std::string &ns, const std::vector< BSONObj >& v , int flags=0, const WriteConcern* wc=NULL );
 
        virtual void remove( const std::string &ns , Query obj , int flags, const WriteConcern* wc=NULL );
 
        virtual void update( const std::string &ns , Query query , BSONObj obj , int flags, const WriteConcern* wc=NULL );
 
        virtual void killCursor( long long cursorID );
 
        // ---- access raw connections ----
 
        DBClientConnection& masterConn();
 
        DBClientConnection& slaveConn();
 
        // ---- callback pieces -------
 
        virtual void say( Message &toSend, bool isRetry = false , std::string* actualServer = 0);
        virtual bool recv( Message &toRecv );
        virtual void checkResponse( const char* data, int nReturned, bool* retry = NULL, std::string* targetHost = NULL );
 
        /* this is the callback from our underlying connections to notify us that we got a "not master" error.
         */
        void isntMaster();
 
        /* this is used to indicate we got a "not master or secondary" error from a secondary.
         */
        void isntSecondary();
 
        // ----- status ------
 
        virtual bool isFailed() const { return ! _master || _master->isFailed(); }
        bool isStillConnected();
 
        // ----- informational ----
 
        double getSoTimeout() const { return _so_timeout; }
 
        std::string toString() const { return getServerAddress(); }
 
        std::string getServerAddress() const;
 
        virtual ConnectionString::ConnectionType type() const { return ConnectionString::SET; }
        virtual bool lazySupported() const { return true; }
 
        // ---- low level ------
 
        virtual bool call( Message &toSend, Message &response, bool assertOk=true , std::string * actualServer = 0 );
        virtual bool callRead( Message& toSend , Message& response ) { return checkMaster()->callRead( toSend , response ); }
 
        static bool MONGO_CLIENT_FUNC isSecondaryQuery( const std::string& ns,
                                                        const BSONObj& queryObj,
                                                        int queryOptions );
 
        virtual void setRunCommandHook(DBClientWithCommands::RunCommandHookFunc func);
        virtual void setPostRunCommandHook(DBClientWithCommands::PostRunCommandHookFunc func);
 
        virtual void reset();
 
        static void setAuthPooledSecondaryConn(bool setting);
 
    protected:
        virtual void _auth(const BSONObj& params);
 
        virtual void sayPiggyBack( Message &toSend ) { checkMaster()->say( toSend ); }
 
    private:
        std::auto_ptr<DBClientCursor> checkSlaveQueryResult( std::auto_ptr<DBClientCursor> result );
 
        DBClientConnection * checkMaster();
 
        DBClientConnection* selectNodeUsingTags(boost::shared_ptr<ReadPreferenceSetting> readPref);
 
        bool checkLastHost(const ReadPreferenceSetting* readPref);
 
        void invalidateLastSlaveOkCache();
 
        void _auth( DBClientConnection * conn );
 
        void logoutAll(DBClientConnection* conn);
 
        void resetMaster();
 
        void resetSlaveOkConn();
 
        static const size_t MAX_RETRY;
 
        // TODO: remove this when processes other than mongos uses the driver version.
        static bool _authPooledSecondaryConn;
 
        // Throws a DBException if the monitor doesn't exist and there isn't a cached seed to use.
        ReplicaSetMonitorPtr _getMonitor() const;
 
        std::string _setName;
 
        HostAndPort _masterHost;
        boost::scoped_ptr<DBClientConnection> _master;
 
        // Last used host in a slaveOk query (can be a primary).
        HostAndPort _lastSlaveOkHost;
        // Last used connection in a slaveOk query (can be a primary).
        // Connection can either be owned here or returned to the connection pool. Note that
        // if connection is primary, it is owned by _master so it is incorrect to return
        // it to the pool.
        std::auto_ptr<DBClientConnection> _lastSlaveOkConn;
        boost::shared_ptr<ReadPreferenceSetting> _lastReadPref;
 
        double _so_timeout;
 
        // we need to store so that when we connect to a new node on failure
        // we can re-auth
        // this could be a security issue, as the password is stored in memory
        // not sure if/how we should handle
        std::map<std::string, BSONObj> _auths; // dbName -> auth parameters
 
    protected:
 
        class LazyState {
        public:
            LazyState() :
                _lastClient( NULL ), _lastOp( -1 ), _secondaryQueryOk( false ), _retries( 0 ) {}
            DBClientConnection* _lastClient;
            int _lastOp;
            bool _secondaryQueryOk;
            int _retries;
 
        } _lazyState;
 
    };
 
    class MONGO_CLIENT_API TagSet {
    public:
        TagSet();
 
        explicit TagSet(const BSONArray& tags) : _tags(tags) {}
 
        const BSONArray& getTagBSON() const { return _tags; }
 
        bool operator==(const TagSet& other) const { return _tags == other._tags; }
 
    private:
        BSONArray _tags;
    };
 
    struct MONGO_CLIENT_API ReadPreferenceSetting {
        ReadPreferenceSetting(ReadPreference pref, const TagSet& tag):
            pref(pref), tags(tag) {
        }
 
        inline bool equals(const ReadPreferenceSetting& other) const {
            return pref == other.pref && tags == other.tags;
        }
 
        BSONObj toBSON() const;
 
        const ReadPreference pref;
        TagSet tags;
    };
}