public void TestEquals()
        {
            var a = new MongoCredentials("user1", "password");
            var b = new MongoCredentials("user1", "password");
            var c = new MongoCredentials("user2", "password");
            var n = (MongoCredentials)null;

            Assert.IsTrue(object.Equals(a, b));
            Assert.IsFalse(object.Equals(a, c));
            Assert.IsFalse(a.Equals(n));
            Assert.IsFalse(a.Equals(null));

            Assert.IsTrue(a == b);
            Assert.IsFalse(a == c);
            Assert.IsFalse(a == null);
            Assert.IsFalse(null == a);
            Assert.IsTrue(n == null);
            Assert.IsTrue(null == n);

            Assert.IsFalse(a != b);
            Assert.IsTrue(a != c);
            Assert.IsTrue(a != null);
            Assert.IsTrue(null != a);
            Assert.IsFalse(n != null);
            Assert.IsFalse(null != n);
        }
Exemple #2
0
        static void Main(string[] args)
        {
            var server = MongoServer.Create("mongodb://localhost");

            MongoDatabase test = server.GetDatabase("test");
            MongoCredentials credentials = new MongoCredentials("username", "password");
            MongoDatabase salaries = server.GetDatabase("salaries", credentials);

            MongoCollection docs = test.GetCollection("docs");
            docs.EnsureIndex("title");

            Console.WriteLine("adding some test documents");

            for (int x = 0; x < 1000; x++) {

                BsonDocument doc = new BsonDocument();
                doc.Add("title", "title: " + x);
                doc.Add("body", "body: " + x);
                docs.Insert(doc);
            }

            Console.WriteLine("querying");

            foreach (var doc in docs.FindAllAs<BsonDocument>()) {
                Console.WriteLine("doc: {0}", doc["body"]);
            }
        }
 public MongoDatabaseSettings()
 {
     this.databaseName = null;
     this.credentials = null;
     this.safeMode = SafeMode.False;
     this.slaveOk = false;
 }
        public MongoDatabaseSettings(
            string databaseName,
            MongoCredentials credentials,
            GuidRepresentation guidRepresentation,
            ReadPreference readPreference,
            WriteConcern writeConcern)
        {
            if (databaseName == null)
            {
                throw new ArgumentNullException("databaseName");
            }
            if (databaseName == "admin" && credentials != null && !credentials.Admin)
            {
                throw new ArgumentOutOfRangeException("credentials", "Credentials for the admin database must have the admin flag set to true.");
            }
            if (readPreference == null)
            {
                throw new ArgumentNullException("readPreference");
            }
            if (writeConcern == null)
            {
                throw new ArgumentNullException("writeConcern");
            }

            _databaseName.Value = databaseName;
            _credentials.Value = credentials;
            _guidRepresentation.Value = guidRepresentation;
            _readPreference.Value = readPreference;
            _writeConcern.Value = writeConcern;
        }
        // constructors
        /// <summary>
        /// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
        /// </summary>
        public MongoServerSettings()
        {
            _connectionMode = ConnectionMode.Automatic;
            _connectTimeout = MongoDefaults.ConnectTimeout;
            _credentialsStore = new MongoCredentialsStore();
            _defaultCredentials = null;
            _guidRepresentation = MongoDefaults.GuidRepresentation;
            _ipv6 = false;
            _maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
            _maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
            _maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
            _minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
            _readPreference = ReadPreference.Primary;
            _replicaSetName = null;
            _secondaryAcceptableLatency = MongoDefaults.SecondaryAcceptableLatency;
            _servers = new List<MongoServerAddress> { new MongoServerAddress("localhost") };
            _socketTimeout = MongoDefaults.SocketTimeout;
            _useSsl = false;
            _verifySslCertificate = true;
            _waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
            _waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
#pragma warning disable 612, 618
            _writeConcern = MongoDefaults.SafeMode.WriteConcern;
#pragma warning restore
        }
        /// <summary>
        /// Creates a new instance of MongoDatabaseSettings.
        /// </summary>
        /// <param name="databaseName">The name of the database.</param>
        /// <param name="credentials">The credentials to access the database.</param>
        /// <param name="guidRepresentation">The representation for Guids.</param>
        /// <param name="readPreference">The read preference.</param>
        /// <param name="safeMode">The safe mode to use.</param>
        public MongoDatabaseSettings(
            string databaseName,
            MongoCredentials credentials,
            GuidRepresentation guidRepresentation,
            ReadPreference readPreference,
            SafeMode safeMode)
        {
            if (databaseName == null)
            {
                throw new ArgumentNullException("databaseName");
            }
            if (databaseName == "admin" && credentials != null && !credentials.Admin)
            {
                throw new ArgumentOutOfRangeException("Credentials for the admin database must have the admin flag set to true.");
            }
            if (readPreference == null)
            {
                throw new ArgumentNullException("readPreference");
            }
            if (safeMode == null)
            {
                throw new ArgumentNullException("safeMode");
            }

            _databaseName = databaseName;
            _credentials = credentials;
            _guidRepresentation = guidRepresentation;
            _readPreference = readPreference;
            _safeMode = safeMode;
        }
 // constructors
 /// <summary>
 /// Creates a new instance of MongoUrlBuilder.
 /// </summary>
 public MongoUrlBuilder()
 {
     _connectionMode = ConnectionMode.Automatic;
     _connectTimeout = MongoDefaults.ConnectTimeout;
     _databaseName = null;
     _defaultCredentials = null;
     _fsync = null;
     _guidRepresentation = MongoDefaults.GuidRepresentation;
     _ipv6 = false;
     _journal = null;
     _maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
     _maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
     _maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
     _minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
     _readPreference = null;
     _replicaSetName = null;
     _secondaryAcceptableLatency = MongoDefaults.SecondaryAcceptableLatency;
     _servers = null;
     _slaveOk = null;
     _socketTimeout = MongoDefaults.SocketTimeout;
     _useSsl = false;
     _verifySslCertificate = true;
     _w = null;
     _waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
     _waitQueueSize = MongoDefaults.WaitQueueSize;
     _waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
     _wTimeout = null;
 }
 public MongoServerSettings(
     ConnectionMode connectionMode,
     TimeSpan connectTimeout,
     MongoCredentials defaultCredentials,
     TimeSpan maxConnectionIdleTime,
     TimeSpan maxConnectionLifeTime,
     int maxConnectionPoolSize,
     int minConnectionPoolSize,
     string replicaSetName,
     SafeMode safeMode,
     IEnumerable<MongoServerAddress> servers,
     bool slaveOk,
     TimeSpan socketTimeout,
     int waitQueueSize,
     TimeSpan waitQueueTimeout
 )
 {
     this.connectionMode = connectionMode;
     this.connectTimeout = connectTimeout;
     this.defaultCredentials = defaultCredentials;
     this.maxConnectionIdleTime = maxConnectionIdleTime;
     this.maxConnectionLifeTime = maxConnectionLifeTime;
     this.maxConnectionPoolSize = maxConnectionPoolSize;
     this.minConnectionPoolSize = minConnectionPoolSize;
     this.replicaSetName = replicaSetName;
     this.safeMode = safeMode;
     this.servers = servers;
     this.slaveOk = slaveOk;
     this.socketTimeout = socketTimeout;
     this.waitQueueSize = waitQueueSize;
     this.waitQueueTimeout = waitQueueTimeout;
 }
 static MongoDatabase CreatDataBase(string bdName, string userName, string userPw)
 {
     var mongoUrlBuilder = new MongoUrlBuilder("mongodb://localhost");
     MongoServer server = MongoServer.Create(mongoUrlBuilder.ToMongoUrl());
     MongoCredentials credentials = new MongoCredentials(userName, userPw);
     MongoDatabase database = server.GetDatabase(bdName, credentials);
     return database;
 }
 /// <summary>
 /// Creates a new instance of MongoUser.
 /// </summary>
 /// <param name="credentials">The user's credentials.</param>
 /// <param name="isReadOnly">Whether the user has read-only access.</param>
 public MongoUser(
     MongoCredentials credentials,
     bool isReadOnly
 ) {
     this.username = credentials.Username;
     this.passwordHash = HashPassword(credentials.Username, credentials.Password);
     this.isReadOnly = isReadOnly;
 }
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(string databaseName, MongoCredentials credentials, GuidRepresentation guidRepresentation, SafeMode safeMode, bool slaveOk)
 {
     _databaseName = databaseName;
     _credentials = credentials;
     _guidRepresentation = guidRepresentation;
     _safeMode = safeMode;
     _slaveOk = slaveOk;
 }
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(string databaseName, MongoCredentials credentials, GuidRepresentation guidRepresentation, SafeMode safeMode, ReadPreference readPreference)
 {
     this.databaseName = databaseName;
     this.credentials = credentials;
     this.guidRepresentation = guidRepresentation;
     this.safeMode = safeMode;
     this.readPreference = readPreference;
 }
 /// <summary>
 /// Add User
 /// </summary>
 /// <param name="strUser">Username</param>
 /// <param name="password">Password</param>
 /// <param name="isReadOnly">Is ReadOnly</param>
 public static void AddUserToDB(String strUser, String password, Boolean isReadOnly)
 {
     MongoDatabase mongoDB = SystemManager.GetCurrentDataBase();
     MongoCredentials newUser = new MongoCredentials(strUser, password, false);
     if (mongoDB.FindUser(strUser) == null)
     {
         mongoDB.AddUser(newUser, isReadOnly);
     }
 }
 // constructors
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="server">The server to inherit settings from.</param>
 /// <param name="databaseName">The name of the database.</param>
 public MongoDatabaseSettings(MongoServer server, string databaseName)
 {
     var serverSettings = server.Settings;
     this.databaseName = databaseName;
     this.credentials = serverSettings.DefaultCredentials;
     this.guidRepresentation = serverSettings.GuidRepresentation;
     this.safeMode = serverSettings.SafeMode;
     this.readPreference = serverSettings.ReadPreference;
 }
 // constructors
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="server">The server to inherit settings from.</param>
 /// <param name="databaseName">The name of the database.</param>
 public MongoDatabaseSettings(MongoServer server, string databaseName)
 {
     var serverSettings = server.Settings;
     _databaseName = databaseName;
     _credentials = serverSettings.DefaultCredentials;
     _guidRepresentation = serverSettings.GuidRepresentation;
     _safeMode = serverSettings.SafeMode;
     _slaveOk = serverSettings.SlaveOk;
 }
 /// <summary>
 /// 添加用户
 /// </summary>
 /// <param name="strDBPath">数据库路径</param>
 /// <param name="strUser">用户名</param>
 /// <param name="password">密码</param>
 /// <param name="isReadOnly">是否为只读</param>
 public static void AddUserToDB(string strDBPath, string strUser, string password, bool isReadOnly)
 {
     MongoDatabase mongoDB = GetMongoDBBySvrPath(strDBPath);
     MongoCredentials newUser = new MongoCredentials(strUser, password, false);
     if (mongoDB.FindUser(strUser) == null)
     {
         mongoDB.AddUser(newUser,isReadOnly);
     }
 }
 //这里有个漏洞,对于数据库来说,对于local的验证和对于admin的验证是相同的。
 //如果是加入用户到服务器中,是加入到local还是admin,需要考虑一下。
 /// <summary>
 /// Add A User to Admin database
 /// </summary>
 /// <param name="strUser">Username</param>
 /// <param name="password">Password</param>
 /// <param name="isReadOnly">Is ReadOnly</param>
 public static void AddUserToSvr(String strUser, String password, Boolean isReadOnly)
 {
     MongoServer mongoSvr = SystemManager.GetCurrentServer();
     //必须使用MongoCredentials来添加用户不然的话,Password将使用明文登入到数据库中!
     //这样的话,在使用MongoCredentials登入的时候,会发生密码错误引发的认证失败
     MongoCredentials newUser = new MongoCredentials(strUser, password, true);
     if (mongoSvr.GetDatabase(DATABASE_NAME_ADMIN).FindUser(strUser) == null)
     {
         mongoSvr.GetDatabase(DATABASE_NAME_ADMIN).AddUser(newUser, isReadOnly);
     }
 }
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings. Usually you would call MongoServer.CreateDatabaseSettings instead.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(
     string databaseName,
     MongoCredentials credentials,
     SafeMode safeMode,
     bool slaveOk
 ) {
     this.databaseName = databaseName;
     this.credentials = credentials;
     this.safeMode = safeMode;
     this.slaveOk = slaveOk;
 }
 /// <summary>
 /// 添加User到Admin数据库[效果如同添加USER到整个服务器]
 /// </summary>
 /// <param name="strDBPath"></param>
 /// <param name="strUser"></param>
 /// <param name="password"></param>
 /// <param name="isReadOnly"></param>
 public static void AddUserToSvr(string strDBPath, string strUser, string password, bool isReadOnly)
 {
     MongoServer mongoSvr = SystemManager.GetCurrentService();
     //必须使用MongoCredentials来添加用户不然的话,Password将使用明文登入到数据库中!
     //这样的话,在使用MongoCredentials登入的时候,会发生密码错误引发的认证失败
     MongoCredentials newUser = new MongoCredentials(strUser, password,true);
     if (mongoSvr.AdminDatabase.FindUser(strUser) == null)
     {
         mongoSvr.AdminDatabase.AddUser(newUser,isReadOnly);
     }
 }
        public void TestCreateCredentials()
        {
            var credentials = new MongoCredentials("username", "password");
            Assert.AreEqual("username", credentials.Username);
            Assert.AreEqual("password", credentials.Password);
            Assert.IsFalse(credentials.Admin);

            credentials = new MongoCredentials("username", "password", false);
            Assert.AreEqual("username", credentials.Username);
            Assert.AreEqual("password", credentials.Password);
            Assert.IsFalse(credentials.Admin);
        }
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings. Usually you would call MongoServer.CreateDatabaseSettings instead.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(
     string databaseName,
     MongoCredentials credentials,
     GuidRepresentation guidRepresentation,
     SafeMode safeMode,
     bool slaveOk
 ) {
     this.databaseName = databaseName;
     this.credentials = credentials;
     this.guidRepresentation = guidRepresentation;
     this.safeMode = safeMode;
     this.slaveOk = slaveOk;
 }
        private SimpleMongoDatabaseFactory(MongoServer mongo, string databaseName, MongoCredentials credentials,
                                     bool mongoInstanceCreated)
        {
            AssertUtils.ArgumentNotNull(mongo, "mongo");
            AssertUtils.ArgumentHasText(databaseName, "databaseName");
            AssertUtils.IsTrue(!Regex.IsMatch(databaseName, @"[^A-Za-z0-9-_]+"),
                               "Database name must only contain letters, numbers, underscores and dashes!");

            _mongo = mongo;
            _databaseName = databaseName;
            _mongoInstanceCreated = mongoInstanceCreated;
            _credentials = credentials;
        }
Exemple #23
0
        public MongoConfig()
        {
            MongoConfigSection mongoSection = (MongoConfigSection)ConfigurationManager.GetSection(MongoConfigSection.DefaultSectionName);

            MongoServerSettings settings = new MongoServerSettings();
            settings.ConnectionMode = ConnectionMode.Direct;
            settings.Server = new MongoServerAddress(mongoSection.Host, mongoSection.Port);
            MongoCredentials credential = new MongoCredentials(mongoSection.UserName, mongoSection.Password);
            settings.DefaultCredentials = credential;
            settings.SafeMode = SafeMode.True;
            settings.SlaveOk = true;
            MongoServer mongoSvr = MongoServer.Create(settings);
            MongoDatabase = mongoSvr.GetDatabase(mongoSection.Database);
        }
 public MongoUrl(
     string url
 )
 {
     var builder = new MongoUrlBuilder(url);
     this.url = builder.ToString(); // keep canonical form
     this.credentials = builder.Credentials;
     this.servers = builder.Servers;
     this.databaseName = builder.DatabaseName;
     this.connectionMode = builder.ConnectionMode;
     this.replicaSetName = builder.ReplicaSetName;
     this.safeMode = builder.SafeMode ?? SafeMode.False; // never null
     this.slaveOk = builder.SlaveOk;
 }
