public MySqlPool(MySqlConnectionStringBuilder settings) { minSize = settings.MinimumPoolSize; maxSize = settings.MaximumPoolSize; if (minSize > maxSize) { minSize = maxSize; } this.settings = settings; #if NET20 inUsePool = new List <Driver>((int)maxSize); idlePool = new Queue <Driver>((int)maxSize); #else inUsePool = new ArrayList(maxSize); idlePool = new Queue(maxSize); #endif // prepopulate the idle pool to minSize for (int i = 0; i < minSize; i++) { CreateNewPooledConnection(); } procedureCache = new ProcedureCache(settings.ProcedureCacheSize); poolGate = new Semaphore((int)maxSize, (int)maxSize); // we don't really need to create this but it makes the code a bit cleaner lockObject = new Object(); }
public MySqlPool(MySqlConnectionStringBuilder settings) { minSize = settings.MinimumPoolSize; maxSize = settings.MaximumPoolSize; available = (int)maxSize; autoEvent = new AutoResetEvent(false); if (minSize > maxSize) { minSize = maxSize; } this.settings = settings; #if NET20 inUsePool = new List <Driver>((int)maxSize); idlePool = new Queue <Driver>((int)maxSize); #else inUsePool = new ArrayList((int)maxSize); idlePool = new Queue((int)maxSize); #endif // prepopulate the idle pool to minSize for (int i = 0; i < minSize; i++) { idlePool.Enqueue(CreateNewPooledConnection()); } procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); beingCleared = false; }
public MySqlPool(MySqlConnectionStringBuilder settings) { minSize = settings.MinimumPoolSize; maxSize = settings.MaximumPoolSize; available = (int)maxSize; autoEvent = new AutoResetEvent(false); if (minSize > maxSize) { minSize = maxSize; } this.settings = settings; inUsePool = new List <Driver>((int)maxSize); idlePool = new Queue <Driver>((int)maxSize); maxUsedConnections = (int)minSize; // prepopulate the idle pool to minSize for (int i = 0; i < minSize; i++) { EnqueueIdle(CreateNewPooledConnection()); } procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); }
public MySqlPool(MySqlConnectionString settings) { this.minSize = settings.MinPoolSize; this.maxSize = settings.MaxPoolSize; this.settings = settings; this.inUsePool = new ArrayList(this.maxSize); this.idlePool = new Queue(this.maxSize); for (int i = 0; i < this.minSize; i++) { this.CreateNewPooledConnection(); } this.procedureCache = new ProcedureCache(settings.ProcedureCacheSize); this.poolGate = new Semaphore(this.maxSize, this.maxSize); this.lockObject = new object(); }
public MySqlPool(MySqlConnectionStringBuilder settings) { minSize = settings.MinimumPoolSize; maxSize = settings.MaximumPoolSize; available = (int)maxSize; autoEvent = new AutoResetEvent(false); if (minSize > maxSize) minSize = maxSize; this.settings = settings; inUsePool = new List<Driver>((int)maxSize); idlePool = new Queue<Driver>((int)maxSize); // prepopulate the idle pool to minSize for (var i = 0; i < minSize; i++) EnqueueIdle(CreateNewPooledConnection()); procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); }
public MySqlPool(MySqlConnectionStringBuilder settings) { this.minSize = settings.MinimumPoolSize; this.maxSize = settings.MaximumPoolSize; this.available = (int)this.maxSize; this.autoEvent = new AutoResetEvent(false); if (this.minSize > this.maxSize) { this.minSize = this.maxSize; } this.settings = settings; this.inUsePool = new List <Driver>((int)this.maxSize); this.idlePool = new Queue <Driver>((int)this.maxSize); int num = 0; while ((long)num < (long)((ulong)this.minSize)) { this.EnqueueIdle(this.CreateNewPooledConnection()); num++; } this.procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); }
public void Open() { if (this.state == (ConnectionState)1) { throw new InvalidOperationException(Resources.ConnectionAlreadyOpen); } this.SetState((ConnectionState)2); try { if (this.settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(this.settings); this.driver = pool.GetConnection(); this.procedureCache = pool.ProcedureCache; } else { this.driver = Driver.Create(this.settings); this.procedureCache = new ProcedureCache(this.settings.ProcedureCacheSize); } } catch (Exception) { this.SetState(0); throw; } if (this.driver.Settings.UseOldSyntax) { Logger.LogWarning("You are using old syntax that will be removed in future versions"); } this.SetState((ConnectionState)1); this.driver.Configure(this); if (this.settings.Database != null && this.settings.Database.Length != 0) { this.ChangeDatabase(this.settings.Database); } this.hasBeenOpen = true; }
private ProcedureCacheEntry AddNew(MySqlConnection connection, string spName) { ProcedureCacheEntry procData = ProcedureCache.GetProcData(connection, spName); if (this.maxSize > 0) { string cacheKey = this.GetCacheKey(spName, procData); int hashCode = cacheKey.GetHashCode(); lock (this.procHash) { if (this.procHash.Keys.Count >= this.maxSize) { this.TrimHash(); } if (!this.procHash.ContainsKey(hashCode)) { this.procHash[hashCode] = procData; this.hashQueue.Enqueue(hashCode); } } } return(procData); }
public MySqlPool(MySqlConnectionStringBuilder settings) { _minSize = settings.MinimumPoolSize; _maxSize = settings.MaximumPoolSize; _available = (int)_maxSize; _autoEvent = new AutoResetEvent(false); if (_minSize > _maxSize) { _minSize = _maxSize; } this.Settings = settings; _inUsePool = new List <Driver>((int)_maxSize); _idlePool = new Queue <Driver>((int)_maxSize); // prepopulate the idle pool to minSize for (int i = 0; i < _minSize; i++) { EnqueueIdle(CreateNewPooledConnection()); } ProcedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { throw new InvalidOperationException(Resources.ConnectionAlreadyOpen); } SetState(ConnectionState.Connecting, true); #if !CF // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) { throw new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported); } } #endif try { if (settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(settings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(settings); } procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); } } catch (Exception) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know if (driver.Settings.UseOldSyntax) { MySqlTrace.LogWarning(ServerThread, "You are using old syntax that will be removed in future versions"); } SetState(ConnectionState.Open, false); driver.Configure(this); if (settings.Database != null && settings.Database != String.Empty) { ChangeDatabase(settings.Database); } // setup our schema provider schemaProvider = new ISSchemaProvider(this); #if !CF perfMonitor = new PerformanceMonitor(this); #endif // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO && !CF if (Transaction.Current != null && settings.AutoEnlist) { EnlistTransaction(Transaction.Current); } #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) throw new InvalidOperationException(Resources.ConnectionAlreadyOpen); SetState(ConnectionState.Connecting, true); #if !CF // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) throw new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported); } #endif try { if (settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(settings); if (driver == null) driver = pool.GetConnection(); procedureCache = pool.ProcedureCache; } else { if (driver == null) driver = Driver.Create(settings); procedureCache = new ProcedureCache((int) settings.ProcedureCacheSize); } } catch (Exception) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know if (driver.Settings.UseOldSyntax) Logger.LogWarning("You are using old syntax that will be removed in future versions"); SetState(ConnectionState.Open, false); driver.Configure(this); if (settings.Database != null && settings.Database != String.Empty) ChangeDatabase(settings.Database); // setup our schema provider if (driver.Version.isAtLeast(5, 0, 0)) schemaProvider = new ISSchemaProvider(this); else schemaProvider = new SchemaProvider(this); #if !CF perfMonitor = new PerformanceMonitor(this); #endif // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO && !CF if (Transaction.Current != null && settings.AutoEnlist) EnlistTransaction(Transaction.Current); #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { throw new InvalidOperationException("Resources.ConnectionAlreadyOpen"); } SetState(ConnectionState.Connecting, true); //AssertPermissions(); try { MySqlConnectionStringBuilder currentSettings = Settings; if (Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(currentSettings); } procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception ex) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know //if (driver.Settings.UseOldSyntax) //MySqlTrace.LogWarning(ServerThread, // "You are using old syntax that will be removed in future versions"); SetState(ConnectionState.Open, false); driver.Configure(this); if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (Settings.Database != null && Settings.Database != String.Empty) { ChangeDatabase(Settings.Database); } } // setup our schema provider schemaProvider = new ISSchemaProvider(this); // // if we are opening up inside a current transaction, then autoenlist // // TODO: control this with a connection string option //#if !MONO && !CF && !RT // if (Transaction.Current != null && Settings.AutoEnlist) // EnlistTransaction(Transaction.Current); //#endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); } // start up our interceptors _exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); SetState(ConnectionState.Connecting, true); #if !NETSTANDARD1_3 AssertPermissions(); //TODO: SUPPORT FOR 452 AND 46X // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (Settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) { Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } } #endif try { MySqlConnectionStringBuilder currentSettings = Settings; //TODO: SUPPORT FOR 452 AND 46X // Load balancing #if !NETSTANDARD1_3 if (ReplicationManager.IsReplicationGroup(Settings.Server)) { if (driver == null) { ReplicationManager.GetNewConnection(Settings.Server, false, this); } else { currentSettings = driver.Settings; } } #endif if (Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } ProcedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(currentSettings); } ProcedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception) { SetState(ConnectionState.Closed, true); throw; } SetState(ConnectionState.Open, false); driver.Configure(this); if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (!string.IsNullOrEmpty(Settings.Database)) { ChangeDatabase(Settings.Database); } } // setup our schema provider _schemaProvider = new ISSchemaProvider(this); PerfMonitor = new PerformanceMonitor(this); // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !NETSTANDARD1_3 if (Transaction.Current != null && Settings.AutoEnlist) { EnlistTransaction(Transaction.Current); } #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
public override void Open() { if (this.State == ConnectionState.Open) { this.Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); } this.exceptionInterceptor = new ExceptionInterceptor(this); this.commandInterceptor = new CommandInterceptor(this); this.SetState(ConnectionState.Connecting, true); this.AssertPermissions(); if (this.Settings.AutoEnlist && Transaction.Current != null) { this.driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (this.driver != null && (this.driver.IsInActiveUse || !this.driver.Settings.EquivalentTo(this.Settings))) { this.Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } } try { MySqlConnectionStringBuilder settings = this.Settings; if (ReplicationManager.IsReplicationGroup(this.Settings.Server)) { if (this.driver == null) { ReplicationManager.GetNewConnection(this.Settings.Server, false, this); return; } settings = this.driver.Settings; } if (this.Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(settings); if (this.driver == null || !this.driver.IsOpen) { this.driver = pool.GetConnection(); } this.procedureCache = pool.ProcedureCache; } else { if (this.driver == null || !this.driver.IsOpen) { this.driver = Driver.Create(settings); } this.procedureCache = new ProcedureCache((int)this.Settings.ProcedureCacheSize); } } catch (Exception) { this.SetState(ConnectionState.Closed, true); throw; } if (this.driver.Settings.UseOldSyntax) { MySqlTrace.LogWarning(this.ServerThread, "You are using old syntax that will be removed in future versions"); } this.SetState(ConnectionState.Open, false); this.driver.Configure(this); if ((!this.driver.SupportsPasswordExpiration || !this.driver.IsPasswordExpired) && this.Settings.Database != null && this.Settings.Database != string.Empty) { this.ChangeDatabase(this.Settings.Database); } this.schemaProvider = new ISSchemaProvider(this); this.perfMonitor = new PerformanceMonitor(this); if (Transaction.Current != null && this.Settings.AutoEnlist) { this.EnlistTransaction(Transaction.Current); } this.hasBeenOpen = true; this.SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); #if !CF && !RT // start up our interceptors exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); #endif SetState(ConnectionState.Connecting, true); AssertPermissions(); #if !CF && !RT // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (Settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } #endif try { MySqlConnectionStringBuilder currentSettings = Settings; #if !CF // Load balancing if (ReplicationManager.IsReplicationGroup(Settings.Server)) { if (driver == null) { ReplicationManager.GetNewConnection(Settings.Server, false, this); return; } else currentSettings = driver.Settings; } #endif if (Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen) driver = pool.GetConnection(); procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) driver = Driver.Create(currentSettings); procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception ex) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know if (driver.Settings.UseOldSyntax) MySqlTrace.LogWarning(ServerThread, "You are using old syntax that will be removed in future versions"); SetState(ConnectionState.Open, false); driver.Configure(this); if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (Settings.Database != null && Settings.Database != String.Empty) ChangeDatabase(Settings.Database); } // setup our schema provider schemaProvider = new ISSchemaProvider(this); #if !CF perfMonitor = new PerformanceMonitor(this); #endif // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO && !CF && !RT if (Transaction.Current != null && Settings.AutoEnlist) EnlistTransaction(Transaction.Current); #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); } // start up our interceptors _exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); SetState(ConnectionState.Connecting, true); try { MySqlConnectionStringBuilder currentSettings = Settings; //TODO: SUPPORT FOR 452 AND 46X // Load balancing if (Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } ProcedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(currentSettings); } ProcedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception) { SetState(ConnectionState.Closed, true); throw; } SetState(ConnectionState.Open, false); driver.Configure(this); if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (!string.IsNullOrEmpty(Settings.Database)) { ChangeDatabase(Settings.Database); } } // setup our schema provider _schemaProvider = new ISSchemaProvider(this); PerfMonitor = new PerformanceMonitor(this); // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); } #if !RT // start up our interceptors exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); #endif SetState(ConnectionState.Connecting, true); AssertPermissions(); #if !RT // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (Settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) { Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } } #endif try { MySqlConnectionStringBuilder currentSettings = Settings; // Load balancing if (ReplicationManager.IsReplicationGroup(Settings.Server)) { if (driver == null) { ReplicationManager.GetNewConnection(Settings.Server, false, this); } else { currentSettings = driver.Settings; } } if (Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(currentSettings); } procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception ex) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know if (driver.Settings.UseOldSyntax) { MySqlTrace.LogWarning(ServerThread, "You are using old syntax that will be removed in future versions"); } SetState(ConnectionState.Open, false); driver.Configure(this); if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (Settings.Database != null && Settings.Database != String.Empty) { ChangeDatabase(Settings.Database); } } // setup our schema provider schemaProvider = new ISSchemaProvider(this); perfMonitor = new PerformanceMonitor(this); // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO && !RT if (Transaction.Current != null && Settings.AutoEnlist) { EnlistTransaction(Transaction.Current); } #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { throw new InvalidOperationException(Resources.ConnectionAlreadyOpen); } SetState(ConnectionState.Connecting); try { if (settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(settings); driver = pool.GetConnection(); procedureCache = pool.ProcedureCache; } else { driver = Driver.Create(settings); procedureCache = new ProcedureCache(settings.ProcedureCacheSize); } } catch (Exception) { SetState(ConnectionState.Closed); throw; } // if the user is using old syntax, let them know if (driver.Settings.UseOldSyntax) { Logger.LogWarning("You are using old syntax that will be removed in future versions"); } SetState(ConnectionState.Open); driver.Configure(this); if (settings.Database != null && settings.Database != String.Empty) { ChangeDatabase(settings.Database); } // setup our schema provider if (driver.Version.isAtLeast(5, 0, 0)) { schemaProvider = new ISSchemaProvider(this); } else { schemaProvider = new SchemaProvider(this); } perfMonitor = new PerformanceMonitor(this); // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO if (System.Transactions.Transaction.Current != null) { EnlistTransaction(System.Transactions.Transaction.Current); } #endif hasBeenOpen = true; }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); } // start up our interceptors _exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); SetState(ConnectionState.Connecting, true); AssertPermissions(); //TODO: SUPPORT FOR 452 AND 46X // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (Settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) { Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } } MySqlConnectionStringBuilder currentSettings = Settings; try { if (Settings.ConnectionProtocol == MySqlConnectionProtocol.Tcp && Settings.IsSshEnabled()) { _sshHandler = new Ssh( Settings.SshHostName, Settings.SshUserName, Settings.SshPassword, Settings.SshKeyFile, Settings.SshPassphrase, Settings.SshPort, Settings.Server, Settings.Port, false ); _sshHandler.StartClient(); } if (!Settings.Pooling || MySqlPoolManager.Hosts == null) { FailoverManager.Reset(); if (Settings.DnsSrv) { var dnsSrvRecords = DnsResolver.GetDnsSrvRecords(Settings.Server); FailoverManager.SetHostList(dnsSrvRecords.ConvertAll(r => new FailoverServer(r.Target, r.Port, null)), FailoverMethod.Sequential); } else { FailoverManager.ParseHostList(Settings.Server, false); } } // Load balancing && Failover if (ReplicationManager.IsReplicationGroup(Settings.Server)) { if (driver == null) { ReplicationManager.GetNewConnection(Settings.Server, false, this); } else { currentSettings = driver.Settings; } } else if (FailoverManager.FailoverGroup != null && !Settings.Pooling) { FailoverManager.AttemptConnection(this, Settings.ConnectionString, out string connectionString); currentSettings.ConnectionString = connectionString; } if (Settings.Pooling) { if (FailoverManager.FailoverGroup != null) { FailoverManager.AttemptConnection(this, Settings.ConnectionString, out string connectionString, true); currentSettings.ConnectionString = connectionString; } MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen) { driver = pool.GetConnection(); } ProcedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) { driver = Driver.Create(currentSettings); } ProcedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception) { SetState(ConnectionState.Closed, true); throw; } SetState(ConnectionState.Open, false); driver.Configure(this); if (driver.IsPasswordExpired && Settings.Pooling) { MySqlPoolManager.ClearPool(currentSettings); } if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (!string.IsNullOrEmpty(Settings.Database)) { ChangeDatabase(Settings.Database); } } // setup our schema provider _schemaProvider = new ISSchemaProvider(this); PerfMonitor = new PerformanceMonitor(this); // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option if (Transaction.Current != null && Settings.AutoEnlist) { EnlistTransaction(Transaction.Current); } hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) throw new InvalidOperationException("Resources.ConnectionAlreadyOpen"); SetState(ConnectionState.Connecting, true); //AssertPermissions(); try { MySqlConnectionStringBuilder currentSettings = Settings; if (Settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(currentSettings); if (driver == null || !driver.IsOpen){ driver = pool.GetConnection(); } procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) driver = Driver.Create(currentSettings); procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); } } catch (Exception ex) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know //if (driver.Settings.UseOldSyntax) //MySqlTrace.LogWarning(ServerThread, // "You are using old syntax that will be removed in future versions"); SetState(ConnectionState.Open, false); driver.Configure(this); if (!(driver.SupportsPasswordExpiration && driver.IsPasswordExpired)) { if (Settings.Database != null && Settings.Database != String.Empty) ChangeDatabase(Settings.Database); } // setup our schema provider schemaProvider = new ISSchemaProvider(this); // // if we are opening up inside a current transaction, then autoenlist // // TODO: control this with a connection string option //#if !MONO && !CF && !RT // if (Transaction.Current != null && Settings.AutoEnlist) // EnlistTransaction(Transaction.Current); //#endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
/// <include file='docs/MySqlConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); #if !CF // start up our interceptors exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); #endif SetState(ConnectionState.Connecting, true); #if !CF // Security Asserts can only be done when the assemblies // are put in the GAC as documented in // http://msdn.microsoft.com/en-us/library/ff648665.aspx if (this.Settings.IncludeSecurityAsserts) { PermissionDemand(); MySqlSecurityPermission.CreatePermissionSet(true).Assert(); } // if we are auto enlisting in a current transaction, then we will be // treating the connection as pooled if (settings.AutoEnlist && Transaction.Current != null) { driver = DriverTransactionManager.GetDriverInTransaction(Transaction.Current); if (driver != null && (driver.IsInActiveUse || !driver.Settings.EquivalentTo(this.Settings))) Throw(new NotSupportedException(Resources.MultipleConnectionsInTransactionNotSupported)); } #endif try { if (settings.Pooling) { MySqlPool pool = MySqlPoolManager.GetPool(settings); if (driver == null || !driver.IsOpen) driver = pool.GetConnection(); procedureCache = pool.ProcedureCache; } else { if (driver == null || !driver.IsOpen) driver = Driver.Create(settings); procedureCache = new ProcedureCache((int)settings.ProcedureCacheSize); } } catch (Exception ex) { SetState(ConnectionState.Closed, true); throw; } // if the user is using old syntax, let them know if (driver.Settings.UseOldSyntax) MySqlTrace.LogWarning(ServerThread, "You are using old syntax that will be removed in future versions"); SetState(ConnectionState.Open, false); driver.Configure(this); if (settings.Database != null && settings.Database != String.Empty) ChangeDatabase(settings.Database); // setup our schema provider schemaProvider = new ISSchemaProvider(this); #if !CF perfMonitor = new PerformanceMonitor(this); #endif // if we are opening up inside a current transaction, then autoenlist // TODO: control this with a connection string option #if !MONO && !CF if (Transaction.Current != null && settings.AutoEnlist) EnlistTransaction(Transaction.Current); #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }