public void Run(int numConcurrentWorkers, Action<ClusterBuilder> configurator)
{
var settings = new MongoClientSettings();
settings.ClusterConfigurator = configurator;
var client = new MongoClient(settings);
#pragma warning disable 618
var server = client.GetServer();
#pragma warning restore 618
var db = server.GetDatabase("foo");
var collection = db.GetCollection<BsonDocument>("bar");
Console.WriteLine("Press Enter to begin");
Console.ReadLine();
Console.WriteLine("Clearing Data");
ClearData(collection);
Console.WriteLine("Inserting Seed Data");
InsertData(collection);
Console.WriteLine("Running CRUD (errors will show up as + (query error) or * (insert/update error))");
for (int i = 0; i < numConcurrentWorkers; i++)
{
ThreadPool.QueueUserWorkItem(_ => DoWork(collection));
}
Console.WriteLine("Press Enter to shutdown");
Console.ReadLine();
_cancellationTokenSource.Cancel();
Console.WriteLine("Press Enter to exit");
Console.ReadLine();
}
public async Task RunAsync(int numConcurrentWorkers, Action<ClusterBuilder> configurator)
{
var settings = new MongoClientSettings();
settings.ClusterConfigurator = configurator;
var client = new MongoClient(settings);
var db = client.GetDatabase("foo");
var collection = db.GetCollection<BsonDocument>("bar");
Console.WriteLine("Press Enter to begin");
Console.ReadLine();
Console.WriteLine("Clearing Data");
await ClearData(collection);
Console.WriteLine("Inserting Seed Data");
await InsertData(collection);
Console.WriteLine("Running CRUD (errors will show up as + (query error) or * (insert/update error))");
var tasks = new List<Task>();
for (int i = 0; i < numConcurrentWorkers; i++)
{
tasks.Add(DoWork(collection));
}
Console.WriteLine("Press Enter to shutdown");
Console.ReadLine();
_cancellationTokenSource.Cancel();
Task.WaitAll(tasks.ToArray());
}
public void TestApplicationName_too_long()
{
var subject = new MongoClientSettings();
var value = new string('x', 129);
var exception = Record.Exception(() => subject.ApplicationName = value);
var argumentException = exception.Should().BeOfType<ArgumentException>().Subject;
argumentException.ParamName.Should().Be("value");
}
public void TestApplicationName()
{
var settings = new MongoClientSettings();
Assert.Equal(null, settings.ApplicationName);
var applicationName = "app";
settings.ApplicationName = applicationName;
Assert.Equal(applicationName, settings.ApplicationName);
settings.Freeze();
Assert.Equal(applicationName, settings.ApplicationName);
Assert.Throws<InvalidOperationException>(() => { settings.ApplicationName = applicationName; });
}
public void TestConnectionMode()
{
var settings = new MongoClientSettings();
Assert.AreEqual(ConnectionMode.Automatic, settings.ConnectionMode);
var connectionMode = ConnectionMode.Direct;
settings.ConnectionMode = connectionMode;
Assert.AreEqual(connectionMode, settings.ConnectionMode);
settings.Freeze();
Assert.AreEqual(connectionMode, settings.ConnectionMode);
Assert.Throws<InvalidOperationException>(() => { settings.ConnectionMode = connectionMode; });
}
public void TestConnectTimeout()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.ConnectTimeout, settings.ConnectTimeout);
var connectTimeout = new TimeSpan(1, 2, 3);
settings.ConnectTimeout = connectTimeout;
Assert.AreEqual(connectTimeout, settings.ConnectTimeout);
settings.Freeze();
Assert.AreEqual(connectTimeout, settings.ConnectTimeout);
Assert.Throws<InvalidOperationException>(() => { settings.ConnectTimeout = connectTimeout; });
}
public void TestFixtureSetUp()
{
__capturedEvents = new EventCapturer()
.Capture<CommandStartedEvent>()
.Capture<CommandSucceededEvent>()
.Capture<CommandFailedEvent>();
var settings = new MongoClientSettings
{
ClusterConfigurator = cb =>
{
cb.Subscribe(__capturedEvents);
// never heartbeat...
cb.ConfigureServer(ss => ss.With(heartbeatInterval: Timeout.InfiniteTimeSpan));
}
};
__client = new MongoClient(settings);
}
// constructors
public ClusterKey(MongoClientSettings clientSettings)
{
_connectionMode = clientSettings.ConnectionMode;
_connectTimeout = clientSettings.ConnectTimeout;
_credentials = clientSettings.Credentials.ToList();
_heartbeatInterval = __defaultHeartbeatInterval; // TODO: add HeartbeatInterval to MongoClientSettings?
_heartbeatTimeout = __defaultHeartbeatTimeout; // TODO: add HeartbeatTimeout to MongoClientSettings?
_ipv6 = clientSettings.IPv6;
_maxConnectionIdleTime = clientSettings.MaxConnectionIdleTime;
_maxConnectionLifeTime = clientSettings.MaxConnectionLifeTime;
_maxConnectionPoolSize = clientSettings.MaxConnectionPoolSize;
_minConnectionPoolSize = clientSettings.MinConnectionPoolSize;
_receiveBufferSize = __defaultReceiveBufferSize; // TODO: add ReceiveBufferSize to MongoClientSettings?
_replicaSetName = clientSettings.ReplicaSetName;
_sendBufferSize = __defaultSendBufferSize; // TODO: add SendBufferSize to MongoClientSettings?
_servers = clientSettings.Servers.ToList();
_socketTimeout = clientSettings.SocketTimeout;
_sslSettings = clientSettings.SslSettings;
_useSsl = clientSettings.UseSsl;
_verifySslCertificate = clientSettings.VerifySslCertificate;
_waitQueueSize = clientSettings.WaitQueueSize;
_waitQueueTimeout = clientSettings.WaitQueueTimeout;
_hashCode = CalculateHashCode();
}
public void TestServerSelectionTimeout()
{
var settings = new MongoClientSettings();
Assert.Equal(MongoDefaults.ServerSelectionTimeout, settings.ServerSelectionTimeout);
var serverSelectionTimeout = new TimeSpan(1, 2, 3);
settings.ServerSelectionTimeout = serverSelectionTimeout;
Assert.Equal(serverSelectionTimeout, settings.ServerSelectionTimeout);
settings.Freeze();
Assert.Equal(serverSelectionTimeout, settings.ServerSelectionTimeout);
Assert.Throws<InvalidOperationException>(() => { settings.ServerSelectionTimeout = serverSelectionTimeout; });
}
public static IHostBuilder CreateHostBuilder(string[] args) =>
Host.CreateDefaultBuilder(args)
.UseNServiceBus(hostBuilderContext =>
{
var endpointConfiguration = new EndpointConfiguration(EndpointName);
endpointConfiguration.UseSerialization <SystemJsonSerializer>();
var transport = endpointConfiguration.UseTransport <RabbitMQTransport>();
transport.ConnectionString("host=localhost");
transport.UseConventionalRoutingTopology();
endpointConfiguration.UsePersistence <LearningPersistence>();
endpointConfiguration.EnableInstallers();
endpointConfiguration.AuditProcessedMessagesTo("NsbActivities.Audit");
endpointConfiguration.PurgeOnStartup(true);
var recoverability = endpointConfiguration.Recoverability();
recoverability.Immediate(i => i.NumberOfRetries(1));
recoverability.Delayed(i => i.NumberOfRetries(0));
var settings = endpointConfiguration.GetSettings();
settings.Set(new NServiceBus.Extensions.Diagnostics.InstrumentationOptions
{
CaptureMessageBody = true
});
// configure endpoint here
return(endpointConfiguration);
})
.ConfigureServices(services =>
{
var runner = MongoDbRunner.Start(singleNodeReplSet: true, singleNodeReplSetWaitTimeout: 20);
services.AddSingleton(runner);
var urlBuilder = new MongoUrlBuilder(runner.ConnectionString)
{
DatabaseName = "dev"
};
var mongoUrl = urlBuilder.ToMongoUrl();
var mongoClientSettings = MongoClientSettings.FromUrl(mongoUrl);
mongoClientSettings.ClusterConfigurator = cb => cb.Subscribe(new DiagnosticsActivityEventSubscriber(new InstrumentationOptions {
CaptureCommandText = true
}));
var mongoClient = new MongoClient(mongoClientSettings);
services.AddSingleton(mongoUrl);
services.AddSingleton(mongoClient);
services.AddTransient(provider => provider.GetService <MongoClient>().GetDatabase(provider.GetService <MongoUrl>().DatabaseName));
services.AddHostedService <Mongo2GoService>();
services.AddOpenTelemetryTracing(builder => builder
.SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(EndpointName))
.AddAspNetCoreInstrumentation()
.AddMongoDBInstrumentation()
.AddNServiceBusInstrumentation()
.AddZipkinExporter(o =>
{
o.Endpoint = new Uri("http://localhost:9411/api/v2/spans");
})
.AddJaegerExporter(c =>
{
c.AgentHost = "localhost";
c.AgentPort = 6831;
}));
})
;
public void TestDefaults()
{
var settings = new MongoClientSettings();
Assert.AreEqual(ConnectionMode.Automatic, settings.ConnectionMode);
Assert.AreEqual(MongoDefaults.ConnectTimeout, settings.ConnectTimeout);
Assert.AreEqual(0, settings.Credentials.Count());
Assert.AreEqual(MongoDefaults.GuidRepresentation, settings.GuidRepresentation);
Assert.AreEqual(false, settings.IPv6);
Assert.AreEqual(MongoDefaults.MaxConnectionIdleTime, settings.MaxConnectionIdleTime);
Assert.AreEqual(MongoDefaults.MaxConnectionLifeTime, settings.MaxConnectionLifeTime);
Assert.AreEqual(MongoDefaults.MaxConnectionPoolSize, settings.MaxConnectionPoolSize);
Assert.AreEqual(MongoDefaults.MinConnectionPoolSize, settings.MinConnectionPoolSize);
Assert.AreEqual(ReadPreference.Primary, settings.ReadPreference);
Assert.AreEqual(null, settings.ReplicaSetName);
Assert.AreEqual(_localHost, settings.Server);
Assert.AreEqual(_localHost, settings.Servers.First());
Assert.AreEqual(1, settings.Servers.Count());
Assert.AreEqual(MongoDefaults.ServerSelectionTimeout, settings.ServerSelectionTimeout);
Assert.AreEqual(MongoDefaults.SocketTimeout, settings.SocketTimeout);
Assert.AreEqual(null, settings.SslSettings);
Assert.AreEqual(false, settings.UseSsl);
Assert.AreEqual(true, settings.VerifySslCertificate);
Assert.AreEqual(MongoDefaults.ComputedWaitQueueSize, settings.WaitQueueSize);
Assert.AreEqual(MongoDefaults.WaitQueueTimeout, settings.WaitQueueTimeout);
Assert.AreEqual(WriteConcern.Acknowledged, settings.WriteConcern);
}
public void TestWriteConcern()
{
var settings = new MongoClientSettings();
Assert.AreEqual(WriteConcern.Acknowledged, settings.WriteConcern);
var writeConcern = new WriteConcern();
settings.WriteConcern = writeConcern;
Assert.AreSame(writeConcern, settings.WriteConcern);
settings.Freeze();
Assert.AreEqual(writeConcern, settings.WriteConcern);
Assert.Throws<InvalidOperationException>(() => { settings.WriteConcern = writeConcern; });
}
public void TestUseSsl()
{
var settings = new MongoClientSettings();
Assert.AreEqual(false, settings.UseSsl);
var useSsl = true;
settings.UseSsl = useSsl;
Assert.AreEqual(useSsl, settings.UseSsl);
settings.Freeze();
Assert.AreEqual(useSsl, settings.UseSsl);
Assert.Throws<InvalidOperationException>(() => { settings.UseSsl = useSsl; });
}
public void TestReplicaSetName()
{
var settings = new MongoClientSettings();
Assert.AreEqual(null, settings.ReplicaSetName);
var replicaSetName = "abc";
settings.ReplicaSetName = replicaSetName;
Assert.AreSame(replicaSetName, settings.ReplicaSetName);
settings.Freeze();
Assert.AreSame(replicaSetName, settings.ReplicaSetName);
Assert.Throws<InvalidOperationException>(() => { settings.ReplicaSetName = replicaSetName; });
}
public void TestIPv6()
{
var settings = new MongoClientSettings();
Assert.AreEqual(false, settings.IPv6);
var ipv6 = true;
settings.IPv6 = ipv6;
Assert.AreEqual(ipv6, settings.IPv6);
settings.Freeze();
Assert.AreEqual(ipv6, settings.IPv6);
Assert.Throws<InvalidOperationException>(() => { settings.IPv6 = ipv6; });
}
public PlainAuthenticationTests()
{
_settings = MongoClientSettings.FromUrl(new MongoUrl(CoreTestConfiguration.ConnectionString.ToString()));
}
public MongoConnectionSettings(MongoClientSettings mongoClientSettings)
{
MongoClientSettings = mongoClientSettings;
}
/// <summary>
/// Add a health check for MongoDb database that list all collections from specified database on <paramref name="mongoDatabaseName"/>.
/// </summary>
/// <param name="builder">The <see cref="IHealthChecksBuilder"/>.</param>
/// <param name="mongoClientSettings">The MongoClientSettings to be used.</param>
/// <param name="mongoDatabaseName">The Database name to check.</param>
/// <param name="name">The health check name. Optional. If <c>null</c> the type name 'mongodb' will be used for the name.</param>
/// <param name="failureStatus">
/// The <see cref="HealthStatus"/> that should be reported when the health check fails. Optional. If <c>null</c> then
/// the default status of <see cref="HealthStatus.Unhealthy"/> will be reported.
/// </param>
/// <param name="tags">A list of tags that can be used to filter sets of health checks. Optional.</param>
/// <returns>The <see cref="IHealthChecksBuilder"/>.</returns>
public static IHealthChecksBuilder AddMongoDb(this IHealthChecksBuilder builder, MongoClientSettings mongoClientSettings, string mongoDatabaseName, string name = default, HealthStatus?failureStatus = default, IEnumerable <string> tags = default)
{
return(builder.Add(new HealthCheckRegistration(
name ?? NAME,
sp => new MongoDbHealthCheck(mongoClientSettings, mongoDatabaseName),
failureStatus,
tags)));
}
/// <summary>
/// Constructs Job Storage by Mongo client settings, name and options
/// </summary>
/// <param name="mongoClientSettings">Client settings for MongoDB</param>
/// <param name="databaseName">Database name</param>
/// <param name="storageOptions">Storage options</param>
public MongoStorage(MongoClientSettings mongoClientSettings, string databaseName, MongoStorageOptions storageOptions)
: this(new MongoClient(mongoClientSettings), databaseName, storageOptions)
{
}
public IRepository GetRepository(MongoClientSettings settings, string databaseName)
{
return(new MongoRepository(settings, databaseName));
}
/// <summary>
/// Tests database connection parameters.
/// </summary>
/// <param name="Form">Settings parameters provided in configuration form.</param>
/// <param name="Save">If parameters should be saved, if OK.</param>
/// <param name="Settings">Settings object for the plugin.</param>
/// <exception cref="Exception">Exception, in case parameters are not correct.</exception>
public async Task Test(Dictionary <string, object> Form, bool Save, object Settings)
{
if (!Form.TryGetValue("HostName", out object Obj) ||
!(Obj is string HostName) ||
!Form.TryGetValue("DatabaseName", out Obj) ||
!(Obj is string DatabaseName) ||
!Form.TryGetValue("DefaultCollection", out Obj) ||
!(Obj is string DefaultCollection) ||
!Form.TryGetValue("UserName", out Obj) ||
!(Obj is string UserName) ||
!Form.TryGetValue("Password", out Obj) ||
!(Obj is string Password) ||
!Form.TryGetValue("PortNumber", out Obj) ||
!(Obj is string PortNumberString) ||
!(Settings is MongoDBSettings MongoDBSettings))
{
throw new BadRequestException();
}
int?PortNumber;
if (string.IsNullOrEmpty(PortNumberString))
{
PortNumber = null;
}
else if (!int.TryParse(PortNumberString, out int i) || i <= 0 || i > 65535)
{
throw new BadRequestException("Invalid Port Number.");
}
else
{
PortNumber = i;
}
MongoClientSettings MongoClientSettings = new MongoClientSettings()
{
ApplicationName = Gateway.ApplicationName,
ConnectTimeout = TimeSpan.FromSeconds(5)
};
if (!string.IsNullOrEmpty(HostName))
{
if (PortNumber.HasValue)
{
MongoClientSettings.Server = new MongoServerAddress(HostName, PortNumber.Value);
}
else
{
MongoClientSettings.Server = new MongoServerAddress(HostName);
}
}
if (!string.IsNullOrEmpty(UserName))
{
MongoClientSettings.Credential = MongoCredential.CreateCredential(DatabaseName, UserName, Password);
}
MongoClient Client = new MongoClient(MongoClientSettings);
await Client.StartSessionAsync();
IMongoDatabase Database = Client.GetDatabase(DatabaseName);
if (Save)
{
MongoDBSettings.Host = HostName;
MongoDBSettings.Port = PortNumber;
MongoDBSettings.UserName = UserName;
MongoDBSettings.Password = Password;
MongoDBSettings.Database = DatabaseName;
MongoDBSettings.DefaultCollection = DefaultCollection;
}
}
public void TestEquals()
{
var settings = new MongoClientSettings();
var clone = settings.Clone();
Assert.IsTrue(clone.Equals(settings));
clone = settings.Clone();
clone.ConnectionMode = ConnectionMode.Direct;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.ConnectTimeout = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.Credentials = new[] { MongoCredential.CreateMongoCRCredential("db2", "user2", "password2") };
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.Credentials = new[] { MongoCredential.CreateMongoCRCredential("db", "user2", "password2") };
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.GuidRepresentation = GuidRepresentation.PythonLegacy;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.IPv6 = !settings.IPv6;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionIdleTime = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionLifeTime = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionPoolSize = settings.MaxConnectionPoolSize + 1;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MinConnectionPoolSize = settings.MinConnectionPoolSize + 1;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.ReadPreference = ReadPreference.Secondary;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.ReplicaSetName = "abc";
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.LocalThreshold = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.Server = new MongoServerAddress("someotherhost");
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.ServerSelectionTimeout = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.SocketTimeout = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.SslSettings = new SslSettings { CheckCertificateRevocation = false };
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.UseSsl = !settings.UseSsl;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.VerifySslCertificate = !settings.VerifySslCertificate;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.WaitQueueSize = settings.WaitQueueSize + 1;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.WaitQueueTimeout = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.WriteConcern = WriteConcern.W2;
Assert.IsFalse(clone.Equals(settings));
}
public void TestFrozenCopy()
{
var settings = new MongoClientSettings();
Assert.AreEqual(false, settings.IsFrozen);
var frozenCopy = settings.FrozenCopy();
Assert.AreEqual(true, frozenCopy.IsFrozen);
Assert.AreNotSame(settings, frozenCopy);
Assert.AreEqual(settings, frozenCopy);
var secondFrozenCopy = frozenCopy.FrozenCopy();
Assert.AreSame(frozenCopy, secondFrozenCopy);
}
public void TestEquals()
{
var settings = new MongoClientSettings();
var clone = settings.Clone();
Assert.IsTrue(clone.Equals(settings));
clone = settings.Clone();
clone.ConnectionMode = ConnectionMode.Direct;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.ConnectTimeout = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.Credentials = new[] { MongoCredential.CreateMongoCRCredential("db2", "user2", "password2") };
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.Credentials = new[] { MongoCredential.CreateMongoCRCredential("db", "user2", "password2") };
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.GuidRepresentation = GuidRepresentation.PythonLegacy;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.IPv6 = !settings.IPv6;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionIdleTime = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionLifeTime = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionPoolSize = settings.MaxConnectionPoolSize + 1;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.MinConnectionPoolSize = settings.MinConnectionPoolSize + 1;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.ReadPreference = ReadPreference.Secondary;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.ReplicaSetName = "abc";
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.SecondaryAcceptableLatency = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.Server = new MongoServerAddress("someotherhost");
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.SocketTimeout = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.SslSettings = new SslSettings {
CheckCertificateRevocation = false
};
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.UseSsl = !settings.UseSsl;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.VerifySslCertificate = !settings.VerifySslCertificate;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.WaitQueueSize = settings.WaitQueueSize + 1;
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.WaitQueueTimeout = new TimeSpan(1, 2, 3);
Assert.IsFalse(clone.Equals(settings));
clone = settings.Clone();
clone.WriteConcern = WriteConcern.W2;
Assert.IsFalse(clone.Equals(settings));
}
public void TestMinConnectionPoolSize()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.MinConnectionPoolSize, settings.MinConnectionPoolSize);
var minConnectionPoolSize = 123;
settings.MinConnectionPoolSize = minConnectionPoolSize;
Assert.AreEqual(minConnectionPoolSize, settings.MinConnectionPoolSize);
settings.Freeze();
Assert.AreEqual(minConnectionPoolSize, settings.MinConnectionPoolSize);
Assert.Throws<InvalidOperationException>(() => { settings.MinConnectionPoolSize = minConnectionPoolSize; });
}
public void TestCredentials()
{
var settings = new MongoClientSettings();
Assert.AreEqual(0, settings.Credentials.Count());
}
public void TestServersWithTwoServers()
{
var settings = new MongoClientSettings();
Assert.AreEqual(_localHost, settings.Server);
Assert.IsTrue(new[] { _localHost }.SequenceEqual(settings.Servers));
var servers = new MongoServerAddress[]
{
new MongoServerAddress("server1"),
new MongoServerAddress("server2")
};
settings.Servers = servers;
Assert.Throws<InvalidOperationException>(() => { var s = settings.Server; });
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
settings.Freeze();
Assert.Throws<InvalidOperationException>(() => { var s = settings.Server; });
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
Assert.Throws<InvalidOperationException>(() => { settings.Servers = servers; });
}
public SunMongoClient(MongoClientSettings settings)
: base(settings)
{
}
public void TestVerifySslCertificate()
{
var settings = new MongoClientSettings();
Assert.AreEqual(true, settings.VerifySslCertificate);
var verifySslCertificate = false;
settings.VerifySslCertificate = verifySslCertificate;
Assert.AreEqual(verifySslCertificate, settings.VerifySslCertificate);
settings.Freeze();
Assert.AreEqual(verifySslCertificate, settings.VerifySslCertificate);
Assert.Throws<InvalidOperationException>(() => { settings.VerifySslCertificate = verifySslCertificate; });
}
private MongoDbClient(MongoClientSettings settings, string database)
{
Client = new MongoClient(settings);
Database = Client.GetDatabase(database);
}
public BDatabaseServiceMongoDB(
string _MongoClientConfigJson,
string _MongoPassword,
string _MongoDatabase,
Action <string> _ErrorMessageAction = null)
{
try
{
var _ClientConfigString = _MongoClientConfigJson;
// Parse the Client Config Json if it's a base64 encoded (for running on local environment with launchSettings.json)
Span <byte> buffer = new Span <byte>(new byte[_ClientConfigString.Length]);
if (Convert.TryFromBase64String(_ClientConfigString, buffer, out int bytesParsed))
{
if (bytesParsed > 0)
{
_ClientConfigString = Encoding.UTF8.GetString(buffer);
}
}
var _ClientConfigJObject = JObject.Parse(_ClientConfigString);
var _HostTokens = _ClientConfigJObject.SelectTokens("$...hostname");
var _Hosts = new List <string>();
foreach (var item in _HostTokens)
{
_Hosts.Add(item.ToObject <string>());
}
var _PortTokens = _ClientConfigJObject.SelectTokens("$....port");
var _Ports = new List <int>();
foreach (var item in _PortTokens)
{
_Ports.Add(item.ToObject <int>());
}
var _ReplicaSetName = _ClientConfigJObject.SelectToken("replicaSets[0]._id").ToObject <string>();
var _DatabaseName = _ClientConfigJObject.SelectToken("auth.usersWanted[0].db").ToObject <string>();
var _UserName = _ClientConfigJObject.SelectToken("auth.usersWanted[0].user").ToObject <string>();
var _AuthMechnasim = _ClientConfigJObject.SelectToken("auth.autoAuthMechanism").ToObject <string>();
int _MongoDBPort = 27017;
var _ServerList = new List <MongoServerAddress>();
for (int i = 0; i < _Hosts.Count; i++)
{
if (i < _Ports.Count)
{
_MongoDBPort = _Ports[i];
}
_ServerList.Add(new MongoServerAddress(_Hosts[i], _MongoDBPort));
}
MongoInternalIdentity _InternalIdentity = new MongoInternalIdentity(_DatabaseName, _UserName);
PasswordEvidence _PasswordEvidence = new PasswordEvidence(_MongoPassword);
MongoCredential _MongoCredential = new MongoCredential(_AuthMechnasim, _InternalIdentity, _PasswordEvidence);
//MongoCredential _MongoCredential = MongoCredential.CreateCredential(_DatabaseName, _UserName, _MongoPassword);
var _ClientSettings = new MongoClientSettings();
_ClientSettings.Servers = _ServerList.ToArray();
_ClientSettings.ConnectionMode = ConnectionMode.ReplicaSet;
_ClientSettings.ReplicaSetName = _ReplicaSetName;
_ClientSettings.Credential = _MongoCredential;
var Client = new MongoClient(_ClientSettings);
MongoDB = Client.GetDatabase(_MongoDatabase);
bInitializationSucceed = MongoDB != null;
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke($"BDatabaseServiceMongoDB->Constructor: {e.Message} \n Trace: {e.StackTrace}");
bInitializationSucceed = false;
}
}
protected virtual MongoClientSettings OnCreateClientSettings()
{
return(MongoClientSettings.FromUrl(new MongoUrl(databaseSettings.ConnectionString)));
}
private ClusterKey CreateSubject(string notEqualFieldName = null)
{
var connectionMode = ConnectionMode.Direct;
var connectTimeout = TimeSpan.FromSeconds(1);
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var guidRepresentation = GuidRepresentation.Standard;
var ipv6 = false;
var localThreshold = TimeSpan.FromMilliseconds(20);
var maxConnectionIdleTime = TimeSpan.FromSeconds(2);
var maxConnectionLifeTime = TimeSpan.FromSeconds(3);
var maxConnectionPoolSize = 50;
var minConnectionPoolSize = 5;
var replicaSetName = "abc";
var servers = new[] { new MongoServerAddress("localhost") };
var serverSelectionTimeout = TimeSpan.FromSeconds(6);
var socketTimeout = TimeSpan.FromSeconds(4);
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Tls
};
var useSsl = false;
var verifySslCertificate = false;
var waitQueueSize = 20;
var waitQueueTimeout = TimeSpan.FromSeconds(5);
switch (notEqualFieldName)
{
case "ConnectionMode": connectionMode = ConnectionMode.ReplicaSet; break;
case "ConnectTimeout": connectTimeout = TimeSpan.FromSeconds(99); break;
case "Credentials": credentials = new[] { MongoCredential.CreateMongoCRCredential("different", "different", "different") }; break;
case "IPv6": ipv6 = !ipv6; break;
case "LocalThreshold": localThreshold = TimeSpan.FromMilliseconds(99); break;
case "MaxConnectionIdleTime": maxConnectionIdleTime = TimeSpan.FromSeconds(99); break;
case "MaxConnectionLifeTime": maxConnectionLifeTime = TimeSpan.FromSeconds(99); break;
case "MaxConnectionPoolSize": maxConnectionPoolSize = 99; break;
case "MinConnectionPoolSize": minConnectionPoolSize = 99; break;
case "ReplicaSetName": replicaSetName = "different"; break;
case "Servers": servers = new[] { new MongoServerAddress("different") }; break;
case "ServerSelectionTimeout": serverSelectionTimeout = TimeSpan.FromSeconds(98); break;
case "SocketTimeout": socketTimeout = TimeSpan.FromSeconds(99); break;
case "SslSettings": sslSettings.CheckCertificateRevocation = !sslSettings.CheckCertificateRevocation; break;
case "UseSsl": useSsl = !useSsl; break;
case "VerifySslCertificate": verifySslCertificate = !verifySslCertificate; break;
case "WaitQueueSize": waitQueueSize = 99; break;
case "WaitQueueTimeout": waitQueueTimeout = TimeSpan.FromSeconds(99); break;
}
var clientSettings = new MongoClientSettings
{
ConnectionMode = connectionMode,
ConnectTimeout = connectTimeout,
Credentials = credentials,
GuidRepresentation = guidRepresentation,
IPv6 = ipv6,
MaxConnectionIdleTime = maxConnectionIdleTime,
MaxConnectionLifeTime = maxConnectionLifeTime,
MaxConnectionPoolSize = maxConnectionPoolSize,
MinConnectionPoolSize = minConnectionPoolSize,
ReplicaSetName = replicaSetName,
LocalThreshold = localThreshold,
Servers = servers,
ServerSelectionTimeout = serverSelectionTimeout,
SocketTimeout = socketTimeout,
SslSettings = sslSettings,
UseSsl = useSsl,
VerifySslCertificate = verifySslCertificate,
WaitQueueSize = waitQueueSize,
WaitQueueTimeout = waitQueueTimeout
};
return(clientSettings.ToClusterKey());
}
private async void btnFillMongoDb_Click(object sender, EventArgs e)
{
this.btnFillMongoDb.Enabled = false;
const string TeamUri = "http://stats.nba.com/stats/commonteamroster?";
try
{
// === Move === //
const string User = "******";
const string Pass = "******";
const string DbHost = "ds029565.mlab.com";
const int DbPort = 29565;
const string DbName = "appharbor_5cwg75nh";
var credentials = MongoCredential.CreateCredential(DbName, User, Pass);
var settings = new MongoClientSettings
{
Server = new MongoServerAddress(DbHost, DbPort),
Credentials = new List <MongoCredential> {
credentials
}
};
var client = new MongoClient(settings);
var db = client.GetDatabase(DbName);
// === Move === //
var xmlDoc = XDocument.Load("../../teams-by-season.xml");
var seasonIdsFromXml = xmlDoc.XPathSelectElements("/seasons/season")
.Select(el => el.Attribute("id").Value);
var seasons = new HashSet <Season>();
var seasonsToAddInMongoDb = new HashSet <Season>();
// get just season Id's to reduce network traffic
var collectionSeasons = db.GetCollection <Season>("Seasons");
var fieldsSeasons = Builders <Season> .Projection.Include(s => s.SeasonId);
var seasonIdsInMongoDb = collectionSeasons.Find(s => true)
.Project <Season>(fieldsSeasons)
.ToList()
.Select(s => s.SeasonId);
foreach (var seasonId in seasonIdsFromXml)
{
var teams = xmlDoc.XPathSelectElements($"/seasons/season[@id='{seasonId}']/teams/team")
.Select(el => new Team(
int.Parse(el.Attribute("id").Value),
el.Element("name").Value,
el.Attribute("abbreviation").Value,
el.Element("logo-src").Value,
el.Element("headcoach").Value,
int.Parse(el.Attribute("founded").Value),
el.Element("arena").Value,
el.Attribute("city").Value,
el.Attribute("country").Value))
.ToList();
seasons.Add(new Season(seasonId, teams));
if (!seasonIdsInMongoDb.Contains(seasonId))
{
seasonsToAddInMongoDb.Add(new Season(seasonId, teams));
}
}
if (seasons.Count == 0)
{
this.btnFillMongoDb.Enabled = true;
// MongoDB already contains this seasons
return;
}
if (seasonsToAddInMongoDb.Count > 0)
{
await FillMongoDB.FillDatabase(
seasonsToAddInMongoDb.Select(x => x.ToBsonDocument <Season>()), "Seasons");
}
foreach (var seasonId in seasonIdsFromXml)
{
var players = new HashSet <Player>();
var coaches = new HashSet <Coach>();
var teams = seasons.First(x => x.SeasonId == seasonId).Teams;
var options = new Dictionary <string, string>();
var tasks = new HashSet <Task <TeamInfo> >();
foreach (var team in teams)
{
string uriString = $"{TeamUri}TeamID={team.TeamId}&Season={seasonId}";
// random delay to simulate human requests and prevent blocking of
// our IP address from server
int milisecondsToDelay = RandomProvider.Instance.Next(0, teams.Count() * 10);
tasks.Add(GetJsonObjFromNetworkFileAsync <TeamInfo>(uriString, Encoding.UTF8, options, milisecondsToDelay));
}
await Task.Run(async() =>
{
// get just player Id's to reduce network traffic
var collectionPlayers = db.GetCollection <Player>("Players");
//var conditionPlayers = Builders<Player>.Filter.Eq(p => p.TeamId, currentTeamId);
var fieldsPlayers = Builders <Player> .Projection.Include(p => p.PlayerId);
var playerIdsInMongoDb = collectionPlayers.Find(p => true)//.Find(conditionPlayers)
.Project <Player>(fieldsPlayers)
.ToList()
.Select(p => p.PlayerId);
// get just coach Id's to reduce network traffic
var collectionCoaches = db.GetCollection <Coach>("Coaches");
//var conditionCoaches = Builders<Coach>.Filter.Eq(c => c.TeamId, currentTeamId);
var fieldsCoaches = Builders <Coach> .Projection.Include(c => c.CoachId);
var coachIdsInMongoDb = collectionCoaches.Find(c => true)//conditionCoaches)
.Project <Coach>(fieldsCoaches)
.ToList()
.Select(c => c.CoachId);
foreach (var teamInfo in await Task.WhenAll(tasks))
{
if (teamInfo == null)
{
MessageBox.Show("TeamInfo url does not response with JSON file.");
return;
}
// we need this when use conditionPlayers and conditionCoaches
//var currentTeamId = (int)(long)teamInfo.ResultSets[0].RowSet[0][0];
foreach (var resultSet in teamInfo.ResultSets)
{
if (resultSet.Name == "CommonTeamRoster")
{
foreach (var row in resultSet.RowSet) // players
{
var playerId = (int)(long)row[12];
if (!playerIdsInMongoDb.Contains(playerId))
{
string uriString = $"http://stats.nba.com/stats/commonplayerinfo?PlayerID={playerId}";
// random delay to simulate human requests and prevent blocking of
// our IP address from server
int milisecondsToDelay = RandomProvider.Instance.Next(0, 20);
var playerInfo = await GetJsonObjFromNetworkFileAsync <PlayerInfo>(uriString, Encoding.UTF8, options, milisecondsToDelay);
var personId = playerInfo.ResultSets[0].RowSet[0][0];
var firstName = playerInfo.ResultSets[0].RowSet[0][1];
var lastName = playerInfo.ResultSets[0].RowSet[0][2];
var displayFirstLastName = playerInfo.ResultSets[0].RowSet[0][3];
var displayLastCommaFirstName = playerInfo.ResultSets[0].RowSet[0][4];
var displayFiLastName = playerInfo.ResultSets[0].RowSet[0][5];
DateTime birthDate = (DateTime)playerInfo.ResultSets[0].RowSet[0][6];
var school = playerInfo.ResultSets[0].RowSet[0][7];
var country = playerInfo.ResultSets[0].RowSet[0][8];
var lastAffiliation = playerInfo.ResultSets[0].RowSet[0][9];
var height = playerInfo.ResultSets[0].RowSet[0][10];
var weight = playerInfo.ResultSets[0].RowSet[0][11];
var seasonExp = playerInfo.ResultSets[0].RowSet[0][12];
var jersey = playerInfo.ResultSets[0].RowSet[0][13];
var position = playerInfo.ResultSets[0].RowSet[0][14];
var rosterStatus = playerInfo.ResultSets[0].RowSet[0][15];
var teamId = playerInfo.ResultSets[0].RowSet[0][16];
var teamName = playerInfo.ResultSets[0].RowSet[0][17];
var teamAbbreviation = playerInfo.ResultSets[0].RowSet[0][18];
var teamCode = playerInfo.ResultSets[0].RowSet[0][19];
var teamCity = playerInfo.ResultSets[0].RowSet[0][20];
var playerCode = playerInfo.ResultSets[0].RowSet[0][21];
var fromYear = playerInfo.ResultSets[0].RowSet[0][22];
var toYear = playerInfo.ResultSets[0].RowSet[0][23];
var dLeagueFlag = playerInfo.ResultSets[0].RowSet[0][24];
var gamesPlayedFlag = playerInfo.ResultSets[0].RowSet[0][25];
// fill pointsPerGame with fake data
var seasonPointsPerGame = new Dictionary <string, double>();
seasonPointsPerGame[seasonId] = (double)RandomProvider.Instance.Next(0, 5000) / 100;
seasonPointsPerGame["2015-16"] = (double)RandomProvider.Instance.Next(0, 5000) / 100;
players.Add(new Player(
(int)(long)personId,
(string)firstName,
(string)lastName,
(string)displayFirstLastName,
(string)displayLastCommaFirstName,
(string)displayFiLastName,
(DateTime)birthDate,
(string)school,
(string)country,
(string)lastAffiliation,
(string)height,
(string)weight,
(int)(long)seasonExp,
(string)jersey,
(string)position,
(string)rosterStatus,
(int)(long)teamId,
(string)teamName,
(string)teamAbbreviation,
(string)teamCode,
(string)teamCity,
(string)playerCode,
(int)(long)fromYear,
(int)(long)toYear,
(string)dLeagueFlag,
(string)gamesPlayedFlag,
seasonPointsPerGame
));
}
}
}
else if (resultSet.Name == "Coaches")
{
foreach (var row in resultSet.RowSet)
{
var coachId = row[2];
if (!coachIdsInMongoDb.Contains((string)coachId))
{
var teamId = row[0];
var season = row[1];
//var coachId = row[2];
var firstName = row[3];
var lastName = row[4];
var coachName = row[5];
var coachCode = row[6];
var isAssistant = row[7];
var coachType = row[8];
var school = row[9];
var sortSequence = row[10];
coaches.Add(new Coach(
(int)(long)teamId,
(string)season,
(string)coachId,
(string)firstName,
(string)lastName,
(string)coachName,
(string)coachCode,
(int)(double)isAssistant,
(string)coachType,
(string)school,
(int?)(double?)sortSequence
));
}
}
}
}
}
await FillMongoDB.FillDatabase(
players.Select(x => x.ToBsonDocument()), "Players");
await FillMongoDB.FillDatabase(
coaches.Select(x => x.ToBsonDocument()), "Coaches");
});
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
this.btnFillMongoDb.Enabled = true;
}
public void TestServersWithOneServer()
{
var settings = new MongoClientSettings();
Assert.Equal(_localHost, settings.Server);
Assert.True(new[] { _localHost }.SequenceEqual(settings.Servers));
var server = new MongoServerAddress("server");
var servers = new[] { server };
settings.Servers = servers;
Assert.Equal(server, settings.Server);
Assert.True(servers.SequenceEqual(settings.Servers));
settings.Freeze();
Assert.Equal(server, settings.Server);
Assert.True(servers.SequenceEqual(settings.Servers));
Assert.Throws<InvalidOperationException>(() => { settings.Server = server; });
}
public JsonDrivenRunAdminCommandTest(IMongoClient mongoClient, IJsonDrivenTestRunner testRunner, Dictionary <string, object> objectMap)
: base(testRunner, objectMap)
{
_mongoClientSettings = mongoClient.Settings.Clone();
_mongoClientSettings.ClusterConfigurator = null;
}
public void TestWaitQueueTimeout()
{
var settings = new MongoClientSettings();
Assert.Equal(MongoDefaults.WaitQueueTimeout, settings.WaitQueueTimeout);
var waitQueueTimeout = new TimeSpan(1, 2, 3);
settings.WaitQueueTimeout = waitQueueTimeout;
Assert.Equal(waitQueueTimeout, settings.WaitQueueTimeout);
settings.Freeze();
Assert.Equal(waitQueueTimeout, settings.WaitQueueTimeout);
Assert.Throws<InvalidOperationException>(() => { settings.WaitQueueTimeout = waitQueueTimeout; });
}
public TBMongoDatabase(string databaseName, string connectionString)
{
_settings = MongoClientSettings.FromUrl(new MongoUrl(connectionString));
DatabaseName = databaseName;
}
public void TestFreeze()
{
var settings = new MongoClientSettings();
Assert.IsFalse(settings.IsFrozen);
var hashCode = settings.GetHashCode();
var stringRepresentation = settings.ToString();
settings.Freeze();
Assert.IsTrue(settings.IsFrozen);
Assert.AreEqual(hashCode, settings.GetHashCode());
Assert.AreEqual(stringRepresentation, settings.ToString());
}
/// <summary>
/// Constructs Job Storage by Mongo client settings and name
/// </summary>
/// <param name="mongoClientSettings">Client settings for MongoDB</param>
/// <param name="databaseName">Database name</param>
public MongoStorage(MongoClientSettings mongoClientSettings, string databaseName)
: this(mongoClientSettings, databaseName, new MongoStorageOptions())
{
}
public void TestGuidRepresentation()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.GuidRepresentation, settings.GuidRepresentation);
var guidRepresentation = GuidRepresentation.PythonLegacy;
settings.GuidRepresentation = guidRepresentation;
Assert.AreEqual(guidRepresentation, settings.GuidRepresentation);
settings.Freeze();
Assert.AreEqual(guidRepresentation, settings.GuidRepresentation);
Assert.Throws<InvalidOperationException>(() => { settings.GuidRepresentation = guidRepresentation; });
}
static void Main(string[] args)
{
using (var docker = new MongoDockerFixture())
{
var testsDb = "tests-db";
var carCollection = "Car";
// Init MongoDB
var client = new MongoClient(MongoClientSettings.FromConnectionString($"mongodb://localhost:{docker.HostPort}"));
var db = client.GetDatabase(testsDb);
db.DropCollection(carCollection);
// Insert old and new version of cars into MongoDB
var cars = new List <BsonDocument>
{
new BsonDocument {
{ "Dors", 3 }, { "Type", "Cabrio" }, { "UnnecessaryField", "" }
},
new BsonDocument {
{ "Dors", 5 }, { "Type", "Combi" }, { "UnnecessaryField", "" }
},
new BsonDocument {
{ "Doors", 3 }, { "Type", "Truck" }, { "UnnecessaryField", "" }, { "Version", "0.0.1" }
},
new BsonDocument {
{ "Doors", 5 }, { "Type", "Van" }, { "Version", "0.1.1" }
}
};
var bsonCollection = db.GetCollection <BsonDocument>(carCollection);
bsonCollection.InsertManyAsync(cars).Wait();
// Init MongoMigration
MongoMigrationClient.Initialize(client, new LightInjectAdapter(new LightInject.ServiceContainer()));
Console.WriteLine("Migrate from:");
cars.ForEach(c => Console.WriteLine(c.ToBsonDocument() + "\n"));
// Migrate old version to current version by reading collection
var typedCollection = db.GetCollection <Car>("Car");
var result = typedCollection.FindAsync(_ => true).Result.ToListAsync().Result;
Console.WriteLine("To:");
result.ForEach(r => Console.WriteLine(r.ToBsonDocument() + "\n"));
// Create new car and add it with current version number into MongoDB
var id = ObjectId.GenerateNewId();
var type = "Test" + id;
var car = new Car {
Doors = 2, Type = type
};
typedCollection.InsertOne(car);
var test = typedCollection.FindAsync(Builders <Car> .Filter.Eq(c => c.Type, type)).Result.Single();
var aggregate = typedCollection.Aggregate()
.Match(new BsonDocument {
{ "Dors", 3 }
});
var results = aggregate.ToListAsync().Result;
Console.WriteLine("New Car was created with version: " + test.Version);
Console.WriteLine("\n");
Console.WriteLine("\n");
Console.WriteLine("Press any Key to exit...");
Console.Read();
db.DropCollection(carCollection);
}
}
public void TestMaxConnectionLifeTime()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.MaxConnectionLifeTime, settings.MaxConnectionLifeTime);
var maxConnectionLifeTime = new TimeSpan(1, 2, 3);
settings.MaxConnectionLifeTime = maxConnectionLifeTime;
Assert.AreEqual(maxConnectionLifeTime, settings.MaxConnectionLifeTime);
settings.Freeze();
Assert.AreEqual(maxConnectionLifeTime, settings.MaxConnectionLifeTime);
Assert.Throws<InvalidOperationException>(() => { settings.MaxConnectionLifeTime = maxConnectionLifeTime; });
}
public MongoDbSslProcessManagerFinder(string connectionString, string databaseName)
{
var connectionParts = connectionString.Split(',');
string nodes = string.Empty;
string username = string.Empty;
string password = string.Empty;
string certPath = string.Empty;
string userdb = string.Empty;
string cert = string.Empty;
string certPassword = string.Empty;
foreach (string connectionPart in connectionParts)
{
var nameValue = connectionPart.Split('=');
switch (nameValue[0].ToLower())
{
case "nodes":
nodes = nameValue[1];
break;
case "userdb":
userdb = nameValue[1];
break;
case "username":
username = nameValue[1];
break;
case "password":
password = nameValue[1];
break;
case "certpath":
certPath = nameValue[1];
break;
case "cert":
cert = nameValue[1];
break;
case "certpassword":
certPassword = nameValue[1];
break;
}
}
var mongoNodes = nodes.Split(';');
List <X509Certificate> certs = null;
if (!string.IsNullOrEmpty(certPath))
{
if (string.IsNullOrEmpty(certPassword))
{
certs = new List <X509Certificate>
{
new X509Certificate2(certPath)
};
}
else
{
certs = new List <X509Certificate>
{
new X509Certificate2(certPath, certPassword)
};
}
}
if (!string.IsNullOrEmpty(cert))
{
if (string.IsNullOrEmpty(certPassword))
{
certs = new List <X509Certificate>
{
new X509Certificate2(Convert.FromBase64String(cert))
};
}
else
{
certs = new List <X509Certificate>
{
new X509Certificate2(Convert.FromBase64String(cert), certPassword)
};
}
}
List <MongoCredential> credentials = null;
if (!string.IsNullOrEmpty(username))
{
string db = "admin";
if (!string.IsNullOrEmpty(userdb))
{
db = userdb;
}
credentials = new List <MongoCredential>
{
MongoCredential.CreateCredential(db, username, password)
};
}
var settings = new MongoClientSettings
{
UseSsl = true,
Credentials = credentials,
ConnectionMode = ConnectionMode.Automatic,
Servers = mongoNodes.Select(x => new MongoServerAddress(x)),
SslSettings = new SslSettings
{
ClientCertificates = certs,
ClientCertificateSelectionCallback = (sender, host, certificates, certificate, issuers) => certificates[0],
CheckCertificateRevocation = false
}
};
var client = new MongoClient(settings);
MongoServer server = client.GetServer();
_mongoDatabase = server.GetDatabase(databaseName);
}
public void TestReadPreference()
{
var settings = new MongoClientSettings();
Assert.AreEqual(ReadPreference.Primary, settings.ReadPreference);
var readPreference = ReadPreference.Primary;
settings.ReadPreference = readPreference;
Assert.AreSame(readPreference, settings.ReadPreference);
settings.Freeze();
Assert.AreEqual(readPreference, settings.ReadPreference);
Assert.Throws<InvalidOperationException>(() => { settings.ReadPreference = readPreference; });
}
/// <summary>
/// MongoDB database provider.
/// </summary>
/// <param name="Settings">Connection settings.</param>
/// <param name="DatabaseName">Name of database.</param>
/// <param name="DefaultCollectionName">Name of default collection.</param>
public MongoDBProvider(MongoClientSettings Settings, string DatabaseName, string DefaultCollectionName)
{
this.Init(Settings, DatabaseName, DefaultCollectionName);
}
public void TestLocalThreshold()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.LocalThreshold, settings.LocalThreshold);
var localThreshold = new TimeSpan(1, 2, 3);
settings.LocalThreshold = localThreshold;
Assert.AreEqual(localThreshold, settings.LocalThreshold);
settings.Freeze();
Assert.AreEqual(localThreshold, settings.LocalThreshold);
Assert.Throws<InvalidOperationException>(() => { settings.LocalThreshold = localThreshold; });
}
public void InitMongoDbConnection(MongoClientSettings settings)
{
_mongoClient = new MongoClient(settings);
}
public void TestSslSettings()
{
var settings = new MongoClientSettings();
Assert.AreEqual(null, settings.SslSettings);
var sslSettings = new SslSettings { CheckCertificateRevocation = false };
settings.SslSettings = sslSettings;
Assert.AreEqual(sslSettings, settings.SslSettings);
settings.Freeze();
Assert.AreEqual(sslSettings, settings.SslSettings);
Assert.Throws<InvalidOperationException>(() => { settings.SslSettings = sslSettings; });
}
static async Task MainAsync()
{
// EXAMPLE PULLED FROM THE DOCS: https://mongodb.github.io/mongo-csharp-driver/2.8/reference/driver/authentication/
// does not work
var client_cert = new X509Certificate2("client-certificate.pfx", "password");
var docsExampleVersionOfSettings = new MongoClientSettings
{
Credentials = new[]
{ // i just pulled this DN (username for x509) from openssl using: openssl pkcs12 -info -in client-certificate.pfx
MongoCredential.CreateMongoX509Credential("OU=TestClientCertificateOrgUnit, O=TestClientCertificateOrg, L=TestClientCertificateLocality, ST=TestClientCertificateState")
}, // note that this DN also matches the DN/subject printed out using cert.ToString()
SslSettings = new SslSettings
{
ClientCertificates = new[] { client_cert },
},
UseSsl = true
};
// working example starting with a connection string, and avoiding the Credential part of the setting object entirely
var connectionString = "mongodb://localmongo1/?authMechanism=MONGODB-X509&tls=true";
var connectionStringPlusObjectSettings = MongoClientSettings.FromConnectionString(connectionString);
var cert = new X509Certificate2("client-certificate.pfx", "password");
Console.WriteLine(cert.ToString());
Console.WriteLine(cert.PrivateKey != null ? "contains private key" : "does not contain private key"); // verify that there's a private key in the cert, docs tell us we need this
var sslSettings = new SslSettings {
ClientCertificates = new List <X509Certificate>()
{
new X509Certificate2("client-certificate.pfx", "password")
}
};
connectionStringPlusObjectSettings.AllowInsecureTls = true; // for testing using self-signed certs, use this option to skip validation. DO NOT USE THIS OPTION FOR PRODUCTION USES
connectionStringPlusObjectSettings.SslSettings = sslSettings;
// just to demonstrate the difference between what mongod uses (order + spacing) vs openssl/c# version of the string:
var from_mongod_logs_str = "OU=TestClientCertificateOrgUnit,O=TestClientCertificateOrg,L=TestClientCertificateLocality,ST=TestClientCertificateState";
var from_openssl_str = "ST = TestClientCertificateState, L = TestClientCertificateLocality, O = TestClientCertificateOrg, OU = TestClientCertificateOrgUnit";
var from_csharp_str = "OU=TestClientCertificateOrgUnit, O=TestClientCertificateOrg, L=TestClientCertificateLocality, S=TestClientCertificateState";
// note that C# adds extra spaces and uses S instead of ST; openssl adds even more extra spaces and puts values in a completely different order.
// suggested example to replace the existing docs example. Should work as long as the certificate is valid!
var settingObjectOnlySettings = new MongoClientSettings
{
Credential = MongoCredential.CreateMongoX509Credential(null),
SslSettings = new SslSettings
{
ClientCertificates = new List <X509Certificate>()
{
new X509Certificate2("client-certificate.pfx", "password")
},
},
UseTls = true,
Server = new MongoServerAddress("localmongo1", 27017),
AllowInsecureTls = true // for testing using self-signed certs, use this option to skip validation. DO NOT USE THIS OPTION FOR PRODUCTION USES
};
var client = new MongoClient(settingObjectOnlySettings); // suggested fixed example
//var client = new MongoClient(connectionStringPlusObjectSettings); // x509 auth activated via connection string
//var client = new MongoClient(docsExampleVersionOfSettings); // example from the docs, in case you want to play around with it
// just doing a quick read + insert to verify the usability of this connection
var database = client.GetDatabase("test");
var collection = database.GetCollection <BsonDocument>("stuff");
var allItemsInCollection = await collection.Find(new BsonDocument()).ToListAsync();
Console.WriteLine(allItemsInCollection.Count);
var entity = new BsonDocument {
{ "count", allItemsInCollection.Count }
};
collection.InsertOne(entity);
Console.WriteLine("wrote " + entity + " to DB");
/*
*
* Driver suggestions:
*
* https://api.mongodb.com/csharp/2.2/html/T_MongoDB_Driver_MongoCredential.htm
*
* - the X509Credential arguments are missing for some reason from the API docs MongoCredential page (above)
*
* https://mongodb.github.io/mongo-csharp-driver/2.8/reference/driver/authentication/
*
* - the x.509 auth portion of this page has 3 problems:
*
* 1) Credentials is deprecated, replaced by Credential
*
* 2) useSsl is deprecated, should be useTls
*
* 3) the value of Credential (created by MongoCredential.CreateMongoX509Credential(connectionStr)) must
*
* match the DN of the certificate EXACTLY as interpreted by mongodb. Unfortunately this means it must
*
* match spacing that openSSL/C# do not necessarily include when one prints out a pfx file with commands
*
* like ``openssl pkcs12 -info -in client-certificate.pfx``.
*
*
*
* Two solutions to #3 for our documentation:
*
* 1) set connectionStr to null and this snippet will work just fine
*
* 2) set the authentication mechanism to x509 in a connection string, then import
*
* that connection string into a settings object using MongoClientSettings.FromConnectionString,
*
* then add the certificate to the SslSettings. This lets you avoid setting a Credential entirely
*
*
*
* Personally I would simply recommend removing/deprecating the argument
*
* from CreateMongoX509Credential entirely, as it was only a source of
*
* pain for me when trying to use X.509 with the drivers.
*
*
*
*/
}
public ExtentXReporter(MongoClientSettings settings)
{
LoadDefaultConfig();
_mongoClient = new MongoClient(settings);
}
public void ConfigureServices(IServiceCollection services)
{
_logger.LogInformation("Configuring services");
LoadAndValidateSettings(services);
if (Environment.IsEnvironment(EnviromentDevVS))
{
_logger.LogInformation("Starting Mongo2Go");
_runner = Mongo2Go.MongoDbRunner.StartForDebugging();
MongoClientSettings settings = new MongoClientSettings
{
GuidRepresentation = GuidRepresentation.Standard
};
services.AddSingleton(new MongoClient(settings).GetDatabase(_swapifyDbSettings.DatabaseName));
}
else
{
services.Configure <SwapifyDatabaseSettings>(Configuration.GetSection(nameof(SwapifyDatabaseSettings)));
var settings = new MongoClientSettings
{
Server = new MongoServerAddress("mongodb", 27017),
GuidRepresentation = GuidRepresentation.Standard
};
services.AddSingleton(new MongoClient(settings).GetDatabase(_swapifyDbSettings.DatabaseName));
services.AddSingleton <ISwapifyDatabaseSettings>(sp => sp.GetRequiredService <IOptions <SwapifyDatabaseSettings> >().Value);
}
if (Environment.IsProduction())
{
services.AddCors(options =>
{
options.AddPolicy("SwapifyCorsPolicy",
builder =>
{
builder.WithOrigins("https://swapify.fri.uniza.sk",
"http://swapify.fri.uniza.sk",
"https://*swapify.fri.uniza.sk",
"http://*swapify.fri.uniza.sk")
.SetIsOriginAllowedToAllowWildcardSubdomains()
.AllowAnyHeader()
.AllowAnyMethod();
});
options.AddPolicy("AllowCredentials",
builder =>
{
builder.WithOrigins("https://swapify.fri.uniza.sk",
"http://swapify.fri.uniza.sk",
"https://*swapify.fri.uniza.sk",
"http://*swapify.fri.uniza.sk")
.AllowCredentials();
});
});
}
else
{
services.AddCors(options =>
{
options.AddPolicy("SwapifyCorsPolicy",
builder =>
{
builder.WithOrigins("http://localhost",
"https://localhost",
"http://localhost:3000",
"https://localhost:3000")
.SetIsOriginAllowedToAllowWildcardSubdomains()
.AllowAnyHeader()
.AllowAnyMethod();
});
options.AddPolicy("AllowCredentials",
builder =>
{
builder.WithOrigins("http://localhost",
"https://localhost",
"http://localhost:3000",
"https://localhost:3000")
.AllowCredentials();
});
});
}
services.ConfigureMongoDbIdentity <User, MongoIdentityRole, Guid>(ConfigureIdentity());
services.AddScoped <IUserService, UserService>();
services.AddSingleton <ICourseService, CourseService>();
services.AddSingleton <ISchoolScheduleProxy, SchoolScheduleProxy>();
services.AddSingleton <ISchoolCourseProxy, SchoolCourseProxy>();
services.AddSingleton <IEmailService, EmailService>();
services.AddSingleton <IBlockChangesService, BlockChangesService>();
services.AddSingleton <IStudentService, StudentService>();
services.AddSingleton <INotificationService, NotificationService>();
services.AddSingleton <ICalendarService, CalendarService>();
services.AddControllersWithViews();
if (!Environment.IsEnvironment(EnviromentDevVS))
{
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = _pathSettings.WwwRootPath;
});
}
services.AddMvcCore().AddApiExplorer();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "Swapify API", Version = "v1"
});
});
ConfigureAuthorization(services);
}
public void TestWaitQueueSize()
{
var settings = new MongoClientSettings();
Assert.AreEqual(MongoDefaults.ComputedWaitQueueSize, settings.WaitQueueSize);
var waitQueueSize = 123;
settings.WaitQueueSize = waitQueueSize;
Assert.AreEqual(waitQueueSize, settings.WaitQueueSize);
settings.Freeze();
Assert.AreEqual(waitQueueSize, settings.WaitQueueSize);
Assert.Throws<InvalidOperationException>(() => { settings.WaitQueueSize = waitQueueSize; });
}
public void TestFromUrl()
{
// set everything to non default values to test that all settings are converted
var connectionString =
"mongodb://*****:*****@somehost/?appname=app1;authSource=db;authMechanismProperties=CANONICALIZE_HOST_NAME:true;" +
"compressors=zlib,snappy;zlibCompressionLevel=9;connect=direct;connectTimeout=123;ipv6=true;heartbeatInterval=1m;heartbeatTimeout=2m;localThreshold=128;" +
"maxIdleTime=124;maxLifeTime=125;maxPoolSize=126;minPoolSize=127;readConcernLevel=majority;" +
"readPreference=secondary;readPreferenceTags=a:1,b:2;readPreferenceTags=c:3,d:4;retryReads=false;retryWrites=true;socketTimeout=129;" +
"serverSelectionTimeout=20s;tls=true;tlsInsecure=true;waitqueuesize=130;waitQueueTimeout=131;" +
"w=1;fsync=true;journal=true;w=2;wtimeout=131;gssapiServiceName=other";
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
connectionString += ";uuidRepresentation=pythonLegacy";
}
#pragma warning restore 618
var builder = new MongoUrlBuilder(connectionString);
var url = builder.ToMongoUrl();
var settings = MongoClientSettings.FromUrl(url);
Assert.Equal(url.AllowInsecureTls, settings.AllowInsecureTls);
Assert.Equal(url.ApplicationName, settings.ApplicationName);
Assert.Equal(url.Compressors, settings.Compressors);
Assert.Equal(url.ConnectionMode, settings.ConnectionMode);
Assert.Equal(url.ConnectTimeout, settings.ConnectTimeout);
#pragma warning disable 618
Assert.Equal(1, settings.Credentials.Count());
#pragma warning restore
Assert.Equal(url.Username, settings.Credential.Username);
Assert.Equal(url.AuthenticationMechanism, settings.Credential.Mechanism);
Assert.Equal("other", settings.Credential.GetMechanismProperty <string>("SERVICE_NAME", "mongodb"));
Assert.Equal(true, settings.Credential.GetMechanismProperty <bool>("CANONICALIZE_HOST_NAME", false));
Assert.Equal(url.AuthenticationSource, settings.Credential.Source);
Assert.Equal(new PasswordEvidence(url.Password), settings.Credential.Evidence);
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
Assert.Equal(url.GuidRepresentation, settings.GuidRepresentation);
}
#pragma warning restore 618
Assert.Equal(url.HeartbeatInterval, settings.HeartbeatInterval);
Assert.Equal(url.HeartbeatTimeout, settings.HeartbeatTimeout);
Assert.Equal(url.IPv6, settings.IPv6);
Assert.Equal(url.LocalThreshold, settings.LocalThreshold);
Assert.Equal(url.MaxConnectionIdleTime, settings.MaxConnectionIdleTime);
Assert.Equal(url.MaxConnectionLifeTime, settings.MaxConnectionLifeTime);
Assert.Equal(url.MaxConnectionPoolSize, settings.MaxConnectionPoolSize);
Assert.Equal(url.MinConnectionPoolSize, settings.MinConnectionPoolSize);
Assert.Equal(url.ReadConcernLevel, settings.ReadConcern.Level);
Assert.Equal(url.ReadPreference, settings.ReadPreference);
Assert.Equal(url.ReplicaSetName, settings.ReplicaSetName);
Assert.Equal(url.RetryReads, settings.RetryReads);
Assert.Equal(url.RetryWrites, settings.RetryWrites);
Assert.Equal(url.Scheme, settings.Scheme);
Assert.True(url.Servers.SequenceEqual(settings.Servers));
Assert.Equal(url.ServerSelectionTimeout, settings.ServerSelectionTimeout);
Assert.Equal(url.SocketTimeout, settings.SocketTimeout);
#pragma warning disable 618
settings.SslSettings.Should().BeNull();
Assert.Equal(url.UseSsl, settings.UseSsl);
#pragma warning restore 618
Assert.Equal(url.UseTls, settings.UseTls);
#pragma warning disable 618
Assert.Equal(url.VerifySslCertificate, settings.VerifySslCertificate);
#pragma warning restore 618
#pragma warning disable 618
Assert.Equal(url.ComputedWaitQueueSize, settings.WaitQueueSize);
#pragma warning restore 618
Assert.Equal(url.WaitQueueTimeout, settings.WaitQueueTimeout);
Assert.Equal(url.GetWriteConcern(true), settings.WriteConcern);
}
public void ToClusterKey_should_copy_relevant_values()
{
var credentials = new[] { MongoCredential.CreateMongoCRCredential("source", "username", "password") };
var servers = new[] { new MongoServerAddress("localhost") };
var sslSettings = new SslSettings
{
CheckCertificateRevocation = true,
EnabledSslProtocols = SslProtocols.Ssl3
};
var subject = new MongoClientSettings
{
ConnectionMode = ConnectionMode.Direct,
ConnectTimeout = TimeSpan.FromSeconds(1),
Credentials = credentials,
GuidRepresentation = GuidRepresentation.Standard,
IPv6 = true,
MaxConnectionIdleTime = TimeSpan.FromSeconds(2),
MaxConnectionLifeTime = TimeSpan.FromSeconds(3),
MaxConnectionPoolSize = 10,
MinConnectionPoolSize = 5,
ReplicaSetName = "rs",
LocalThreshold = TimeSpan.FromMilliseconds(20),
Servers = servers,
ServerSelectionTimeout = TimeSpan.FromSeconds(6),
SocketTimeout = TimeSpan.FromSeconds(4),
SslSettings = sslSettings,
UseSsl = true,
VerifySslCertificate = true,
WaitQueueSize = 20,
WaitQueueTimeout = TimeSpan.FromSeconds(5)
};
var result = subject.ToClusterKey();
result.ConnectionMode.Should().Be(subject.ConnectionMode);
result.ConnectTimeout.Should().Be(subject.ConnectTimeout);
result.Credentials.Should().Equal(subject.Credentials);
result.IPv6.Should().Be(subject.IPv6);
result.MaxConnectionIdleTime.Should().Be(subject.MaxConnectionIdleTime);
result.MaxConnectionLifeTime.Should().Be(subject.MaxConnectionLifeTime);
result.MaxConnectionPoolSize.Should().Be(subject.MaxConnectionPoolSize);
result.MinConnectionPoolSize.Should().Be(subject.MinConnectionPoolSize);
result.ReplicaSetName.Should().Be(subject.ReplicaSetName);
result.LocalThreshold.Should().Be(subject.LocalThreshold);
result.Servers.Should().Equal(subject.Servers);
result.ServerSelectionTimeout.Should().Be(subject.ServerSelectionTimeout);
result.SocketTimeout.Should().Be(subject.SocketTimeout);
result.SslSettings.Should().Be(subject.SslSettings);
result.UseSsl.Should().Be(subject.UseSsl);
result.VerifySslCertificate.Should().Be(subject.VerifySslCertificate);
result.WaitQueueSize.Should().Be(subject.WaitQueueSize);
result.WaitQueueTimeout.Should().Be(subject.WaitQueueTimeout);
}
public void Setup()
{
_settings = MongoClientSettings.FromUrl(new MongoUrl(CoreTestConfiguration.ConnectionString.ToString()));
}
public void TestCredentials()
{
var settings = new MongoClientSettings();
Assert.AreEqual(0, settings.Credentials.Count());
}
public MongoDbHealthCheck(MongoClientSettings clientSettings, string databaseName = default)
{
_specifiedDatabase = databaseName;
_mongoClientSettings = clientSettings;
}
public void TestEquals()
{
var settings = new MongoClientSettings();
var clone = settings.Clone();
Assert.True(clone.Equals(settings));
clone = settings.Clone();
clone.AllowInsecureTls = !settings.AllowInsecureTls;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.ApplicationName = "app2";
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.Compressors = new[] { new CompressorConfiguration(CompressorType.Zlib) };
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.ConnectionMode = ConnectionMode.Direct;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.ConnectTimeout = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
#pragma warning disable 618
clone.Credential = MongoCredential.CreateMongoCRCredential("db2", "user2", "password2");
#pragma warning restore 618
Assert.False(clone.Equals(settings));
clone = settings.Clone();
#pragma warning disable 618
clone.Credential = MongoCredential.CreateMongoCRCredential("db", "user2", "password2");
#pragma warning restore 618
Assert.False(clone.Equals(settings));
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
clone = settings.Clone();
var unequalGuidRepresentation = clone.GuidRepresentation != GuidRepresentation.PythonLegacy ? GuidRepresentation.PythonLegacy : GuidRepresentation.CSharpLegacy;
clone.GuidRepresentation = unequalGuidRepresentation;
Assert.False(clone.Equals(settings));
}
#pragma warning restore 618
clone = settings.Clone();
clone.HeartbeatInterval = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.HeartbeatTimeout = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.IPv6 = !settings.IPv6;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.LocalThreshold = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionIdleTime = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionLifeTime = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.MaxConnectionPoolSize = settings.MaxConnectionPoolSize + 1;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.ReadConcern = ReadConcern.Majority;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.MinConnectionPoolSize = settings.MinConnectionPoolSize + 1;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.ReadPreference = ReadPreference.Secondary;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.ReplicaSetName = "abc";
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.RetryReads = false;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.RetryWrites = false;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.Scheme = ConnectionStringScheme.MongoDBPlusSrv;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.Server = new MongoServerAddress("someotherhost");
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.ServerSelectionTimeout = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.SocketTimeout = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.SslSettings = new SslSettings {
CheckCertificateRevocation = false
};
Assert.False(clone.Equals(settings));
clone = settings.Clone();
#pragma warning disable 618
clone.UseSsl = !settings.UseSsl;
#pragma warning restore 618
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.UseTls = !settings.UseTls;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
#pragma warning disable 618
clone.VerifySslCertificate = !settings.VerifySslCertificate;
#pragma warning restore 618
Assert.False(clone.Equals(settings));
clone = settings.Clone();
#pragma warning disable 618
clone.WaitQueueSize = settings.WaitQueueSize + 1;
#pragma warning restore 618
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.WaitQueueTimeout = new TimeSpan(1, 2, 3);
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.WriteConcern = WriteConcern.W2;
Assert.False(clone.Equals(settings));
clone = settings.Clone();
clone.SdamLogFilename = "garbage";
Assert.False(clone.Equals(settings));
}
/// <summary>
/// Initializes the MongoDB connection with an advanced set of parameters.
/// </summary>
/// <param name="settings">A MongoClientSettings object</param>
/// <param name="database">Name of the database</param>
public DB(MongoClientSettings settings, string database)
{
Initialize(settings, database);
}