Exemple #25
0
 /// <summary>
 /// Creates a new instance of MongoDatabaseSettings.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to access the database.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="safeMode">The safe mode to use.</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 public MongoDatabaseSettings(
     string databaseName,
     MongoCredentials credentials,
     GuidRepresentation guidRepresentation,
     SafeMode safeMode,
     bool slaveOk)
 {
     if (databaseName == "admin" && credentials != null && !credentials.Admin)
     {
         throw new ArgumentOutOfRangeException("Credentials for the admin database must have the admin flag set to true.");
     }
     _databaseName = databaseName;
     _credentials = credentials;
     _guidRepresentation = guidRepresentation;
     _safeMode = safeMode;
     _slaveOk = slaveOk;
 }
 /// <summary>
 /// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
 /// </summary>
 public MongoServerSettings() {
     connectionMode = ConnectionMode.Direct;
     connectTimeout = MongoDefaults.ConnectTimeout;
     defaultCredentials = null;
     ipv6 = false;
     maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
     maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
     maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
     minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
     replicaSetName = null;
     safeMode = MongoDefaults.SafeMode;
     servers = null;
     slaveOk = false;
     socketTimeout = MongoDefaults.SocketTimeout;
     waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
     waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
 }
        public void TestCreateAdminCredentials()
        {
            var credentials = MongoCredentials.Create("username(admin)", "password");
            Assert.AreEqual("username", credentials.Username);
            Assert.AreEqual("password", credentials.Password);
            Assert.IsTrue(credentials.Admin);

            credentials = new MongoCredentials("username(admin)", "password");
            Assert.AreEqual("username", credentials.Username);
            Assert.AreEqual("password", credentials.Password);
            Assert.IsTrue(credentials.Admin);

            credentials = new MongoCredentials("username", "password", true);
            Assert.AreEqual("username", credentials.Username);
            Assert.AreEqual("password", credentials.Password);
            Assert.IsTrue(credentials.Admin);
        }
 // public methods
 /// <summary>
 /// Adds the credentials for a database to the store.
 /// </summary>
 /// <param name="databaseName">The database name.</param>
 /// <param name="credentials">The credentials.</param>
 public void AddCredentials(string databaseName, MongoCredentials credentials)
 {
     if (_isFrozen) { throw new InvalidOperationException("MongoCredentialsStore is frozen."); }
     if (databaseName == null)
     {
         throw new ArgumentNullException("databaseName");
     }
     if (credentials == null)
     {
         throw new ArgumentNullException("credentials");
     }
     if (databaseName == "admin" && !credentials.Admin)
     {
         throw new ArgumentOutOfRangeException("credentials", "Credentials for the admin database must have the admin flag set to true.");
     }
     _credentialsStore.Add(databaseName, credentials);
 }
        // constructors
        /// <summary>
        /// Creates a new instance of MongoDatabaseSettings.
        /// </summary>
        /// <param name="server">The server to inherit settings from.</param>
        /// <param name="databaseName">The name of the database.</param>
        public MongoDatabaseSettings(MongoServer server, string databaseName)
        {
            if (server == null)
            {
                throw new ArgumentNullException("server");
            }
            if (databaseName == null)
            {
                throw new ArgumentNullException("databaseName");
            }

            var serverSettings = server.Settings;
            _databaseName = databaseName;
            _credentials = serverSettings.GetCredentials(databaseName);
            _guidRepresentation = serverSettings.GuidRepresentation;
            _readPreference = serverSettings.ReadPreference;
            _writeConcern = serverSettings.WriteConcern;
        }
 // constructors
 /// <summary>
 /// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
 /// </summary>
 public MongoServerSettings()
 {
     _connectionMode = ConnectionMode.Direct;
     _connectTimeout = MongoDefaults.ConnectTimeout;
     _defaultCredentials = null;
     _guidRepresentation = MongoDefaults.GuidRepresentation;
     _ipv6 = false;
     _maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
     _maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
     _maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
     _minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
     _replicaSetName = null;
     _safeMode = MongoDefaults.SafeMode;
     _servers = null;
     _slaveOk = false;
     _socketTimeout = MongoDefaults.SocketTimeout;
     _waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
     _waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
 }
        /// <summary>
        /// Parses a URL and sets all settings to match the URL.
        /// </summary>
        /// <param name="url">The URL.</param>
        public void Parse(string url)
        {
            const string serverPattern = @"((\[[^]]+?\]|[^:,/]+)(:\d+)?)";
            const string pattern       =
                @"^mongodb://" +
                @"((?<username>[^:]+):(?<password>[^@]+)@)?" +
                @"(?<servers>" + serverPattern + "(," + serverPattern + ")*)?" +
                @"(/(?<database>[^?]+)?(\?(?<query>.*))?)?$";
            Match match = Regex.Match(url, pattern);

            if (match.Success)
            {
                string username     = Uri.UnescapeDataString(match.Groups["username"].Value);
                string password     = Uri.UnescapeDataString(match.Groups["password"].Value);
                string servers      = match.Groups["servers"].Value;
                string databaseName = match.Groups["database"].Value;
                string query        = match.Groups["query"].Value;

                if (username != "" && password != "")
                {
                    _defaultCredentials = new MongoCredentials(username, password);
                }
                else
                {
                    _defaultCredentials = null;
                }

                if (servers != "")
                {
                    List <MongoServerAddress> addresses = new List <MongoServerAddress>();
                    foreach (string server in servers.Split(','))
                    {
                        var address = MongoServerAddress.Parse(server);
                        addresses.Add(address);
                    }
                    _servers = addresses;
                }

                _databaseName = (databaseName != "") ? databaseName : null;

                if (!string.IsNullOrEmpty(query))
                {
                    foreach (var pair in query.Split('&', ';'))
                    {
                        var parts = pair.Split('=');
                        if (parts.Length != 2)
                        {
                            throw new FormatException(string.Format("Invalid connection string '{0}'.", parts));
                        }
                        var name  = parts[0];
                        var value = parts[1];

                        switch (name.ToLower())
                        {
                        case "connect":
                            ConnectionMode = ParseConnectionMode(name, value);
                            break;

                        case "connecttimeout":
                        case "connecttimeoutms":
                            ConnectTimeout = ParseTimeSpan(name, value);
                            break;

                        case "fsync":
                            FSync = ParseBoolean(name, value);
                            break;

                        case "guids":
                        case "uuidrepresentation":
                            GuidRepresentation = (GuidRepresentation)Enum.Parse(typeof(GuidRepresentation), value, true);     // ignoreCase
                            break;

                        case "ipv6":
                            IPv6 = ParseBoolean(name, value);
                            break;

                        case "j":
                        case "journal":
                            Journal = ParseBoolean(name, value);
                            break;

                        case "maxidletime":
                        case "maxidletimems":
                            MaxConnectionIdleTime = ParseTimeSpan(name, value);
                            break;

                        case "maxlifetime":
                        case "maxlifetimems":
                            MaxConnectionLifeTime = ParseTimeSpan(name, value);
                            break;

                        case "maxpoolsize":
                            MaxConnectionPoolSize = ParseInt32(name, value);
                            break;

                        case "minpoolsize":
                            MinConnectionPoolSize = ParseInt32(name, value);
                            break;

                        case "readpreference":
                            if (_readPreference == null)
                            {
                                _readPreference = new ReadPreference();
                            }
                            ReadPreference.ReadPreferenceMode = ParseReadPreferenceMode(name, value);
                            break;

                        case "readpreferencetags":
                            if (_readPreference == null)
                            {
                                _readPreference = new ReadPreference {
                                    ReadPreferenceMode = ReadPreferenceMode.Primary
                                };
                            }
                            ReadPreference.AddTagSet(ParseReplicaSetTagSet(name, value));
                            break;

                        case "replicaset":
                            ReplicaSetName = value;
                            break;

                        case "safe":
                            var safe = Convert.ToBoolean(value);
                            if (_w == null)
                            {
                                W = safe ? 1 : 0;
                            }
                            else
                            {
                                if (safe)
                                {
                                    // don't overwrite existing W value unless it's 0
                                    var wCount = _w as WriteConcern.WCount;
                                    if (wCount != null && wCount.Value == 0)
                                    {
                                        W = 1;
                                    }
                                }
                                else
                                {
                                    W = 0;
                                }
                            }
                            break;

                        case "secondaryacceptablelatency":
                        case "secondaryacceptablelatencyms":
                            SecondaryAcceptableLatency = ParseTimeSpan(name, value);
                            break;

                        case "slaveok":
#pragma warning disable 618
                            SlaveOk = ParseBoolean(name, value);
#pragma warning restore
                            break;

                        case "sockettimeout":
                        case "sockettimeoutms":
                            SocketTimeout = ParseTimeSpan(name, value);
                            break;

                        case "ssl":
                            UseSsl = ParseBoolean(name, value);
                            break;

                        case "sslverifycertificate":
                            VerifySslCertificate = ParseBoolean(name, value);
                            break;

                        case "w":
                            W = WriteConcern.WValue.Parse(value);
                            break;

                        case "waitqueuemultiple":
                            WaitQueueMultiple = ParseDouble(name, value);
                            break;

                        case "waitqueuesize":
                            WaitQueueSize = ParseInt32(name, value);
                            break;

                        case "waitqueuetimeout":
                        case "waitqueuetimeoutms":
                            WaitQueueTimeout = ParseTimeSpan(name, value);
                            break;

                        case "wtimeout":
                        case "wtimeoutms":
                            WTimeout = ParseTimeSpan(name, value);
                            break;

                        default:
                            var message = string.Format("Invalid option '{0}'.", name);
                            throw new ArgumentException(message, "url");
                        }
                    }
                }
            }
            else
            {
                throw new FormatException(string.Format("Invalid connection string '{0}'.", url));
            }
        }
 /// <summary>
 /// Gets a MongoDatabase instance representing the admin database on this server. Only one instance
 /// is created for each combination of database settings.
 /// </summary>
 /// <param name="credentials">The credentials to use with the admin database.</param>
 /// <returns>A new or existing instance of MongoDatabase.</returns>
 public virtual MongoDatabase GetAdminDatabase(
     MongoCredentials credentials
     )
 {
     return(GetDatabase("admin", credentials));
 }
        // public methods
        /// <summary>
        /// Parses a URL and sets all settings to match the URL.
        /// </summary>
        /// <param name="url">The URL.</param>
        public void Parse(string url)
        {
            ResetValues();
            const string serverPattern = @"((\[[^]]+?\]|[^:,/]+)(:\d+)?)";
            const string pattern       =
                @"^mongodb://" +
                @"((?<username>[^:]+):(?<password>[^@]+)@)?" +
                @"(?<servers>" + serverPattern + "(," + serverPattern + ")*)" +
                @"(/(?<database>[^?]+)?(\?(?<query>.*))?)?$";
            Match match = Regex.Match(url, pattern);

            if (match.Success)
            {
                string username     = Uri.UnescapeDataString(match.Groups["username"].Value);
                string password     = Uri.UnescapeDataString(match.Groups["password"].Value);
                string servers      = match.Groups["servers"].Value;
                string databaseName = match.Groups["database"].Value;
                string query        = match.Groups["query"].Value;

                if (username != "" && password != "")
                {
                    _defaultCredentials = new MongoCredentials(username, password);
                }
                else
                {
                    _defaultCredentials = null;
                }

                if (servers != "")
                {
                    List <MongoServerAddress> addresses = new List <MongoServerAddress>();
                    foreach (string server in servers.Split(','))
                    {
                        var address = MongoServerAddress.Parse(server);
                        addresses.Add(address);
                    }
                    if (addresses.Count == 1)
                    {
                        _connectionMode = ConnectionMode.Direct;
                    }
                    else if (addresses.Count > 1)
                    {
                        _connectionMode = ConnectionMode.ReplicaSet;
                    }
                    _servers = addresses;
                }
                else
                {
                    throw new FormatException("Invalid connection string. Server missing.");
                }

                _databaseName = (databaseName != "") ? databaseName : null;

                if (!string.IsNullOrEmpty(query))
                {
                    foreach (var pair in query.Split('&', ';'))
                    {
                        var parts = pair.Split('=');
                        if (parts.Length != 2)
                        {
                            throw new FormatException(string.Format("Invalid connection string '{0}'.", parts));
                        }
                        var name  = parts[0];
                        var value = parts[1];

                        switch (name.ToLower())
                        {
                        case "connect":
                            _connectionMode = ParseConnectionMode(name, value);
                            break;

                        case "connecttimeout":
                        case "connecttimeoutms":
                            _connectTimeout = ParseTimeSpan(name, value);
                            break;

                        case "fsync":
                            if (_safeMode == null)
                            {
                                _safeMode = new SafeMode(false);
                            }
                            _safeMode.FSync = ParseBoolean(name, value);
                            break;

                        case "guids":
                        case "uuidrepresentation":
                            _guidRepresentation = (GuidRepresentation)Enum.Parse(typeof(GuidRepresentation), value, true);     // ignoreCase
                            break;

                        case "ipv6":
                            _ipv6 = ParseBoolean(name, value);
                            break;

                        case "j":
                        case "journal":
                            if (_safeMode == null)
                            {
                                _safeMode = new SafeMode(false);
                            }
                            SafeMode.Journal = ParseBoolean(name, value);
                            break;

                        case "maxidletime":
                        case "maxidletimems":
                            _maxConnectionIdleTime = ParseTimeSpan(name, value);
                            break;

                        case "maxlifetime":
                        case "maxlifetimems":
                            _maxConnectionLifeTime = ParseTimeSpan(name, value);
                            break;

                        case "maxpoolsize":
                            _maxConnectionPoolSize = ParseInt32(name, value);
                            break;

                        case "minpoolsize":
                            _minConnectionPoolSize = ParseInt32(name, value);
                            break;

                        case "replicaset":
                            _replicaSetName = value;
                            _connectionMode = ConnectionMode.ReplicaSet;
                            break;

                        case "safe":
                            if (_safeMode == null)
                            {
                                _safeMode = new SafeMode(false);
                            }
                            SafeMode.Enabled = ParseBoolean(name, value);
                            break;

                        case "slaveok":
                            _slaveOk = ParseBoolean(name, value);
                            break;

                        case "sockettimeout":
                        case "sockettimeoutms":
                            _socketTimeout = ParseTimeSpan(name, value);
                            break;

                        case "w":
                            if (_safeMode == null)
                            {
                                _safeMode = new SafeMode(false);
                            }
                            try
                            {
                                SafeMode.W = ParseInt32(name, value);
                            }
                            catch (FormatException)
                            {
                                SafeMode.WMode = value;
                            }
                            break;

                        case "waitqueuemultiple":
                            _waitQueueMultiple = ParseDouble(name, value);
                            _waitQueueSize     = 0;
                            break;

                        case "waitqueuesize":
                            _waitQueueMultiple = 0;
                            _waitQueueSize     = ParseInt32(name, value);
                            break;

                        case "waitqueuetimeout":
                        case "waitqueuetimeoutms":
                            _waitQueueTimeout = ParseTimeSpan(name, value);
                            break;

                        case "wtimeout":
                        case "wtimeoutms":
                            if (_safeMode == null)
                            {
                                _safeMode = new SafeMode(false);
                            }
                            SafeMode.WTimeout = ParseTimeSpan(name, value);
                            break;
                        }
                    }
                }
            }
            else
            {
                throw new FormatException(string.Format("Invalid connection string '{0}'.", url));
            }
        }
 /// <summary>
 /// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
 /// </summary>
 /// <param name="connectionMode">The connection mode (Direct or ReplicaSet).</param>
 /// <param name="connectTimeout">The connect timeout.</param>
 /// <param name="defaultCredentials">The default credentials.</param>
 /// <param name="guidRepresentation">The representation for Guids.</param>
 /// <param name="ipv6">Whether to use IPv6.</param>
 /// <param name="maxConnectionIdleTime">The max connection idle time.</param>
 /// <param name="maxConnectionLifeTime">The max connection life time.</param>
 /// <param name="maxConnectionPoolSize">The max connection pool size.</param>
 /// <param name="minConnectionPoolSize">The min connection pool size.</param>
 /// <param name="replicaSetName">The name of the replica set.</param>
 /// <param name="safeMode">The safe mode.</param>
 /// <param name="servers">The server addresses (normally one unless it is the seed list for connecting to a replica set).</param>
 /// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
 /// <param name="socketTimeout">The socket timeout.</param>
 /// <param name="waitQueueSize">The wait queue size.</param>
 /// <param name="waitQueueTimeout">The wait queue timeout.</param>
 public MongoServerSettings(ConnectionMode connectionMode, TimeSpan connectTimeout, MongoCredentials defaultCredentials, GuidRepresentation guidRepresentation, bool ipv6, TimeSpan maxConnectionIdleTime, TimeSpan maxConnectionLifeTime, int maxConnectionPoolSize, int minConnectionPoolSize, string replicaSetName, SafeMode safeMode, IEnumerable <MongoServerAddress> servers, bool slaveOk, TimeSpan socketTimeout, int waitQueueSize, TimeSpan waitQueueTimeout)
 {
     this.connectionMode     = connectionMode;
     this.connectTimeout     = connectTimeout;
     this.defaultCredentials = defaultCredentials;
     this.guidRepresentation = guidRepresentation;
     this.ipv6 = ipv6;
     this.maxConnectionIdleTime = maxConnectionIdleTime;
     this.maxConnectionLifeTime = maxConnectionLifeTime;
     this.maxConnectionPoolSize = maxConnectionPoolSize;
     this.minConnectionPoolSize = minConnectionPoolSize;
     this.replicaSetName        = replicaSetName;
     this.safeMode         = safeMode;
     this.servers          = servers;
     this.slaveOk          = slaveOk;
     this.socketTimeout    = socketTimeout;
     this.waitQueueSize    = waitQueueSize;
     this.waitQueueTimeout = waitQueueTimeout;
 }
