public IWorkflowStore Create()
{
var mongoDbConfigurationSection = _configurationProvider.GetSection <IWorkflowMongoDbConfigurationSection>();
var credentialPassword = new SecureString();
foreach (var @char in mongoDbConfigurationSection.CredentialPassword)
{
credentialPassword.AppendChar(@char);
}
var mongoClient = new MongoClient(new MongoClientSettings
{
Server = new MongoServerAddress(mongoDbConfigurationSection.ServerHost, mongoDbConfigurationSection.ServerPort),
Credential = MongoCredential.CreateCredential(
mongoDbConfigurationSection.CredentialDatabaseName,
mongoDbConfigurationSection.CredentialUserName,
credentialPassword),
ConnectionMode = ConnectionMode.Automatic
});
var mongoDatabase = mongoClient.GetDatabase(mongoDbConfigurationSection.DatabaseName);
var mongoStore = new MongoDbWorkflowStore(mongoDatabase);
return(mongoStore);
}
public MongoContext(IOptions <MongoOptions> options)
{
var permissionSystem =
MongoCredential.CreateCredential(options.Value.DataBase, options.Value.UserName,
options.Value.Password);
var services = new List <MongoServerAddress>();
foreach (var item in options.Value.Services)
{
services.Add(new MongoServerAddress(item.Host, item.Port));
}
//var settings = new MongoClientSettings
//{
// Credentials = new[] { permissionSystem },
// Servers = services
//};
var settings = new MongoClientSettings
{
Servers = services
};
var _mongoClient = new MongoClient(settings);
database = _mongoClient.GetDatabase(options.Value.DataBase);
}
public IMongoDatabase GetDatabase()
{
string databaseName = ConnectionString.Split('/').Last();
MongoClientSettings settings = new MongoClientSettings();
settings.ConnectTimeout = new TimeSpan(0, 0, 0, 30, 0);
settings.ConnectionMode = ConnectionMode.Direct;
string server = new Regex("@.+/").Match(ConnectionString).Value.Substring(1);
string host = server.Split(':').First();
string userName = new Regex("//[^@]+").Match(ConnectionString).Value.Split(':').First().Substring(2);
string password = new Regex("//[^@]+").Match(ConnectionString).Value.Split(':').Last();
MongoCredential credential = MongoCredential.CreateCredential(databaseName, userName, password);
settings.Credential = credential;
settings.Server = new MongoServerAddress(host);
MongoClient client = new MongoClient(settings);
IMongoDatabase database = client.GetDatabase(databaseName);
var pack = new ConventionPack();
pack.Add(new IgnoreExtraElementsConvention(true));
ConventionRegistry.Register("EntityFrameworkCore.BootKit", pack, t => true);
return(database);
}
public void ReadFromEnvironment()
{
CollectionName = Environment.GetEnvironmentVariable(_collectionName);
ConnectionString = Environment.GetEnvironmentVariable(_connectionString);
DatabaseName = Environment.GetEnvironmentVariable(_databaseName);
try
{
Credentials = MongoCredential.CreateCredential(
databaseName: "ApplicationDb",
username: Environment.GetEnvironmentVariable(_mongoUsername),
password: Environment.GetEnvironmentVariable(_mongoPassword));
}
catch (System.Exception)
{
throw new EnvironmentNotSet("Mongodb credentials not given");
}
if (String.IsNullOrEmpty(CollectionName) ||
String.IsNullOrEmpty(ConnectionString) ||
String.IsNullOrEmpty(DatabaseName) ||
Credentials == null)
{
throw new EnvironmentNotSet("Database variables not set");
}
}
/// <summary>
/// É mais seguro né!
/// 1. Você precisa criar um usuário no seu mongodb
/// 2. garantir o acesso a todos os databases
/// 3. Criar um novo usuário em seu database e conceder o acesso que você quiser
/// </summary>
public static void CriandoConexaoAutenticada()
{
try
{
var settings = new MongoClientSettings
{
ServerSelectionTimeout = new TimeSpan(0, 0, 5),
Server = new MongoServerAddress("localhost", 27017),
Credentials = new[]
{
MongoCredential.CreateCredential("loja", "felipe", "felipe123456")
}
};
var client = new MongoClient(settings);
var database = client.GetDatabase("loja");
var colecao = database.GetCollection <Usuario>("usuarios");
//se tiver registro no mongdb sem endereço, retornara um erro porque não tratamos no override do tostring
var filtro = Builders <Usuario> .Filter.Empty;
var usuarios = colecao.Find(filtro).ToList();
usuarios.ForEach(u => Console.WriteLine(u));
}
catch (Exception ex)
{
Console.Write($"Erro: {ex.Message}");
}
}
private void _CreateDB(string dbname, string username, string password)
{
var adminCredentials = MongoCredential.CreateCredential("admin", "manager", "mystique00R");
var adminClientSeetings = new MongoClientSettings {
Credentials = new List <MongoCredential> {
adminCredentials
}
};
var myDatabaseWithAdminCredentials = new MongoClient(adminClientSeetings).GetDatabase(dbname);
var user = new BsonDocument {
{ "createUser", username }, { "pwd", password }, { "roles", new BsonArray {
new BsonDocument {
{ "role", "dbOwner" }, { "db", dbname }
}
} }
};
try
{
var result = myDatabaseWithAdminCredentials.RunCommand <BsonDocument>(user);
}
catch
{
}
}
public override void Initialize(string name, NameValueCollection config)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
base.Initialize(name, config);
_enablePasswordReset = TryReadBool(config["enablePasswordReset"], _enablePasswordReset);
_maxInvalidPasswordAttempts = TryReadInt(config["maxInvalidPasswordAttempts"], _maxInvalidPasswordAttempts);
_minRequiredNonAlphanumericCharacters = TryReadInt(config["minRequiredNonAlphanumericCharacters"], _minRequiredNonAlphanumericCharacters);
_minRequriedPasswordLength = TryReadInt(config["minRequriedPasswordLength"], _minRequriedPasswordLength);
_passwordAttemptWindow = TryReadInt(config["passwordAttemptWindow"], _passwordAttemptWindow);
_requiresUniqueEmail = TryReadBool(config["requiresUniqueEmail"], _requiresUniqueEmail);
MongoClientSettings settings = new MongoClientSettings
{
Server = new MongoServerAddress(DatabaseConfig.Host, DatabaseConfig.Port)
};
if (!string.IsNullOrEmpty(DatabaseConfig.Username) && !string.IsNullOrEmpty(DatabaseConfig.Password))
{
settings.Credentials = new List <MongoCredential>
{
MongoCredential.CreateCredential(DatabaseConfig.Database, DatabaseConfig.Username, DatabaseConfig.Password)
};
}
MongoClient dbClient = new MongoClient(settings);
_memberCollection = dbClient.GetDatabase(DatabaseConfig.Database).GetCollection <MongoMember>(MEMBER_COLLECTION_NAME);
}
public MongoClientSettings GetMongoClientSettings()
{
var settings = new MongoClientSettings()
{
ApplicationName = ApplicationName,
Server = new MongoServerAddress(Host, Port)
};
if (!string.IsNullOrEmpty(UserName))
{
settings.Credential =
MongoCredential.CreateCredential(DatabaseName, UserName, Password);
}
if (ConnectTimeout >= 1)
{
settings.ConnectTimeout = TimeSpan.FromSeconds(ConnectTimeout);
}
if (ServerSelectionTimeout >= 1)
{
settings.ServerSelectionTimeout = TimeSpan.FromSeconds(ServerSelectionTimeout);
}
return(settings);
}
public MongoStorage(IMongoSettings settings)
{
var mongoDataBaseName = settings.MongoDatabaseName;
var mongoClientSettings = new MongoClientSettings
{
Servers = settings.MongoServers,
WriteConcern = WriteConcern.W1,
ReadPreference = ReadPreference.Primary,
GuidRepresentation = GuidRepresentation.Standard
};
var mongoReplicaSetName = settings.MongoReplicaSetName;
if (!string.IsNullOrEmpty(mongoReplicaSetName))
{
mongoClientSettings.ReplicaSetName = mongoReplicaSetName;
}
var mongoUserName = settings.MongoUserName;
if (!string.IsNullOrEmpty(mongoUserName))
{
mongoClientSettings.Credential =
MongoCredential.CreateCredential(
mongoDataBaseName,
mongoUserName,
settings.MongoPassword);
}
var client = new MongoClient(mongoClientSettings);
this.database = client.GetDatabase(mongoDataBaseName);
}
public MongoConnection(string host, int port, string database, string username = "", string password = "", string replicaSetName = "", TimeSpan?socketTimeOut = null, TimeSpan?connectTimeOut = null, TimeSpan?serverSelectionTimeOut = null)
{
if (string.IsNullOrEmpty(host))
{
throw new ArgumentNullException(nameof(host));
}
if (string.IsNullOrEmpty(database))
{
throw new ArgumentNullException(nameof(database));
}
DatabaseName = database;
MongoCredential mongoCredential = null;
if (!string.IsNullOrEmpty(username))
{
mongoCredential = MongoCredential.CreateCredential(database, username, password);
}
Server = new MongoServerAddress(host, port);
SocketTimeout = socketTimeOut ?? TimeOut();
ConnectTimeout = connectTimeOut ?? TimeOut();
ServerSelectionTimeout = serverSelectionTimeOut ?? TimeOut();
Credential = mongoCredential;
if (!string.IsNullOrEmpty(replicaSetName))
{
ReplicaSetName = replicaSetName;
}
}
public async static Task FillDatabase(
IEnumerable <BsonDocument> seasons,
IEnumerable <BsonDocument> players,
IEnumerable <BsonDocument> coaches)
{
await Task.Run(() =>
{
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);
var seasonsCollection = db.GetCollection <BsonDocument>("Seasons");
seasonsCollection.InsertMany(seasons);
var playersCollection = db.GetCollection <BsonDocument>("Players");
playersCollection.InsertMany(players);
var coachesCollection = db.GetCollection <BsonDocument>("Coaches");
coachesCollection.InsertMany(coaches);
});
}
public MongoContext() //constructor
{
// Reading credentials from Web.config file
var MongoDatabaseName = ConfigurationManager.AppSettings["MongoDatabaseName"]; //CarDatabase
var MongoUsername = ConfigurationManager.AppSettings["MongoUsername"]; //demouser
var MongoPassword = ConfigurationManager.AppSettings["MongoPassword"]; //Pass@123
var MongoPort = ConfigurationManager.AppSettings["MongoPort"]; //27017
var MongoHost = ConfigurationManager.AppSettings["MongoHost"]; //localhost
// Creating credentials
var credential = MongoCredential.CreateCredential
(MongoDatabaseName,
MongoUsername,
MongoPassword);
// Creating MongoClientSettings
var settings = new MongoClientSettings
{
Credential = credential,
Server = new MongoServerAddress(MongoHost, Convert.ToInt32(MongoPort))
};
_client = new MongoClient(settings);
var database = _client.GetDatabase("TmspDatabase");
}
/// <summary>
/// Constructor.
/// </summary>
private DatabaseClient()
{
MongoClientSettings settings = new MongoClientSettings
{
AllowInsecureTls = Program.Settings.DBAllowInsecureTls,
ApplicationName = "StreamActions",
ConnectionMode = ConnectionMode.Automatic,
ConnectTimeout = TimeSpan.FromSeconds(30),
GuidRepresentation = GuidRepresentation.Standard,
UseTls = Program.Settings.DBUseTls
};
if (!string.IsNullOrWhiteSpace(Program.Settings.DBHost))
{
settings.Server = Program.Settings.DBPort > 0
? new MongoServerAddress(Program.Settings.DBHost, Program.Settings.DBPort)
: new MongoServerAddress(Program.Settings.DBHost);
}
if (!string.IsNullOrWhiteSpace(Program.Settings.DBName) || !string.IsNullOrWhiteSpace(Program.Settings.DBUsername))
{
settings.Credential = MongoCredential.CreateCredential(Program.Settings.DBName, Program.Settings.DBUsername, Program.Settings.DBPassword);
}
this._mongoClient = new MongoClient(settings);
}
public MongoDBCache(IOptions <MongoDBCacheOptions> settings)
{
var mongoSetttings = new Mongo.MongoClientSettings()
{
Server = new Mongo.MongoServerAddress(settings.Value.Hostname)
};
if (settings.Value.Username != null)
{
mongoSetttings.Credential = MongoCredential.CreateCredential(settings.Value.Database, settings.Value.Username, settings.Value.Password);
}
Client = new Mongo.MongoClient(mongoSetttings);
Database = Client.GetDatabase(settings.Value.Database);
ImageMetadatas = Database.GetCollection <ImageMetadataModel>("ImageMetadata");
ImageBuffer = new GridFSBucket(Database, new GridFSBucketOptions()
{
BucketName = "ImageBuffer"
});
//create index
ImageMetadatas.Indexes.CreateOne(new CreateIndexModel <ImageMetadataModel>(new IndexKeysDefinitionBuilder <ImageMetadataModel>().Ascending(x => x.Key)));
ImageMetadatas.Indexes.CreateOne(new CreateIndexModel <ImageMetadataModel>(new IndexKeysDefinitionBuilder <ImageMetadataModel>().Ascending(x => x.Created)));
ImageMetadatas.Indexes.CreateOne(new CreateIndexModel <ImageMetadataModel>(new IndexKeysDefinitionBuilder <ImageMetadataModel>().Ascending(x => x.MimeType)));
ImageMetadatas.Indexes.CreateOne(new CreateIndexModel <ImageMetadataModel>(new IndexKeysDefinitionBuilder <ImageMetadataModel>().Ascending(x => x.DPR)));
ImageMetadatas.Indexes.CreateOne(new CreateIndexModel <ImageMetadataModel>(new IndexKeysDefinitionBuilder <ImageMetadataModel>().Ascending(x => x.Width)));
ImageMetadatas.Indexes.CreateOne(new CreateIndexModel <ImageMetadataModel>(new IndexKeysDefinitionBuilder <ImageMetadataModel>().Ascending(x => x.Height)));
}
public void ReadFromEnvironment()
{
try
{
CollectionName = Environment.GetEnvironmentVariable(_collectionName);
ConnectionString = Environment.GetEnvironmentVariable(_connectionString);
DatabaseName = Environment.GetEnvironmentVariable(_databaseName);
MongoServiceName = Environment.GetEnvironmentVariable(_mongoServiceName);
if (int.TryParse(Environment.GetEnvironmentVariable(_mongoServicePort), out var dbPort))
{
MongoServicePort = dbPort;
}
else
{
throw new EnvironmentNotSet("DatabasePort not set");
}
Credentials = MongoCredential.CreateCredential(
DatabaseName,
Environment.GetEnvironmentVariable(_mongoUsername),
Environment.GetEnvironmentVariable(_mongoPassword));
}
catch (System.Exception)
{
throw new EnvironmentNotSet("Mongodb credentials not given");
}
if (string.IsNullOrEmpty(CollectionName) ||
string.IsNullOrEmpty(ConnectionString) ||
string.IsNullOrEmpty(DatabaseName) ||
Credentials == null)
{
throw new EnvironmentNotSet("Database variables not set");
}
}
/// <summary>
/// 获取mongodb实例
/// </summary>
public static IMongoCollection <T> MongodbInfoClient(MongodbHost host)
{
try
{
var hosts = host.DBHost.Split(new char[] { '|' });
var servers = new List <MongoServerAddress>();
foreach (var h in hosts)
{
servers.Add(new MongoServerAddress(h, int.Parse(host.DBPort)));
}
var mc = new MongoClient(new MongoClientSettings
{
Servers = servers,
Credentials = new List <MongoCredential> {
MongoCredential.CreateCredential("admin", host.DBUser, host.DBPwd)
},
SocketTimeout = TimeSpan.FromSeconds(double.Parse(host.DBTimeOut))
});
var Database = mc.GetDatabase(host.DBName);
return(Database.GetCollection <T>(host.Table));
}
catch (Exception ex)
{
throw ex;
}
}
public BlogMongoDbDatabaseProvider()
{
var settings = new MongoClientSettings();
var servers = new List <MongoServerAddress>();
AppSettings.MongoDb.Servers.ForEach(x =>
{
servers.Add(new MongoServerAddress(x.Host, x.Port));
});
settings.Servers = servers;
if (AppSettings.MongoDb.Username.IsNotNullOrEmpty())
{
settings.Credential = MongoCredential.CreateCredential("admin", AppSettings.MongoDb.Username, AppSettings.MongoDb.Password);
}
if (AppSettings.MongoDb.ConnectionMode.ToLower() == "replicaset")
{
settings.ConnectionMode = ConnectionMode.ReplicaSet;
settings.ReadPreference = new ReadPreference(ReadPreferenceMode.SecondaryPreferred);
}
Client = new MongoClient(settings);
Database = Client.GetDatabase(AppSettings.MongoDb.DatabaseName);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
MongoCredential credential = MongoCredential.CreateCredential("shawndb", "shawn", "password");
var server = new MongoServerAddress(host: "115.159.155.126", port: 27017);
MongoClientSettings settings = new MongoClientSettings
{
Credential = credential,
Server = server,
ConnectionMode = ConnectionMode.Standalone
};
var mongoclient = new MongoClient(settings);
services.AddSingleton(mongoclient);
var databse = mongoclient.GetDatabase("shawndb");
services.AddScoped <IMongoDatabase>((p) => { return(databse); });
services.AddScoped <IMongoRepository <Order> >(p =>
{
return(new MongoRepository <Order>(databse, "Orders"));
});
services.AddScoped <IBookRepository>(p =>
{
return(new BookRepository(databse, "Books"));
});
}
/// <summary>
/// Creates the credentials for a user given a db
/// </summary>
/// <returns>The credentials.</returns>
/// <param name="db">Database name</param>
/// <param name="usr">Username</param>
/// <param name="pwd">Password</param>
private MongoCredential CreateCredentials(string db, string usr, string pwd)
{
MongoCredential dbCredential = MongoCredential
.CreateCredential(db, usr, pwd);
return(dbCredential);
}
public MongoDbProvider(IOptions<HttpTrackerMongoDbOptions> options)
{
Options = options.Value;
if (Options.Services == null)
throw new Exception("MongoDb 配置有误，请检查。");
var settings = new MongoClientSettings();
var servers = new List<MongoServerAddress>();
foreach (var item in Options.Services)
{
var host = item.Split(":");
servers.Add(new MongoServerAddress(host.First(), Convert.ToInt32(host.Last())));
}
settings.Servers = servers;
if (!string.IsNullOrEmpty(Options.Username) && !string.IsNullOrEmpty(Options.Password))
{
settings.Credential = MongoCredential.CreateCredential("admin", Options.Username, Options.Password);
}
if (Options.ConnectionMode?.ToLower() == "replicaset")
{
settings.ConnectionMode = ConnectionMode.ReplicaSet;
settings.ReadPreference = new ReadPreference(ReadPreferenceMode.SecondaryPreferred);
}
Client = new MongoClient(settings);
Database = Client.GetDatabase(Options.DatabaseName);
}
private void Initialize(DBCredentials _credentials)
{
if (_credentials.Port <= 0)
{
_credentials.Port = 27017;
}
//TODO - Fix so uses ServiceCredentials
MongoCredential credential = MongoCredential.CreateCredential(_credentials.AuthenticationDBName,
_credentials.UserName,
_credentials.Password);
List <MongoServerAddress> serverAddresses = new List <MongoServerAddress>();
foreach (string serverName in _credentials.Servers)
{
MongoServerAddress msa = new MongoServerAddress(serverName, _credentials.Port);
serverAddresses.Add(msa);
}
MongoClientSettings mcs = new MongoClientSettings
{
Servers = serverAddresses,
Credentials = new[] { credential }
};
m_MongoClient = new MongoClient(mcs);
m_MongoServer = m_MongoClient.GetServer();
MongoDB = m_MongoServer.GetDatabase(_credentials.DBName);
}
public BaseRepository(IConfigurationUtility configurationUtility, string collection)
{
this.ConfigurationUtility = configurationUtility;
this.CollectionName = collection;
var server = new MongoServerAddress(
this.ConfigurationUtility.DatabaseConnectionHost,
Int32.Parse(this.ConfigurationUtility.DatabaseConnectionPort));
var settings = new MongoClientSettings()
{
Server = server,
MaxConnectionIdleTime = TimeSpan.FromMilliseconds(45000)
};
MongoCredential credentials = null;
if (string.IsNullOrWhiteSpace(this.ConfigurationUtility.DatabaseConnectionUsername) == false)
{
credentials = MongoCredential.CreateCredential(this.ConfigurationUtility.DatabaseConnectionName,
this.ConfigurationUtility.DatabaseConnectionUsername,
this.ConfigurationUtility.DatabaseConnectionPassword);
settings.Credential = credentials;
}
this.Client = new MongoClient(settings);
this.Database = this.Client.GetDatabase(this.ConfigurationUtility.DatabaseConnectionName);
}
public IMongoDatabase BuildDatabaseClient(DatabaseSettings dbSettings)
{
Console.WriteLine($"Configured with these Settings: {Environment.NewLine}" +
$"{JToken.FromObject(dbSettings).ToString()}");
var credential = MongoCredential.CreateCredential("admin",
dbSettings.DatabaseUserName,
dbSettings.DatabasePassword);
var clientSettings = new MongoClientSettings()
{
Credential = credential,
Server = MongoServerAddress.Parse(dbSettings.ConnectionString),
AllowInsecureTls = true
};
var client = new MongoClient(clientSettings);
// DB Configuration
var pack = new ConventionPack()
{
new EnumRepresentationConvention(BsonType.String)
};
ConventionRegistry.Register("EnumStringConvention", pack, t => true);
return(client.GetDatabase(dbSettings.DatabaseName));
}
private IWorkflowStore BuildWorkflowStore(bool mockWorkflowStore, bool nested)
{
if (mockWorkflowStore)
{
return(nested ? BuildWorkflowStoreNested().Object : BuildWorkflowStoreFlat().Object);
}
var password = new SecureString();
password.AppendChar('f');
password.AppendChar('l');
password.AppendChar('o');
password.AppendChar('w');
var mongoClient = new MongoClient(new MongoClientSettings
{
Server = new MongoServerAddress("localhost", 27017),
Credential = MongoCredential.CreateCredential("admin", "flow", password),
ConnectionMode = ConnectionMode.Automatic
});
var mongoDatabase = mongoClient.GetDatabase("workflow");
var mongoStore = new MongoDbWorkflowStore(mongoDatabase);
InitializeWorkflowStore(mongoStore);
return(mongoStore);
}
public static void Initialize()
{
login = Security.Encrypting.AES_Decrypt(LOGIN_enc);
password = Security.Encrypting.AES_Decrypt(PASSWORD_enc);
databaseName = Security.Encrypting.AES_Decrypt(DATABASE_enc);
MongoUrl url = new MongoUrl(connectionString);
var settings = MongoClientSettings.FromUrl(url);
MongoCredential credentials = MongoCredential.CreateCredential(databaseName, login, password); //TODO encrypt this things
List <MongoCredential> credentials_list = new List <MongoCredential>();
credentials_list.Add(credentials);
//settings.Credentials = credentials_list;
client = new MongoClient(settings);
server = client.GetServer();
//database = client.GetDatabase(DATABASE_NAME);
database = server.GetDatabase(databaseName);
iDatabase = client.GetDatabase(databaseName);
_client = new MongoClient(settings);
_database = _client.GetDatabase(databaseName);
}
/// <summary>
/// 静态构造方法，初始化链接池管理对象
/// </summary>
protected IMongoDatabase ShareMongoDb(string dbConfigSelectionKey)
{
if (!dbDic.ContainsKey(dbConfigSelectionKey))
{
lock (lockObj)
{
if (!dbDic.ContainsKey(dbConfigSelectionKey))
{
MongoConfig _mongoConfig = MongoConfig.GetConfig(dbConfigSelectionKey);
var logSetting = new MongoClientSettings
{
Server = new MongoServerAddress(_mongoConfig.ServerConStr, _mongoConfig.ServerPort),
MaxConnectionPoolSize = _mongoConfig.MaxConnectionPoolSize,
MaxConnectionIdleTime = TimeSpan.FromSeconds(_mongoConfig.MaxConnectionIdleTime),
MaxConnectionLifeTime = TimeSpan.FromSeconds(_mongoConfig.MaxConnectionLifeTime),
ConnectTimeout = TimeSpan.FromSeconds(_mongoConfig.ConnectTimeout),
WaitQueueSize = _mongoConfig.WaitQueueSize,
SocketTimeout = TimeSpan.FromSeconds(_mongoConfig.SocketTimeout),
WaitQueueTimeout = TimeSpan.FromSeconds(_mongoConfig.WaitQueueTimeout)
};
if (!string.IsNullOrEmpty(_mongoConfig.UserName) && !string.IsNullOrEmpty(_mongoConfig.PassWord))//设置MongoDb用户密码
{
MongoCredential mongoCredential = MongoCredential.CreateCredential(_mongoConfig.DefaultDb, _mongoConfig.UserName, _mongoConfig.PassWord);
List <MongoCredential> mongoCredentialList = new List <MongoCredential>();
mongoCredentialList.Add(mongoCredential);
logSetting.Credentials = mongoCredentialList;
}
var logClient = new MongoClient(logSetting);
IMongoDatabase db = logClient.GetDatabase(_mongoConfig.DefaultDb);
dbDic.Add(dbConfigSelectionKey, db);
}
}
}
return(dbDic[dbConfigSelectionKey]);
}
public MongoDbService(MongoDBConfig dBConfig)
{
_dBConfig = dBConfig;
_client = new MongoClient(new MongoClientSettings()
{
Server = MongoServerAddress.Parse(_dBConfig.Host),
Credential = string.IsNullOrEmpty(_dBConfig.AuthMechanism)
? null
: MongoCredential.CreateCredential(
_dBConfig.AuthSource,
_dBConfig.Username,
_dBConfig.Password
)
});
_dB = _client.GetDatabase(_dBConfig.Database);
_data = _dB.GetCollection <CcData>(_dBConfig.CollectionData);
_events = _dB.GetCollection <CcEvent>(_dBConfig.CollectionEvents);
_groups = _dB.GetCollection <CcGroup>(_dBConfig.CollectionGroups);
Data = new MongoCollection <CcData>(_data);
Events = new MongoCollection <CcEvent>(_events);
Groups = new MongoCollection <CcGroup>(_groups);
}
private static MongoClient ConnectToDatabase()
{
try
{
// Connect to the MongoDB database
MongoClient client = new MongoClient(new MongoClientSettings
{
Server = new MongoServerAddress(address, port),
ServerSelectionTimeout = TimeSpan.FromSeconds(10),
//
// Credential settings for MongoDB
//
Credential = MongoCredential.CreateCredential(database, azureLogin.UserName, azureLogin.SecurePassword),
//
// Credential settings for CosmosDB Mongo API
//
//UseTls = true,
//Credential = new MongoCredential("SCRAM-SHA-1", new MongoInternalIdentity(database, azureLogin.UserName), new PasswordEvidence(azureLogin.SecurePassword))
// End of Mongo API settings
});
return(client);
}
catch (Exception e)
{
Console.WriteLine($"Failed to connect to database: {e.Message}");
return(null);
}
}
public IMongoDatabase GetDatabase()
{
string databaseName = ConnectionString.Split('/').Last();
MongoClientSettings settings = new MongoClientSettings();
settings.ConnectTimeout = new TimeSpan(0, 0, 0, 30, 0);
settings.ConnectionMode = ConnectionMode.Direct;
string server = new Regex("@.+/").Match(ConnectionString).Value.Substring(1);
string host = server.Split(':').First();
string userName = new Regex("//[^@]+").Match(ConnectionString).Value.Split(':').First().Substring(2);
string password = new Regex("//[^@]+").Match(ConnectionString).Value.Split(':').Last();
MongoCredential credential = MongoCredential.CreateCredential(databaseName, userName, password);
settings.Credential = credential;
settings.Server = new MongoServerAddress(host);
MongoClient client = new MongoClient(settings);
IMongoDatabase database = client.GetDatabase(databaseName);
return(database);
}
public MongoDbContext()
{
try
{
//var mongoUrl = new MongoUrl(ConnectionString);
var credential = MongoCredential.CreateCredential("dbstockmanager", "diego", "Linx@123456");
var mongoClientSettings = new MongoClientSettings
{
Server = new MongoServerAddress("ds040027.mlab.com", 40027),
ClusterConfigurator = builder =>
{
builder.ConfigureCluster(settings => settings.With(serverSelectionTimeout: TimeSpan.FromSeconds(100000)));
},
Credential = credential,
RetryWrites = false
//SslSettings.SslSettings = new SslSettings { EnabledSslProtocols = System.Security.Authentication.SslProtocols.Tls12 }
};
var mongoClient = new MongoClient(mongoClientSettings);
_database = mongoClient.GetDatabase(DatabaseName);
}
catch (Exception ex)
{
throw new Exception("Não foi possível se conectar com o servidor.", ex);
}
}