예제 #1
0
    void PubSubSendSocket::initSharding(const std::string configServers) {
        if (!pubsubEnabled)
            return;

        vector<string> configdbs;
        splitStringDelim(configServers, &configdbs, ',');

        // find config db we are using for pubsub
        HostAndPort maxConfigHP;
        maxConfigHP.setPort(0);

        for (vector<string>::iterator it = configdbs.begin(); it != configdbs.end(); it++) {
            HostAndPort configHP = HostAndPort(*it);
            if (configHP.port() > maxConfigHP.port())
                maxConfigHP = configHP;
        }

        HostAndPort configPullEndpoint = HostAndPort(maxConfigHP.host(), maxConfigHP.port() + 1234);

        try {
            dbEventSocket = new zmq::socket_t(zmqContext, ZMQ_PUSH);
            dbEventSocket->connect(("tcp://" + configPullEndpoint.toString()).c_str());
        }
        catch (zmq::error_t& e) {
            log() << "PubSub could not connect to config server. Turning off db events..."
                  << causedBy(e);
            publishDataEvents = false;
        }

    }
예제 #2
0
/**
 * Save a BSON obj representing the host system's details
 */
void ProcessInfo::SystemInfo::collectSystemInfo() {
    struct utsname unameData;
    if (uname(&unameData) == -1) {
        log() << "Unable to collect detailed system information: " << strerror(errno) << endl;
    }

    char buf_64[32];
    char buf_native[32];
    if (sysinfo(SI_ARCHITECTURE_64, buf_64, sizeof(buf_64)) != -1 &&
        sysinfo(SI_ARCHITECTURE_NATIVE, buf_native, sizeof(buf_native)) != -1) {
        addrSize = mongoutils::str::equals(buf_64, buf_native) ? 64 : 32;
    } else {
        log() << "Unable to determine system architecture: " << strerror(errno) << endl;
    }

    osType = unameData.sysname;
    osName = mongoutils::str::ltrim(readLineFromFile("/etc/release"));
    osVersion = unameData.version;
    pageSize = static_cast<unsigned long long>(sysconf(_SC_PAGESIZE));
    memSize = pageSize * static_cast<unsigned long long>(sysconf(_SC_PHYS_PAGES));
    numCores = static_cast<unsigned>(sysconf(_SC_NPROCESSORS_CONF));
    cpuArch = unameData.machine;
    hasNuma = checkNumaEnabled();

    // We prefer FSync over msync, when:
    // 1. Pre-Oracle Solaris 11.2 releases
    // 2. Illumos kernel releases (which is all non Oracle Solaris releases)
    preferMsyncOverFSync = false;

    if (mongoutils::str::startsWith(osName, "Oracle Solaris")) {
        std::vector<std::string> versionComponents;
        splitStringDelim(osVersion, &versionComponents, '.');

        if (versionComponents.size() > 1) {
            unsigned majorInt, minorInt;
            Status majorStatus = parseNumberFromString<unsigned>(versionComponents[0], &majorInt);

            Status minorStatus = parseNumberFromString<unsigned>(versionComponents[1], &minorInt);

            if (!majorStatus.isOK() || !minorStatus.isOK()) {
                warning() << "Could not parse OS version numbers from uname: " << osVersion;
            } else if ((majorInt == 11 && minorInt >= 2) || majorInt > 11) {
                preferMsyncOverFSync = true;
            }
        } else {
            warning() << "Could not parse OS version string from uname: " << osVersion;
        }
    }

    BSONObjBuilder bExtra;
    bExtra.append("kernelVersion", unameData.release);
    bExtra.append("pageSize", static_cast<long long>(pageSize));
    bExtra.append("numPages", static_cast<int>(sysconf(_SC_PHYS_PAGES)));
    bExtra.append("maxOpenFiles", static_cast<int>(sysconf(_SC_OPEN_MAX)));
    _extraStats = bExtra.obj();
}
예제 #3
0
boost::filesystem::path ProgramRunner::findProgram(const string& prog) {
    boost::filesystem::path p = prog;

#ifdef _WIN32
    // The system programs either come versioned in the form of <utility>-<major.minor>
    // (e.g., mongorestore-2.4) or just <utility>. For windows, the appropriate extension
    // needs to be appended.
    //
    if (p.extension() != ".exe") {
        p = prog + ".exe";
    }
#endif

    // The file could exist if it is specified as a full path.
    if (p.is_absolute() && boost::filesystem::exists(p)) {
        return p;
    }

    // Check if the binary exists in the current working directory
    boost::filesystem::path t = boost::filesystem::current_path() / p;
    if (boost::filesystem::exists(t)) {
        return t;
    }

#ifndef _WIN32
    // On POSIX, we need to manually resolve the $PATH variable, to try and find the binary in the
    // filesystem.
    const char* cpath = getenv("PATH");
    if (!cpath) {
        // PATH was unset, so path search is implementation defined
        return t;
    }

    std::string path(cpath);
    std::vector<std::string> pathEntries;

    // PATH entries are separated by colons. Per POSIX 2013, there is no way to escape a colon in
    // an entry.
    splitStringDelim(path, &pathEntries, ':');

    for (const std::string& pathEntry : pathEntries) {
        boost::filesystem::path potentialBinary = boost::filesystem::path(pathEntry) / p;
        if (boost::filesystem::exists(potentialBinary) &&
            boost::filesystem::is_regular_file(potentialBinary) &&
            access(potentialBinary.c_str(), X_OK) == 0) {
            return potentialBinary;
        }
    }
#endif

    return p;
}
예제 #4
0
Status ActionSet::parseActionSetFromString(const std::string& actionsString, ActionSet* result) {
    std::vector<std::string> actionsList;
    splitStringDelim(actionsString, &actionsList, ',');
    std::vector<std::string> unrecognizedActions;
    Status status = parseActionSetFromStringVector(actionsList, result, &unrecognizedActions);
    invariantOK(status);
    if (unrecognizedActions.empty()) {
        return Status::OK();
    }
    std::string unrecognizedActionsString;
    joinStringDelim(unrecognizedActions, &unrecognizedActionsString, ',');
    return Status(
        ErrorCodes::FailedToParse,
        str::stream() << "Unrecognized action privilege strings: " << unrecognizedActionsString);
}
예제 #5
0
 Status ActionSet::parseActionSetFromString(const std::string& actionsString,
                                            ActionSet* result) {
     std::vector<std::string> actionsList;
     splitStringDelim(actionsString, &actionsList, ',');
     ActionSet actions;
     for (size_t i = 0; i < actionsList.size(); i++) {
         ActionType action;
         Status status = ActionType::parseActionFromString(actionsList[i], &action);
         if (status != Status::OK()) {
             ActionSet empty;
             *result = empty;
             return status;
         }
         actions.addAction(action);
     }
     *result = actions;
     return Status::OK();
 }