Exemple #35
0
 /// <summary>
 /// Gets a MongoDatabase instance representing a database on this server. Only one instance
 /// is created for each combination of database settings.
 /// </summary>
 /// <param name="databaseName">The name of the database.</param>
 /// <param name="credentials">The credentials to use with this database.</param>
 /// <param name="safeMode">The safe mode to use with this database.</param>
 /// <returns>A new or existing instance of MongoDatabase.</returns>
 public virtual MongoDatabase this[string databaseName, MongoCredentials credentials, SafeMode safeMode]
 {
     get { return(GetDatabase(databaseName, credentials, safeMode)); }
 }
        /// <summary>
        /// Parses a URL and sets all settings to match the URL.
        /// </summary>
        /// <param name="url">The URL.</param>
        public void Parse(
            string url
            )
        {
            ResetValues();
            const string pattern =
                @"^mongodb://" +
                @"((?<username>[^:]+):(?<password>[^@]+)@)?" +
                @"(?<servers>[^:,/]+(:\d+)?(,[^:,/]+(:\d+)?)*)" +
                @"(/(?<database>[^?]+)?(\?(?<query>.*))?)?$";
            Match match = Regex.Match(url, pattern);

            if (match.Success)
            {
                string username     = Uri.UnescapeDataString(match.Groups["username"].Value);
                string password     = Uri.UnescapeDataString(match.Groups["password"].Value);
                string servers      = match.Groups["servers"].Value;
                string databaseName = match.Groups["database"].Value;
                string query        = match.Groups["query"].Value;

                if (username != "" && password != "")
                {
                    this.defaultCredentials = new MongoCredentials(username, password);
                }
                else
                {
                    this.defaultCredentials = null;
                }

                if (servers != "")
                {
                    List <MongoServerAddress> addresses = new List <MongoServerAddress>();
                    foreach (string server in servers.Split(','))
                    {
                        var address = MongoServerAddress.Parse(server);
                        addresses.Add(address);
                    }
                    if (addresses.Count == 1)
                    {
                        this.connectionMode = ConnectionMode.Direct;
                    }
                    else if (addresses.Count > 1)
                    {
                        this.connectionMode = ConnectionMode.ReplicaSet;
                    }
                    this.servers = addresses;
                }
                else
                {
                    throw new FormatException("Invalid connection string: server missing");
                }

                this.databaseName = (databaseName != "") ? databaseName : null;

                if (!string.IsNullOrEmpty(query))
                {
                    var safeModeChanged = false;
                    var safe            = false;
                    var w        = 0;
                    var wtimeout = TimeSpan.Zero;
                    var fsync    = false;

                    foreach (var pair in query.Split('&', ';'))
                    {
                        var parts = pair.Split('=');
                        if (parts.Length != 2)
                        {
                            throw new FormatException(string.Format("Invalid connection string: {0}", parts));
                        }
                        var name  = parts[0];
                        var value = parts[1];

                        switch (name.ToLower())
                        {
                        case "connect":
                            connectionMode = ParseConnectionMode(name, value);
                            break;

                        case "connecttimeout":
                        case "connecttimeoutms":
                            connectTimeout = ParseTimeSpan(name, value);
                            break;

                        case "fsync":
                            safeModeChanged = true;
                            safe            = true;
                            fsync           = ParseBoolean(name, value);
                            break;

                        case "ipv6":
                            ipv6 = ParseBoolean(name, value);
                            break;

                        case "maxidletime":
                        case "maxidletimems":
                            maxConnectionIdleTime = ParseTimeSpan(name, value);
                            break;

                        case "maxlifetime":
                        case "maxlifetimems":
                            maxConnectionLifeTime = ParseTimeSpan(name, value);
                            break;

                        case "maxpoolsize":
                            maxConnectionPoolSize = ParseInt32(name, value);
                            break;

                        case "minpoolsize":
                            minConnectionPoolSize = ParseInt32(name, value);
                            break;

                        case "replicaset":
                            this.replicaSetName = value;
                            this.connectionMode = ConnectionMode.ReplicaSet;
                            break;

                        case "safe":
                            safeModeChanged = true;
                            safe            = ParseBoolean(name, value);
                            break;

                        case "slaveok":
                            slaveOk = ParseBoolean(name, value);
                            break;

                        case "sockettimeout":
                        case "sockettimeoutms":
                            socketTimeout = ParseTimeSpan(name, value);
                            break;

                        case "w":
                            safeModeChanged = true;
                            safe            = true;
                            w = ParseInt32(name, value);
                            break;

                        case "waitqueuemultiple":
                            waitQueueMultiple = ParseDouble(name, value);
                            waitQueueSize     = 0;
                            break;

                        case "waitqueuesize":
                            waitQueueMultiple = 0;
                            waitQueueSize     = ParseInt32(name, value);
                            break;

                        case "waitqueuetimeout":
                        case "waitqueuetimeoutms":
                            waitQueueTimeout = ParseTimeSpan(name, value);
                            break;

                        case "wtimeout":
                        case "wtimeoutms":
                            safeModeChanged = true;
                            safe            = true;
                            wtimeout        = ParseTimeSpan(name, value);
                            break;
                        }
                    }

                    if (safeModeChanged)
                    {
                        this.safeMode = SafeMode.Create(safe, fsync, w, wtimeout);
                    }
                }
            }
            else
            {
                throw new FormatException(string.Format("Invalid connection string: {0}", url));
            }
        }
 /// <summary>
 /// Adds a user to this database.
 /// </summary>
 /// <param name="credentials">The user's credentials.</param>
 public virtual void AddUser(
     MongoCredentials credentials
     )
 {
     AddUser(credentials, false);
 }
 /// <summary>
 /// Compares this MongoCredentials to another MongoCredentials.
 /// </summary>
 /// <param name="rhs">The other credentials.</param>
 /// <returns>True if the two credentials are equal.</returns>
 public bool Equals(
     MongoCredentials rhs
     )
 {
     return(this == rhs);
 }
