options.h

/*    Copyright 2014 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 <string>
 
#include "mongo/client/export_macros.h"
#include "mongo/logger/log_domain.h"
#include "mongo/logger/message_log_domain.h"
#include "mongo/stdx/functional.h"
 
namespace mongo {
namespace client {
 
    class MONGO_CLIENT_API Options {
    public:
 
        // Defaults for non-boolean or std::string parameters that are not defaulted to the
        // empty string. These are useful in case you which to set a parameter to a scale
        // factor or mutation of the default.
        static const unsigned int kDefaultAutoShutdownGracePeriodMillis = 0;
        static const int kDefaultDefaultLocalThresholdMillis = 15;
 
        // Helpful typedefs for logging-related options
        typedef std::auto_ptr<logger::MessageLogDomain::EventAppender> LogAppenderPtr;
        typedef stdx::function<LogAppenderPtr()> LogAppenderFactory;
 
        static const Options& current();
 
        Options();
 
        enum DefaultPorts {
            kDbServer = 27017,
            kShardServer = 27018,
            kConfigServer = 27019
        };
 
        enum SSLModes {
 
            kSSLDisabled,
 
            // kSSLPreferred,
 
            kSSLRequired
        };
 
        enum TLSProtocol {
            kTLS1_0,
            kTLS1_1,
            kTLS1_2
        };
 
        //
        // Startup and shutdown
        //
 
        Options& setCallShutdownAtExit(bool value = true);
        bool callShutdownAtExit() const;
 
        Options& setAutoShutdownGracePeriodMillis(unsigned int millis);
        unsigned int autoShutdownGracePeriodMillis() const;
 
 
        //
        // Replication
        //
 
        Options& setDefaultLocalThresholdMillis(int millis);
        int defaultLocalThresholdMillis() const;
 
 
        //
        // SSL
        //
        // NOTE: None of the below settings have any effect unless the driver
        // was compiled with SSL support.
        //
        // Glossary:
        //  - CA File: certificate authority certificate file
        //  - PEM Key File: SSL certificate file in PEM format
        //  - CRL: certificate revocation list
        //  - FIPS Mode: OpenSSL crypto library FIPS 140-2 mode processing
        //
 
        Options& setSSLMode(SSLModes sslMode = kSSLRequired);
        SSLModes SSLMode() const;
 
        inline bool SSLEnabled() const {
            return SSLMode() != kSSLDisabled;
        }
 
        Options& setFIPSMode(bool value = true);
        const bool FIPSMode() const;
 
        Options& setSSLDisabledTLSProtocols(const std::vector<TLSProtocol>& protocols);
        const std::vector<TLSProtocol>& SSLDisabledTLSProtocols() const;
 
        Options& setSSLCAFile(const std::string& fileName);
        const std::string& SSLCAFile() const;
 
        Options& setSSLPEMKeyFile(const std::string& fileName);
        const std::string& SSLPEMKeyFile() const;
 
        Options& setSSLPEMKeyPassword(const std::string& password);
        const std::string& SSLPEMKeyPassword() const;
 
        Options& setSSLCRLFile(const std::string& fileName);
        const std::string& SSLCRLFile() const;
 
        Options& setSSLAllowInvalidCertificates(bool value = true);
        const bool SSLAllowInvalidCertificates() const;
 
        Options& setSSLAllowInvalidHostnames(bool value = true);
        const bool SSLAllowInvalidHostnames() const;
 
        Options& setSSLCipherConfig(const std::string& config);
        const std::string& SSLCipherConfig() const;
 
        //
        // Logging
        //
 
        Options& setLogAppenderFactory(const LogAppenderFactory& factory);
        const LogAppenderFactory& logAppenderFactory() const;
 
        Options& setMinLoggedSeverity(logger::LogSeverity level);
        logger::LogSeverity minLoggedSeverity() const;
 
        //
        // Misc
        //
 
        Options& setValidateObjects(bool value = true);
        bool validateObjects() const;
 
    private:
        bool _callShutdownAtExit;
        unsigned int _autoShutdownGracePeriodMillis;
        SSLModes _sslMode;
        bool _useFIPSMode;
        std::vector<TLSProtocol> _sslDisabledTLSProtocols;
        std::string _sslCAFile;
        std::string _sslPEMKeyFile;
        std::string _sslPEMKeyPassword;
        std::string _sslCRLFile;
        bool _sslAllowInvalidCertificates;
        bool _sslAllowInvalidHostnames;
        std::string _sslCipherConfig;
        int _defaultLocalThresholdMillis;
        LogAppenderFactory _appenderFactory;
        logger::LogSeverity _minLoggedSeverity;
        bool _validateObjects;
    };
 
} // namespace client
} // namespace mongo