예제 #6
0
 Status ExportedServerParameter< vector<string> >::setFromString( const string& str ) {
     vector<string> v;
     splitStringDelim( str, &v, ',' );
     return set( v );
 }
예제 #7
0
    Status storeMongosOptions(const moe::Environment& params,
                              const std::vector<std::string>& args) {

        Status ret = storeServerOptions(params, args);
        if (!ret.isOK()) {
            return ret;
        }

        if ( params.count( "chunkSize" ) ) {
            int csize = params["chunkSize"].as<int>();

            // validate chunksize before proceeding
            if ( csize == 0 ) {
                return Status(ErrorCodes::BadValue, "error: need a non-zero chunksize");
            }

            if ( !Chunk::setMaxChunkSizeSizeMB( csize ) ) {
                return Status(ErrorCodes::BadValue, "MaxChunkSize invalid");
            }
        }

        if (params.count( "port" ) ) {
            int port = params["port"].as<int>();
            if ( port <= 0 || port > 65535 ) {
                return Status(ErrorCodes::BadValue,
                              "error: port number must be between 1 and 65535");
            }
        }

        if ( params.count( "localThreshold" ) ) {
            serverGlobalParams.defaultLocalThresholdMillis = params["localThreshold"].as<int>();
        }

        if ( params.count( "ipv6" ) ) {
            enableIPv6();
        }

        if ( params.count( "jsonp" ) ) {
            serverGlobalParams.jsonp = true;
        }

        if (params.count("noscripting")) {
            // This option currently has no effect for mongos
        }

        if (params.count("httpinterface")) {
            if (params.count("nohttpinterface")) {
                return Status(ErrorCodes::BadValue,
                              "can't have both --httpinterface and --nohttpinterface");
            }
            serverGlobalParams.isHttpInterfaceEnabled = true;
        }

        if (params.count("noAutoSplit")) {
            warning() << "running with auto-splitting disabled" << endl;
            Chunk::ShouldAutoSplit = false;
        }

        if ( ! params.count( "configdb" ) ) {
            return Status(ErrorCodes::BadValue, "error: no args for --configdb");
        }

        splitStringDelim(params["configdb"].as<std::string>(), &mongosGlobalParams.configdbs, ',');
        if (mongosGlobalParams.configdbs.size() != 1 && mongosGlobalParams.configdbs.size() != 3) {
            return Status(ErrorCodes::BadValue, "need either 1 or 3 configdbs");
        }

        if (mongosGlobalParams.configdbs.size() == 1) {
            warning() << "running with 1 config server should be done only for testing purposes "
                      << "and is not recommended for production" << endl;
        }

        mongosGlobalParams.upgrade = params.count("upgrade");

        return Status::OK();
    }
