config.h

Go to the documentation of this file.

// config.h

/* This file is things related to the "grid configuration":
   - what machines make up the db component of our cloud
   - where various ranges of things live
*/

#pragma once

#include "../db/namespace.h"
#include "../client/dbclient.h"
#include "../client/model.h"

#include "chunk.h"
#include "shard.h"
#include "shardkey.h"

namespace mongo {

    struct ShardNS {
        static string shard;

        static string database;
        static string collection;
        static string chunk;

        static string mongos;
        static string settings;
    };

    struct ShardFields {
        static BSONField<bool> draining;      // is it draining chunks?
        static BSONField<long long> maxSize;  // max allowed disk space usage
    };

    class ConfigServer;

    class DBConfig;
    typedef boost::shared_ptr<DBConfig> DBConfigPtr;

    extern DBConfigPtr configServerPtr;
    extern ConfigServer& configServer;

    class DBConfig  {

        struct CollectionInfo {
            CollectionInfo() {
                _dirty = false;
                _dropped = false;
            }

            CollectionInfo( const BSONObj& in );

            bool isSharded() const {
                return _cm.get();
            }

            ChunkManagerPtr getCM() const {
                return _cm;
            }

            void shard( const string& ns , const ShardKeyPattern& key , bool unique );
            void unshard();

            bool isDirty() const { return _dirty; }
            bool wasDropped() const { return _dropped; }

            void save( const string& ns , DBClientBase* conn );


        private:
            ChunkManagerPtr _cm;
            bool _dirty;
            bool _dropped;
        };

        typedef map<string,CollectionInfo> Collections;

    public:

        DBConfig( string name )
            : _name( name ) ,
              _primary("config","") ,
              _shardingEnabled(false),
              _lock("DBConfig") {
            assert( name.size() );
        }
        virtual ~DBConfig() {}

        string getName() { return _name; };

        bool isShardingEnabled() {
            return _shardingEnabled;
        }

        void enableSharding();
        ChunkManagerPtr shardCollection( const string& ns , ShardKeyPattern fieldsAndOrder , bool unique );

        bool removeSharding( const string& ns );

        bool isSharded( const string& ns );

        ChunkManagerPtr getChunkManager( const string& ns , bool reload = false );

        const Shard& getShard( const string& ns );

        const Shard& getPrimary() const {
            uassert( 8041 , (string)"no primary shard configured for db: " + _name , _primary.ok() );
            return _primary;
        }

        void setPrimary( string s );

        bool load();
        bool reload();

        bool dropDatabase( string& errmsg );

        // model stuff

        // lockless loading
        void serialize(BSONObjBuilder& to);

        void unserialize(const BSONObj& from);

        void getAllShards(set<Shard>& shards) const;

    protected:

        bool _isSharded( const string& ns );

        bool _dropShardedCollections( int& num, set<Shard>& allServers , string& errmsg );

        bool _load();
        bool _reload();
        void _save();

        string _name; // e.g. "alleyinsider"
        Shard _primary; // e.g. localhost , mongo.foo.com:9999
        bool _shardingEnabled;

        //map<string,CollectionInfo> _sharded; // { "alleyinsider.blog.posts" : { ts : 1 }  , ... ] - all ns that are sharded
        //map<string,ChunkManagerPtr> _shards; // this will only have entries for things that have been looked at

        Collections _collections;

        mongo::mutex _lock; // TODO: change to r/w lock ??
    };

    class ConfigServer : public DBConfig {
    public:

        ConfigServer();
        ~ConfigServer();

        bool ok( bool checkConsistency = false );

        virtual string modelServer() {
            uassert( 10190 ,  "ConfigServer not setup" , _primary.ok() );
            return _primary.getConnString();
        }

        bool init( vector<string> configHosts );

        bool init( string s );

        bool allUp();
        bool allUp( string& errmsg );

        int dbConfigVersion();
        int dbConfigVersion( DBClientBase& conn );

        void reloadSettings();

        int checkConfigVersion( bool upgrade );

        void logChange( const string& what , const string& ns , const BSONObj& detail = BSONObj() );

        ConnectionString getConnectionString() const {
            return ConnectionString( _primary.getConnString() , ConnectionString::SYNC );
        }

        void replicaSetChange( const ReplicaSetMonitor * monitor );

        static int VERSION;


        bool checkConfigServersConsistent( string& errmsg , int tries = 4 ) const;

    private:
        string getHost( string name , bool withPort );
        vector<string> _config;
    };

} // namespace mongo

---

mongodb
Author(s): Nate Koenig
autogenerated on Fri Jan 11 12:15:18 2013