public MongoServerSettings(
ConnectionMode connectionMode,
TimeSpan connectTimeout,
MongoCredentials defaultCredentials,
TimeSpan maxConnectionIdleTime,
TimeSpan maxConnectionLifeTime,
int maxConnectionPoolSize,
int minConnectionPoolSize,
string replicaSetName,
SafeMode safeMode,
IEnumerable<MongoServerAddress> servers,
bool slaveOk,
TimeSpan socketTimeout,
int waitQueueSize,
TimeSpan waitQueueTimeout
)
{
this.connectionMode = connectionMode;
this.connectTimeout = connectTimeout;
this.defaultCredentials = defaultCredentials;
this.maxConnectionIdleTime = maxConnectionIdleTime;
this.maxConnectionLifeTime = maxConnectionLifeTime;
this.maxConnectionPoolSize = maxConnectionPoolSize;
this.minConnectionPoolSize = minConnectionPoolSize;
this.replicaSetName = replicaSetName;
this.safeMode = safeMode;
this.servers = servers;
this.slaveOk = slaveOk;
this.socketTimeout = socketTimeout;
this.waitQueueSize = waitQueueSize;
this.waitQueueTimeout = waitQueueTimeout;
}
public Connector(ConnectionMode mode, Direction dir, Vector2 position)
{
enabled = false;
this.mode = mode;
this.dir = dir;
this.position = position;
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrlBuilder.
/// </summary>
public MongoUrlBuilder()
{
_authenticationMechanism = MongoDefaults.AuthenticationMechanism;
_authenticationSource = null;
_connectionMode = ConnectionMode.Automatic;
_connectTimeout = MongoDefaults.ConnectTimeout;
_databaseName = null;
_fsync = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_journal = null;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_password = null;
_readPreference = null;
_replicaSetName = null;
_servers = null;
_slaveOk = null;
_socketTimeout = MongoDefaults.SocketTimeout;
_username = null;
_useSsl = false;
_verifySslCertificate = true;
_w = null;
_waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
_waitQueueSize = MongoDefaults.WaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
_wTimeout = null;
}
// constructors
/// <summary>
/// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
/// </summary>
public MongoServerSettings()
{
_connectionMode = ConnectionMode.Automatic;
_connectTimeout = MongoDefaults.ConnectTimeout;
_credentialsStore = new MongoCredentialsStore();
_defaultCredentials = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_readPreference = ReadPreference.Primary;
_replicaSetName = null;
_secondaryAcceptableLatency = MongoDefaults.SecondaryAcceptableLatency;
_servers = new List<MongoServerAddress> { new MongoServerAddress("localhost") };
_socketTimeout = MongoDefaults.SocketTimeout;
_useSsl = false;
_verifySslCertificate = true;
_waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
#pragma warning disable 612, 618
_writeConcern = MongoDefaults.SafeMode.WriteConcern;
#pragma warning restore
}
public static void ConnectToServer(ConnectionInfo ConnectionInfo, ConnectionMode ConnectionMode, String[] Params)
{
if (ConnectionInfo.Hostname != "") {
Log.AddStatusText("Attempting to resolve hostname: " + ConnectionInfo.Hostname);
IPHostEntry hostInfo = Dns.GetHostEntry(ConnectionInfo.Hostname);
if (hostInfo.AddressList.Length > 0) {
ConnectionInfo.IPAddress = hostInfo.AddressList[0].ToString();
Log.AddStatusText("Hostname (" + ConnectionInfo.Hostname + ") resolved to " + ConnectionInfo.IPAddress + ".");
}
}
serverConnection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint connectionEndpoint = new IPEndPoint(IPAddress.Parse(ConnectionInfo.IPAddress), ConnectionInfo.StreamPort);
try {
serverConnection.Connect(connectionEndpoint);
} catch (SocketException Se) {
if (Se.ErrorCode == 10061) {
Log.AddStatusText("Stream server @ " + ConnectionInfo.IPAddress + ":" + ConnectionInfo.StreamPort + " refused connection.");
MessageBox.Show("The Stream Server refused connection. Is the server running? Are ports forwarded?");
}
}
if (serverConnection.Connected) {
String tempCreate = Protocol.CreateSTREAMSONG(Params[0]);
Console.WriteLine("To ServerStream:\t" + tempCreate);
serverConnection.Send(Encoding.UTF8.GetBytes(tempCreate + "\x4"));
WaitForData(serverConnection);
} else {
Forms.MainFrm.UpdateStatusLabel("Ready");
}
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrlBuilder.
/// </summary>
public MongoUrlBuilder()
{
_authenticationMechanism = MongoDefaults.AuthenticationMechanism;
_authenticationMechanismProperties = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
_authenticationSource = null;
_connectionMode = ConnectionMode.Automatic;
_connectTimeout = MongoDefaults.ConnectTimeout;
_databaseName = null;
_fsync = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_journal = null;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_password = null;
_readConcernLevel = null;
_readPreference = null;
_replicaSetName = null;
_localThreshold = MongoDefaults.LocalThreshold;
_servers = new[] { new MongoServerAddress("localhost", 27017) };
_serverSelectionTimeout = MongoDefaults.ServerSelectionTimeout;
_socketTimeout = MongoDefaults.SocketTimeout;
_username = null;
_useSsl = false;
_verifySslCertificate = true;
_w = null;
_waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
_waitQueueSize = MongoDefaults.WaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
_wTimeout = null;
}
// constructors
/// <summary>
/// Creates a new instance of MongoUrlBuilder.
/// </summary>
public MongoUrlBuilder()
{
_connectionMode = ConnectionMode.Automatic;
_connectTimeout = MongoDefaults.ConnectTimeout;
_databaseName = null;
_defaultCredentials = null;
_fsync = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_journal = null;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_readPreference = null;
_replicaSetName = null;
_secondaryAcceptableLatency = MongoDefaults.SecondaryAcceptableLatency;
_servers = null;
_slaveOk = null;
_socketTimeout = MongoDefaults.SocketTimeout;
_useSsl = false;
_verifySslCertificate = true;
_w = null;
_waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
_waitQueueSize = MongoDefaults.WaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
_wTimeout = null;
}
static ConnectionPolicy CreateConnectionPolicy(ConnectionMode connectionMode, Protocol protocol)
{
return new ConnectionPolicy
{
ConnectionMode = connectionMode,
ConnectionProtocol = protocol
};
}
/// <summary>
/// Public constructor for createing a Server object
/// </summary>
/// <param name="iSocket">Socket associated with Server object</param>
/// <param name="iServerInfoIndex">Index number of the associated Server object</param>
public ServerInfo(Socket iSocket, int iServerInfoIndex, ConnectionInfo iConnectionInfo, ConnectionMode iConnectionMode)
{
Socket = iSocket;
Index = iServerInfoIndex;
ConnectionInfo = iConnectionInfo;
ConnectionMode = iConnectionMode;
ConnectionStatus = ConnectionStatus.Pending;
OnServerConnect();
}
internal WlanConnectionNotificationEventArgs(WlanInternNotificationData data, WlanInternNotificationConnectionData c)
{
Source = data.notificationSource;
Code = data.NotificationCode;
BssType = c.dot11BssType;
ProfileName = c.profileName;
ProfileXml = c.profileXml;
SecurityEnabled = c.securityEnabled;
ConnectionMode = c.ConnectionMode;
ReasonCode = c.wlanReasonCode;
Ssid = c.Dot11Ssid.GetSsid();
}
// constructors
public ClusterKey(
string applicationName,
Action<ClusterBuilder> clusterConfigurator,
ConnectionMode connectionMode,
TimeSpan connectTimeout,
IReadOnlyList<MongoCredential> credentials,
TimeSpan heartbeatInterval,
TimeSpan heartbeatTimeout,
bool ipv6,
TimeSpan localThreshold,
TimeSpan maxConnectionIdleTime,
TimeSpan maxConnectionLifeTime,
int maxConnectionPoolSize,
int minConnectionPoolSize,
string replicaSetName,
IReadOnlyList<MongoServerAddress> servers,
TimeSpan serverSelectionTimeout,
TimeSpan socketTimeout,
SslSettings sslSettings,
bool useSsl,
bool verifySslCertificate,
int waitQueueSize,
TimeSpan waitQueueTimeout)
{
_applicationName = applicationName;
_clusterConfigurator = clusterConfigurator;
_connectionMode = connectionMode;
_connectTimeout = connectTimeout;
_credentials = credentials;
_heartbeatInterval = heartbeatInterval;
_heartbeatTimeout = heartbeatTimeout;
_ipv6 = ipv6;
_localThreshold = localThreshold;
_maxConnectionIdleTime = maxConnectionIdleTime;
_maxConnectionLifeTime = maxConnectionLifeTime;
_maxConnectionPoolSize = maxConnectionPoolSize;
_minConnectionPoolSize = minConnectionPoolSize;
_receiveBufferSize = __defaultReceiveBufferSize; // TODO: add ReceiveBufferSize to MongoServerSettings?
_replicaSetName = replicaSetName;
_sendBufferSize = __defaultSendBufferSize; // TODO: add SendBufferSize to MongoServerSettings?
_servers = servers;
_serverSelectionTimeout = serverSelectionTimeout;
_socketTimeout = socketTimeout;
_sslSettings = sslSettings;
_useSsl = useSsl;
_verifySslCertificate = verifySslCertificate;
_waitQueueSize = waitQueueSize;
_waitQueueTimeout = waitQueueTimeout;
_hashCode = CalculateHashCode();
}
public string GetAddress(ConnectionMode mode)
{
switch (mode)
{
case ConnectionMode.Local:
return LocalAddress;
case ConnectionMode.Manual:
return ManualAddress;
case ConnectionMode.Remote:
return RemoteAddress;
default:
throw new ArgumentException("Unexpected ConnectionMode");
}
}
public MongoUrl(
string url
)
{
var builder = new MongoUrlBuilder(url);
this.url = builder.ToString(); // keep canonical form
this.credentials = builder.Credentials;
this.servers = builder.Servers;
this.databaseName = builder.DatabaseName;
this.connectionMode = builder.ConnectionMode;
this.replicaSetName = builder.ReplicaSetName;
this.safeMode = builder.SafeMode ?? SafeMode.False; // never null
this.slaveOk = builder.SlaveOk;
}
/// <summary>
/// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
/// </summary>
public MongoServerSettings() {
connectionMode = ConnectionMode.Direct;
connectTimeout = MongoDefaults.ConnectTimeout;
defaultCredentials = null;
ipv6 = false;
maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
replicaSetName = null;
safeMode = MongoDefaults.SafeMode;
servers = null;
slaveOk = false;
socketTimeout = MongoDefaults.SocketTimeout;
waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
}
/// <summary>
/// Creates a context with an optionally open database and SMTP connection.
/// </summary>
/// <param name="openConnection">True if a database connection should be opened.</param>
/// <param name="beginTransaction">True if a transaction is required.</param>
/// <param name="openSmtp">True if an SMTP connection should be opened.</param>
/// <returns>A valid connection.</returns>
public Context CreateContext(ConnectionMode connectionMode, TransactionMode transactionMode)
{
var context = new Context()
{
ConnectionString = connectionString,
ConnectionMode = connectionMode,
TransactionMode = transactionMode,
UserGuid = userGuid,
UserName = userName,
};
context.ClusterProperty.Name = clusterName;
context.DomainProperty.Name = domainName;
context.FederationProperty.Name = federationName;
return context;
}
// constructors
/// <summary>
/// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
/// </summary>
public MongoServerSettings()
{
_connectionMode = ConnectionMode.Direct;
_connectTimeout = MongoDefaults.ConnectTimeout;
_defaultCredentials = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_replicaSetName = null;
_safeMode = MongoDefaults.SafeMode;
_servers = null;
_slaveOk = false;
_socketTimeout = MongoDefaults.SocketTimeout;
_waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
}
// constructors
/// <summary>
/// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
/// </summary>
public MongoServerSettings()
{
connectionMode = ConnectionMode.Direct;
connectTimeout = MongoDefaults.ConnectTimeout;
defaultCredentials = null;
guidRepresentation = MongoDefaults.GuidRepresentation;
ipv6 = false;
maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
replicaSetName = null;
safeMode = MongoDefaults.SafeMode;
servers = null;
//slaveOk = false;
readPreference = ReadPreference.Primary;
socketTimeout = MongoDefaults.SocketTimeout;
waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
}
/// <summary>
/// Function to retrieve registration repository.
/// </summary>
/// <param name="connectionMode">The connection mode.</param>
/// <returns>
/// Object of type IRegistrationRepository
/// </returns>
public static IRepository Retrieve(ConnectionMode connectionMode)
{
Workstation workstation = DIContainer.Instance.Resolve<Workstation>();
if (connectionMode == ConnectionMode.Offline)
{
workstation.LastConnectionMode = ConnectionMode.Offline;
return DIContainer.Instance.Resolve<IRepository>(OfflineRepository.InstanceName);
}
workstation.LastConnectionMode = ConnectionMode.Online;
if (string.IsNullOrEmpty(workstation.GangwayServiceBaseAddress))
{
// Retrieve configuration settings for on line mode.
Messenger.Instance.Notify(MessengerMessage.RetrieveConfigurationSettings);
}
return DIContainer.Instance.Resolve<IRepository>(OnlineRepository.InstanceName);
}
// constructors
/// <summary>
/// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
/// </summary>
public MongoServerSettings()
{
_connectionMode = ConnectionMode.Direct;
_connectTimeout = MongoDefaults.ConnectTimeout;
_credentialsStore = new MongoCredentialsStore();
_defaultCredentials = null;
_guidRepresentation = MongoDefaults.GuidRepresentation;
_ipv6 = false;
_maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
_maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
_maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
_minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
_readPreference = ReadPreference.Primary;
_replicaSetName = null;
_safeMode = MongoDefaults.SafeMode;
_servers = new List<MongoServerAddress> { new MongoServerAddress("localhost") };
_serversReadOnly = new ReadOnlyCollection<MongoServerAddress>(_servers);
_socketTimeout = MongoDefaults.SocketTimeout;
_waitQueueSize = MongoDefaults.ComputedWaitQueueSize;
_waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
}
/// <summary>
/// Connect to a server.
/// </summary>
/// <param name="ConnectionInfo">ConnectionInfo object containing connection information</param>
/// <param name="ConnectionMode">Mode describing the type of connection</param>
/// <param name="Params">Optional params to be passed to the ServerInfo object</param>
public static void ConnectToServer(ConnectionInfo ConnectionInfo, ConnectionMode ConnectionMode, String[] Params)
{
if ((ConnectionMode != ConnectionMode.FirstConnect) && (ConnectionMode != ConnectionMode.SongRequest)) {
Forms.MainFrm.UpdateStatusLabel("Connecting to \"" + ConnectionInfo.Description + "\" (" + ConnectionMode.ToString() + " mode).");
}
Log.AddStatusText("Connecting to server (" + ConnectionMode.ToString() + " mode): " + ConnectionInfo.Description);
if (ConnectionInfo.Hostname != "") {
Log.AddStatusText("Attempting to resolve hostname: " + ConnectionInfo.Hostname);
IPHostEntry hostInfo = Dns.GetHostEntry(ConnectionInfo.Hostname);
if (hostInfo.AddressList.Length > 0) {
ConnectionInfo.IPAddress = hostInfo.AddressList[0].ToString();
Log.AddStatusText("Hostname (" + ConnectionInfo.Hostname + ") resolved to " + ConnectionInfo.IPAddress + ".");
}
}
serverConnection = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
IPEndPoint connectionEndpoint = new IPEndPoint(IPAddress.Parse(ConnectionInfo.IPAddress), ConnectionInfo.InfoPort);
try {
serverConnection.Connect(connectionEndpoint);
} catch (SocketException Se) {
if (Se.ErrorCode == 10061) {
ServerManager.SetOffline(ConnectionInfo.InternalGUID);
Log.AddStatusText("Info server @ " + ConnectionInfo.IPAddress + ":" + ConnectionInfo.InfoPort + " refused connection.");
if ((ConnectionMode != ConnectionMode.FirstConnect) && (ConnectionMode != ConnectionMode.OnlineTest) && (ConnectionMode != ConnectionMode.SongRequest)) {
MessageBox.Show("The Info Server refused connection. Is the server running? Are ports forwarded?");
}
if (ConnectionMode == ConnectionMode.OnlineTest) {
Forms.MainFrm.UpdateStatusLabel("Server \"" + ConnectionInfo.Description + "\" is offline. Song skipped.");
}
}
}
if (serverConnection.Connected) {
ServerInfo tempServerInfo = new ServerInfo(serverConnection, SocketCounter, ConnectionInfo, ConnectionMode);
if (Params.Length > 0) { tempServerInfo.ConnectionParams = Params; }
ServerInfoList.Add(tempServerInfo);
WaitForData(tempServerInfo);
Interlocked.Increment(ref SocketCounter);
} else {
Forms.MainFrm.UpdateStatusLabel("Ready");
}
}
public static bool Connect(ConnectionMode mode = ConnectionMode.Client)
{
if (IsConnected)
return true;
if (Server.ServerStartAttempts > 20 && Client.ConnectionAttempts > 20)
{
Log.Info("Failed to Connect too many times, Disabling Plugin");
AutoFollow.DisablePlugin();
}
if (ConnectionMode == ConnectionMode.Client)
{
Client.ClientInitialize();
}
else
{
Server.ServerInitialize();
}
return IsConnected;
}
// 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();
}
private void Connect(ConnectionMode mode)
{
Connect(mode, _netTcpCallback);
}
private void Connect(ConnectionMode mode, string clientVersion, string minServerVersion)
{
Connect(mode, _netTcpCallback, clientVersion, minServerVersion);
}
internal MongoUrl(MongoUrlBuilder builder)
{
_allowInsecureTls = builder.AllowInsecureTls;
_applicationName = builder.ApplicationName;
_authenticationMechanism = builder.AuthenticationMechanism;
_authenticationMechanismProperties = builder.AuthenticationMechanismProperties;
_authenticationSource = builder.AuthenticationSource;
_compressors = builder.Compressors;
#pragma warning disable CS0618 // Type or member is obsolete
if (builder.ConnectionModeSwitch == ConnectionModeSwitch.UseConnectionMode)
{
_connectionMode = builder.ConnectionMode;
}
_connectionModeSwitch = builder.ConnectionModeSwitch;
#pragma warning restore CS0618 // Type or member is obsolete
_connectTimeout = builder.ConnectTimeout;
_databaseName = builder.DatabaseName;
#pragma warning disable CS0618 // Type or member is obsolete
if (builder.ConnectionModeSwitch == ConnectionModeSwitch.UseDirectConnection)
{
_directConnection = builder.DirectConnection;
}
#pragma warning restore CS0618 // Type or member is obsolete
_fsync = builder.FSync;
#pragma warning disable 618
if (BsonDefaults.GuidRepresentationMode == GuidRepresentationMode.V2)
{
_guidRepresentation = builder.GuidRepresentation;
}
#pragma warning restore 618
_heartbeatInterval = builder.HeartbeatInterval;
_heartbeatTimeout = builder.HeartbeatTimeout;
_ipv6 = builder.IPv6;
_isResolved = builder.Scheme != ConnectionStringScheme.MongoDBPlusSrv;
_journal = builder.Journal;
_loadBalanced = builder.LoadBalanced;
_localThreshold = builder.LocalThreshold;
_maxConnecting = builder.MaxConnecting;
_maxConnectionIdleTime = builder.MaxConnectionIdleTime;
_maxConnectionLifeTime = builder.MaxConnectionLifeTime;
_maxConnectionPoolSize = builder.MaxConnectionPoolSize;
_minConnectionPoolSize = builder.MinConnectionPoolSize;
_password = builder.Password;
_readConcernLevel = builder.ReadConcernLevel;
_readPreference = builder.ReadPreference;
_replicaSetName = builder.ReplicaSetName;
_retryReads = builder.RetryReads;
_retryWrites = builder.RetryWrites;
_scheme = builder.Scheme;
_servers = builder.Servers;
_serverSelectionTimeout = builder.ServerSelectionTimeout;
_socketTimeout = builder.SocketTimeout;
_srvMaxHosts = builder.SrvMaxHosts;
_tlsDisableCertificateRevocationCheck = builder.TlsDisableCertificateRevocationCheck;
_username = builder.Username;
_useTls = builder.UseTls;
_w = builder.W;
#pragma warning disable 618
_waitQueueMultiple = builder.WaitQueueMultiple;
_waitQueueSize = builder.WaitQueueSize;
#pragma warning restore 618
_waitQueueTimeout = builder.WaitQueueTimeout;
_wTimeout = builder.WTimeout;
_url = builder.ToString(); // keep canonical form
}
/// <summary>
/// Creates a new instance of MongoServerSettings. Usually you would use a connection string instead.
/// </summary>
/// <param name="connectionMode">The connection mode (Direct or ReplicaSet).</param>
/// <param name="connectTimeout">The connect timeout.</param>
/// <param name="defaultCredentials">The default credentials.</param>
/// <param name="guidRepresentation">The representation for Guids.</param>
/// <param name="ipv6">Whether to use IPv6.</param>
/// <param name="maxConnectionIdleTime">The max connection idle time.</param>
/// <param name="maxConnectionLifeTime">The max connection life time.</param>
/// <param name="maxConnectionPoolSize">The max connection pool size.</param>
/// <param name="minConnectionPoolSize">The min connection pool size.</param>
/// <param name="replicaSetName">The name of the replica set.</param>
/// <param name="safeMode">The safe mode.</param>
/// <param name="servers">The server addresses (normally one unless it is the seed list for connecting to a replica set).</param>
/// <param name="slaveOk">Whether queries should be sent to secondary servers.</param>
/// <param name="socketTimeout">The socket timeout.</param>
/// <param name="waitQueueSize">The wait queue size.</param>
/// <param name="waitQueueTimeout">The wait queue timeout.</param>
public MongoServerSettings(ConnectionMode connectionMode, TimeSpan connectTimeout, MongoCredentials defaultCredentials, GuidRepresentation guidRepresentation, bool ipv6, TimeSpan maxConnectionIdleTime, TimeSpan maxConnectionLifeTime, int maxConnectionPoolSize, int minConnectionPoolSize, string replicaSetName, SafeMode safeMode, IEnumerable<MongoServerAddress> servers, ReadPreference readPreference, TimeSpan socketTimeout, int waitQueueSize, TimeSpan waitQueueTimeout)
{
this.connectionMode = connectionMode;
this.connectTimeout = connectTimeout;
this.defaultCredentials = defaultCredentials;
this.guidRepresentation = guidRepresentation;
this.ipv6 = ipv6;
this.maxConnectionIdleTime = maxConnectionIdleTime;
this.maxConnectionLifeTime = maxConnectionLifeTime;
this.maxConnectionPoolSize = maxConnectionPoolSize;
this.minConnectionPoolSize = minConnectionPoolSize;
this.replicaSetName = replicaSetName;
this.safeMode = safeMode;
this.servers = servers;
//this.slaveOk = slaveOk;
this.readPreference = readPreference;
this.socketTimeout = socketTimeout;
this.waitQueueSize = waitQueueSize;
this.waitQueueTimeout = waitQueueTimeout;
}
// constructors
public ClusterKey(
bool allowInsecureTls,
string applicationName,
Action <ClusterBuilder> clusterConfigurator,
IReadOnlyList <CompressorConfiguration> compressors,
#pragma warning disable CS0618 // Type or member is obsolete
ConnectionMode connectionMode,
ConnectionModeSwitch connectionModeSwitch,
#pragma warning restore CS0618 // Type or member is obsolete
TimeSpan connectTimeout,
IReadOnlyList <MongoCredential> credentials,
bool?directConnection,
TimeSpan heartbeatInterval,
TimeSpan heartbeatTimeout,
bool ipv6,
IReadOnlyDictionary <string, IReadOnlyDictionary <string, object> > kmsProviders,
bool loadBalanced,
TimeSpan localThreshold,
TimeSpan maxConnectionIdleTime,
TimeSpan maxConnectionLifeTime,
int maxConnectionPoolSize,
int minConnectionPoolSize,
int receiveBufferSize,
string replicaSetName,
IReadOnlyDictionary <string, BsonDocument> schemaMap,
ConnectionStringScheme scheme,
string sdamLogFilename,
int sendBufferSize,
ServerApi serverApi,
IReadOnlyList <MongoServerAddress> servers,
TimeSpan serverSelectionTimeout,
TimeSpan socketTimeout,
SslSettings sslSettings,
bool useTls,
int waitQueueSize,
TimeSpan waitQueueTimeout)
{
ConnectionModeHelper.EnsureConnectionModeValuesAreValid(connectionMode, connectionModeSwitch, directConnection);
_allowInsecureTls = allowInsecureTls;
_applicationName = applicationName;
_clusterConfigurator = clusterConfigurator;
_compressors = compressors;
_connectionMode = connectionMode;
_connectionModeSwitch = connectionModeSwitch;
_connectTimeout = connectTimeout;
_credentials = credentials;
_directConnection = directConnection;
_heartbeatInterval = heartbeatInterval;
_heartbeatTimeout = heartbeatTimeout;
_ipv6 = ipv6;
_kmsProviders = kmsProviders;
_loadBalanced = loadBalanced;
_localThreshold = localThreshold;
_maxConnectionIdleTime = maxConnectionIdleTime;
_maxConnectionLifeTime = maxConnectionLifeTime;
_maxConnectionPoolSize = maxConnectionPoolSize;
_minConnectionPoolSize = minConnectionPoolSize;
_receiveBufferSize = receiveBufferSize;
_replicaSetName = replicaSetName;
_schemaMap = schemaMap;
_scheme = scheme;
_sdamLogFilename = sdamLogFilename;
_sendBufferSize = sendBufferSize;
_serverApi = serverApi;
_servers = servers;
_serverSelectionTimeout = serverSelectionTimeout;
_socketTimeout = socketTimeout;
_sslSettings = sslSettings;
_useTls = useTls;
_waitQueueSize = waitQueueSize;
_waitQueueTimeout = waitQueueTimeout;
_hashCode = CalculateHashCode();
}
public override void AddConnection(Connection conn, ConnectionMode mode)
{
this.Start = conn;
}
/// <summary>
/// Converts a connection mode to the equivalent XMS value.
/// </summary>
/// <param name="inputValue">Input value.</param>
/// <returns>Converted value.</returns>
public static Int32 ToXMSConnectionMode(ConnectionMode inputValue)
{
return((Int32)inputValue);
}
private void ResetValues() {
connectionMode = ConnectionMode.Direct;
connectTimeout = MongoDefaults.ConnectTimeout;
databaseName = null;
defaultCredentials = null;
ipv6 = false;
maxConnectionIdleTime = MongoDefaults.MaxConnectionIdleTime;
maxConnectionLifeTime = MongoDefaults.MaxConnectionLifeTime;
maxConnectionPoolSize = MongoDefaults.MaxConnectionPoolSize;
minConnectionPoolSize = MongoDefaults.MinConnectionPoolSize;
replicaSetName = null;
safeMode = null;
servers = null;
slaveOk = false;
socketTimeout = MongoDefaults.SocketTimeout;
waitQueueMultiple = MongoDefaults.WaitQueueMultiple;
waitQueueSize = MongoDefaults.WaitQueueSize;
waitQueueTimeout = MongoDefaults.WaitQueueTimeout;
}
public MySqlDBHelperEx(string connString, ConnectionMode connMode)
{
InitConnStringInfo(connString, connMode);
}
public void LaunchDirectConnection(ConnectionMode mode)
{
directConnectionSectionController.Launch(mode);
}
void Disconnect()
{
_instance = null;
if (connectionMode != null)
{
connectionMode.Terminate();
connectionMode = null;
}
}
/// <summary>
/// Create a new connection instance
/// </summary>
/// <param name="mode">Mode of the new connection</param>
protected BaseConnection(ConnectionMode mode)
{
_connectionMode = mode;
}
public void TestConnect(ConnectionMode mode, string module, bool expectEvents)
{
_hogController.StopService(module);
bool result = _hogController.WaitForService(module, ServerModuleState.Stopped, 5);
Assert.IsTrue(result, "Service '{0}' did not reach state 'Stopped'", module);
Connect(mode);
_basicHttpDisconnectedEvent.Wait(MediumWait);
_netTcpDisconnectedEvent.Wait(ShortWait);
_netTcpConnectedEvent.Wait(ShortWait);
lock (_receivedClientInfos)
{
if (expectEvents)
{
Assert.IsTrue(_netTcpDisconnectedEvent.IsSet, "No ClientDisconnected received for IHelloWorldWcfService");
Assert.IsFalse(_netTcpConnectedEvent.IsSet, "ClientConnected received for IHelloWorldWcfService");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName && i.State == ConnectionState.New && i.Tries == 0), "Received IHelloWorldWcfService client info event 'New'");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName && i.State == ConnectionState.FailedTry && i.Tries == 1), "Received IHelloWorldWcfService client info event 'FailedTry'");
}
else
{
Assert.IsFalse(_netTcpDisconnectedEvent.IsSet, "ClientDisconnected received for IHelloWorldWcfService");
Assert.IsTrue(_netTcpConnectedEvent.IsSet, "No ClientConnected received for IHelloWorldWcfService");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName && i.State == ConnectionState.New && i.Tries == 0), "Received initial IHelloWorldWcfService client info event");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName && i.State == ConnectionState.New && i.Tries == 1), "Received intermediate IHelloWorldWcfService client info event");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName && i.State == ConnectionState.Success && i.Tries == 1), "Received final IHelloWorldWcfService client info event");
}
Assert.IsTrue(_basicHttpDisconnectedEvent.IsSet, "No ClientDisconnected received for ISimpleHelloWorldWcfService");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == BasicHttpServiceName && i.State == ConnectionState.New && i.Tries == 0), "Received ISimpleHelloWorldWcfService client info event 'New'");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == BasicHttpServiceName && i.State == ConnectionState.FailedTry && i.Tries == 1), "Received ISimpleHelloWorldWcfService client info event 'FailedTry'");
}
Clear(true);
_hogController.StartService("DependentTestModule");
result = _hogController.WaitForService("DependentTestModule", ServerModuleState.Running, 5);
Assert.IsTrue(result, "Service 'DependentTestModule' did not reach state 'Running'");
_netTcpConnectedEvent.Wait(LongWait);
_basicHttpConnectedEvent.Wait(ShortWait);
lock (_receivedClientInfos)
{
if (expectEvents)
{
Assert.IsTrue(_netTcpConnectedEvent.IsSet, "No ClientConnected received for IHelloWorldWcfService");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName && i.State == ConnectionState.FailedTry && i.Tries > 1), "Received IHelloWorldWcfService client info event 'FailedTry'");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName && i.State == ConnectionState.Success && i.Tries == 1), "Received IHelloWorldWcfService client info event 'Success'");
}
else
{
Assert.IsFalse(_netTcpConnectedEvent.IsSet, "ClientConnected received for IHelloWorldWcfService");
Assert.Null(_receivedClientInfos.FirstOrDefault(i => i.Service == NetTcpServiceName), "Received initial IHelloWorldWcfService client info event");
}
Assert.IsTrue(_basicHttpConnectedEvent.IsSet, "No ClientConnected received for ISimpleHelloWorldWcfService");
Assert.NotNull(_receivedClientInfos.FirstOrDefault(i => i.Service == BasicHttpServiceName && i.State == ConnectionState.Success && i.Tries == 1), "Received final ISimpleHelloWorldWcfService client info event");
}
}
/// <summary>
/// Parses a URL and sets all settings to match the URL.
/// </summary>
/// <param name="url">The URL.</param>
public void Parse(
string url
)
{
ResetValues();
const string pattern =
@"^mongodb://" +
@"((?<username>[^:]+):(?<password>[^@]+)@)?" +
@"(?<servers>[^:,/]+(:\d+)?(,[^:,/]+(:\d+)?)*)" +
@"(/(?<database>[^?]+)?(\?(?<query>.*))?)?$";
Match match = Regex.Match(url, pattern);
if (match.Success)
{
string username = Uri.UnescapeDataString(match.Groups["username"].Value);
string password = Uri.UnescapeDataString(match.Groups["password"].Value);
string servers = match.Groups["servers"].Value;
string databaseName = match.Groups["database"].Value;
string query = match.Groups["query"].Value;
if (username != "" && password != "")
{
this.defaultCredentials = new MongoCredentials(username, password);
}
else
{
this.defaultCredentials = null;
}
if (servers != "")
{
List <MongoServerAddress> addresses = new List <MongoServerAddress>();
foreach (string server in servers.Split(','))
{
var address = MongoServerAddress.Parse(server);
addresses.Add(address);
}
if (addresses.Count == 1)
{
this.connectionMode = ConnectionMode.Direct;
}
else if (addresses.Count > 1)
{
this.connectionMode = ConnectionMode.ReplicaSet;
}
this.servers = addresses;
}
else
{
throw new FormatException("Invalid connection string. Server missing.");
}
this.databaseName = (databaseName != "") ? databaseName : null;
if (!string.IsNullOrEmpty(query))
{
var safeModeChanged = false;
var safe = false;
var w = 0;
var wtimeout = TimeSpan.Zero;
var fsync = false;
foreach (var pair in query.Split('&', ';'))
{
var parts = pair.Split('=');
if (parts.Length != 2)
{
throw new FormatException(string.Format("Invalid connection string '{0}'.", parts));
}
var name = parts[0];
var value = parts[1];
switch (name.ToLower())
{
case "connect":
connectionMode = ParseConnectionMode(name, value);
break;
case "connecttimeout":
case "connecttimeoutms":
connectTimeout = ParseTimeSpan(name, value);
break;
case "fsync":
safeModeChanged = true;
safe = true;
fsync = ParseBoolean(name, value);
break;
case "guids":
guidRepresentation = (GuidRepresentation)Enum.Parse(typeof(GuidRepresentation), value, true); // ignoreCase
break;
case "ipv6":
ipv6 = ParseBoolean(name, value);
break;
case "maxidletime":
case "maxidletimems":
maxConnectionIdleTime = ParseTimeSpan(name, value);
break;
case "maxlifetime":
case "maxlifetimems":
maxConnectionLifeTime = ParseTimeSpan(name, value);
break;
case "maxpoolsize":
maxConnectionPoolSize = ParseInt32(name, value);
break;
case "minpoolsize":
minConnectionPoolSize = ParseInt32(name, value);
break;
case "replicaset":
this.replicaSetName = value;
this.connectionMode = ConnectionMode.ReplicaSet;
break;
case "safe":
safeModeChanged = true;
safe = ParseBoolean(name, value);
break;
case "slaveok":
slaveOk = ParseBoolean(name, value);
break;
case "sockettimeout":
case "sockettimeoutms":
socketTimeout = ParseTimeSpan(name, value);
break;
case "w":
safeModeChanged = true;
safe = true;
w = ParseInt32(name, value);
break;
case "waitqueuemultiple":
waitQueueMultiple = ParseDouble(name, value);
waitQueueSize = 0;
break;
case "waitqueuesize":
waitQueueMultiple = 0;
waitQueueSize = ParseInt32(name, value);
break;
case "waitqueuetimeout":
case "waitqueuetimeoutms":
waitQueueTimeout = ParseTimeSpan(name, value);
break;
case "wtimeout":
case "wtimeoutms":
safeModeChanged = true;
safe = true;
wtimeout = ParseTimeSpan(name, value);
break;
}
}
if (safeModeChanged)
{
this.safeMode = SafeMode.Create(safe, fsync, w, wtimeout);
}
}
}
else
{
throw new FormatException(string.Format("Invalid connection string '{0}'.", url));
}
}
/// <summary>
///
/// </summary>
/// <param name="port"></param>
/// <returns></returns>
public ConfigurationBuilder Mode(ConnectionMode mode)
{
_mode = mode;
return(this);
}
/// <summary> /// Configures the context to use the provided connection mode. /// </summary> /// <param name="connectionMode"> Azure Cosmos DB connection mode. </param> public virtual CosmosDbContextOptionsBuilder ConnectionMode(ConnectionMode connectionMode) => WithOption(e => e.WithConnectionMode(Check.NotNull(connectionMode, nameof(connectionMode))));
public IEnumerable <uint> GetNodeNeighbours(Node centerNode, ConnectionMode mode)
{
return(centerNode.GetConnections(mode).Where(id => id != centerNode.ID));
}
public async Task ContainerPartitionResourcePermissionTest(ConnectionMode connectionMode)
{
CosmosClientOptions cosmosClientOptions = new CosmosClientOptions()
{
ConnectionMode = connectionMode
};
CosmosClient cosmosClient = TestCommon.CreateCosmosClient(cosmosClientOptions);
Database database = await cosmosClient.CreateDatabaseIfNotExistsAsync("PermissionTest");
//create user
string userId = Guid.NewGuid().ToString();
UserResponse userResponse = await database.CreateUserAsync(userId);
Assert.AreEqual(HttpStatusCode.Created, userResponse.StatusCode);
Assert.AreEqual(userId, userResponse.Resource.Id);
User user = userResponse.User;
//create resource
string containerId = Guid.NewGuid().ToString();
ContainerResponse containerResponse = await database.CreateContainerAsync(
id : containerId,
partitionKeyPath : "/id");
Assert.AreEqual(HttpStatusCode.Created, containerResponse.StatusCode);
Container container = containerResponse.Container;
// Create items to read
ToDoActivity itemAccess = ToDoActivity.CreateRandomToDoActivity();
ToDoActivity itemNoAccess = ToDoActivity.CreateRandomToDoActivity();
await container.CreateItemAsync <ToDoActivity>(
itemAccess,
new PartitionKey(itemAccess.id));
await container.CreateItemAsync <ToDoActivity>(
itemNoAccess,
new PartitionKey(itemNoAccess.id));
//create permission
string permissionId = Guid.NewGuid().ToString();
PartitionKey partitionKey = new PartitionKey(itemAccess.id);
PermissionProperties permissionProperties = new PermissionProperties(
permissionId,
PermissionMode.Read,
container,
partitionKey);
PermissionResponse permissionResponse = await user.CreatePermissionAsync(permissionProperties);
PermissionProperties permission = permissionResponse.Resource;
Assert.AreEqual(HttpStatusCode.Created, userResponse.StatusCode);
Assert.AreEqual(permissionId, permission.Id);
Assert.AreEqual(permissionProperties.PermissionMode, permission.PermissionMode);
using (CosmosClient tokenCosmosClient = TestCommon.CreateCosmosClient(clientOptions: cosmosClientOptions, resourceToken: permission.Token))
{
Container tokenContainer = tokenCosmosClient.GetContainer(database.Id, containerId);
await tokenContainer.ReadItemAsync <ToDoActivity>(itemAccess.id, new PartitionKey(itemAccess.id));
try
{
await tokenContainer.ReadItemAsync <ToDoActivity>(itemNoAccess.id, new PartitionKey(itemNoAccess.id));
Assert.Fail();
}
catch (CosmosException ex)
{
Assert.AreEqual(HttpStatusCode.Forbidden, ex.StatusCode);
}
QueryRequestOptions queryRequestOptions = new QueryRequestOptions()
{
PartitionKey = new PartitionKey(itemAccess.id)
};
FeedIterator <ToDoActivity> feedIterator = tokenContainer.GetItemQueryIterator <ToDoActivity>(
queryText: "select * from T",
requestOptions: queryRequestOptions);
List <ToDoActivity> result = new List <ToDoActivity>();
while (feedIterator.HasMoreResults)
{
FeedResponse <ToDoActivity> toDoActivities = await feedIterator.ReadNextAsync();
result.AddRange(toDoActivities);
}
Assert.AreEqual(1, result.Count);
// Test query with no service interop via gateway query plan to replicate x32 app
ContainerInternal containerCore = (ContainerInlineCore)tokenContainer;
MockCosmosQueryClient mock = new MockCosmosQueryClient(
clientContext: containerCore.ClientContext,
cosmosContainerCore: containerCore,
forceQueryPlanGatewayElseServiceInterop: true);
Container tokenGatewayQueryPlan = new ContainerInlineCore(
containerCore.ClientContext,
(DatabaseInternal)containerCore.Database,
containerCore.Id,
mock);
FeedIterator <ToDoActivity> feedIteratorGateway = tokenGatewayQueryPlan.GetItemQueryIterator <ToDoActivity>(
queryText: "select * from T",
requestOptions: queryRequestOptions);
List <ToDoActivity> resultGateway = new List <ToDoActivity>();
while (feedIteratorGateway.HasMoreResults)
{
FeedResponse <ToDoActivity> toDoActivities = await feedIteratorGateway.ReadNextAsync();
resultGateway.AddRange(toDoActivities);
}
Assert.AreEqual(1, resultGateway.Count);
}
}
/// <summary>
/// Parses a URL and sets all settings to match the URL.
/// </summary>
/// <param name="url">The URL.</param>
public void Parse(string url)
{
var connectionString = new ConnectionString(url);
_authenticationMechanism = connectionString.AuthMechanism;
_authenticationMechanismProperties = connectionString.AuthMechanismProperties.ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);
_authenticationSource = connectionString.AuthSource;
switch (connectionString.Connect)
{
case ClusterConnectionMode.Direct:
_connectionMode = Driver.ConnectionMode.Direct;
break;
case ClusterConnectionMode.ReplicaSet:
_connectionMode = Driver.ConnectionMode.ReplicaSet;
break;
case ClusterConnectionMode.Sharded:
_connectionMode = Driver.ConnectionMode.ShardRouter;
break;
case ClusterConnectionMode.Standalone:
_connectionMode = Driver.ConnectionMode.Standalone;
break;
default:
_connectionMode = Driver.ConnectionMode.Automatic;
break;
}
_connectTimeout = connectionString.ConnectTimeout.GetValueOrDefault(MongoDefaults.ConnectTimeout);
_databaseName = connectionString.DatabaseName;
_fsync = connectionString.FSync;
_guidRepresentation = connectionString.UuidRepresentation.GetValueOrDefault(MongoDefaults.GuidRepresentation);
_ipv6 = connectionString.Ipv6.GetValueOrDefault(false);
_journal = connectionString.Journal;
_maxConnectionIdleTime = connectionString.MaxIdleTime.GetValueOrDefault(MongoDefaults.MaxConnectionIdleTime);
_maxConnectionLifeTime = connectionString.MaxLifeTime.GetValueOrDefault(MongoDefaults.MaxConnectionLifeTime);
_maxConnectionPoolSize = connectionString.MaxPoolSize.GetValueOrDefault(MongoDefaults.MaxConnectionPoolSize);
_minConnectionPoolSize = connectionString.MinPoolSize.GetValueOrDefault(MongoDefaults.MinConnectionPoolSize);
_password = connectionString.Password;
_readConcernLevel = connectionString.ReadConcernLevel;
if (connectionString.ReadPreference != null)
{
_readPreference = new ReadPreference(connectionString.ReadPreference.Value);
}
if (connectionString.ReadPreferenceTags != null)
{
if (_readPreference == null)
{
throw new MongoConfigurationException("ReadPreferenceMode is required when using tag sets.");
}
_readPreference = _readPreference.With(tagSets: connectionString.ReadPreferenceTags);
}
_replicaSetName = connectionString.ReplicaSet;
_localThreshold = connectionString.LocalThreshold.GetValueOrDefault(MongoDefaults.LocalThreshold);
_servers = connectionString.Hosts.Select(endPoint =>
{
DnsEndPoint dnsEndPoint;
IPEndPoint ipEndPoint;
if ((dnsEndPoint = endPoint as DnsEndPoint) != null)
{
return new MongoServerAddress(dnsEndPoint.Host, dnsEndPoint.Port);
}
else if ((ipEndPoint = endPoint as IPEndPoint) != null)
{
var address = ipEndPoint.Address.ToString();
if (ipEndPoint.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
{
address = "[" + address + "]";
}
return new MongoServerAddress(address, ipEndPoint.Port);
}
else
{
throw new NotSupportedException("Only DnsEndPoint and IPEndPoints are supported in the connection string.");
}
});
_serverSelectionTimeout = connectionString.ServerSelectionTimeout.GetValueOrDefault(MongoDefaults.ServerSelectionTimeout);
_socketTimeout = connectionString.SocketTimeout.GetValueOrDefault(MongoDefaults.SocketTimeout);
_username = connectionString.Username;
_useSsl = connectionString.Ssl.GetValueOrDefault(false);
_verifySslCertificate = connectionString.SslVerifyCertificate.GetValueOrDefault(true);
_w = connectionString.W;
if (connectionString.WaitQueueSize != null)
{
_waitQueueSize = connectionString.WaitQueueSize.Value;
_waitQueueMultiple = 0.0;
}
else if (connectionString.WaitQueueMultiple != null)
{
_waitQueueMultiple = connectionString.WaitQueueMultiple.Value;
_waitQueueSize = 0;
}
_waitQueueTimeout = connectionString.WaitQueueTimeout.GetValueOrDefault(MongoDefaults.WaitQueueTimeout);
_wTimeout = connectionString.WTimeout;
}
// constructors
public ClusterKey(
bool allowInsecureTls,
string applicationName,
Action <ClusterBuilder> clusterConfigurator,
IReadOnlyList <CompressorConfiguration> compressors,
ConnectionMode connectionMode,
TimeSpan connectTimeout,
IReadOnlyList <MongoCredential> credentials,
TimeSpan heartbeatInterval,
TimeSpan heartbeatTimeout,
bool ipv6,
IReadOnlyDictionary <string, IReadOnlyDictionary <string, object> > kmsProviders,
TimeSpan localThreshold,
TimeSpan maxConnectionIdleTime,
TimeSpan maxConnectionLifeTime,
int maxConnectionPoolSize,
int minConnectionPoolSize,
int receiveBufferSize,
string replicaSetName,
IReadOnlyDictionary <string, BsonDocument> schemaMap,
ConnectionStringScheme scheme,
string sdamLogFilename,
int sendBufferSize,
IReadOnlyList <MongoServerAddress> servers,
TimeSpan serverSelectionTimeout,
TimeSpan socketTimeout,
SslSettings sslSettings,
bool useTls,
int waitQueueSize,
TimeSpan waitQueueTimeout)
{
_allowInsecureTls = allowInsecureTls;
_applicationName = applicationName;
_clusterConfigurator = clusterConfigurator;
_compressors = compressors;
_connectionMode = connectionMode;
_connectTimeout = connectTimeout;
_credentials = credentials;
_heartbeatInterval = heartbeatInterval;
_heartbeatTimeout = heartbeatTimeout;
_ipv6 = ipv6;
_kmsProviders = kmsProviders;
_localThreshold = localThreshold;
_maxConnectionIdleTime = maxConnectionIdleTime;
_maxConnectionLifeTime = maxConnectionLifeTime;
_maxConnectionPoolSize = maxConnectionPoolSize;
_minConnectionPoolSize = minConnectionPoolSize;
_receiveBufferSize = receiveBufferSize;
_replicaSetName = replicaSetName;
_schemaMap = schemaMap;
_scheme = scheme;
_sdamLogFilename = sdamLogFilename;
_sendBufferSize = sendBufferSize;
_servers = servers;
_serverSelectionTimeout = serverSelectionTimeout;
_socketTimeout = socketTimeout;
_sslSettings = sslSettings;
_useTls = useTls;
_waitQueueSize = waitQueueSize;
_waitQueueTimeout = waitQueueTimeout;
_hashCode = CalculateHashCode();
}
public ConexionBackpropagation(ActivationLayer sourceLayer, ActivationLayer targetLayer, ConnectionMode connectionMode)
: base(sourceLayer, targetLayer, connectionMode)
{
ConstructSynapses();
}
// public methods
/// <summary>
/// Parses a URL and sets all settings to match the URL.
/// </summary>
/// <param name="url">The URL.</param>
public void Parse(string url)
{
ResetValues();
const string serverPattern = @"((\[[^]]+?\]|[^:,/]+)(:\d+)?)";
const string pattern =
@"^mongodb://" +
@"((?<username>[^:]+):(?<password>[^@]+)@)?" +
@"(?<servers>" + serverPattern + "(," + serverPattern + ")*)" +
@"(/(?<database>[^?]+)?(\?(?<query>.*))?)?$";
Match match = Regex.Match(url, pattern);
if (match.Success)
{
string username = Uri.UnescapeDataString(match.Groups["username"].Value);
string password = Uri.UnescapeDataString(match.Groups["password"].Value);
string servers = match.Groups["servers"].Value;
string databaseName = match.Groups["database"].Value;
string query = match.Groups["query"].Value;
if (username != "" && password != "")
{
_defaultCredentials = new MongoCredentials(username, password);
}
else
{
_defaultCredentials = null;
}
if (servers != "")
{
List <MongoServerAddress> addresses = new List <MongoServerAddress>();
foreach (string server in servers.Split(','))
{
var address = MongoServerAddress.Parse(server);
addresses.Add(address);
}
_servers = addresses;
}
else
{
throw new FormatException("Invalid connection string. Server missing.");
}
_databaseName = (databaseName != "") ? databaseName : null;
if (!string.IsNullOrEmpty(query))
{
foreach (var pair in query.Split('&', ';'))
{
var parts = pair.Split('=');
if (parts.Length != 2)
{
throw new FormatException(string.Format("Invalid connection string '{0}'.", parts));
}
var name = parts[0];
var value = parts[1];
switch (name.ToLower())
{
case "connect":
_connectionMode = ParseConnectionMode(name, value);
break;
case "connecttimeout":
case "connecttimeoutms":
_connectTimeout = ParseTimeSpan(name, value);
break;
case "fsync":
if (_safeMode == null)
{
_safeMode = new SafeMode(false);
}
_safeMode.FSync = ParseBoolean(name, value);
break;
case "guids":
case "uuidrepresentation":
_guidRepresentation = (GuidRepresentation)Enum.Parse(typeof(GuidRepresentation), value, true); // ignoreCase
break;
case "ipv6":
_ipv6 = ParseBoolean(name, value);
break;
case "j":
case "journal":
if (_safeMode == null)
{
_safeMode = new SafeMode(false);
}
SafeMode.Journal = ParseBoolean(name, value);
break;
case "maxidletime":
case "maxidletimems":
_maxConnectionIdleTime = ParseTimeSpan(name, value);
break;
case "maxlifetime":
case "maxlifetimems":
_maxConnectionLifeTime = ParseTimeSpan(name, value);
break;
case "maxpoolsize":
_maxConnectionPoolSize = ParseInt32(name, value);
break;
case "minpoolsize":
_minConnectionPoolSize = ParseInt32(name, value);
break;
case "readpreference":
if (_readPreference == null)
{
_readPreference = new ReadPreference();
}
_readPreference.ReadPreferenceMode = ParseReadPreferenceMode(name, value);
break;
case "readpreferencetags":
if (_readPreference == null)
{
_readPreference = new ReadPreference {
ReadPreferenceMode = ReadPreferenceMode.Primary
};
}
_readPreference.AddTagSet(ParseReplicaSetTagSet(name, value));
break;
case "replicaset":
_replicaSetName = value;
break;
case "safe":
if (_safeMode == null)
{
_safeMode = new SafeMode(false);
}
SafeMode.Enabled = ParseBoolean(name, value);
break;
case "slaveok":
_slaveOk = ParseBoolean(name, value);
break;
case "sockettimeout":
case "sockettimeoutms":
_socketTimeout = ParseTimeSpan(name, value);
break;
case "ssl":
_useSsl = ParseBoolean(name, value);
break;
case "sslverifycertificate":
_verifySslCertificate = ParseBoolean(name, value);
break;
case "w":
if (_safeMode == null)
{
_safeMode = new SafeMode(false);
}
try
{
SafeMode.W = ParseInt32(name, value);
}
catch (FormatException)
{
SafeMode.WMode = value;
}
break;
case "waitqueuemultiple":
_waitQueueMultiple = ParseDouble(name, value);
_waitQueueSize = 0;
break;
case "waitqueuesize":
_waitQueueMultiple = 0;
_waitQueueSize = ParseInt32(name, value);
break;
case "waitqueuetimeout":
case "waitqueuetimeoutms":
_waitQueueTimeout = ParseTimeSpan(name, value);
break;
case "wtimeout":
case "wtimeoutms":
if (_safeMode == null)
{
_safeMode = new SafeMode(false);
}
SafeMode.WTimeout = ParseTimeSpan(name, value);
break;
}
}
}
}
else
{
throw new FormatException(string.Format("Invalid connection string '{0}'.", url));
}
}
public void SetConnectionMode(ConnectionMode mode)
{
CurrentConnectionMode = mode;
}
/// <summary>
/// Parses a URL and sets all settings to match the URL.
/// </summary>
/// <param name="url">The URL.</param>
public void Parse(string url)
{
var connectionString = new ConnectionString(url);
_applicationName = connectionString.ApplicationName;
_authenticationMechanism = connectionString.AuthMechanism;
_authenticationMechanismProperties = connectionString.AuthMechanismProperties.ToDictionary(x => x.Key, x => x.Value, StringComparer.OrdinalIgnoreCase);
_authenticationSource = connectionString.AuthSource;
switch (connectionString.Connect)
{
case ClusterConnectionMode.Direct:
_connectionMode = Driver.ConnectionMode.Direct;
break;
case ClusterConnectionMode.ReplicaSet:
_connectionMode = Driver.ConnectionMode.ReplicaSet;
break;
case ClusterConnectionMode.Sharded:
_connectionMode = Driver.ConnectionMode.ShardRouter;
break;
case ClusterConnectionMode.Standalone:
_connectionMode = Driver.ConnectionMode.Standalone;
break;
default:
_connectionMode = Driver.ConnectionMode.Automatic;
break;
}
_connectTimeout = connectionString.ConnectTimeout.GetValueOrDefault(MongoDefaults.ConnectTimeout);
_databaseName = connectionString.DatabaseName;
_fsync = connectionString.FSync;
_guidRepresentation = connectionString.UuidRepresentation.GetValueOrDefault(MongoDefaults.GuidRepresentation);
_heartbeatInterval = connectionString.HeartbeatInterval ?? ServerSettings.DefaultHeartbeatInterval;
_heartbeatTimeout = connectionString.HeartbeatTimeout ?? ServerSettings.DefaultHeartbeatTimeout;
_ipv6 = connectionString.Ipv6.GetValueOrDefault(false);
_journal = connectionString.Journal;
_maxConnectionIdleTime = connectionString.MaxIdleTime.GetValueOrDefault(MongoDefaults.MaxConnectionIdleTime);
_maxConnectionLifeTime = connectionString.MaxLifeTime.GetValueOrDefault(MongoDefaults.MaxConnectionLifeTime);
_maxConnectionPoolSize = connectionString.MaxPoolSize.GetValueOrDefault(MongoDefaults.MaxConnectionPoolSize);
_minConnectionPoolSize = connectionString.MinPoolSize.GetValueOrDefault(MongoDefaults.MinConnectionPoolSize);
_password = connectionString.Password;
_readConcernLevel = connectionString.ReadConcernLevel;
if (connectionString.ReadPreference.HasValue || connectionString.ReadPreferenceTags != null || connectionString.MaxStaleness.HasValue)
{
if (!connectionString.ReadPreference.HasValue)
{
throw new MongoConfigurationException("readPreference mode is required when using tag sets or max staleness.");
}
_readPreference = new ReadPreference(connectionString.ReadPreference.Value, connectionString.ReadPreferenceTags, connectionString.MaxStaleness);
}
_replicaSetName = connectionString.ReplicaSet;
_retryWrites = connectionString.RetryWrites;
_localThreshold = connectionString.LocalThreshold.GetValueOrDefault(MongoDefaults.LocalThreshold);
_scheme = connectionString.Scheme;
_servers = connectionString.Hosts.Select(endPoint =>
{
DnsEndPoint dnsEndPoint;
IPEndPoint ipEndPoint;
if ((dnsEndPoint = endPoint as DnsEndPoint) != null)
{
return(new MongoServerAddress(dnsEndPoint.Host, dnsEndPoint.Port));
}
else if ((ipEndPoint = endPoint as IPEndPoint) != null)
{
var address = ipEndPoint.Address.ToString();
if (ipEndPoint.AddressFamily == System.Net.Sockets.AddressFamily.InterNetworkV6)
{
address = "[" + address + "]";
}
return(new MongoServerAddress(address, ipEndPoint.Port));
}
else
{
throw new NotSupportedException("Only DnsEndPoint and IPEndPoints are supported in the connection string.");
}
});
_serverSelectionTimeout = connectionString.ServerSelectionTimeout.GetValueOrDefault(MongoDefaults.ServerSelectionTimeout);
_socketTimeout = connectionString.SocketTimeout.GetValueOrDefault(MongoDefaults.SocketTimeout);
_username = connectionString.Username;
_useSsl = connectionString.Ssl.GetValueOrDefault(false);
_verifySslCertificate = connectionString.SslVerifyCertificate.GetValueOrDefault(true);
_w = connectionString.W;
if (connectionString.WaitQueueSize != null)
{
_waitQueueSize = connectionString.WaitQueueSize.Value;
_waitQueueMultiple = 0.0;
}
else if (connectionString.WaitQueueMultiple != null)
{
_waitQueueMultiple = connectionString.WaitQueueMultiple.Value;
_waitQueueSize = 0;
}
_waitQueueTimeout = connectionString.WaitQueueTimeout.GetValueOrDefault(MongoDefaults.WaitQueueTimeout);
_wTimeout = connectionString.WTimeout;
}
// Connect to DF, fetch initial data, start things running
void ConnectAndInit()
{
blockRequest = new RemoteFortressReader.BlockRequest();
blockRequest.blocks_needed = BlocksToFetch;
pendingBlocks = new Util.UniqueQueue<DFCoord, RemoteFortressReader.MapBlock>();
networkClient = new DFHack.RemoteClient(dfNetworkOut);
bool success = networkClient.connect();
if (!success)
{
networkClient.disconnect();
networkClient = null;
throw new UnityException("DF Connection Failure");
}
BindMethods();
FetchUnchangingInfo();
networkClient.suspend_game();
viewInfoCall.execute(null, out _netViewInfo);
unitListCall.execute(null, out _netUnitList);
worldMapCall.execute(null, out _netWorldMap);
regionMapCall.execute(null, out _netRegionMaps);
networkClient.resume_game();
mapResetCall.execute();
InitStatics();
foreach (System.Action callback in connectionCallbacks)
{
callback.Invoke();
}
connectionCallbacks.Clear();
connectionMode = ConnectionMode.GetConnectionMode(this, RunOnAlternateThread);
}
public void VerifyCosmosConfigurationPropertiesGetUpdated()
{
string endpoint = AccountEndpoint;
string key = Guid.NewGuid().ToString();
string region = CosmosRegions.WestCentralUS;
ConnectionMode connectionMode = ConnectionMode.Gateway;
TimeSpan requestTimeout = TimeSpan.FromDays(1);
int maxConnections = 9001;
string userAgentSuffix = "testSuffix";
CosmosRequestHandler preProcessHandler = new TestHandler();
ApiType apiType = ApiType.Sql;
int maxRetryAttemptsOnThrottledRequests = 9999;
TimeSpan maxRetryWaitTime = TimeSpan.FromHours(6);
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
accountEndPoint: endpoint,
accountKey: key);
CosmosClient cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
CosmosClientOptions clientOptions = cosmosClient.ClientOptions;
Assert.AreEqual(endpoint, clientOptions.AccountEndPoint.OriginalString, "AccountEndPoint did not save correctly");
Assert.AreEqual(key, clientOptions.AccountKey, "AccountKey did not save correctly");
//Verify the default values are different from the new values
Assert.AreNotEqual(region, clientOptions.ApplicationRegion);
Assert.AreNotEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreNotEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreNotEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreNotEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreNotEqual(apiType, clientOptions.ApiType);
Assert.IsNull(clientOptions.CustomHandlers);
//Verify GetConnectionPolicy returns the correct values for default
ConnectionPolicy policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(ConnectionMode.Direct, policy.ConnectionMode);
Assert.AreEqual(Protocol.Tcp, policy.ConnectionProtocol);
Assert.AreEqual(clientOptions.GatewayModeMaxConnectionLimit, policy.MaxConnectionLimit);
Assert.AreEqual(clientOptions.RequestTimeout, policy.RequestTimeout);
cosmosClientBuilder.WithApplicationRegion(region)
.WithConnectionModeGateway(maxConnections)
.WithRequestTimeout(requestTimeout)
.WithApplicationName(userAgentSuffix)
.AddCustomHandlers(preProcessHandler)
.WithApiType(apiType)
.WithThrottlingRetryOptions(maxRetryWaitTime, maxRetryAttemptsOnThrottledRequests);
cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
clientOptions = cosmosClient.ClientOptions;
//Verify all the values are updated
Assert.AreEqual(region, clientOptions.ApplicationRegion);
Assert.AreEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreEqual(preProcessHandler, clientOptions.CustomHandlers[0]);
Assert.AreEqual(apiType, clientOptions.ApiType);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, clientOptions.MaxRetryAttemptsOnThrottledRequests);
Assert.AreEqual(maxRetryWaitTime, clientOptions.MaxRetryWaitTimeOnThrottledRequests);
//Verify GetConnectionPolicy returns the correct values
policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(region, policy.PreferredLocations[0]);
Assert.AreEqual(ConnectionMode.Gateway, policy.ConnectionMode);
Assert.AreEqual(Protocol.Https, policy.ConnectionProtocol);
Assert.AreEqual(maxConnections, policy.MaxConnectionLimit);
Assert.AreEqual(requestTimeout, policy.RequestTimeout);
Assert.AreEqual(userAgentSuffix, policy.UserAgentSuffix);
Assert.IsTrue(policy.UseMultipleWriteLocations);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, policy.RetryOptions.MaxRetryAttemptsOnThrottledRequests);
Assert.AreEqual((int)maxRetryWaitTime.TotalSeconds, policy.RetryOptions.MaxRetryWaitTimeInSeconds);
}
public MongoServerSettings(
ConnectionMode connectionMode,
TimeSpan connectTimeout,
MongoCredentialsStore credentialsStore,
MongoCredentials defaultCredentials,
GuidRepresentation guidRepresentation,
bool ipv6,
TimeSpan maxConnectionIdleTime,
TimeSpan maxConnectionLifeTime,
int maxConnectionPoolSize,
int minConnectionPoolSize,
ReadPreference readPreference,
string replicaSetName,
SafeMode safeMode,
TimeSpan secondaryAcceptableLatency,
IEnumerable<MongoServerAddress> servers,
TimeSpan socketTimeout,
bool useSsl,
bool verifySslCertificate,
int waitQueueSize,
TimeSpan waitQueueTimeout)
{
if (servers == null)
{
throw new ArgumentNullException("servers");
}
if (readPreference == null)
{
throw new ArgumentNullException("readPreference");
}
if (safeMode == null)
{
throw new ArgumentNullException("safeMode");
}
_connectionMode = connectionMode;
_connectTimeout = connectTimeout;
_credentialsStore = credentialsStore ?? new MongoCredentialsStore();
_defaultCredentials = defaultCredentials;
_guidRepresentation = guidRepresentation;
_ipv6 = ipv6;
_maxConnectionIdleTime = maxConnectionIdleTime;
_maxConnectionLifeTime = maxConnectionLifeTime;
_maxConnectionPoolSize = maxConnectionPoolSize;
_minConnectionPoolSize = minConnectionPoolSize;
_readPreference = readPreference;
_replicaSetName = replicaSetName;
_secondaryAcceptableLatency = secondaryAcceptableLatency;
_servers = new List<MongoServerAddress>(servers);
_socketTimeout = socketTimeout;
_useSsl = useSsl;
_verifySslCertificate = verifySslCertificate;
_waitQueueSize = waitQueueSize;
_waitQueueTimeout = waitQueueTimeout;
_writeConcern = safeMode;
}
public void VerifyCosmosConfigurationPropertiesGetUpdated()
{
string endpoint = AccountEndpoint;
string key = Guid.NewGuid().ToString();
string region = Regions.WestCentralUS;
ConnectionMode connectionMode = ConnectionMode.Gateway;
TimeSpan requestTimeout = TimeSpan.FromDays(1);
int maxConnections = 9001;
string userAgentSuffix = "testSuffix";
RequestHandler preProcessHandler = new TestHandler();
ApiType apiType = ApiType.Sql;
int maxRetryAttemptsOnThrottledRequests = 9999;
TimeSpan maxRetryWaitTime = TimeSpan.FromHours(6);
CosmosSerializationOptions cosmosSerializerOptions = new CosmosSerializationOptions()
{
IgnoreNullValues = true,
PropertyNamingPolicy = CosmosPropertyNamingPolicy.CamelCase,
};
TimeSpan idleTcpConnectionTimeout = new TimeSpan(0, 10, 0);
TimeSpan openTcpConnectionTimeout = new TimeSpan(0, 0, 5);
int maxRequestsPerTcpConnection = 30;
int maxTcpConnectionsPerEndpoint = 65535;
IWebProxy webProxy = new TestWebProxy();
CosmosClientBuilder cosmosClientBuilder = new CosmosClientBuilder(
accountEndpoint: endpoint,
authKeyOrResourceToken: key);
CosmosClient cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
CosmosClientOptions clientOptions = cosmosClient.ClientOptions;
Assert.AreEqual(endpoint, cosmosClient.Endpoint.OriginalString, "AccountEndpoint did not save correctly");
Assert.AreEqual(key, cosmosClient.AccountKey, "AccountKey did not save correctly");
//Verify the default values are different from the new values
Assert.AreNotEqual(region, clientOptions.ApplicationRegion);
Assert.AreNotEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreNotEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreNotEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreNotEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreNotEqual(apiType, clientOptions.ApiType);
Assert.IsFalse(clientOptions.AllowBulkExecution);
Assert.AreEqual(0, clientOptions.CustomHandlers.Count);
Assert.IsNull(clientOptions.SerializerOptions);
Assert.IsNull(clientOptions.Serializer);
Assert.IsNull(clientOptions.WebProxy);
Assert.IsFalse(clientOptions.LimitToEndpoint);
//Verify GetConnectionPolicy returns the correct values for default
ConnectionPolicy policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(ConnectionMode.Direct, policy.ConnectionMode);
Assert.AreEqual(Protocol.Tcp, policy.ConnectionProtocol);
Assert.AreEqual(clientOptions.GatewayModeMaxConnectionLimit, policy.MaxConnectionLimit);
Assert.AreEqual(clientOptions.RequestTimeout, policy.RequestTimeout);
Assert.IsNull(policy.IdleTcpConnectionTimeout);
Assert.IsNull(policy.OpenTcpConnectionTimeout);
Assert.IsNull(policy.MaxRequestsPerTcpConnection);
Assert.IsNull(policy.MaxTcpConnectionsPerEndpoint);
Assert.IsTrue(policy.EnableEndpointDiscovery);
cosmosClientBuilder.WithApplicationRegion(region)
.WithConnectionModeGateway(maxConnections, webProxy)
.WithRequestTimeout(requestTimeout)
.WithApplicationName(userAgentSuffix)
.AddCustomHandlers(preProcessHandler)
.WithApiType(apiType)
.WithThrottlingRetryOptions(maxRetryWaitTime, maxRetryAttemptsOnThrottledRequests)
.WithBulkExecution(true)
.WithSerializerOptions(cosmosSerializerOptions);
cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
clientOptions = cosmosClient.ClientOptions;
//Verify all the values are updated
Assert.AreEqual(region, clientOptions.ApplicationRegion);
Assert.AreEqual(connectionMode, clientOptions.ConnectionMode);
Assert.AreEqual(maxConnections, clientOptions.GatewayModeMaxConnectionLimit);
Assert.AreEqual(requestTimeout, clientOptions.RequestTimeout);
Assert.AreEqual(userAgentSuffix, clientOptions.ApplicationName);
Assert.AreEqual(preProcessHandler, clientOptions.CustomHandlers[0]);
Assert.AreEqual(apiType, clientOptions.ApiType);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, clientOptions.MaxRetryAttemptsOnRateLimitedRequests);
Assert.AreEqual(maxRetryWaitTime, clientOptions.MaxRetryWaitTimeOnRateLimitedRequests);
Assert.AreEqual(cosmosSerializerOptions.IgnoreNullValues, clientOptions.SerializerOptions.IgnoreNullValues);
Assert.AreEqual(cosmosSerializerOptions.PropertyNamingPolicy, clientOptions.SerializerOptions.PropertyNamingPolicy);
Assert.AreEqual(cosmosSerializerOptions.Indented, clientOptions.SerializerOptions.Indented);
Assert.IsTrue(object.ReferenceEquals(webProxy, clientOptions.WebProxy));
Assert.IsTrue(clientOptions.AllowBulkExecution);
//Verify GetConnectionPolicy returns the correct values
policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(region, policy.PreferredLocations[0]);
Assert.AreEqual(ConnectionMode.Gateway, policy.ConnectionMode);
Assert.AreEqual(Protocol.Https, policy.ConnectionProtocol);
Assert.AreEqual(maxConnections, policy.MaxConnectionLimit);
Assert.AreEqual(requestTimeout, policy.RequestTimeout);
Assert.IsTrue(policy.UserAgentSuffix.Contains(userAgentSuffix));
Assert.IsTrue(policy.UseMultipleWriteLocations);
Assert.AreEqual(maxRetryAttemptsOnThrottledRequests, policy.RetryOptions.MaxRetryAttemptsOnThrottledRequests);
Assert.AreEqual((int)maxRetryWaitTime.TotalSeconds, policy.RetryOptions.MaxRetryWaitTimeInSeconds);
//Verify Direct Mode settings
cosmosClientBuilder = new CosmosClientBuilder(
accountEndpoint: endpoint,
authKeyOrResourceToken: key);
cosmosClientBuilder.WithConnectionModeDirect(
idleTcpConnectionTimeout,
openTcpConnectionTimeout,
maxRequestsPerTcpConnection,
maxTcpConnectionsPerEndpoint
);
cosmosClient = cosmosClientBuilder.Build(new MockDocumentClient());
clientOptions = cosmosClient.ClientOptions;
//Verify all the values are updated
Assert.AreEqual(idleTcpConnectionTimeout, clientOptions.IdleTcpConnectionTimeout);
Assert.AreEqual(openTcpConnectionTimeout, clientOptions.OpenTcpConnectionTimeout);
Assert.AreEqual(maxRequestsPerTcpConnection, clientOptions.MaxRequestsPerTcpConnection);
Assert.AreEqual(maxTcpConnectionsPerEndpoint, clientOptions.MaxTcpConnectionsPerEndpoint);
//Verify GetConnectionPolicy returns the correct values
policy = clientOptions.GetConnectionPolicy();
Assert.AreEqual(idleTcpConnectionTimeout, policy.IdleTcpConnectionTimeout);
Assert.AreEqual(openTcpConnectionTimeout, policy.OpenTcpConnectionTimeout);
Assert.AreEqual(maxRequestsPerTcpConnection, policy.MaxRequestsPerTcpConnection);
Assert.AreEqual(maxTcpConnectionsPerEndpoint, policy.MaxTcpConnectionsPerEndpoint);
}
/// <summary>
/// Parses a URL and sets all settings to match the URL.
/// </summary>
/// <param name="url">The URL.</param>
public void Parse(
string url
) {
ResetValues();
const string pattern =
@"^mongodb://" +
@"((?<username>[^:]+):(?<password>[^@]+)@)?" +
@"(?<servers>[^:,/]+(:\d+)?(,[^:,/]+(:\d+)?)*)" +
@"(/(?<database>[^?]+)?(\?(?<query>.*))?)?$";
Match match = Regex.Match(url, pattern);
if (match.Success) {
string username = Uri.UnescapeDataString(match.Groups["username"].Value);
string password = Uri.UnescapeDataString(match.Groups["password"].Value);
string servers = match.Groups["servers"].Value;
string databaseName = match.Groups["database"].Value;
string query = match.Groups["query"].Value;
if (username != "" && password != "") {
this.defaultCredentials = new MongoCredentials(username, password);
} else {
this.defaultCredentials = null;
}
if (servers != "") {
List<MongoServerAddress> addresses = new List<MongoServerAddress>();
foreach (string server in servers.Split(',')) {
var address = MongoServerAddress.Parse(server);
addresses.Add(address);
}
if (addresses.Count == 1) {
this.connectionMode = ConnectionMode.Direct;
} else if (addresses.Count > 1) {
this.connectionMode = ConnectionMode.ReplicaSet;
}
this.servers = addresses;
} else {
throw new FormatException("Invalid connection string: server missing");
}
this.databaseName = (databaseName != "") ? databaseName : null;
if (!string.IsNullOrEmpty(query)) {
var safeModeChanged = false;
var safe = false;
var w = 0;
var wtimeout = TimeSpan.Zero;
var fsync = false;
foreach (var pair in query.Split('&', ';')) {
var parts = pair.Split('=');
if (parts.Length != 2) {
throw new FormatException(string.Format("Invalid connection string: {0}", parts));
}
var name = parts[0];
var value = parts[1];
switch (name.ToLower()) {
case "connect":
connectionMode = ParseConnectionMode(name, value);
break;
case "connecttimeout":
case "connecttimeoutms":
connectTimeout = ParseTimeSpan(name, value);
break;
case "fsync":
safeModeChanged = true;
safe = true;
fsync = ParseBoolean(name, value);
break;
case "ipv6":
ipv6 = ParseBoolean(name, value);
break;
case "maxidletime":
case "maxidletimems":
maxConnectionIdleTime = ParseTimeSpan(name, value);
break;
case "maxlifetime":
case "maxlifetimems":
maxConnectionLifeTime = ParseTimeSpan(name, value);
break;
case "maxpoolsize":
maxConnectionPoolSize = ParseInt32(name, value);
break;
case "minpoolsize":
minConnectionPoolSize = ParseInt32(name, value);
break;
case "replicaset":
this.replicaSetName = value;
this.connectionMode = ConnectionMode.ReplicaSet;
break;
case "safe":
safeModeChanged = true;
safe = ParseBoolean(name, value);
break;
case "slaveok":
slaveOk = ParseBoolean(name, value);
break;
case "sockettimeout":
case "sockettimeoutms":
socketTimeout = ParseTimeSpan(name, value);
break;
case "w":
safeModeChanged = true;
safe = true;
w = ParseInt32(name, value);
break;
case "waitqueuemultiple":
waitQueueMultiple = ParseDouble(name, value);
waitQueueSize = 0;
break;
case "waitqueuesize":
waitQueueMultiple = 0;
waitQueueSize = ParseInt32(name, value);
break;
case "waitqueuetimeout":
case "waitqueuetimeoutms":
waitQueueTimeout = ParseTimeSpan(name, value);
break;
case "wtimeout":
case "wtimeoutms":
safeModeChanged = true;
safe = true;
wtimeout = ParseTimeSpan(name, value);
break;
}
}
if (safeModeChanged) {
this.safeMode = SafeMode.Create(safe, fsync, w, wtimeout);
}
}
} else {
throw new FormatException(string.Format("Invalid connection string: {0}", url));
}
}
/// <summary>
/// Parses a URL and sets all settings to match the URL.
/// </summary>
/// <param name="url">The URL.</param>
public void Parse(string url)
{
var connectionString = new ConnectionString(url);
_authenticationMechanism = connectionString.AuthMechanism;
_authenticationMechanismProperties = connectionString.AuthMechanismProperties.ToDictionary(x => x.Key, x => x.Value, StringComparer.InvariantCultureIgnoreCase);
_authenticationSource = connectionString.AuthSource;
switch (connectionString.Connect)
{
case ClusterConnectionMode.Direct:
_connectionMode = Driver.ConnectionMode.Direct;
break;
case ClusterConnectionMode.ReplicaSet:
_connectionMode = Driver.ConnectionMode.ReplicaSet;
break;
case ClusterConnectionMode.Sharded:
_connectionMode = Driver.ConnectionMode.ShardRouter;
break;
case ClusterConnectionMode.Standalone:
_connectionMode = Driver.ConnectionMode.Standalone;
break;
default:
_connectionMode = Driver.ConnectionMode.Automatic;
break;
}
_connectTimeout = connectionString.ConnectTimeout.GetValueOrDefault(MongoDefaults.ConnectTimeout);
_databaseName = connectionString.DatabaseName;
_fsync = connectionString.FSync;
_guidRepresentation = connectionString.UuidRepresentation.GetValueOrDefault(MongoDefaults.GuidRepresentation);
_ipv6 = connectionString.Ipv6.GetValueOrDefault(false);
_journal = connectionString.Journal;
_maxConnectionIdleTime = connectionString.MaxIdleTime.GetValueOrDefault(MongoDefaults.MaxConnectionIdleTime);
_maxConnectionLifeTime = connectionString.MaxLifeTime.GetValueOrDefault(MongoDefaults.MaxConnectionLifeTime);
_maxConnectionPoolSize = connectionString.MaxPoolSize.GetValueOrDefault(MongoDefaults.MaxConnectionPoolSize);
_minConnectionPoolSize = connectionString.MinPoolSize.GetValueOrDefault(MongoDefaults.MinConnectionPoolSize);
_password = connectionString.Password;
if (connectionString.ReadPreference != null)
{
_readPreference = new ReadPreference(connectionString.ReadPreference.Value);
}
if (connectionString.ReadPreferenceTags != null)
{
if (_readPreference == null)
{
throw new MongoConfigurationException("ReadPreferenceMode is required when using tag sets.");
}
_readPreference = _readPreference.With(tagSets: Optional.Create <IEnumerable <TagSet> >(connectionString.ReadPreferenceTags));
}
_replicaSetName = connectionString.ReplicaSet;
_localThreshold = connectionString.LocalThreshold.GetValueOrDefault(MongoDefaults.LocalThreshold);
_servers = connectionString.Hosts.Select(endPoint =>
{
DnsEndPoint dnsEndPoint;
IPEndPoint ipEndPoint;
if ((dnsEndPoint = endPoint as DnsEndPoint) != null)
{
return(new MongoServerAddress(dnsEndPoint.Host, dnsEndPoint.Port));
}
else if ((ipEndPoint = endPoint as IPEndPoint) != null)
{
return(new MongoServerAddress(ipEndPoint.Address.ToString(), ipEndPoint.Port));
}
else
{
throw new NotSupportedException("Only DnsEndPoint and IPEndPoints are supported in the connection string.");
}
});
_socketTimeout = connectionString.SocketTimeout.GetValueOrDefault(MongoDefaults.SocketTimeout);
_username = connectionString.Username;
_useSsl = connectionString.Ssl.GetValueOrDefault(false);
_verifySslCertificate = connectionString.SslVerifyCertificate.GetValueOrDefault(true);
_w = connectionString.W;
if (connectionString.WaitQueueSize != null)
{
_waitQueueSize = connectionString.WaitQueueSize.Value;
_waitQueueMultiple = 0.0;
}
else if (connectionString.WaitQueueMultiple != null)
{
_waitQueueMultiple = connectionString.WaitQueueMultiple.Value;
_waitQueueSize = 0;
}
_waitQueueTimeout = connectionString.WaitQueueTimeout.GetValueOrDefault(MongoDefaults.WaitQueueTimeout);
_wTimeout = connectionString.WTimeout;
}
public void TestConnectionMode(ConnectionMode? connectionMode, string formatString, string[] values)
{
var built = new MongoUrlBuilder { Server = _localhost };
if (connectionMode != null) { built.ConnectionMode = connectionMode.Value; }
var canonicalConnectionString = string.Format(formatString, values[0]);
foreach (var builder in EnumerateBuiltAndParsedBuilders(built, formatString, values))
{
Assert.AreEqual(connectionMode ?? ConnectionMode.Automatic, builder.ConnectionMode);
Assert.AreEqual(canonicalConnectionString, builder.ToString());
}
}
/// <summary>
/// Change the connection mode of the ThreadedComPortBase.
/// </summary>
/// <param name="mode">The new mode to use for selection of the ComPorts.</param>
/// <param name="selectionRule">The new rule to use for selecting ComPorts when mode = SelectionRule.</param>
public void ChangeMode(ConnectionMode mode, Func <ComPortInfo, bool> selectionRule = null)
{
TargetSelectionRule = selectionRule;
TargetMode = mode;
MachineFunctions.JumpToStep("Searching", WorkerStateMachine);
}
