440 lines
16 KiB
C#
440 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using MySql.Data.MySqlClient;
|
|
|
|
namespace MontoyaTech.MySqlPlus
|
|
{
|
|
/// <summary>
|
|
/// The outline of a managed MySqlConnection that adds extra functionality like automatic
|
|
/// query retrying and reconnecting if the remote DB goes away or becomes busy.
|
|
/// </summary>
|
|
public class MySqlManagedConnection : IDisposable
|
|
{
|
|
/// <summary>
|
|
/// The Internal MySqlConnection for this managed copy.
|
|
/// </summary>
|
|
public MySqlConnection MySqlConnection = null;
|
|
|
|
/// <summary>
|
|
/// The connection string that is used to repoen the connection.
|
|
/// </summary>
|
|
private string ConnectionString = null;
|
|
|
|
/// <summary>
|
|
/// Wether or not we are connected to the remote server.
|
|
/// </summary>
|
|
public bool IsConnected
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
if (this.MySqlConnection == null || this.MySqlConnection.State != System.Data.ConnectionState.Open || !this.MySqlConnection.Ping())
|
|
return false;
|
|
}
|
|
catch
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new managed MySqlConnection and sets its internal
|
|
/// MySql connection.
|
|
/// </summary>
|
|
/// <param name="conn"></param>
|
|
public MySqlManagedConnection(MySqlConnection conn)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(conn.ConnectionString))
|
|
throw new Exception("Connection string must be set on MySqlConnection.");
|
|
|
|
this.MySqlConnection = conn;
|
|
this.ConnectionString = conn.ConnectionString;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Creates a new managed MySqlConnection and setups up the internal connection string and gets everything ready.
|
|
/// </summary>
|
|
/// <param name="conn"></param>
|
|
public MySqlManagedConnection(string conn)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(conn))
|
|
throw new Exception("Invalid connection string passed, it must not be null or empty.");
|
|
|
|
this.MySqlConnection = new MySqlConnection(conn);
|
|
this.ConnectionString = conn;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Attempts to reconnect to the server and retrys if needed, returns whether or not a connection
|
|
/// was successfully reastablished.
|
|
/// </summary>
|
|
public bool Reconnect(int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true)
|
|
{
|
|
int backoffSleep = 2000;
|
|
for (int i = 0; i < maxRetrys; i++)
|
|
{
|
|
try
|
|
{
|
|
if (this.MySqlConnection == null)
|
|
{
|
|
this.MySqlConnection = new MySqlConnection(this.ConnectionString);
|
|
}
|
|
else
|
|
{
|
|
try { this.MySqlConnection.Close(); } catch { }
|
|
|
|
try { this.MySqlConnection.Dispose(); } catch { }
|
|
|
|
this.MySqlConnection = new MySqlConnection(this.ConnectionString);
|
|
}
|
|
|
|
this.MySqlConnection.Open();
|
|
|
|
//If we are now connected then stop trying.
|
|
if (this.IsConnected)
|
|
return true;
|
|
else
|
|
throw new Exception("Failed to open a valid MySqlConnection.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//See if we have reached our max retry.
|
|
if (i + 1 >= maxRetrys || !retry)
|
|
throw;
|
|
|
|
//If not backoff for a bit and see if the server comes back online.
|
|
if (exponentialBackoff)
|
|
{
|
|
Thread.Sleep(backoffSleep);
|
|
backoffSleep *= 2;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Attempts to connect to the remote MySql server.
|
|
/// </summary>
|
|
public void Connect()
|
|
{
|
|
//Just invoke reconnect it handles everything for us.
|
|
this.Reconnect();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Disconnects from the remote MySql server.
|
|
/// </summary>
|
|
public void Disconnect()
|
|
{
|
|
if (this.MySqlConnection != null)
|
|
{
|
|
try { this.MySqlConnection.Close(); } catch { }
|
|
|
|
try { this.MySqlConnection.Dispose(); } catch { }
|
|
|
|
this.MySqlConnection = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Executes a data reader for a command and retrys
|
|
/// </summary>
|
|
/// <param name="command"></param>
|
|
/// <param name="maxRetrys"></param>
|
|
/// <param name="exponentialBackoff"></param>
|
|
/// <param name="retry"></param>
|
|
/// <returns></returns>
|
|
public MySqlDataReader ExecuteReader(MySqlCommand command, int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(command.CommandText))
|
|
throw new ArgumentException("Given command must have CommandText set.");
|
|
|
|
int backoffSleep = 2000;
|
|
command.CommandTimeout = 60; //Time in seconds
|
|
|
|
for (int i = 0; i < maxRetrys; i++)
|
|
{
|
|
ulong startTimestamp = GlobalTimeStamp.Current;
|
|
|
|
try
|
|
{
|
|
command.Connection = this.MySqlConnection;
|
|
return command.ExecuteReader();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//Get the inner most exception.
|
|
var innerException = ex;
|
|
while (innerException.InnerException != null)
|
|
innerException = innerException.InnerException;
|
|
|
|
//Try to get the MySql error code
|
|
int code = -1;
|
|
if (ex is MySqlException)
|
|
code = ((MySqlException)ex).Number;
|
|
|
|
//See if we have reached our max retry.
|
|
if (i + 1 >= maxRetrys || !retry)
|
|
throw;
|
|
|
|
//See if the connection was invalid
|
|
if (innerException.GetType().IsAssignableFrom(typeof(System.Net.Sockets.SocketException)) ||
|
|
innerException.GetType().IsAssignableFrom(typeof(MySqlConnection)) ||
|
|
ex.GetType().IsAssignableFrom(typeof(MySqlConnection)) ||
|
|
ex.Message.ToLower().Contains("connection must be valid and open") ||
|
|
ex.Message.ToLower().Contains("a connection attempt failed because the connected party did not properly respond after a period of time") ||
|
|
ex.Message.ToLower().Contains("an existing connection was forcibly closed by the remote host"))
|
|
{
|
|
//Attempt to reconnect, but if this fails, it means we can't try any more since the reconnect retrys more than once.
|
|
if (!this.Reconnect(maxRetrys, exponentialBackoff))
|
|
throw;
|
|
}
|
|
//See if we should retry or just throw.
|
|
else if (!ShouldRetryBasedOnMySqlErrorNum(code))
|
|
{
|
|
throw;
|
|
}
|
|
else
|
|
{
|
|
//If the operation took less than 5 seconds, then sleep. Otherwise continue right away. This is to prevent OpenRetry from making us wait even longer.
|
|
if (GlobalTimeStamp.GetDifference(startTimestamp) <= 5000 && exponentialBackoff)
|
|
{
|
|
Thread.Sleep(backoffSleep);
|
|
backoffSleep *= 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
throw new Exception($"MySql ExecuteReader failed. Max timeout reached. Query: {command.CommandText}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Executes a non query command.
|
|
/// </summary>
|
|
/// <param name="command"></param>
|
|
/// <param name="maxRetrys"></param>
|
|
/// <param name="exponentialBackoff"></param>
|
|
/// <param name="retry"></param>
|
|
/// <returns>The number of rows affected.</returns>
|
|
/// <exception cref="Exception"></exception>
|
|
public int ExecuteNonQuery(MySqlCommand command, int maxRetrys = 5, bool exponentialBackoff = true, bool retry = true)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(command.CommandText))
|
|
throw new ArgumentException("Given command must have CommandText set.");
|
|
|
|
int backoffSleep = 2000;
|
|
command.CommandTimeout = 60; // time in seconds
|
|
|
|
for (int i = 0; i < maxRetrys; i++)
|
|
{
|
|
ulong startTimestamp = GlobalTimeStamp.Current;
|
|
|
|
try
|
|
{
|
|
command.Connection = this.MySqlConnection;
|
|
|
|
return command.ExecuteNonQuery();
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
//Get the inner most exception.
|
|
var innerException = ex;
|
|
while (innerException.InnerException != null)
|
|
innerException = innerException.InnerException;
|
|
|
|
//Try to get the MySql error code if we can
|
|
int code = -1;
|
|
if (ex is MySqlException)
|
|
code = ((MySqlException)ex).Number;
|
|
|
|
//See if we have reached our max retry.
|
|
if (i + 1 >= maxRetrys || !retry)
|
|
throw;
|
|
|
|
//See if the connection was invalid
|
|
if (innerException.GetType().IsAssignableFrom(typeof(System.Net.Sockets.SocketException)) ||
|
|
innerException.GetType().IsAssignableFrom(typeof(MySqlConnection)) ||
|
|
ex.GetType().IsAssignableFrom(typeof(MySqlConnection)) ||
|
|
ex.Message.ToLower().Contains("connection must be valid and open") ||
|
|
ex.Message.ToLower().Contains("a connection attempt failed because the connected party did not properly respond after a period of time") ||
|
|
ex.Message.ToLower().Contains("an existing connection was forcibly closed by the remote host"))
|
|
{
|
|
//Attempt to reconnect, but if this fails, it means we can't try any more since the reconnect retrys more than once.
|
|
if (!this.Reconnect(maxRetrys, exponentialBackoff))
|
|
throw;
|
|
}
|
|
//See if we should retry or just throw.
|
|
else if (!ShouldRetryBasedOnMySqlErrorNum(code))
|
|
{
|
|
throw;
|
|
}
|
|
else
|
|
{
|
|
//If the operation took less than 5 seconds, then sleep. Otherwise continue right away.
|
|
if (GlobalTimeStamp.GetDifference(startTimestamp) <= 5000 && exponentialBackoff)
|
|
{
|
|
Thread.Sleep(backoffSleep);
|
|
backoffSleep *= 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
throw new Exception($"MySql ExecuteNonQuery failed. Max timeout reached. Query: {command.CommandText}");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns whether or not we should retry a query based on the MySql error number.
|
|
/// </summary>
|
|
/// <param name="number"></param>
|
|
/// <returns></returns>
|
|
private static bool ShouldRetryBasedOnMySqlErrorNum(int number)
|
|
{
|
|
//List of codes here: https://www.briandunning.com/error-codes/?source=MySQL
|
|
switch (number)
|
|
{
|
|
case 1021:
|
|
case 1023:
|
|
case 1027:
|
|
case 1030:
|
|
case 1037:
|
|
case 1038:
|
|
case 1040:
|
|
case 1041:
|
|
case 1043:
|
|
case 1076:
|
|
case 1078:
|
|
case 1079:
|
|
case 1080:
|
|
case 1081:
|
|
case 1094:
|
|
case 1099:
|
|
case 1105:
|
|
case 1119:
|
|
case 1129:
|
|
case 1130:
|
|
case 1135:
|
|
case 1150:
|
|
case 1151:
|
|
case 1152:
|
|
case 1154:
|
|
case 1155:
|
|
case 1157:
|
|
case 1158:
|
|
case 1160:
|
|
case 1161:
|
|
case 1180:
|
|
case 1181:
|
|
case 1182:
|
|
case 1183:
|
|
case 1184:
|
|
case 1186:
|
|
case 1189:
|
|
case 1190:
|
|
case 1192:
|
|
case 1194:
|
|
case 1195:
|
|
case 1196:
|
|
case 1199:
|
|
case 1200:
|
|
case 1202:
|
|
case 1203:
|
|
case 1205:
|
|
case 1206:
|
|
case 1207:
|
|
case 1208:
|
|
case 1213:
|
|
case 1218:
|
|
case 1219:
|
|
case 1220:
|
|
case 1236:
|
|
case 1244:
|
|
case 1257:
|
|
case 1258:
|
|
case 1259:
|
|
case 1297:
|
|
case 1316:
|
|
case 1341:
|
|
case 2000:
|
|
case 2001:
|
|
case 2002:
|
|
case 2003:
|
|
case 2004:
|
|
case 2005:
|
|
case 2006:
|
|
case 2007:
|
|
case 2008:
|
|
case 2009:
|
|
case 2010:
|
|
case 2011:
|
|
case 2012:
|
|
case 2013:
|
|
case 2014:
|
|
case 2024:
|
|
case 2025:
|
|
case 2026:
|
|
case 2027:
|
|
case 2037:
|
|
case 2038:
|
|
case 2039:
|
|
case 2040:
|
|
case 2041:
|
|
case 2042:
|
|
case 2043:
|
|
case 2044:
|
|
case 2045:
|
|
case 2046:
|
|
case 2048:
|
|
case 2050:
|
|
case 2051:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Allows the exposal of the internal MySqlConnection from the managed version.
|
|
/// </summary>
|
|
/// <param name="connection"></param>
|
|
public static implicit operator MySqlConnection(MySqlManagedConnection connection)
|
|
{
|
|
return connection.MySqlConnection;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Disposes this managed connection and releases all resources.
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
if (this.MySqlConnection != null)
|
|
{
|
|
try { this.MySqlConnection.Close(); } catch { }
|
|
|
|
try { this.MySqlConnection.Dispose(); } catch { }
|
|
|
|
this.MySqlConnection = null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cleans up this MySqlManagedConnection when GC is collecting.
|
|
/// </summary>
|
|
~MySqlManagedConnection()
|
|
{
|
|
Dispose();
|
|
}
|
|
}
|
|
}
|