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;
};
}