private static string GetKey(MyCatConnectionStringBuilder settings) { string key = ""; lock (settings) { key = settings.ConnectionString; } #if !NETSTANDARD1_3 if (settings.IntegratedSecurity && !settings.ConnectionReset) { try { // Append SID to the connection string to generate a key // With Integrated security different Windows users with the same // connection string may be mapped to different MySQL accounts. System.Security.Principal.WindowsIdentity id = System.Security.Principal.WindowsIdentity.GetCurrent(); key += ";" + id.User; } catch (System.Security.SecurityException ex) { // Documentation for WindowsIdentity.GetCurrent() states // SecurityException can be thrown. In this case the // connection can only be pooled if reset is done. throw new MyCatException(Resources.NoWindowsIdentity, ex); } } #endif return(key); }
public static MyNetworkStream CreateStream(MyCatConnectionStringBuilder settings, bool unix) { MyNetworkStream stream = null; IPAddress[] ipHE = GetHostEntry(settings.Server); foreach (IPAddress address in ipHE) { try { stream = CreateSocketStream(settings, address, unix); if (stream != null) { break; } } catch (Exception ex) { SocketException socketException = ex as SocketException; // if the exception is a ConnectionRefused then we eat it as we may have other address // to attempt if (socketException == null) { throw; } if (socketException.SocketErrorCode != SocketError.ConnectionRefused) { throw; } } } return(stream); }
private static MyNetworkStream CreateSocketStream(MyCatConnectionStringBuilder settings, IPAddress ip, bool unix) { EndPoint endPoint; endPoint = new IPEndPoint(ip, (int)settings.Port); Socket socket = unix ? new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.IP) : new Socket(ip.AddressFamily, SocketType.Stream, ProtocolType.Tcp); if (settings.Keepalive > 0) { SetKeepAlive(socket, settings.Keepalive); } try { socket.Connect(endPoint); } catch (Exception ex) { #if !NETSTANDARD1_3 socket.Close(); #else socket.Dispose(); #endif throw ex; } MyNetworkStream stream = new MyNetworkStream(socket, true); GC.SuppressFinalize(socket); GC.SuppressFinalize(stream); return(stream); }
internal void Serialize(MyCatPacket packet, bool binary, MyCatConnectionStringBuilder settings) { if (!binary && (paramValue == null || paramValue == DBNull.Value)) { packet.WriteStringNoNull("NULL"); } else { if (ValueObject.MyCatDbType == MyCatDbType.Guid) { MyCatGuid g = (MyCatGuid)ValueObject; g.OldGuids = settings.OldGuids; ValueObject = g; } if (ValueObject.MyCatDbType == MyCatDbType.Geometry) { MyCatGeometry v = (MyCatGeometry)ValueObject; if (v.IsNull && Value != null) { MyCatGeometry.TryParse(Value.ToString(), out v); } ValueObject = v; } ValueObject.WriteValue(packet, binary, paramValue, Size); } }
private static Stream GetSharedMemoryStream(MyCatConnectionStringBuilder settings) { SharedMemoryStream str = new SharedMemoryStream(settings.SharedMemoryName); str.Open(settings.ConnectionTimeout); return(str); }
/// <summary> /// Assigns a new server driver to the connection object /// </summary> /// <param name="groupName">Group name</param> /// <param name="master">True if the server connection to assign must be a master</param> /// <param name="connection">MyCatConnection object where the new driver will be assigned</param> internal static void GetNewConnection(string groupName, bool master, MyCatConnection connection) { do { lock (thisLock) { if (!IsReplicationGroup(groupName)) { return; } ReplicationServerGroup group = GetGroup(groupName); ReplicationServer server = group.GetServer(master, connection.Settings); if (server == null) { throw new MyCatException(Properties.Resources.Replication_NoAvailableServer); } try { bool isNewServer = false; if (connection.driver == null || !connection.driver.IsOpen) { isNewServer = true; } else { MyCatConnectionStringBuilder msb = new MyCatConnectionStringBuilder(server.ConnectionString); if (!msb.Equals(connection.driver.Settings)) { isNewServer = true; } } if (isNewServer) { Driver driver = Driver.Create(new MyCatConnectionStringBuilder(server.ConnectionString)); connection.driver = driver; } return; } catch (MyCatException ex) { connection.driver = null; server.IsAvailable = false; MyCatTrace.LogError(ex.Number, ex.ToString()); if (ex.Number == 1042) { // retry to open a failed connection and update its status group.HandleFailover(server, ex); } else { throw; } } } } while (true); }
public void ParseConnectionString() { var csb = new MyCatConnectionStringBuilder { ConnectionString = "Data Source=db-server;" + "Initial Catalog=schema_name;" + "Allow User Variables=true;" + "certificate file=file.pfx;" + "certificate password=Pass1234;" + "Character Set=latin1;" + "Compress=true;" + "connect timeout=30;" + "ConnectionReset=false;" + "Convert Zero Datetime=true;" + #if !BASELINE "forcesynchronous=true;" + #endif "Keep Alive=90;" + "minpoolsize=5;" + "maxpoolsize=15;" + "OldGuids=true;" + "persistsecurityinfo=yes;" + "Pooling=no;" + "Port=1234;" + "pwd=Pass1234;" + "Treat Tiny As Boolean=false;" + "ssl mode=verifyca;" + "Uid=username;" + "useaffectedrows=false" }; Assert.Equal(true, csb.AllowUserVariables); Assert.Equal("file.pfx", csb.CertificateFile); Assert.Equal("Pass1234", csb.CertificatePassword); Assert.Equal("latin1", csb.CharacterSet); Assert.Equal(false, csb.ConnectionReset); Assert.Equal(30u, csb.ConnectionTimeout); Assert.Equal(true, csb.ConvertZeroDateTime); Assert.Equal("schema_name", csb.Database); #if !BASELINE Assert.Equal(true, csb.ForceSynchronous); #endif Assert.Equal(90u, csb.Keepalive); Assert.Equal(15u, csb.MaximumPoolSize); Assert.Equal(5u, csb.MinimumPoolSize); Assert.Equal("Pass1234", csb.Password); Assert.Equal(true, csb.OldGuids); Assert.Equal(true, csb.PersistSecurityInfo); Assert.Equal(false, csb.Pooling); Assert.Equal(1234u, csb.Port); Assert.Equal("db-server", csb.Server); Assert.Equal(false, csb.TreatTinyAsBoolean); Assert.Equal(MyCatSslMode.VerifyCA, csb.SslMode); Assert.Equal(false, csb.UseAffectedRows); Assert.Equal(true, csb.UseCompression); Assert.Equal("username", csb.UserID); }
private static Stream GetUnixSocketStream(MyCatConnectionStringBuilder settings) { if (Platform.IsWindows()) { throw new InvalidOperationException(Resources.NoUnixSocketsOnWindows); } MyNetworkStream s = MyNetworkStream.CreateStream(settings, true); return(s); }
public static Stream GetStream(string server, uint port, string pipename, uint keepalive, DBVersion v, uint timeout) { MyCatConnectionStringBuilder settings = new MyCatConnectionStringBuilder(); settings.Server = server; settings.Port = port; settings.PipeName = pipename; settings.Keepalive = keepalive; settings.ConnectionTimeout = timeout; return(GetStream(settings)); }
public Driver(MyCatConnectionStringBuilder settings) { encoding = Encoding.UTF8; if (encoding == null) { throw new MyCatException(Resources.DefaultEncodingNotFound); } connectionString = settings; serverCharSet = "utf8"; serverCharSetIndex = -1; maxPacketSize = 1024; handler = new NativeDriver(this); }
public MyCatRelationalConnection CreateMasterConnection() { var csb = new MyCatConnectionStringBuilder(ConnectionString) { Database = "mysql", Pooling = false }; var optionsBuilder = new DbContextOptionsBuilder(); optionsBuilder.UseMyCat(csb.GetConnectionString(true)); return(new MyCatRelationalConnection(optionsBuilder.Options, Logger)); }
public ConnectionSettings(MyCatConnectionStringBuilder csb) { ConnectionString = csb.ConnectionString; // Base Options if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && (csb.Server.StartsWith("/", StringComparison.Ordinal) || csb.Server.StartsWith("./", StringComparison.Ordinal))) { if (!File.Exists(csb.Server)) { throw new MyCatException("Cannot find Unix Socket at " + csb.Server); } ConnectionType = ConnectionType.Unix; UnixSocket = Path.GetFullPath(csb.Server); } else { ConnectionType = ConnectionType.Tcp; Hostnames = csb.Server.Split(','); Port = (int)csb.Port; } UserID = csb.UserID; Password = csb.Password; Database = csb.Database; // SSL/TLS Options SslMode = csb.SslMode; CertificateFile = csb.CertificateFile; CertificatePassword = csb.CertificatePassword; // Connection Pooling Options Pooling = csb.Pooling; ConnectionReset = csb.ConnectionReset; if (csb.MinimumPoolSize > csb.MaximumPoolSize) { throw new MyCatException("MaximumPoolSize must be greater than or equal to MinimumPoolSize"); } MinimumPoolSize = (int)csb.MinimumPoolSize; MaximumPoolSize = (int)csb.MaximumPoolSize; // Other Options AllowUserVariables = csb.AllowUserVariables; ConnectionTimeout = (int)csb.ConnectionTimeout; ConvertZeroDateTime = csb.ConvertZeroDateTime; ForceSynchronous = csb.ForceSynchronous; Keepalive = csb.Keepalive; OldGuids = csb.OldGuids; PersistSecurityInfo = csb.PersistSecurityInfo; TreatTinyAsBoolean = csb.TreatTinyAsBoolean; UseAffectedRows = csb.UseAffectedRows; UseCompression = csb.UseCompression; }
public MyCatRelationalConnection CreateMasterConnection(MyCatDatabaseHost node) { var csb = new MyCatConnectionStringBuilder(ConnectionString) { Database = "mysql", UserID = node.Username, Server = node.Host, Port = node.Port, Password = node.Password, Pooling = false }; var optionsBuilder = new DbContextOptionsBuilder(); optionsBuilder.UseMyCat(csb.GetConnectionString(true)); return(new MyCatRelationalConnection(optionsBuilder.Options, Logger)); }
public static void ClearPool(MyCatConnectionStringBuilder settings) { Debug.Assert(settings != null); string text; try { text = GetKey(settings); } catch (MyCatException) { // Cannot retrieve windows identity for IntegratedSecurity=true // This can be ignored. return; } ClearPoolByText(text); }
public static Driver Create(MyCatConnectionStringBuilder settings) { Driver d = null; #if !NETSTANDARD1_3 try { if (MyCatTrace.QueryAnalysisEnabled || settings.Logging || settings.UseUsageAdvisor) { d = new TracingDriver(settings); } } catch (TypeInitializationException ex) { if (!(ex.InnerException is SecurityException)) { throw ex; } //Only rethrow if InnerException is not a SecurityException. If it is a SecurityException then //we couldn't initialize MyCatTrace because we don't have unmanaged code permissions. } #else if (settings.Logging || settings.UseUsageAdvisor) { throw new NotImplementedException("Logging not supported in this WinRT release."); } #endif if (d == null) { d = new Driver(settings); } //this try was added as suggested fix submitted on MyCat Bug 72025, socket connections are left in CLOSE_WAIT status when connector fails to open a new connection. //the bug is present when the client try to get more connections that the server support or has configured in the max_connections variable. try { d.Open(); } catch (Exception ex) { d.Dispose(); throw ex; } return(d); }
public void CancelQuery(int timeout) { MyCatConnectionStringBuilder cb = new MyCatConnectionStringBuilder( Settings.ConnectionString); cb.Pooling = false; cb.AutoEnlist = false; cb.ConnectionTimeout = (uint)timeout; using (MyCatConnection c = new MyCatConnection(cb.ConnectionString)) { c.isKillQueryConnection = true; c.Open(); string commandText = "KILL QUERY " + ServerThread; MyCatCommand cmd = new MyCatCommand(commandText, c); cmd.CommandTimeout = timeout; cmd.ExecuteNonQuery(); } }
public void Defaults() { var csb = new MyCatConnectionStringBuilder(); Assert.Equal(false, csb.AllowUserVariables); Assert.Equal(null, csb.CertificateFile); Assert.Equal(null, csb.CertificatePassword); Assert.Equal("", csb.CharacterSet); #if BASELINE Assert.Equal(false, csb.ConnectionReset); #else Assert.Equal(true, csb.ConnectionReset); #endif Assert.Equal(15u, csb.ConnectionTimeout); Assert.Equal(false, csb.ConvertZeroDateTime); Assert.Equal("", csb.Database); #if !BASELINE Assert.Equal(false, csb.ForceSynchronous); #endif Assert.Equal(0u, csb.Keepalive); Assert.Equal(100u, csb.MaximumPoolSize); Assert.Equal(0u, csb.MinimumPoolSize); Assert.Equal("", csb.Password); Assert.Equal(false, csb.OldGuids); Assert.Equal(false, csb.PersistSecurityInfo); Assert.Equal(true, csb.Pooling); Assert.Equal(3306u, csb.Port); Assert.Equal("", csb.Server); #if BASELINE Assert.Equal(MyCatSslMode.Prefered, csb.SslMode); #else Assert.Equal(MyCatSslMode.None, csb.SslMode); #endif Assert.Equal(true, csb.TreatTinyAsBoolean); Assert.Equal(false, csb.UseCompression); Assert.Equal("", csb.UserID); #if BASELINE Assert.False(csb.UseAffectedRows); #else Assert.True(csb.UseAffectedRows); #endif }
public virtual void CommitSchema(MyCatRelationalConnection _connection) { var csb = new MyCatConnectionStringBuilder(_connection.ConnectionString); using (var client = new HttpClient() { BaseAddress = new Uri("http://" + csb.Server + ":7066") }) { var task = client.PostAsync("/", new FormUrlEncodedContent(new[] { new KeyValuePair <string, string>("Username", csb.UserID), new KeyValuePair <string, string>("Password", csb.Password), new KeyValuePair <string, string>("Database", csb.Database), new KeyValuePair <string, string>("DataNodes", Newtonsoft.Json.JsonConvert.SerializeObject(DbContextOptions.FindExtension <MyCatOptionsExtension>().DataNodes)), new KeyValuePair <string, string>("Schema", Newtonsoft.Json.JsonConvert.SerializeObject(Schema)), })); task.Wait(); } }
public static MyCatPool GetPool(MyCatConnectionStringBuilder settings) { string text = GetKey(settings); lock (pools) { MyCatPool pool; pools.TryGetValue(text, out pool); if (pool == null) { pool = new MyCatPool(settings); pools.Add(text, pool); } else { pool.Settings = settings; } return(pool); } }
public static DbContextOptionsBuilder UseMyCat( [NotNull] this DbContextOptionsBuilder optionsBuilder, [NotNull] DbConnection connection, [CanBeNull] Action <MyCatDbContextOptionsBuilder> MyCatOptionsAction = null) { Check.NotNull(optionsBuilder, nameof(optionsBuilder)); Check.NotNull(connection, nameof(connection)); var csb = new MyCatConnectionStringBuilder(connection.ConnectionString) { AllowUserVariables = true }; connection.ConnectionString = csb.ConnectionString; var extension = GetOrCreateExtension(optionsBuilder); extension.Connection = connection; ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension); MyCatOptionsAction?.Invoke(new MyCatDbContextOptionsBuilder(optionsBuilder)); return(optionsBuilder); }
public static Stream GetStream(MyCatConnectionStringBuilder settings) { switch (settings.ConnectionProtocol) { case MyCatConnectionProtocol.Tcp: return(GetTcpStream(settings)); #if RT case MyCatConnectionProtocol.UnixSocket: throw new NotImplementedException(); case MyCatConnectionProtocol.SharedMemory: throw new NotImplementedException(); #else #if !NETSTANDARD1_3 case MyCatConnectionProtocol.UnixSocket: return(GetUnixSocketStream(settings)); case MyCatConnectionProtocol.SharedMemory: return(GetSharedMemoryStream(settings)); #endif #endif #if !NETSTANDARD1_3 case MyCatConnectionProtocol.NamedPipe: return(GetNamedPipeStream(settings)); #endif } throw new InvalidOperationException(Resources.UnknownConnectionProtocol); }
public MyCatPool(MyCatConnectionStringBuilder 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); }
public TracingDriver(MyCatConnectionStringBuilder settings) : base(settings) { driverId = Interlocked.Increment(ref driverCounter); }
public void SslModePreferredInvalidOperation() { var csb = new MyCatConnectionStringBuilder("ssl mode=preferred;"); Assert.Throws <InvalidOperationException>(() => csb.SslMode); }
internal protected virtual ReplicationServer GetServer(bool isMaster, MyCatConnectionStringBuilder settings) { return(GetServer(isMaster)); }
/// <include file='docs/MyCatConnection.xml' path='docs/DefaultCtor/*'/> public MyCatConnection() { //TODO: add event data to StateChange docs Settings = new MyCatConnectionStringBuilder(); database = String.Empty; }
private static Stream GetNamedPipeStream(MyCatConnectionStringBuilder settings) { Stream stream = NamedPipeStream.Create(settings.PipeName, settings.Server, settings.ConnectionTimeout); return(stream); }
/// <include file='docs/MyCatConnection.xml' path='docs/Open/*'/> public override void Open() { if (State == ConnectionState.Open) { Throw(new InvalidOperationException(Resources.ConnectionAlreadyOpen)); } #if !NETSTANDARD1_3 // start up our interceptors exceptionInterceptor = new ExceptionInterceptor(this); commandInterceptor = new CommandInterceptor(this); #endif SetState(ConnectionState.Connecting, true); AssertPermissions(); #if !NETSTANDARD1_3 // 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 { MyCatConnectionStringBuilder currentSettings = Settings; #if SUPPORT_REPLICATION // Load balancing if (ReplicationManager.IsReplicationGroup(Settings.Server)) { if (driver == null) { ReplicationManager.GetNewConnection(Settings.Server, false, this); } else { currentSettings = driver.Settings; } } #endif #if !NETSTANDARD1_3 if (Settings.Pooling) { MyCatPool pool = MyCatPoolManager.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); } #else if (driver == null || !driver.IsOpen) { driver = Driver.Create(currentSettings); } procedureCache = new ProcedureCache((int)Settings.ProcedureCacheSize); #endif } catch (Exception ex) { SetState(ConnectionState.Closed, true); throw ex; } 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 !NETSTANDARD1_3 if (Transaction.Current != null && Settings.AutoEnlist) { EnlistTransaction(Transaction.Current); } #endif hasBeenOpen = true; SetState(ConnectionState.Open, true); }
private static Stream GetTcpStream(MyCatConnectionStringBuilder settings) { MyNetworkStream s = MyNetworkStream.CreateStream(settings, false); return(s); }