예제 #8
0
 Status ActionSet::parseActionSetFromString(const std::string& actionsString,
                                            ActionSet* result) {
     std::vector<std::string> actionsList;
     splitStringDelim(actionsString, &actionsList, ',');
     return parseActionSetFromStringVector(actionsList, result);
 }
예제 #9
0
    Status storeMongosOptions(const moe::Environment& params,
                              const std::vector<std::string>& args) {

        Status ret = storeServerOptions(params, args);
        if (!ret.isOK()) {
            std::cerr << "Error storing command line: " << ret.toString() << std::endl;
            ::_exit(EXIT_BADOPTIONS);
        }

        if ( params.count( "chunkSize" ) ) {
            int csize = params["chunkSize"].as<int>();

            // validate chunksize before proceeding
            if ( csize == 0 ) {
                std::cerr << "error: need a non-zero chunksize" << std::endl;
                ::_exit(EXIT_BADOPTIONS);
            }

            if ( !Chunk::setMaxChunkSizeSizeMB( csize ) ) {
                std::cerr << "MaxChunkSize invalid" << std::endl;
                ::_exit(EXIT_BADOPTIONS);
            }
        }

        if (params.count( "port" ) ) {
            int port = params["port"].as<int>();
            if ( port <= 0 || port > 65535 ) {
                out() << "error: port number must be between 1 and 65535" << endl;
                ::_exit(EXIT_FAILURE);
            }
        }

        if ( params.count( "localThreshold" ) ) {
            serverGlobalParams.defaultLocalThresholdMillis = params["localThreshold"].as<int>();
        }

        if ( params.count( "ipv6" ) ) {
            enableIPv6();
        }

        if ( params.count( "jsonp" ) ) {
            serverGlobalParams.jsonp = true;
        }

        if ( params.count( "test" ) ) {
            ::mongo::logger::globalLogDomain()->setMinimumLoggedSeverity(
                    ::mongo::logger::LogSeverity::Debug(5));
            StartupTest::runTests();
            ::_exit(EXIT_SUCCESS);
        }

        if (params.count("noscripting")) {
            // This option currently has no effect for mongos
        }

        if (params.count("httpinterface")) {
            if (params.count("nohttpinterface")) {
                std::cerr << "can't have both --httpinterface and --nohttpinterface" << std::endl;
                ::_exit(EXIT_BADOPTIONS);
            }
            serverGlobalParams.isHttpInterfaceEnabled = true;
        }

        if (params.count("noAutoSplit")) {
            warning() << "running with auto-splitting disabled" << endl;
            Chunk::ShouldAutoSplit = false;
        }

        if ( ! params.count( "configdb" ) ) {
            std::cerr << "error: no args for --configdb" << std::endl;
            ::_exit(EXIT_BADOPTIONS);
        }

        splitStringDelim(params["configdb"].as<std::string>(), &mongosGlobalParams.configdbs, ',');
        if (mongosGlobalParams.configdbs.size() != 1 && mongosGlobalParams.configdbs.size() != 3) {
            std::cerr << "need either 1 or 3 configdbs" << std::endl;
            ::_exit(EXIT_BADOPTIONS);
        }

        if (mongosGlobalParams.configdbs.size() == 1) {
            warning() << "running with 1 config server should be done only for testing purposes "
                      << "and is not recommended for production" << endl;
        }

        mongosGlobalParams.upgrade = params.count("upgrade");

        return Status::OK();
    }
예제 #10
0
파일: config.cpp 프로젝트: BendustiK/mongo
 bool ConfigServer::init( string s ) {
     vector<string> configdbs;
     splitStringDelim( s, &configdbs, ',' );
     return init( configdbs );
 }