//=========================================================================
//
// AJAX ACTIONS
//
//=========================================================================
/// <summary>
/// Fetches the instance log by connecting to its mongod server.
/// This is fast and cheap, but won't work if the instance is down.
/// </summary>
public JsonResult GetServerLog(int id)
{
var server = ServerStatus.Get(id);
var urlBuilder = new MongoUrlBuilder();
urlBuilder.ConnectTimeout = new TimeSpan(0, 0, 3);
urlBuilder.Server = MongoServerAddress.Parse(server.Name);
urlBuilder.ReadPreference = ReadPreference.SecondaryPreferred;
var client = new MongoClient(urlBuilder.ToMongoUrl());
var conn = client.GetServer();
try
{
var command = new CommandDocument
{
{ "getLog", "global" }
};
var result = conn.GetDatabase("admin").RunCommand(command);
return Json(new { log = HtmlizeFromLogArray(result.
Response["log"].AsBsonArray) },
JsonRequestBehavior.AllowGet);
}
catch (MongoException e)
{
return Json(new { error = e.Message },
JsonRequestBehavior.AllowGet);
}
}
public virtual IPersistStreams Build()
{
var connectionString = this.TransformConnectionString(this.GetConnectionString());
var builder = new MongoUrlBuilder(connectionString);
var database = (new MongoClient(connectionString)).GetServer().GetDatabase(builder.DatabaseName);
return new MongoPersistenceEngine(database, this.serializer);
}
public TokuMXDatabase()
{
Name = "TokuMX";
CollectionName = "collection";
Category = "NoSQL\\Document Store";
Description = "TokuMX v2.0";
Website = "http://www.tokutek.com/tokumx-for-mongodb/";
Color = Color.Chartreuse;
Requirements = new string[]
{
"MongoDB.Bson.dll",
"MongoDB.Driver.dll",
"MongoDB.Driver.Core.dll",
"MongoDB.Driver.Legacy.dll"
};
MongoUrlBuilder builder = new MongoUrlBuilder();
builder.MaxConnectionIdleTime = TimeSpan.FromHours(1);
builder.MaxConnectionLifeTime = TimeSpan.FromHours(1);
builder.Server = new MongoServerAddress("localhost");
builder.W = 1;
ConnectionString = builder.ToString();
InsertsPerQuery = 5000;
}
public void TestDefaults() {
var builder = new MongoUrlBuilder();
Assert.AreEqual(MongoDefaults.ComputedWaitQueueSize, builder.ComputedWaitQueueSize);
Assert.AreEqual(ConnectionMode.Direct, builder.ConnectionMode);
Assert.AreEqual(MongoDefaults.ConnectTimeout, builder.ConnectTimeout);
Assert.AreEqual(null, builder.DatabaseName);
Assert.AreEqual(null, builder.DefaultCredentials);
Assert.AreEqual(false, builder.IPv6);
Assert.AreEqual(MongoDefaults.MaxConnectionIdleTime, builder.MaxConnectionIdleTime);
Assert.AreEqual(MongoDefaults.MaxConnectionLifeTime, builder.MaxConnectionLifeTime);
Assert.AreEqual(MongoDefaults.MaxConnectionPoolSize, builder.MaxConnectionPoolSize);
Assert.AreEqual(MongoDefaults.MinConnectionPoolSize, builder.MinConnectionPoolSize);
Assert.AreEqual(null, builder.ReplicaSetName);
Assert.AreEqual(null, builder.SafeMode);
Assert.AreEqual(null, builder.Server);
Assert.AreEqual(null, builder.Servers);
Assert.AreEqual(false, builder.SlaveOk);
Assert.AreEqual(MongoDefaults.SocketTimeout, builder.SocketTimeout);
Assert.AreEqual(MongoDefaults.WaitQueueMultiple, builder.WaitQueueMultiple);
Assert.AreEqual(MongoDefaults.WaitQueueSize, builder.WaitQueueSize);
Assert.AreEqual(MongoDefaults.WaitQueueTimeout, builder.WaitQueueTimeout);
var connectionString = "mongodb://";
Assert.AreEqual(connectionString, builder.ToString());
}
public void TestConnectTimeout()
{
var connectionString = "mongodb://localhost/?connectTimeout=123ms";
var builder = new MongoUrlBuilder("mongodb://localhost") { ConnectTimeout = TimeSpan.FromMilliseconds(123) };
Assert.AreEqual(TimeSpan.FromMilliseconds(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
connectionString = "mongodb://localhost/?connectTimeout=123s";
builder = new MongoUrlBuilder("mongodb://localhost") { ConnectTimeout = TimeSpan.FromSeconds(123) };
Assert.AreEqual(TimeSpan.FromSeconds(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
connectionString = "mongodb://localhost/?connectTimeout=123m";
builder = new MongoUrlBuilder("mongodb://localhost") { ConnectTimeout = TimeSpan.FromMinutes(123) };
Assert.AreEqual(TimeSpan.FromMinutes(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
connectionString = "mongodb://localhost/?connectTimeout=123h";
builder = new MongoUrlBuilder("mongodb://localhost") { ConnectTimeout = TimeSpan.FromHours(123) };
Assert.AreEqual(TimeSpan.FromHours(123), builder.ConnectTimeout);
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
}
public MongoDBDatabase()
{
Name = "MongoDB";
CollectionName = "collection";
Category = "NoSQL\\Document Store";
Description = "MongoDB C# Driver 2.0.0beta";
Website = "http://www.mongodb.org/";
Color = Color.FromArgb(235, 215, 151);
Requirements = new string[]
{
"MongoDB.Bson.dll",
"MongoDB.Driver.dll",
"MongoDB.Driver.Core.dll",
"MongoDB.Driver.Legacy.dll"
};
MongoUrlBuilder builder = new MongoUrlBuilder();
builder.MaxConnectionIdleTime = TimeSpan.FromHours(1);
builder.MaxConnectionLifeTime = TimeSpan.FromHours(1);
builder.Server = new MongoServerAddress("localhost");
builder.W = 1;
ConnectionString = builder.ToString();
InsertsPerQuery = 5000;
}
public static void Initalize(TestContext testContext)
{
XmlConfigurator.Configure();
// we have to start mongo DB
DirectoryInfo mongoDbDir = GetMongoDbDir(testContext);
var mongodbexe = mongoDbDir.GetFiles("mongod.exe").Single();
DirectoryInfo testCtxDirectory = new DirectoryInfo(testContext.TestDir);
DirectoryInfo dataDbDir = testCtxDirectory.CreateSubdirectory(new Config().GetAppSetting<string>(CommonTestStrings.MongodbDir));
string connectionString = new Config().GetConnectionString(CommonStrings.Database.ConnectionStringName).ConnectionString;
MongoUrlBuilder mub = new MongoUrlBuilder(connectionString);
string args = string.Format(@"--dbpath ""{0}"" --port {1}", dataDbDir.FullName, mub.Server.Port);
var psi = new ProcessStartInfo {
FileName = mongodbexe.FullName,
WorkingDirectory = testCtxDirectory.FullName,
Arguments = args,
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true
};
mongoDbProcess = Process.Start(psi);
}
private void InitiateDatabase()
{
var connectionString = ConfigurationManager.ConnectionStrings["Mongo.ConnectionString"].ConnectionString;
var mongoUrlBuilder = new MongoUrlBuilder(connectionString);
mongoClient = new MongoClient(mongoUrlBuilder.ToMongoUrl());
Database = mongoClient.GetDatabase(mongoUrlBuilder.DatabaseName);
}
public void TestDefaults()
{
var builder = new MongoUrlBuilder();
Assert.AreEqual(null, builder.DefaultCredentials);
Assert.AreEqual(null, builder.Server);
Assert.AreEqual(null, builder.Servers);
Assert.AreEqual(null, builder.DatabaseName);
Assert.AreEqual(ConnectionMode.Automatic, builder.ConnectionMode);
Assert.AreEqual(MongoDefaults.ConnectTimeout, builder.ConnectTimeout);
Assert.AreEqual(MongoDefaults.GuidRepresentation, builder.GuidRepresentation);
Assert.AreEqual(false, builder.IPv6);
Assert.AreEqual(MongoDefaults.MaxConnectionIdleTime, builder.MaxConnectionIdleTime);
Assert.AreEqual(MongoDefaults.MaxConnectionLifeTime, builder.MaxConnectionLifeTime);
Assert.AreEqual(MongoDefaults.MaxConnectionPoolSize, builder.MaxConnectionPoolSize);
Assert.AreEqual(MongoDefaults.MinConnectionPoolSize, builder.MinConnectionPoolSize);
Assert.AreEqual(null, builder.ReadPreference);
Assert.AreEqual(null, builder.ReplicaSetName);
Assert.AreEqual(null, builder.SafeMode);
#pragma warning disable 618
Assert.AreEqual(false, builder.SlaveOk);
#pragma warning restore
Assert.AreEqual(MongoDefaults.SocketTimeout, builder.SocketTimeout);
Assert.AreEqual(MongoDefaults.WaitQueueMultiple, builder.WaitQueueMultiple);
Assert.AreEqual(MongoDefaults.WaitQueueSize, builder.WaitQueueSize);
Assert.AreEqual(MongoDefaults.WaitQueueTimeout, builder.WaitQueueTimeout);
Assert.AreEqual(MongoDefaults.ComputedWaitQueueSize, builder.ComputedWaitQueueSize);
var connectionString = "mongodb://"; // not actually a valid connection string because it's missing the host
Assert.AreEqual(connectionString, builder.ToString());
}
private static string MangoDBSetDatabaseNameRandom(string connectionString)
{
var urlBuilder = new MongoUrlBuilder(connectionString)
{
DatabaseName = "brCounterTest_" + Guid.NewGuid().ToString("N")
};
return urlBuilder.ToString();
}
/// <summary>
/// Gets the database connection string.
/// </summary>
/// <param name="config">The config.</param>
/// <returns></returns>
internal static string GetDatabaseConnectionString(NameValueCollection config)
{
string connectionString = GetConnectionString(config);
var builder = new MongoUrlBuilder(connectionString);
builder.DatabaseName = GetDatabaseName(connectionString, config);
return builder.ToString();
}
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;
}
public void MongoUriConstructor()
{
var uriBuilder = new MongoUrlBuilder("mongodb://*****:*****@localhost/myDatabase");
IMongoDatabaseFactory mongoDbFactory = new SimpleMongoDatabaseFactory(uriBuilder.ToMongoUrl());
Assert.That(ReflectionUtils.GetInstanceFieldValue(mongoDbFactory, "_credentials"), Is.EqualTo(new MongoCredentials("myUsername", "myPassword")));
Assert.That(ReflectionUtils.GetInstanceFieldValue(mongoDbFactory, "_databaseName").ToString(), Is.EqualTo("myDatabase"));
}
public MongoContentTypeRegistry(string connectionString, string collectionName)
{
var builder = new MongoUrlBuilder(connectionString);
this.collectionName = collectionName;
databaseName = builder.DatabaseName;
mongoServer = MongoServer.Create(connectionString);
DropContentTypesCollection();
}
public MongoEventStore(string connectionString, ITypeCatalog typeCatalog)
{
_eventHashRef = new Dictionary<string, string>();
typeCatalog.GetDerivedTypes(typeof(DomainEvent)).ToList().
ForEach(x => BsonClassMap.RegisterClassMap(new DomainEventMapper(x, _eventHashRef)));
var connection = new MongoUrlBuilder(connectionString);
_collection = MongoServer.Create(connection.ToMongoUrl()).GetDatabase(connection.DatabaseName).GetCollection<DomainEvent>("events");
}
public static CountersDatabase Connect(string mongoUrl)
{
MongoUrlBuilder builder = new MongoUrlBuilder(mongoUrl);
builder.SocketTimeout = new TimeSpan(0, 30, 0);
//builder.Server = port.HasValue ? new MongoServerAddress(host, port.Value) : new MongoServerAddress(host);
MongoServer server = MongoServer.Create(builder.ToServerSettings());
server.Connect();
MongoDatabase db = server.GetDatabase(builder.DatabaseName);
return new CountersDatabase(server, db);
}
/// <summary>
/// Creates a new instance of MongoUrl.
/// </summary>
/// <param name="url">The URL containing the settings.</param>
public MongoUrl(
string url
) {
var builder = new MongoUrlBuilder(url); // parses url
serverSettings = builder.ToServerSettings().FrozenCopy();
this.waitQueueMultiple = builder.WaitQueueMultiple;
this.waitQueueSize = builder.WaitQueueSize;
this.databaseName = builder.DatabaseName;
this.url = builder.ToString(); // keep canonical form
}
public BookContext()
{
string connectionString = ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString;
var con = new MongoUrlBuilder(connectionString);
client = new MongoClient(connectionString);
database = client.GetDatabase(con.DatabaseName);
gridFS = new MongoGridFS(new MongoServer(new MongoServerSettings { Server = con.Server }),con.DatabaseName, new MongoGridFSSettings());
}
private static MongoDatabase GetDatabase()
{
var testDbConnStrBuilder = new MongoUrlBuilder("mongodb://localhost/Guid-vs-ObjectId?safe=true");
var connectionString = testDbConnStrBuilder.ToMongoUrl();
var client = new MongoClient(connectionString);
var mongoDatabase = client.GetServer().GetDatabase(connectionString.DatabaseName);
mongoDatabase.SetProfilingLevel(ProfilingLevel.All);
return mongoDatabase;
}
public MongoContentTreeProvider(string connectionString, string collectionName, Uri invalidateCacheUri)
{
ContentChanged += (sender, e) => { };
var builder = new MongoUrlBuilder(connectionString);
this.collectionName = collectionName;
databaseName = builder.DatabaseName;
mongoServer = MongoServer.Create(connectionString);
cacheEndpoint = new InvalidateCacheEndpoint(invalidateCacheUri);
cacheEndpoint.CacheInvalidated += InvalidateCache;
cacheEndpoint.Open();
}
/// <summary>
/// Creates a new instance of MongoUrl.
/// </summary>
/// <param name="url">The URL containing the settings.</param>
public MongoUrl(
string url
)
{
var builder = new MongoUrlBuilder(url); // parses url
serverSettings = builder.ToServerSettings().Freeze();
this.waitQueueMultiple = builder.WaitQueueMultiple;
this.waitQueueSize = builder.WaitQueueSize;
this.databaseName = builder.DatabaseName;
this.url = builder.ToString(); // keep canonical form
}
static MongoHelper()
{
if (Configuration.ConnectionString.StartsWith("mongodb://"))
{
IsConnectionUrl = true;
ConnectionUrl = new MongoUrlBuilder(Configuration.ConnectionString);
}
else
{
ConnectionString = new MongoConnectionStringBuilder(Configuration.ConnectionString);
}
}
public void TestHostWithPort() {
var builder = new MongoUrlBuilder() { Server = new MongoServerAddress("mongo.xyz.com", 12345) };
Assert.AreEqual(1, builder.Servers.Count());
Assert.AreEqual("mongo.xyz.com", builder.Server.Host);
Assert.AreEqual(12345, builder.Server.Port);
Assert.AreEqual(ConnectionMode.Direct, builder.ConnectionMode);
Assert.AreEqual(null, builder.ReplicaSetName);
var connectionString = "mongodb://mongo.xyz.com:12345";
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
}
static void Main(string[] args)
{
//new Mongo().RunInsert();
var mongoUrl = new MongoUrlBuilder();
mongoUrl.Server = new MongoServerAddress("localhost", 27071);
MongoUrl mongoUrl1 = null;
var crudTest = new Crud("test", mongoUrl1);
crudTest.Init().Wait();
crudTest.Create(1000).Wait();
crudTest.Read(1000).Wait();
//crudTest.OneStepDelete(1000).Wait();
}
public void Init()
{
var connectionString = ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString;
var connectionStringBuilder = new MongoUrlBuilder(connectionString);
var mongoClient = new MongoClient(connectionStringBuilder.ToMongoUrl());
_server = mongoClient.GetServer();
var dbName = connectionStringBuilder.DatabaseName;
_db = _server.GetDatabase(dbName);
}
public void Test_GetLatestPackageByName_1Package()
{
string connectionString = new Config().GetConnectionString(CommonStrings.Database.ConnectionStringName).ConnectionString;
MongoUrlBuilder mub = new MongoUrlBuilder(connectionString);
MongoPackageRepository repo = new MongoPackageRepository(connectionString);
repo.Reset();
Package package = RandomDataHelper.Instance.CreateRandomePackage();
repo.AddPackage(package);
Package latestPackage = repo.GetLatestPackageByName(package.Name);
CustomAssert.AreEqual(package, latestPackage);
}
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;
}
public void Test_DynamicTypedFields()
{
var connectionString = ConfigurationManager.ConnectionStrings["MongoDB"].ConnectionString;
var server = MongoServer.Create(connectionString);
var connectionStringBuilder = new MongoUrlBuilder(connectionString);
var dbName = connectionStringBuilder.DatabaseName;
var loggerName = "testDynamicTypedFields";
var db = server.GetDatabase(dbName);
var collection = db.GetCollection(loggerName);
collection.RemoveAll();
var logger = LogManager.GetLogger(loggerName);
var logEventTime = DateTime.UtcNow;
var logEvent = new LogEventInfo
{
TimeStamp = logEventTime,
LoggerName = loggerName,
Level = LogLevel.Error,
Message = "Test Log Message",
Exception = new Exception("Test Exception", new Exception("Inner Exception"))
};
logEvent.Properties.Add("transactionId", 1);
logger.Log(logEvent);
Thread.Sleep(2000);
collection.FindAll().Count().Should().Be(1);
var logEntry = collection.FindAll().First();
Assert.IsTrue(logEntry.Contains("_id"));
Assert.AreEqual(logEventTime.Date, logEntry["timestamp"].AsDateTime.Date);
logEntry["level"].Should().Be(LogLevel.Error.ToString());
logEntry["message"].Should().Be("Test Log Message");
var exception = logEntry["exception"].AsBsonDocument;
Assert.AreEqual("Test Exception", exception["message"].AsString);
var innerException = exception["innerException"].AsBsonDocument;
Assert.AreEqual("Inner Exception", innerException["message"].AsString);
Assert.AreEqual(1, logEntry["transactionId"].AsInt32);
db.DropCollection(loggerName);
server.Disconnect();
}
public void TestHostWithPort()
{
var builder = new MongoUrlBuilder() { Server = new MongoServerAddress("mongo.xyz.com", 12345) };
Assert.AreEqual(null, builder.DefaultCredentials);
Assert.AreEqual(1, builder.Servers.Count());
Assert.AreEqual("mongo.xyz.com", builder.Server.Host);
Assert.AreEqual(12345, builder.Server.Port);
Assert.AreEqual(null, builder.DatabaseName);
Assert.AreEqual(ConnectionMode.Automatic, builder.ConnectionMode);
var connectionString = "mongodb://mongo.xyz.com:12345";
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
}
public void TestConnectionMode()
{
var connectionString = "mongodb://localhost";
var builder = new MongoUrlBuilder("mongodb://localhost") { ConnectionMode = ConnectionMode.Direct };
Assert.AreEqual(ConnectionMode.Direct, builder.ConnectionMode);
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
connectionString = "mongodb://localhost/?connect=replicaSet";
builder = new MongoUrlBuilder("mongodb://localhost") { ConnectionMode = ConnectionMode.ReplicaSet };
Assert.AreEqual(ConnectionMode.ReplicaSet, builder.ConnectionMode);
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
}
public void TestTwoHosts() {
var builder = new MongoUrlBuilder() { Servers = new[] { new MongoServerAddress("mongo1.xyz.com"), new MongoServerAddress("mongo2.xyz.com") } };
var servers = builder.Servers.ToArray();
Assert.AreEqual(2, servers.Length);
Assert.AreEqual("mongo1.xyz.com", servers[0].Host);
Assert.AreEqual(27017, servers[0].Port);
Assert.AreEqual("mongo2.xyz.com", servers[1].Host);
Assert.AreEqual(27017, servers[1].Port);
Assert.AreEqual(ConnectionMode.ReplicaSet, builder.ConnectionMode);
Assert.AreEqual(null, builder.ReplicaSetName);
var connectionString = "mongodb://mongo1.xyz.com,mongo2.xyz.com";
Assert.AreEqual(connectionString, builder.ToString());
Assert.AreEqual(connectionString, new MongoUrlBuilder(connectionString).ToString());
}
/// <summary>
/// Resolves a connection string. If the connection string indicates more information is available
/// in the DNS system, it will acquire that information as well.
/// </summary>
/// <param name="resolveHosts">Whether to resolve hosts.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A resolved MongoURL.</returns>
public MongoUrl Resolve(bool resolveHosts, CancellationToken cancellationToken = default(CancellationToken))
{
if (_isResolved)
{
return(this);
}
var connectionString = new ConnectionString(_originalUrl);
var resolved = connectionString.Resolve(resolveHosts, cancellationToken);
var mongoUrlBuilder = new MongoUrlBuilder(resolved);
return(new MongoUrl(mongoUrlBuilder));
}
/// <summary>
/// Resolves a connection string. If the connection string indicates more information is available
/// in the DNS system, it will acquire that information as well.
/// </summary>
/// <param name="resolveHosts">Whether to resolve hosts.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A resolved MongoURL.</returns>
public async Task <MongoUrl> ResolveAsync(bool resolveHosts, CancellationToken cancellationToken = default(CancellationToken))
{
if (_isResolved)
{
return(this);
}
var connectionString = new ConnectionString(_originalUrl);
var resolved = await connectionString.ResolveAsync(resolveHosts, cancellationToken).ConfigureAwait(false);
var mongoUrlBuilder = new MongoUrlBuilder(resolved);
return(new MongoUrl(mongoUrlBuilder));
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrl.
/// </summary>
/// <param name="url">The URL containing the settings.</param>
public MongoUrl(string url)
{
_originalUrl = url;
var builder = new MongoUrlBuilder(url); // parses url
_applicationName = builder.ApplicationName;
_authenticationMechanism = builder.AuthenticationMechanism;
_authenticationMechanismProperties = builder.AuthenticationMechanismProperties;
_authenticationSource = builder.AuthenticationSource;
_connectionMode = builder.ConnectionMode;
_connectTimeout = builder.ConnectTimeout;
_databaseName = builder.DatabaseName;
_fsync = builder.FSync;
_guidRepresentation = builder.GuidRepresentation;
_heartbeatInterval = builder.HeartbeatInterval;
_heartbeatTimeout = builder.HeartbeatTimeout;
_ipv6 = builder.IPv6;
_isResolved = builder.Scheme != ConnectionStringScheme.MongoDBPlusSrv;
_journal = builder.Journal;
_localThreshold = builder.LocalThreshold;
_maxConnectionIdleTime = builder.MaxConnectionIdleTime;
_maxConnectionLifeTime = builder.MaxConnectionLifeTime;
_maxConnectionPoolSize = builder.MaxConnectionPoolSize;
_minConnectionPoolSize = builder.MinConnectionPoolSize;
_password = builder.Password;
_readConcernLevel = builder.ReadConcernLevel;
_readPreference = builder.ReadPreference;
_replicaSetName = builder.ReplicaSetName;
_retryReads = builder.RetryReads;
_retryWrites = builder.RetryWrites;
_scheme = builder.Scheme;
_servers = builder.Servers;
_serverSelectionTimeout = builder.ServerSelectionTimeout;
_socketTimeout = builder.SocketTimeout;
_username = builder.Username;
_useSsl = builder.UseSsl;
_verifySslCertificate = builder.VerifySslCertificate;
_w = builder.W;
_waitQueueMultiple = builder.WaitQueueMultiple;
_waitQueueSize = builder.WaitQueueSize;
_waitQueueTimeout = builder.WaitQueueTimeout;
_wTimeout = builder.WTimeout;
_url = builder.ToString(); // keep canonical form
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrl.
/// </summary>
/// <param name="url">The URL containing the settings.</param>
public MongoUrl(string url)
{
var builder = new MongoUrlBuilder(url); // parses url
_authenticationMechanism = builder.AuthenticationMechanism;
_authenticationSource = builder.AuthenticationSource;
_connectionMode = builder.ConnectionMode;
_connectTimeout = builder.ConnectTimeout;
_databaseName = builder.DatabaseName;
_fsync = builder.FSync;
_gssapiServiceName = builder.GssapiServiceName;
_guidRepresentation = builder.GuidRepresentation;
_ipv6 = builder.IPv6;
_journal = builder.Journal;
_maxConnectionIdleTime = builder.MaxConnectionIdleTime;
_maxConnectionLifeTime = builder.MaxConnectionLifeTime;
_maxConnectionPoolSize = builder.MaxConnectionPoolSize;
_minConnectionPoolSize = builder.MinConnectionPoolSize;
_password = builder.Password;
_readPreference = builder.ReadPreference;
_replicaSetName = builder.ReplicaSetName;
_secondaryAcceptableLatency = builder.SecondaryAcceptableLatency;
_servers = builder.Servers;
#pragma warning disable 618
_slaveOk = builder.SlaveOk;
#pragma warning restore
_socketTimeout = builder.SocketTimeout;
_username = builder.Username;
_useSsl = builder.UseSsl;
_verifySslCertificate = builder.VerifySslCertificate;
_w = builder.W;
_waitQueueMultiple = builder.WaitQueueMultiple;
_waitQueueSize = builder.WaitQueueSize;
_waitQueueTimeout = builder.WaitQueueTimeout;
_wTimeout = builder.WTimeout;
_url = builder.ToString(); // keep canonical form
}
/// <summary>
/// Builds the connection string for MongoDB.
/// </summary>
/// <param name="login">The login.</param>
/// <param name="password">The password.</param>
/// <param name="safeMode">The safe mode. True to receive write confirmation from mongo.</param>
/// <param name="readOnSecondary">The read on secondary. True to direct read operations to cluster secondary nodes (secondaryPreferred), else try to read from primary (primaryPreferred).</param>
/// <param name="addresses">List of addresses. Format: host1[:port1][,host2[:port2],...[,hostN[:portN]]]</param>
/// <param name="connectionTimeoutMilliseconds">The time to attempt a connection before timing out.</param>
/// <param name="socketTimeoutMilliseconds">The time to attempt a send or receive on a socket before the attempt times out.</param>
/// <param name="databaseName">Database name required to authenticate against a specific database [optional].</param>
/// <param name="readPreferenceTags">The read preference tags. List of a comma-separated list of colon-separated key-value pairs. Ex.: { {dc:ny,rack:1}, { dc:ny } } </param>
public static string BuildConnectionString(string login, string password, bool safeMode, bool readOnSecondary, string addresses, int connectionTimeoutMilliseconds, int socketTimeoutMilliseconds, string databaseName = null, IEnumerable <string> readPreferenceTags = null)
{
var cb = new MongoDB.Driver.MongoUrlBuilder("mongodb://" + addresses.Replace("mongodb://", ""));
cb.Username = login;
cb.Password = password;
cb.ConnectionMode = MongoDB.Driver.ConnectionMode.Automatic;
cb.DatabaseName = databaseName;
cb.W = safeMode ? WriteConcern.W1.W : WriteConcern.Unacknowledged.W;
if (connectionTimeoutMilliseconds < 15000)
{
connectionTimeoutMilliseconds = 15000;
}
if (socketTimeoutMilliseconds < 15000)
{
socketTimeoutMilliseconds = 15000;
}
cb.ConnectTimeout = TimeSpan.FromMilliseconds(connectionTimeoutMilliseconds);
cb.SocketTimeout = TimeSpan.FromMilliseconds(socketTimeoutMilliseconds);
cb.MaxConnectionIdleTime = TimeSpan.FromSeconds(30);
cb.ReadPreference = new ReadPreference();
cb.ReadPreference.ReadPreferenceMode = readOnSecondary ? ReadPreferenceMode.SecondaryPreferred : ReadPreferenceMode.PrimaryPreferred;
if (readPreferenceTags != null)
{
foreach (var tag in readPreferenceTags.Where(i => i != null && i.IndexOf(':') > 0).Select(i => i.Split(':')).Select(i => new ReplicaSetTag(i[0], i[1])))
{
cb.ReadPreference.AddTagSet(new ReplicaSetTagSet().Add(tag));
}
}
// generate final connection string
return(cb.ToString());
}
internal MongoUrl(MongoUrlBuilder builder)
{
_allowInsecureTls = builder.AllowInsecureTls;
_applicationName = builder.ApplicationName;
_authenticationMechanism = builder.AuthenticationMechanism;
_authenticationMechanismProperties = builder.AuthenticationMechanismProperties;
_authenticationSource = builder.AuthenticationSource;
_compressors = builder.Compressors;
#pragma warning disable CS0618 // Type or member is obsolete
if (builder.ConnectionModeSwitch == ConnectionModeSwitch.UseConnectionMode)
{
_connectionMode = builder.ConnectionMode;
}
_connectionModeSwitch = builder.ConnectionModeSwitch;
#pragma warning restore CS0618 // Type or member is obsolete
_connectTimeout = builder.ConnectTimeout;
_databaseName = builder.DatabaseName;
#pragma warning disable CS0618 // Type or member is obsolete
if (builder.ConnectionModeSwitch == ConnectionModeSwitch.UseDirectConnection)
{
_directConnection = builder.DirectConnection;
}
#pragma warning restore CS0618 // Type or member is obsolete
_fsync = builder.FSync;
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
_guidRepresentation = builder.GuidRepresentation;
}
#pragma warning restore 618
_heartbeatInterval = builder.HeartbeatInterval;
_heartbeatTimeout = builder.HeartbeatTimeout;
_ipv6 = builder.IPv6;
_isResolved = builder.Scheme != ConnectionStringScheme.MongoDBPlusSrv;
_journal = builder.Journal;
_loadBalanced = builder.LoadBalanced;
_localThreshold = builder.LocalThreshold;
_maxConnecting = builder.MaxConnecting;
_maxConnectionIdleTime = builder.MaxConnectionIdleTime;
_maxConnectionLifeTime = builder.MaxConnectionLifeTime;
_maxConnectionPoolSize = builder.MaxConnectionPoolSize;
_minConnectionPoolSize = builder.MinConnectionPoolSize;
_password = builder.Password;
_readConcernLevel = builder.ReadConcernLevel;
_readPreference = builder.ReadPreference;
_replicaSetName = builder.ReplicaSetName;
_retryReads = builder.RetryReads;
_retryWrites = builder.RetryWrites;
_scheme = builder.Scheme;
_servers = builder.Servers;
_serverSelectionTimeout = builder.ServerSelectionTimeout;
_socketTimeout = builder.SocketTimeout;
_srvMaxHosts = builder.SrvMaxHosts;
_tlsDisableCertificateRevocationCheck = builder.TlsDisableCertificateRevocationCheck;
_username = builder.Username;
_useTls = builder.UseTls;
_w = builder.W;
#pragma warning disable 618
_waitQueueMultiple = builder.WaitQueueMultiple;
_waitQueueSize = builder.WaitQueueSize;
#pragma warning restore 618
_waitQueueTimeout = builder.WaitQueueTimeout;
_wTimeout = builder.WTimeout;
_url = builder.ToString(); // keep canonical form
}
