Ejemplo n.º 1
0
 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);
 }
Ejemplo n.º 2
0
        /// <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);
        }
Ejemplo n.º 3
0
        /// <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);
        }
Ejemplo n.º 4
0
        /// <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);
        }
Ejemplo n.º 5
0
    /// <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);
    }
Ejemplo n.º 6
0
        /// <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);
        }
Ejemplo n.º 7
0
        /// <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);
        }