public static MongoServerSettings GetReplicaSetSettings(string roleName)
{
var settings = new MongoServerSettings();
var replicaSetName = RoleEnvironment.GetConfigurationSettingValue(ReplicaSetNameSetting);
settings.ReplicaSetName = replicaSetName;
ReadOnlyCollection<RoleInstance> workerRoleInstances;
try
{
workerRoleInstances = RoleEnvironment.Roles[roleName].Instances;
}
catch (KeyNotFoundException ke)
{
throw new Exception(
string.Format("The MongoDB role should be called {0}", roleName),
ke);
}
var servers = new List<MongoServerAddress>();
foreach (var instance in workerRoleInstances)
{
var endpoint = AzureRoleHelper.GetEndPoint(instance, MongodPortKey);
var server = new MongoServerAddress(endpoint.Address.ToString(), endpoint.Port);
servers.Add(server);
}
settings.Servers = servers;
settings.ConnectionMode = ConnectionMode.ReplicaSet;
return settings;
}
/// <summary>
/// 设置你的collection
/// </summary>
public void SetCollection(string DBAddress, int port, int connectionPool, int minpool, string dbName)
{
MongoServerAddress ipaddress = new MongoServerAddress(DBAddress, port); //设置服务器的ip和端口
MongoClientSettings settingsclient = new MongoClientSettings(); //实例化客户端设置类
settingsclient.Server = ipaddress;//端口赋值
settingsclient.MaxConnectionPoolSize = connectionPool;
settingsclient.MinConnectionPoolSize = minpool;
settingsclient.ConnectionMode = 0; //链接模式设置
MongoClient client = new MongoClient(settingsclient); //调用客户端类构造函数设置参数
MongoServer server = client.GetServer();//服务端获取客户端参数
var database = server.GetDatabase(dbName);//获取数据库名称
collection = database.GetCollection <T>(collectionName);
}
private void ProcessFirstResponse(ConnectResponse response)
{
var isMasterResponse = response.IsMasterResult.Response;
// first response has to match replica set name in settings (if any)
var replicaSetName = isMasterResponse["setName"].AsString;
if (_server.Settings.ReplicaSetName != null && replicaSetName != _server.Settings.ReplicaSetName)
{
var message = string.Format(
"Server at address '{0}' is a member of replica set '{1}' and not '{2}'.",
response.ServerInstance.Address, replicaSetName, _server.Settings.ReplicaSetName);
throw new MongoConnectionException(message);
}
_server.ReplicaSetName = replicaSetName;
// find all valid addresses
var validAddresses = new HashSet <MongoServerAddress>();
if (isMasterResponse.Contains("hosts"))
{
foreach (string address in isMasterResponse["hosts"].AsBsonArray)
{
validAddresses.Add(MongoServerAddress.Parse(address));
}
}
if (isMasterResponse.Contains("passives"))
{
foreach (string address in isMasterResponse["passives"].AsBsonArray)
{
validAddresses.Add(MongoServerAddress.Parse(address));
}
}
if (isMasterResponse.Contains("arbiters"))
{
foreach (string address in isMasterResponse["arbiters"].AsBsonArray)
{
validAddresses.Add(MongoServerAddress.Parse(address));
}
}
// remove server instances created from the seed list that turn out to be invalid
var invalidInstances = _server.Instances.Where(i => !validAddresses.Contains(i.Address)).ToArray(); // force evaluation
foreach (var invalidInstance in invalidInstances)
{
_server.RemoveInstance(invalidInstance);
}
// add any server instances that were missing from the seed list
foreach (var address in validAddresses)
{
if (!_server.Instances.Any(i => i.Address == address))
{
var missingInstance = new MongoServerInstance(_server, address);
_server.AddInstance(missingInstance);
QueueConnect(missingInstance);
}
}
}
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));
}
public MongoEventStore(ILoggerFactory loggerFactory, IEventStoreOptions options)
{
if (!(options is IMongoEventStoreOptions mongoOptions))
{
throw new Exception("Options should be of type IMongoDatabaseOptions");
}
Logger = loggerFactory.CreateLogger(GetType());
var mongoClientSettings = new MongoClientSettings
{
Server = MongoServerAddress.Parse(mongoOptions.ConnectionString)
};
try
{
var client = new MongoClient(mongoClientSettings);
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
if (string.IsNullOrWhiteSpace(environment))
{
environment = "testing";
}
var mongoDatabase = client.GetDatabase($"{mongoOptions.DatabaseName}-{environment}");
Collection = mongoDatabase.GetCollection <TEvent>(options.CollectionName);
}
catch (Exception exception)
{
Logger.LogCritical(
$"Error while connecting to {mongoClientSettings.Server.Host}. Exception: {exception.Message}",
exception);
throw;
}
}
public void TestEquals()
{
var a = new MongoServerAddress("host1");
var b = new MongoServerAddress("host1");
var c = new MongoServerAddress("host2");
var n = (MongoServerAddress)null;
Assert.True(object.Equals(a, b));
Assert.False(object.Equals(a, c));
Assert.False(a.Equals(n));
Assert.False(a.Equals(null));
Assert.True(a == b);
Assert.False(a == c);
Assert.False(a == null);
Assert.False(null == a);
Assert.True(n == null);
Assert.True(null == n);
Assert.False(a != b);
Assert.True(a != c);
Assert.True(a != null);
Assert.True(null != a);
Assert.False(n != null);
Assert.False(null != n);
}
public DatabaseContext(MongoDBConfig config)
{
//var client = new MongoClient(config.ConnectionString);
//_db = client.GetDatabase(config.Database);
//string username = config.User;
//string password = config.Password;
string mongoDbAuthMechanism = "SCRAM-SHA-1";
MongoInternalIdentity internalIdentity =
new MongoInternalIdentity("admin", config.User);
PasswordEvidence passwordEvidence = new PasswordEvidence(config.Password);
MongoCredential mongoCredential =
new MongoCredential(mongoDbAuthMechanism,
internalIdentity, passwordEvidence);
List <MongoCredential> credentials =
new List <MongoCredential>()
{
mongoCredential
};
MongoClientSettings settings = new MongoClientSettings();
// comment this line below if your mongo doesn't run on secured mode
//settings.Credentials = credentials;
String mongoHost = config.Host;
MongoServerAddress address = new MongoServerAddress(mongoHost);
settings.Server = address;
MongoClient client = new MongoClient(settings);
_db = client.GetDatabase(config.Database);
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
var connectionString = "ConnectTo=tcp://admin:changeit@localhost:1113; HeartBeatTimeout=500";
services.AddSingleton(x => EventStoreConnection.Create(connectionString: connectionString));
services.AddTransient <ITransientDomainEventPublisher, TransientDomainEventPubSub>();
services.AddTransient <ITransientDomainEventSubscriber, TransientDomainEventPubSub>();
services.AddTransient <IRepository <Cart, CartId>, EventSourcingRepository <Cart, CartId> >();
services.AddSingleton <IEventStore, EventStoreEventStore>();
var mongoSettings = new MongoClientSettings()
{
Server = MongoServerAddress.Parse("localhost:1234"),
};
services.AddSingleton(x => new MongoClient(mongoSettings));
services.AddSingleton(x => x.GetService <MongoClient>().GetDatabase(ReadModelDBName));
services.AddTransient <IReadOnlyRepository <ReadCart>, MongoDBRepository <ReadCart> >();
services.AddTransient <IRepository <ReadCart>, MongoDBRepository <ReadCart> >();
services.AddTransient <IReadOnlyRepository <ReadCartItem>, MongoDBRepository <ReadCartItem> >();
services.AddTransient <IRepository <ReadCartItem>, MongoDBRepository <ReadCartItem> >();
services.AddTransient <IReadOnlyRepository <Product>, MongoDBRepository <Product> >();
services.AddTransient <IRepository <Product>, MongoDBRepository <Product> >();
services.AddTransient <IReadOnlyRepository <Customer>, MongoDBRepository <Customer> >();
services.AddTransient <IRepository <Customer>, MongoDBRepository <Customer> >();
services.AddTransient <IDomainEventHandler <CartId, CartCreatedEvent>, CartUpdater>();
services.AddTransient <IDomainEventHandler <CartId, ProductAddedEvent>, CartUpdater>();
services.AddTransient <IDomainEventHandler <CartId, ProductQuantityChangedEvent>, CartUpdater>();
services.AddTransient <ICartWriter, CartWriter>();
services.AddTransient <ICartReader, CartReader>();
}
protected MongoClient ConnectToServer(string connectionString)
{
if (string.IsNullOrEmpty(connectionString))
{
// Default to using camel case for properties
var conventionPack = new ConventionPack {
new CamelCaseElementNameConvention()
};
ConventionRegistry.Register("camelCase", conventionPack, t => true);
var mongoServer = new MongoServerAddress(_mongoDbSettings.Server);
var mongoSettings = new MongoClientSettings
{
ApplicationName = _mongoDbSettings.ApplicationName,
ConnectTimeout = TimeSpan.FromSeconds(_mongoDbSettings.Timeout),
Server = mongoServer
};
if (_mongoDbSettings.Admin != null &&
!string.IsNullOrWhiteSpace(_mongoDbSettings.Admin.Trim()))
{
var mongoCredential =
MongoCredential.CreateCredential(
"admin",
_mongoDbSettings.Admin,
_mongoDbSettings.Password);
mongoSettings.Credential = mongoCredential;
}
return(new MongoClient(mongoSettings));
}
return(new MongoClient(connectionString));
}
private static IMongoDatabase conectar()
{
string username = "******";
string password = "******";
string mongoDbAuthMechanism = "SCRAM-SHA-1";
MongoInternalIdentity internalIdentity = new MongoInternalIdentity("admin", username);
PasswordEvidence passwordEvidence = new PasswordEvidence(password);
MongoCredential mongoCredential = new MongoCredential(mongoDbAuthMechanism, internalIdentity, passwordEvidence);
List <MongoCredential> credentials = new List <MongoCredential>()
{
mongoCredential
};
MongoClientSettings settings = new MongoClientSettings();
// comment this line below if your mongo doesn't run on secured mode
settings.Credentials = credentials;
String mongoHost = "localhost";
MongoServerAddress address = new MongoServerAddress(mongoHost);
settings.Server = address;
MongoClient client = new MongoClient(settings);
var mongoServer = client.GetDatabase("TesteMongoDb");
return(mongoServer);
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="ReplicaSetInformation"/> class.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="primary">The primary.</param>
/// <param name="members">The members.</param>
/// <param name="tagSet">The tag set.</param>
public ReplicaSetInformation(string name, MongoServerAddress primary, IEnumerable <MongoServerAddress> members, ReplicaSetTagSet tagSet)
{
_name = name;
_primary = primary;
_members = members == null ? new List <MongoServerAddress>() : members.ToList();
_tagSet = tagSet.FrozenCopy();
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="MongoServerInstance"/> class.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="address">The address.</param>
internal MongoServerInstance(MongoServerSettings settings, MongoServerAddress address)
{
_settings = settings;
_address = address;
_sequentialId = Interlocked.Increment(ref __nextSequentialId);
_state = MongoServerState.Disconnected;
_serverInfo = new ServerInformation
{
MaxDocumentSize = MongoDefaults.MaxDocumentSize,
MaxMessageLength = MongoDefaults.MaxMessageLength,
InstanceType = MongoServerInstanceType.Unknown
};
_connectionPool = new MongoConnectionPool(this);
_pingTimeAggregator = new PingTimeAggregator(5);
_permanentlyDisconnected = false;
// Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);
_stateVerificationAcquireConnectionOptions = new MongoConnectionPool.AcquireConnectionOptions
{
OkToAvoidWaitingByCreatingNewConnection = false,
OkToExceedMaxConnectionPoolSize = true,
OkToExceedWaitQueueSize = true,
WaitQueueTimeout = TimeSpan.FromSeconds(2)
};
}
// 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"));
});
}
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 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);
}
private DatabaseClient()
{
if (ConnectionInfo == null)
{
var colorWas = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("! default mongo connection is used !");
Console.ForegroundColor = colorWas;
this.client = new MongoClient();
}
else
{
//var settings = new MongoClientSettings();
//settings.Server = MongoServerAddress.Parse(ConnectionInfo.Server);
//settings.
var mongourlBuilder = new MongoUrlBuilder();
mongourlBuilder.Server = MongoServerAddress.Parse(ConnectionInfo.Server);
mongourlBuilder.Username = ConnectionInfo.Username;
mongourlBuilder.Password = ConnectionInfo.Password;
this.client = new MongoClient(mongourlBuilder.ToMongoUrl());
}
//TODO: implement connection
//this.client = new MongoClient();
}
public void TestParseWithHostAndPort()
{
var credentials = MongoServerAddress.Parse("host:123");
Assert.AreEqual("host", credentials.Host);
Assert.AreEqual(123, credentials.Port);
}
//=========================================================================
//
// AJAX ACTIONS
//
//=========================================================================
/// <summary>
/// Fetches the instance log by connecting to its mongod server.
/// This is fast and cheap, but won't work if the instance is down.
/// </summary>
public JsonResult GetServerLog(int id)
{
var server = ServerStatus.Get(id);
var urlBuilder = new MongoUrlBuilder();
urlBuilder.ConnectTimeout = new TimeSpan(0, 0, 3);
urlBuilder.Server = MongoServerAddress.Parse(server.Name);
urlBuilder.ReadPreference = ReadPreference.SecondaryPreferred;
var client = new MongoClient(urlBuilder.ToMongoUrl());
var conn = client.GetServer();
try
{
var command = new CommandDocument
{
{ "getLog", "global" }
};
var result = conn.GetDatabase("admin").RunCommand(command);
return(Json(new { log = HtmlizeFromLogArray(result.
Response["log"].AsBsonArray) },
JsonRequestBehavior.AllowGet));
}
catch (MongoException e)
{
return(Json(new { error = e.Message },
JsonRequestBehavior.AllowGet));
}
}
private static MongoClient GetClient()
{
MongoInternalIdentity internalIdentity =
new MongoInternalIdentity(MongoHelper.Database, MongoHelper.UserName);
PasswordEvidence passwordEvidence = new PasswordEvidence(MongoHelper.Password);
MongoCredential mongoCredential =
new MongoCredential(MongoHelper.AuthType,
internalIdentity, passwordEvidence);
List <MongoCredential> credentials =
new List <MongoCredential>()
{
mongoCredential
};
MongoClientSettings settings = new MongoClientSettings
{
Credentials = credentials
};
String mongoHost = MongoHelper.Server;
MongoServerAddress address = new MongoServerAddress(MongoHelper.Server);
settings.Server = address;
return(new MongoClient(settings));
}
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);
}
/// <summary>
///
/// </summary>
public static void LoadConfig()
{
XElement root = XElement.Load(HttpContext.Current.Server.MapPath("~/Configs/Retech.config"));
root = root.Element("MongoDBConnection");
DbName = root.Element("DbName").Value;
var writeElement = root.Element("WriteHost");
if (writeElement == null)
{
throw new Exception("~/Configs/MongoDB.config 中缺少 WriteHost");
}
WrietAddress = new MongoServerAddress(writeElement.Attribute("Ip").Value, int.Parse(writeElement.Attribute("Port").Value));
var readHostElements = root.Element("ReadHost").Elements("host");
ReadAddresss = new MongoServerAddress[readHostElements.Count()];
for (int i = 0; i < readHostElements.Count(); i++)
{
var hostElement = readHostElements.ElementAt(i);
var address = new MongoServerAddress(hostElement.Attribute("Ip").Value, int.Parse(hostElement.Attribute("Port").Value));
ReadAddresss[i] = address;
}
var poolElement = root.Element("ConnectionPool");
MaxConnectionPoolSize = int.Parse(poolElement.Attribute("maxSize").Value);
MinConnectionPoolSize = int.Parse(poolElement.Attribute("minSize").Value);
WaitQueueSize = int.Parse(poolElement.Attribute("waitQueueSize").Value);
}
public void TestConstructor(string host, int port)
{
var address = new MongoServerAddress(host, port);
Assert.AreEqual(host, address.Host);
Assert.AreEqual(port, address.Port);
}
/// <summary>
/// 配置连接池数据连接数据库
/// </summary>
/// <param name="maxConnectPoolSize">最大连接数</param>
/// <param name="minConnectPoolSize">最小链接数</param>
/// <param name="hostName">主机名</param>
/// <param name="port">端口</param>
/// <param name="database">数据库名</param>
public MongoDbProvider(int maxConnectPoolSize, int minConnectPoolSize, string hostName, Int32 port, string database)
{
if (string.IsNullOrEmpty(hostName) && string.IsNullOrEmpty(database))
{
// 输出错误：主机名或数据库名为空
}
else
{
try
{
MongoServerAddress ipaddress = new MongoServerAddress(hostName, port);
// 初始化连接数据
MongoClientSettings settingsClient = new MongoClientSettings
{
Server = ipaddress,
MaxConnectionPoolSize = maxConnectPoolSize,
MinConnectionPoolSize = minConnectPoolSize,
ConnectionMode = 0
};
// MongoUrl url=newMongoUrl(ConnectionString);
MongoClient client = new MongoClient(settingsClient);
_server = client.GetServer();
_database = _server.GetDatabase(database);
}
catch (Exception ex)
{
throw ex;
}
}
}
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 void TestEquals()
{
var a = new MongoServerAddress("host1");
var b = new MongoServerAddress("host1");
var c = new MongoServerAddress("host2");
var n = (MongoServerAddress)null;
Assert.IsTrue(object.Equals(a, b));
Assert.IsFalse(object.Equals(a, c));
Assert.IsFalse(a.Equals(n));
Assert.IsFalse(a.Equals(null));
Assert.IsTrue(a == b);
Assert.IsFalse(a == c);
Assert.IsFalse(a == null);
Assert.IsFalse(null == a);
Assert.IsTrue(n == null);
Assert.IsTrue(null == n);
Assert.IsFalse(a != b);
Assert.IsTrue(a != c);
Assert.IsTrue(a != null);
Assert.IsTrue(null != a);
Assert.IsFalse(n != null);
Assert.IsFalse(null != n);
}
public void TestConstructor_with_host(string host)
{
var address = new MongoServerAddress(host);
Assert.Equal(host, address.Host);
Assert.Equal(27017, address.Port);
}
public void TestConstructor_with_host_and_port(string host, int port)
{
var address = new MongoServerAddress(host, port);
Assert.Equal(host, address.Host);
Assert.Equal(port, address.Port);
}
public DBContext(IOptions <Settings> optionSettings)
{
string mongoDbAuthMechanism = "SCRAM-SHA-1";
MongoInternalIdentity internalIdentity =
new MongoInternalIdentity("admin", optionSettings.Value.Username);
PasswordEvidence passwordEvidence = new PasswordEvidence(optionSettings.Value.Password);
MongoCredential mongoCredential =
new MongoCredential(mongoDbAuthMechanism,
internalIdentity, passwordEvidence);
List <MongoCredential> credentials =
new List <MongoCredential>()
{
mongoCredential
};
MongoClientSettings settings = new MongoClientSettings();
// comment this line below if your mongo doesn't run on secured mode
//settings.Credentials = credentials;
String mongoHost = optionSettings.Value.Host;
MongoServerAddress address = new MongoServerAddress(mongoHost);
settings.Server = address;
MongoClient client = new MongoClient(settings);
if (client != null)
{
_database = client.GetDatabase(optionSettings.Value.Database);
}
}
public IMongoCollection <T> MongoConnection()
{
var settings = new MongoClientSettings();
if (!string.IsNullOrWhiteSpace(this._config.Username))
{
var internalIdentity = new MongoInternalIdentity(Mongo_Root_DB, this._config.Username);
var passwordEvidence = new PasswordEvidence(this._config.Password);
var mongoCredential = new MongoCredential(
this._config.AuthMechanism,
internalIdentity,
passwordEvidence);
settings.Credential = mongoCredential;
}
var address = new MongoServerAddress(this._config.Host);
settings.Server = address;
var client = new MongoClient(settings);
if (!BsonClassMap.IsClassMapRegistered(typeof(TenantUserProfileBase)))
{
BsonClassMap.RegisterClassMap <TenantUserProfileBase>();
}
var db = client.GetDatabase(this._config.Database);
var coll = db.GetCollection <T>(this._config.Collection);
return(coll);
}
public void TestCreateWithHostAndPort()
{
var credentials = new MongoServerAddress("host", 123);
Assert.AreEqual("host", credentials.Host);
Assert.AreEqual(123, credentials.Port);
}
public void TestParse(string host, int port, string value)
{
var address = MongoServerAddress.Parse(value);
Assert.AreEqual(host, address.Host);
Assert.AreEqual(port, address.Port);
}
public void TestDefaults()
{
var localhost = new MongoServerAddress("localhost");
var settings = new MongoServerSettings();
Assert.AreEqual(ConnectionMode.Direct, settings.ConnectionMode);
Assert.AreEqual(MongoDefaults.ConnectTimeout, settings.ConnectTimeout);
Assert.AreEqual(null, settings.DefaultCredentials);
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(SafeMode.False, settings.SafeMode);
Assert.AreEqual(1, settings.Servers.Count());
Assert.AreEqual(localhost, settings.Server);
Assert.AreEqual(localhost, settings.Servers.First());
Assert.AreEqual(MongoDefaults.SocketTimeout, settings.SocketTimeout);
Assert.AreEqual(false, settings.UseSsl);
Assert.AreEqual(MongoDefaults.ComputedWaitQueueSize, settings.WaitQueueSize);
Assert.AreEqual(MongoDefaults.WaitQueueTimeout, settings.WaitQueueTimeout);
Assert.IsFalse(settings.IsFrozen);
var hashCode = settings.GetHashCode();
var stringRepresentation = settings.ToString();
Assert.AreEqual(settings, settings);
settings.Freeze();
Assert.IsTrue(settings.IsFrozen);
Assert.AreEqual(hashCode, settings.GetHashCode());
Assert.AreEqual(stringRepresentation, settings.ToString());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
services.AddScoped <ITransactionsRepository, TransactionsRepository>();
services.AddScoped <IMongoDatabase>(s =>
{
string username = "******";
string password = "******";
string mongoDbAuthMechanism = "SCRAM-SHA-1";
MongoInternalIdentity internalIdentity =
new MongoInternalIdentity("admin", username);
PasswordEvidence passwordEvidence = new PasswordEvidence(password);
MongoCredential mongoCredential =
new MongoCredential(mongoDbAuthMechanism,
internalIdentity, passwordEvidence);
List <MongoCredential> credentials =
new List <MongoCredential>()
{
mongoCredential
};
MongoClientSettings settings = new MongoClientSettings();
// comment this line below if your mongo doesn't run on secured mode
settings.Credentials = credentials;
String mongoHost = Configuration["DOTNET_RUNNING_IN_CONTAINER"] != null ? "mongo" : "localhost"; // <== weblocal 'locahost', container 'mongo'
MongoServerAddress address = new MongoServerAddress(mongoHost);
settings.Server = address;
MongoDB.Driver.MongoClient client = new MongoDB.Driver.MongoClient(settings);
return(client.GetDatabase("bank"));
});
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="MongoServerInstance" /> class.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="address">The address.</param>
/// <param name="cluster">The cluster.</param>
/// <param name="endPoint">The end point.</param>
internal MongoServerInstance(MongoServerSettings settings, MongoServerAddress address, ICluster cluster, EndPoint endPoint)
{
_settings = settings;
_address = address;
_cluster = cluster;
_sequentialId = Interlocked.Increment(ref __nextSequentialId);
_endPoint = endPoint;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="MongoServerInstance"/> class.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="address">The address.</param>
/// <param name="cluster">The cluster.</param>
internal MongoServerInstance(MongoServerSettings settings, MongoServerAddress address, ICluster cluster)
{
_settings = settings;
_address = address;
_cluster = cluster;
_sequentialId = Interlocked.Increment(ref __nextSequentialId);
_endPoint = new DnsEndPoint(address.Host, address.Port);
}
/// <summary>
/// 通过连接名称获得Host信息
/// </summary>
/// <param name="ConnectionName"></param>
/// <returns></returns>
public static MongoServerAddress GetMongoSvrAddrByConnectionName(String ConnectionName)
{
MongoServerAddress mongosrvAddr = null;
if (SystemManager.config.ConnectionList.ContainsKey(ConnectionName)) {
mongosrvAddr = new MongoServerAddress(SystemManager.config.ConnectionList[ConnectionName].Host,
SystemManager.config.ConnectionList[ConnectionName].Port);
}
return mongosrvAddr;
}
public void PrimaryIsAtAddress(MongoServerAddress address)
{
Config.Out.WriteLine("Forcing primary to be at address {0}.", address);
Util.Timeout(TimeSpan.FromMinutes(5),
string.Format("Unable to make member at address {0} primary.", address),
TimeSpan.FromSeconds(10),
remaining => TryMakePrimaryAtAddress(address));
Config.Out.WriteLine("Primary is at address {0}.", address);
}
private MongoServerState state; // always use property to set value so event gets raised
#endregion
#region constructors
internal MongoServerInstance(
MongoServer server,
MongoServerAddress address
) {
this.server = server;
this.address = address;
this.maxDocumentSize = MongoDefaults.MaxDocumentSize;
this.maxMessageLength = MongoDefaults.MaxMessageLength;
this.state = MongoServerState.Disconnected;
}
private MongoServerState _state; // always use property to set value so event gets raised
// constructors
internal MongoServerInstance(MongoServer server, MongoServerAddress address)
{
_server = server;
_address = address;
_sequentialId = Interlocked.Increment(ref __nextSequentialId);
_maxDocumentSize = MongoDefaults.MaxDocumentSize;
_maxMessageLength = MongoDefaults.MaxMessageLength;
_state = MongoServerState.Disconnected;
_connectionPool = new MongoConnectionPool(this);
// Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);
}
internal MongoConnectionPool(
MongoServer server,
MongoConnection firstConnection
)
{
this.server = server;
this.address = firstConnection.Address;
pool.Add(firstConnection);
firstConnection.JoinConnectionPool(this);
}
// constructors
internal MongoServerInstance(MongoServer server, MongoServerAddress address)
{
this.server = server;
this.address = address;
this.sequentialId = Interlocked.Increment(ref nextSequentialId);
this.maxDocumentSize = MongoDefaults.MaxDocumentSize;
this.maxMessageLength = MongoDefaults.MaxMessageLength;
this.state = MongoServerState.Disconnected;
this.connectionPool = new MongoConnectionPool(this);
this.tags = new HashSet<string>();
// Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);
}
public MongoDatabase GetDB()
{
MongoServerAddress address = new MongoServerAddress("127.0.0.1", 27017);
MongoServerSettings settings = new MongoServerSettings();
settings.Server = address;
MongoServer server = new MongoServer(settings);
MongoDatabase myDB = server.GetDatabase("MyDB");
return myDB;
}
private IMongoCollection<Task> GetCollection() {
var mongoCredential = MongoCredential.CreateMongoCRCredential(databaseName, mongoToken.Key, mongoToken.Secret);
var serverAddress = new MongoServerAddress(serverName, serverPort);
var mongoClientSettings = new MongoClientSettings {
Credentials = new[] { mongoCredential },
Server = serverAddress
};
var client = new MongoClient(mongoClientSettings);
var database = client.GetDatabase(databaseName);
var collection = database.GetCollection<Task>(collectionName);
return collection;
}
// constructors
/// <summary>
/// Initializes a new instance of the <see cref="MongoServerInstance"/> class.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="address">The address.</param>
internal MongoServerInstance(MongoServer server, MongoServerAddress address)
{
_server = server;
_address = address;
_sequentialId = Interlocked.Increment(ref __nextSequentialId);
_state = MongoServerState.Disconnected;
_stateInfo = new ServerInformation
{
MaxDocumentSize = MongoDefaults.MaxDocumentSize,
MaxMessageLength = MongoDefaults.MaxMessageLength,
InstanceType = MongoServerInstanceType.Unknown
};
_connectionPool = new MongoConnectionPool(this);
_pingTimeAggregator = new PingTimeAggregator(5);
// Console.WriteLine("MongoServerInstance[{0}]: {1}", sequentialId, address);
}
public static MongoUrlBuilder GetReplicaSetConnectionUri()
{
var connection = new MongoUrlBuilder();
// TODO - Should only have 1 setting across both roles
var replicaSetName = RoleEnvironment.GetConfigurationSettingValue(ReplicaSetNameSetting);
connection.ReplicaSetName = replicaSetName;
int replicaSetRoleCount = RoleEnvironment.Roles[MongoDBHelper.MongoRoleName].Instances.Count;
var servers = new List<MongoServerAddress>();
foreach (var instance in RoleEnvironment.Roles[MongoDBHelper.MongoRoleName].Instances)
{
var endpoint = instance.InstanceEndpoints[MongoDBHelper.MongodPortKey].IPEndpoint;
int instanceId = ParseNodeInstanceId(instance.Id);
var server = new MongoServerAddress(
endpoint.Address.ToString(),
(RoleEnvironment.IsEmulated ? endpoint.Port + instanceId : endpoint.Port)
);
servers.Add(server);
}
connection.Servers = servers;
return connection;
}
public ApiResponse SetConnection(ConnectionModel model)
{
var builder = new MongoUrlBuilder();
var server = new MongoServerAddress(model.Server, model.Port ?? 27017);
builder.Server = server;
var url = builder.ToMongoUrl();
try
{
var conn = MongoServer.Create(url);
conn.Connect();
conn.Disconnect();
}
catch
{
return new ApiResponse(false, string.Format("Connection to {0} failed.", url));
}
HttpContext.Current.Response.Cookies.Add(new HttpCookie("Mongo.Manager.Connection", url.ToString()));
return new ApiResponse();
}
static void Main(string[] args)
{
var mongoServerAddress = new MongoServerAddress("127.0.0.1", 27017);
var mongoServerSettings = new MongoServerSettings();
mongoServerSettings.Server = mongoServerAddress;
var mongoServer = new MongoServer(mongoServerSettings);
mongoServer.Connect();
IEnumerable<string> databases = mongoServer.GetDatabaseNames();
var mongoDatabase = mongoServer.GetDatabase("classfrogdb");
var classCollection = mongoDatabase.GetCollection("classes");
classCollection.RemoveAll();
var documents = classCollection.FindAll();
ClassInstance instance = new ClassInstance();
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
classCollection.Insert(instance.NewDocument());
mongoServer.Disconnect();
}
public void TestTwoServers()
{
var servers = new MongoServerAddress[]
{
new MongoServerAddress("server1"),
new MongoServerAddress("server2")
};
var settings = new MongoServerSettings();
settings.Servers = servers;
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
Assert.Throws<InvalidOperationException>(() => { var s = settings.Server; });
}
public void TestOneServer()
{
var server = new MongoServerAddress("server");
var servers = new[] { server };
var settings = new MongoServerSettings();
settings.Server = server;
Assert.AreEqual(server, settings.Server);
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
settings.Servers = servers;
Assert.AreEqual(server, settings.Server);
Assert.IsTrue(servers.SequenceEqual(settings.Servers));
}
/// <summary>
/// 通过连接名称获得Host信息
/// </summary>
/// <param name="ConnectionName"></param>
/// <returns></returns>
public MongoServerAddress GetMongoSvrAddrByConnectionName(String ConnectionName)
{
MongoServerAddress mongosrvAddr = null;
if (ConnectionList.ContainsKey(ConnectionName))
{
mongosrvAddr = new MongoServerAddress(ConnectionList[ConnectionName].IpAddr, ConnectionList[ConnectionName].Port);
}
return mongosrvAddr;
}
public void TestConstructor_with_host_and_port(string host, int port)
{
var address = new MongoServerAddress(host, port);
Assert.Equal(host, address.Host);
Assert.Equal(port, address.Port);
}
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 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; });
}
/// <summary>
/// 根据config获得MongoClientSettings,同时更新一些运行时变量
/// </summary>
/// <param name="config"></param>
/// <returns></returns>
public static MongoClientSettings CreateMongoClientSettingsByConfig(ref ConfigHelper.MongoConnectionConfig config)
{
//修改获得数据实例的方法
MongoClientSettings mongoClientSetting = new MongoClientSettings();
if (String.IsNullOrEmpty(config.ConnectionString))
{
mongoClientSetting.ConnectionMode = ConnectionMode.Direct;
SetReadPreferenceWriteConcern(mongoClientSetting, config);
//Replset时候可以不用设置吗？
mongoClientSetting.Server = new MongoServerAddress(config.Host, config.Port);
//MapReduce的时候将消耗大量时间。不过这里需要平衡一下，太长容易造成并发问题
//From Driver 1.4 Pay attention to this comment
//The default value for SocketTimeout has been changed from 30 seconds to 0,
//which is a special value meaning to use the operating system default value,
//which in turn is infinity. If you actually want a SocketTimeout you now have to set it yourself.
//The SocketTimeout is currently a server level setting, but most likely in a future release it will be possible to set it at other levels,
//including for individual operations.
if (config.socketTimeoutMS != 0)
{
mongoClientSetting.SocketTimeout = new TimeSpan(0, 0, (int)(config.socketTimeoutMS / 1000));
}
if (config.connectTimeoutMS != 0)
{
mongoClientSetting.ConnectTimeout = new TimeSpan(0, 0, (int)(config.connectTimeoutMS / 1000));
}
if (config.wtimeoutMS != 0)
{
mongoClientSetting.WaitQueueTimeout = new TimeSpan(0, 0, (int)(config.wtimeoutMS / 1000));
}
if (config.WaitQueueSize != 0)
{
mongoClientSetting.WaitQueueSize = config.WaitQueueSize;
}
//运行时LoginAsAdmin的设定
config.LoginAsAdmin = (config.DataBaseName == String.Empty);
if (!(String.IsNullOrEmpty(config.UserName) || String.IsNullOrEmpty(config.Password)))
{
//认证的设定:注意，这里的密码是明文
//
}
if (config.ReplSetName != String.Empty)
{
mongoClientSetting.ReplicaSetName = config.ReplSetName;
config.ServerRole = ConfigHelper.SvrRoleType.ReplsetSvr;
}
else
{
config.ServerRole = ConfigHelper.SvrRoleType.DataSvr;
}
if (config.ServerRole == ConfigHelper.SvrRoleType.ReplsetSvr)
{
//ReplsetName不是固有属性,可以设置，不过必须保持与配置文件的一致
mongoClientSetting.ConnectionMode = ConnectionMode.ReplicaSet;
//添加Replset服务器，注意，这里可能需要事先初始化副本
List<MongoServerAddress> ReplsetSvrList = new List<MongoServerAddress>();
foreach (String item in config.ReplsetList)
{
//如果这里的服务器在启动的时候没有--Replset参数，将会出错，当然作为单体的服务器，启动是没有任何问题的
MongoServerAddress ReplSrv;
if (item.Split(":".ToCharArray()).Length == 2)
{
ReplSrv = new MongoServerAddress(
item.Split(":".ToCharArray())[0],
Convert.ToInt16(item.Split(":".ToCharArray())[1]));
}
else
{
ReplSrv = new MongoServerAddress(item);
}
ReplsetSvrList.Add(ReplSrv);
}
mongoClientSetting.Servers = ReplsetSvrList;
}
}
else
{
//使用MongoConnectionString建立连接
mongoClientSetting = MongoClientSettings.FromUrl(MongoUrl.Create(config.ConnectionString));
}
//为了避免出现无法读取数据库结构的问题，将读权限都设置为Preferred
if (mongoClientSetting.ReadPreference == ReadPreference.Primary)
{
mongoClientSetting.ReadPreference = ReadPreference.PrimaryPreferred;
}
if (mongoClientSetting.ReadPreference == ReadPreference.Secondary)
{
mongoClientSetting.ReadPreference = ReadPreference.SecondaryPreferred;
}
return mongoClientSetting;
}
public void TestCreateWithHostAndPort()
{
var credentials = new MongoServerAddress("host", 123);
Assert.AreEqual("host", credentials.Host);
Assert.AreEqual(123, credentials.Port);
}
/// <summary>
/// 将Mongodb的服务器在树形控件中展示
/// </summary>
/// <param name="trvMongoDB"></param>
public static void FillConnectionToTreeView(TreeView trvMongoDB)
{
trvMongoDB.Nodes.Clear();
foreach (String mongoConnKey in _mongoConnSvrLst.Keys)
{
MongoServer mongoSrv = _mongoConnSvrLst[mongoConnKey];
TreeNode ConnectionNode = new TreeNode();
EachDatabaseUser UserList = new EachDatabaseUser();
try
{
//ReplSetName只能使用在虚拟的Replset服务器，Sharding体系等无效。虽然一个Sharding可以看做一个ReplSet
ConfigHelper.MongoConnectionConfig config = SystemManager.ConfigHelperInstance.ConnectionList[mongoConnKey];
ConnectionNode.SelectedImageIndex = (int)GetSystemIcon.MainTreeImageType.Connection;
ConnectionNode.ImageIndex = (int)GetSystemIcon.MainTreeImageType.Connection;
//ReplSet服务器需要Connect才能连接。可能因为这个是虚拟的服务器，没有Mongod实体。
//不过现在改为全部显示的打开连接
mongoSrv.Connect();
///mongoSvr.ReplicaSetName只有在连接后才有效，但是也可以使用Config.ReplsetName
ConnectionNode.Text = mongoConnKey;
ConnectionNode.Nodes.Add(GetInstanceNode(mongoConnKey, ref config, mongoSrv, null, mongoSrv, UserList));
if (mongoSrv.ReplicaSetName != null)
{
ConnectionNode.Tag = CONNECTION_REPLSET_TAG + ":" + config.ConnectionName;
TreeNode ServerListNode = new TreeNode("Servers");
ServerListNode.SelectedImageIndex = (int)GetSystemIcon.MainTreeImageType.Servers;
ServerListNode.ImageIndex = (int)GetSystemIcon.MainTreeImageType.Servers;
foreach (MongoServerInstance ServerInstace in mongoSrv.Instances)
{
ServerListNode.Nodes.Add(GetInstanceNode(mongoConnKey, ref config, mongoSrv, ServerInstace, null, UserList));
}
ConnectionNode.Nodes.Add(ServerListNode);
config.ServerRole = ConfigHelper.SvrRoleType.ReplsetSvr;
}
else
{
BsonDocument ServerStatusDoc = ExecuteMongoSvrCommand(serverStatus_Command, mongoSrv).Response;
//ServerStatus可能没有权限打开
if (ServerStatusDoc.Contains("process") && ServerStatusDoc.GetElement("process").Value == ServerStatus_PROCESS_MONGOS)
{
//Shard的时候，必须将所有服务器的ReadPreferred设成可读
config.ServerRole = ConfigHelper.SvrRoleType.ShardSvr;
ConnectionNode.Tag = CONNECTION_CLUSTER_TAG + ":" + config.ConnectionName;
TreeNode ShardListNode = new TreeNode("Shards");
ShardListNode.SelectedImageIndex = (int)GetSystemIcon.MainTreeImageType.Servers;
ShardListNode.ImageIndex = (int)GetSystemIcon.MainTreeImageType.Servers;
foreach (var lst in GetShardInfo(mongoSrv, "host"))
{
TreeNode ShardNode = new TreeNode();
ShardNode.Text = lst.Key;
ShardNode.SelectedImageIndex = (int)GetSystemIcon.MainTreeImageType.Servers;
ShardNode.ImageIndex = (int)GetSystemIcon.MainTreeImageType.Servers;
String strHostList = lst.Value.ToString();
String[] strAddress = strHostList.Split("/".ToCharArray());
String strAddresslst;
if (strAddress.Length == 2)
{
//#1 replset/host:port,host:port
ShardNode.Text += "[Replset:" + strAddress[0] + "]";
strAddresslst = strAddress[1];
}
else
{
//#2 host:port,host:port
strAddresslst = strHostList;
}
foreach (String item in strAddresslst.Split(",".ToCharArray()))
{
MongoClientSettings tinySetting = new MongoClientSettings();
tinySetting.ConnectionMode = ConnectionMode.Direct;
//防止无法读取Sharding状态。Sharding可能是一个Slaver
tinySetting.ReadPreference = ReadPreference.PrimaryPreferred;
tinySetting.ReplicaSetName = strAddress[0];
MongoServerAddress SecondaryAddr;
if (item.Split(":".ToCharArray()).Length == 2)
{
SecondaryAddr = new MongoServerAddress(item.Split(":".ToCharArray())[0], Convert.ToInt32(item.Split(":".ToCharArray())[1]));
}
else
{
SecondaryAddr = new MongoServerAddress(item.Split(":".ToCharArray())[0]);
}
tinySetting.Server = SecondaryAddr;
MongoServer ReplsetMember = new MongoClient(tinySetting).GetServer();
ShardNode.Nodes.Add(GetInstanceNode(mongoConnKey, ref config, mongoSrv, ReplsetMember.Instance, null, UserList));
}
ShardListNode.Nodes.Add(ShardNode);
}
ConnectionNode.Nodes.Add(ShardListNode);
}
else
{
///Server Status mongod
///Master - Slave 的判断
BsonElement replElement;
ServerStatusDoc.TryGetElement("repl", out replElement);
if (replElement == null)
{
config.ServerRole = ConfigHelper.SvrRoleType.DataSvr;
}
else
{
if (replElement.Value.AsBsonDocument.GetElement("ismaster").Value == BsonBoolean.True)
{
config.ServerRole = ConfigHelper.SvrRoleType.MasterSvr;
}
else
{
//ismaster 的值不一定是True和False...
config.ServerRole = ConfigHelper.SvrRoleType.SlaveSvr;
}
}
ConnectionNode.Tag = CONNECTION_TAG + ":" + config.ConnectionName;
}
}
//设定是否可用
config.Health = true;
//设定版本
if (mongoSrv.BuildInfo != null)
{
config.MongoDBVersion = mongoSrv.BuildInfo.Version;
}
SystemManager.ConfigHelperInstance.ConnectionList[mongoConnKey] = config;
switch (config.ServerRole)
{
case ConfigHelper.SvrRoleType.DataSvr:
ConnectionNode.Text = "[Data] " + ConnectionNode.Text;
break;
case ConfigHelper.SvrRoleType.ShardSvr:
ConnectionNode.Text = "[Cluster] " + ConnectionNode.Text;
break;
case ConfigHelper.SvrRoleType.ReplsetSvr:
ConnectionNode.Text = "[Replset] " + ConnectionNode.Text;
break;
case ConfigHelper.SvrRoleType.MasterSvr:
ConnectionNode.Text = "[Master] " + ConnectionNode.Text;
break;
case ConfigHelper.SvrRoleType.SlaveSvr:
ConnectionNode.Text = "[Slave] " + ConnectionNode.Text;
break;
default:
break;
}
trvMongoDB.Nodes.Add(ConnectionNode);
if (_mongoUserLst.ContainsKey(mongoConnKey))
{
_mongoUserLst[mongoConnKey] = UserList;
}
else
{
_mongoUserLst.Add(mongoConnKey, UserList);
}
}
catch (MongoAuthenticationException ex)
{
//需要验证的数据服务器，没有Admin权限无法获得数据库列表
if (!SystemManager.IsUseDefaultLanguage)
{
ConnectionNode.Text += "[" + SystemManager.mStringResource.GetText(StringResource.TextType.Exception_AuthenticationException) + "]";
SystemManager.ExceptionDeal(ex, SystemManager.mStringResource.GetText(StringResource.TextType.Exception_AuthenticationException),
SystemManager.mStringResource.GetText(StringResource.TextType.Exception_AuthenticationException_Note));
}
else
{
ConnectionNode.Text += "[MongoAuthenticationException]";
SystemManager.ExceptionDeal(ex, "MongoAuthenticationException:", "Please check UserName and Password");
}
ConnectionNode.Tag = CONNECTION_EXCEPTION_TAG + ":" + mongoConnKey;
trvMongoDB.Nodes.Add(ConnectionNode);
}
catch (MongoCommandException ex)
{
//listDatabase命令错误，本质是用户名称错误
if (ex.CommandResult.Response["errmsg"] == "unauthorized")
{
if (!SystemManager.IsUseDefaultLanguage)
{
ConnectionNode.Text += "[" + SystemManager.mStringResource.GetText(StringResource.TextType.Exception_AuthenticationException) + "]";
SystemManager.ExceptionDeal(ex, SystemManager.mStringResource.GetText(StringResource.TextType.Exception_AuthenticationException),
SystemManager.mStringResource.GetText(StringResource.TextType.Exception_AuthenticationException_Note));
}
else
{
ConnectionNode.Text += "[MongoAuthenticationException]";
SystemManager.ExceptionDeal(ex, "MongoAuthenticationException:", "Please check UserName and Password");
}
}
else
{
if (!SystemManager.IsUseDefaultLanguage)
{
ConnectionNode.Text += "[" + SystemManager.mStringResource.GetText(StringResource.TextType.Exception_NotConnected) + "]";
SystemManager.ExceptionDeal(ex, SystemManager.mStringResource.GetText(StringResource.TextType.Exception_NotConnected),
"Unknown Exception");
}
else
{
ConnectionNode.Text += "[Exception]";
SystemManager.ExceptionDeal(ex, "Not Connected", "Unknown Exception");
}
}
ConnectionNode.Tag = CONNECTION_EXCEPTION_TAG + ":" + mongoConnKey;
trvMongoDB.Nodes.Add(ConnectionNode);
}
catch (MongoConnectionException ex)
{
//暂时不处理任何异常，简单跳过
//无法连接的理由：
//1.服务器没有启动
//2.认证模式不正确
if (!SystemManager.IsUseDefaultLanguage)
{
ConnectionNode.Text += "[" + SystemManager.mStringResource.GetText(StringResource.TextType.Exception_NotConnected) + "]";
SystemManager.ExceptionDeal(ex, SystemManager.mStringResource.GetText(StringResource.TextType.Exception_NotConnected),
SystemManager.mStringResource.GetText(StringResource.TextType.Exception_NotConnected_Note));
}
else
{
ConnectionNode.Text += "[Exception]";
SystemManager.ExceptionDeal(ex, "Not Connected", "Mongo Server may not Startup or Auth Mode is not correct");
}
ConnectionNode.Tag = CONNECTION_EXCEPTION_TAG + ":" + mongoConnKey;
trvMongoDB.Nodes.Add(ConnectionNode);
}
catch (Exception ex)
{
if (!SystemManager.IsUseDefaultLanguage)
{
ConnectionNode.Text += "[" + SystemManager.mStringResource.GetText(StringResource.TextType.Exception_NotConnected) + "]";
SystemManager.ExceptionDeal(ex, SystemManager.mStringResource.GetText(StringResource.TextType.Exception_NotConnected),
"Unknown Exception");
}
else
{
ConnectionNode.Text += "[Exception]";
SystemManager.ExceptionDeal(ex, "Not Connected", "Unknown Exception");
}
ConnectionNode.Tag = CONNECTION_EXCEPTION_TAG + ":" + mongoConnKey;
trvMongoDB.Nodes.Add(ConnectionNode);
}
}
}
public void TestConstructor_with_host(string host)
{
var address = new MongoServerAddress(host);
Assert.Equal(host, address.Host);
Assert.Equal(27017, address.Port);
}
/// <summary>
/// Ensures that an instance with the address exists.
/// </summary>
/// <param name="address">The address.</param>
protected void EnsureInstanceWithAddress(MongoServerAddress address)
{
if (address == null)
{
throw new ArgumentNullException("address");
}
lock (_lock)
{
if (!_instances.Any(x => x.Address == address))
{
var instance = new MongoServerInstance(_server, address);
AddInstance(instance);
if (_state != MongoServerState.Disconnecting && _state != MongoServerState.Disconnected)
{
_state = MongoServerState.Connecting;
ConnectInstance(instance);
}
}
}
}
/// <summary>
/// Ensures that an instance with the address exists.
/// </summary>
/// <param name="address">The address.</param>
protected void EnsureInstanceWithAddress(MongoServerAddress address)
{
lock (_lock)
{
if (!_instances.Any(x => x.Address == address))
{
var instance = new MongoServerInstance(_server, address);
AddInstance(instance);
if (_state != MongoServerState.Disconnecting && _state != MongoServerState.Disconnected)
{
SetState(MongoServerState.Connecting);
ConnectInstance(instance);
}
}
}
}
