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