Exemple #39
0
 public virtual MongoDatabase this[string databaseName, MongoCredentials credentials, WriteConcern writeConcern]
 {
     get { return(GetDatabase(databaseName, credentials, writeConcern)); }
 }
Exemple #40
0
        /// <summary>
        /// Tests whether a database exists.
        /// </summary>
        /// <param name="databaseName">The name of the database.</param>
        /// <param name="adminCredentials">Credentials for the admin database.</param>
        /// <returns>True if the database exists.</returns>
        public virtual bool DatabaseExists(string databaseName, MongoCredentials adminCredentials)
        {
            var databaseNames = GetDatabaseNames(adminCredentials);

            return(databaseNames.Contains(databaseName));
        }
Exemple #41
0
 // constructors
 /// <summary>
 /// Creates a new instance of MongoUser.
 /// </summary>
 /// <param name="credentials">The user's credentials.</param>
 /// <param name="isReadOnly">Whether the user has read-only access.</param>
 public MongoUser(MongoCredentials credentials, bool isReadOnly)
 {
     _username     = credentials.Username;
     _passwordHash = HashPassword(credentials.Username, credentials.Password);
     _isReadOnly   = isReadOnly;
 }
Exemple #42
0
 /// <summary>
 /// Renames a collection on this database.
 /// </summary>
 /// <param name="oldCollectionName">The old name for the collection.</param>
 /// <param name="newCollectionName">The new name for the collection.</param>
 /// <param name="adminCredentials">Credentials for the admin database.</param>
 /// <returns>A CommandResult.</returns>
 public virtual CommandResult RenameCollection(string oldCollectionName, string newCollectionName, MongoCredentials adminCredentials)
 {
     return(RenameCollection(oldCollectionName, newCollectionName, false, adminCredentials)); // dropTarget = false
 }
Exemple #43
0
        /// <summary>
        /// Adds a user to this database.
        /// </summary>
        /// <param name="credentials">The user's credentials.</param>
        /// <param name="readOnly">True if the user is a read-only user.</param>
        public virtual void AddUser(MongoCredentials credentials, bool readOnly)
        {
            var user = new MongoUser(credentials, readOnly);

            AddUser(user);
        }
Exemple #44
0
 public virtual MongoDatabase this[string databaseName, MongoCredentials credentials]
 {
     get { return(GetDatabase(databaseName, credentials)); }
 }
Exemple #45
0
        /// <summary>
        /// Gets the last error (if any) that occurred on this connection. You MUST be within a RequestStart to call this method.
        /// </summary>
        /// <param name="adminCredentials">Credentials for the admin database.</param>
        /// <returns>The last error (<see cref=" GetLastErrorResult"/>)</returns>
        public virtual GetLastErrorResult GetLastError(MongoCredentials adminCredentials)
        {
            var adminDatabase = GetDatabase("admin", adminCredentials);

            return(adminDatabase.GetLastError());
        }