/// <summary>
/// Test with NO conversation and "connection.release_mode"
/// "auto"(<see cref="ConnectionReleaseMode.AfterTransaction"/>).
/// </summary>
private void connection_release_mode_auto_no_conversation()
{
//with NO conversation and "connection.release_mode" "auto"(AfterTransaction)
//forcing "auto" by reflection.
Settings settings = ((SessionFactoryImpl)this.SessionFactory).Settings;
ConnectionReleaseMode connReleaseModeOriginal = settings.ConnectionReleaseMode;
this.setConnectionReleaseModeByReflection(settings, ConnectionReleaseMode.AfterTransaction);
//with no conversation
SessionScopeSettings sessionScopeSettings = new SessionScopeSettings(this.sessionFactory);
ConnectionCreationTrackingDbProvider.Count = 0;
using (new SessionScope(sessionScopeSettings, true))
{
ISession sessionNoConv = this.SessionFactory.GetCurrentSession();
SPCMasterEnt masterEnt2 = sessionNoConv.Get <SPCMasterEnt>(2);
Assert.AreEqual(1, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
Assert.AreEqual(1, masterEnt2.SPCDetailEntList.Count, "masterEnt2.SPCDetailEntList.Count");
Assert.AreEqual(2, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
SPCMasterEnt masterEnt3 = sessionNoConv.Get <SPCMasterEnt>(3);
Assert.AreEqual(3, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
Assert.AreEqual(1, masterEnt3.SPCDetailEntList.Count, "masterEnt3.SPCDetailEntList.Count");
Assert.AreEqual(4, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
}
this.setConnectionReleaseModeByReflection(settings, connReleaseModeOriginal);
}
private Settings BuildSettings(SessionElement sessionElement)
{
Settings settings = new Settings();
IConnectionProvider connectionProvider = ConnectionProviderFactory.NewConnectionProvider(sessionElement);
ITransactionFactory transactionFactory = CreateTransactionFactory(sessionElement);
string releaseModeName = sessionElement.ConnectionReleaseMode;
ConnectionReleaseMode releaseMode = "auto".Equals(releaseModeName) ? ConnectionReleaseMode.AfterTransaction : ParseConnectionReleaseMode(releaseModeName);
settings.SessionFactoryName = sessionElement.Name;
settings.ConnectionReleaseMode = releaseMode;
// settings.DefaultBatchFetchSize = sessionElement.DefaultBatchFetchSize;
settings.BatchSize = sessionElement.BatchSize;
settings.BatcherFactory = new BatcherFactory();// CreateBatcherFactory(sessionElement, settings.BatchSize, connectionProvider);
string isolationString = sessionElement.IsolationString;
IsolationLevel isolation = IsolationLevel.Unspecified;
if (isolationString.Length > 0)
{
try
{
isolation = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), isolationString);
}
catch
{
throw new Exception("The isolation level of " + isolationString + " is not a valid IsolationLevel. Please use one of the Member Names from the IsolationLevel.");
}
}
settings.IsolationLevel = isolation;
settings.ConnectionProvider = connectionProvider;
settings.TransactionFactory = transactionFactory;
return(settings);
}
public ConnectionManager(
ISessionImplementor session,
DbConnection suppliedConnection,
ConnectionReleaseMode connectionReleaseMode,
IInterceptor interceptor,
bool shouldAutoJoinTransaction) : this(session, suppliedConnection, connectionReleaseMode, interceptor, shouldAutoJoinTransaction, new NonContextualConnectionAccess(session.Factory))
{
}
ISession ISessionFactoryImplementor.OpenSession(
IDbConnection connection,
bool flushBeforeCompletionEnabled,
bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
throw new NotSupportedException();
}
private ConnectionManager(SerializationInfo info, StreamingContext context)
{
ownConnection = info.GetBoolean("ownConnection");
session = (ISessionImplementor) info.GetValue("session", typeof(ISessionImplementor));
connectionReleaseMode =
(ConnectionReleaseMode) info.GetValue("connectionReleaseMode", typeof(ConnectionReleaseMode));
interceptor = (IInterceptor)info.GetValue("interceptor", typeof(IInterceptor));
}
private ConnectionManager(SerializationInfo info, StreamingContext context)
{
_ownConnection = info.GetBoolean("ownConnection");
Session = (ISessionImplementor)info.GetValue("session", typeof(ISessionImplementor));
_connectionReleaseMode =
(ConnectionReleaseMode)info.GetValue("connectionReleaseMode", typeof(ConnectionReleaseMode));
_interceptor = (IInterceptor)info.GetValue("interceptor", typeof(IInterceptor));
}
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
return
(new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor,
settings.DefaultEntityMode, flushBeforeCompletionEnabled, autoCloseSessionEnabled,
connectionReleaseMode));
}
public ISession OpenSession(DbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
#pragma warning disable 618
var isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled = settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled;
#pragma warning restore 618
return
(new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor, flushBeforeCompletionEnabled, autoCloseSessionEnabled,
isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled, connectionReleaseMode, settings.DefaultFlushMode));
}
public ConnectionManager(ISessionImplementor session, string connectionString, ConnectionReleaseMode connectionReleaseMode, IInterceptor interceptor)
{
this.session = session;
ConnectionString = connectionString;
this.connectionReleaseMode = connectionReleaseMode;
this.interceptor = interceptor;
batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor);
ownConnection = true;
}
ISession ISessionFactoryImplementor.OpenSession(
DbConnection connection,
bool flushBeforeCompletionEnabled,
bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
var s = ActualFactory.OpenSession(connection, flushBeforeCompletionEnabled, autoCloseSessionEnabled, connectionReleaseMode);
_openedSessions.Add(s.GetSessionImplementation());
return(s);
}
ISession ISessionFactoryImplementor.OpenSession(
DbConnection connection,
bool flushBeforeCompletionEnabled,
bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
#pragma warning disable CS0618 // Type or member is obsolete
var s = ActualFactory.OpenSession(connection, flushBeforeCompletionEnabled, autoCloseSessionEnabled, connectionReleaseMode);
#pragma warning restore CS0618 // Type or member is obsolete
_openedSessions.Add(s.GetSessionImplementation());
return(s);
}
/// <summary>
/// Sets the <see cref="Settings.ConnectionReleaseMode"/> by reflection.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="mode">The mode.</param>
private void setConnectionReleaseModeByReflection(Settings settings, ConnectionReleaseMode mode)
{
PropertyInfo pInfoConnectionReleaseMode =
settings.GetType().GetProperty(
"ConnectionReleaseMode",
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.SetProperty |
BindingFlags.Instance);
pInfoConnectionReleaseMode.SetValue(settings, mode, null);
}
/// <summary>
/// Test with conversation and "connection.release_mode"
/// "auto"(<see cref="ConnectionReleaseMode.AfterTransaction"/>).
/// </summary>
/// <remarks>
/// Here we can see that every statement causes a closing of the IDbConnection.
/// </remarks>
private void connection_release_mode_auto()
{
//with conversation and "connection.release_mode" "auto"(AfterTransaction)
//forcing "auto" by reflection.
Settings settings = ((SessionFactoryImpl)this.SessionFactory).Settings;
ConnectionReleaseMode connReleaseModeOriginal = settings.ConnectionReleaseMode;
this.setConnectionReleaseModeByReflection(settings, ConnectionReleaseMode.AfterTransaction);
//((SessionFactoryImpl)this.sessionFactory).Settings.ConnectionReleaseMode = ConnectionReleaseMode.AfterTransaction;
ConnectionCreationTrackingDbProvider.Count = 0;
this.Conversation.StartResumeConversation();
ISession sessionA = this.SessionFactory.GetCurrentSession();
SPCDetailEnt detailEnt = sessionA.Get <SPCDetailEnt>(1);
Assert.AreEqual(1, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
SessionScopeSettings sessionScopeSettings = new SessionScopeSettings(this.sessionFactory);
sessionScopeSettings.SingleSession = true;
SPCMasterEnt masterEnt;
using (new SessionScope(sessionScopeSettings, false))
{
ISession sessionB = this.SessionFactory.GetCurrentSession();
masterEnt = sessionB.Get <SPCMasterEnt>(1);
Assert.AreEqual(2, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
Assert.AreSame(sessionA, sessionB, "sessionA, sessionB");
}
SPCMasterEnt masterEnt2 = sessionA.Get <SPCMasterEnt>(2);
Assert.AreEqual(3, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
Assert.AreEqual(1, masterEnt2.SPCDetailEntList.Count, "masterEnt2.SPCDetailEntList.Count");
Assert.AreEqual(4, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
SPCMasterEnt masterEnt3 = sessionA.Get <SPCMasterEnt>(3);
Assert.AreEqual(5, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
Assert.AreEqual(1, masterEnt3.SPCDetailEntList.Count, "masterEnt3.SPCDetailEntList.Count");
Assert.AreEqual(6, ConnectionCreationTrackingDbProvider.Count, "ConnectionCreationTrackingDbProvider.Count");
//Renew the conversation.
this.Conversation.EndConversation();
this.Conversation.ConversationManager.FreeEnded();
this.Conversation = (IConversationState)this.applicationContext.GetObject("convConnectionReleaseModeIssue");
this.setConnectionReleaseModeByReflection(settings, connReleaseModeOriginal);
}
/// <summary>
/// Manejador de conexiones contra la BBDD
/// </summary>
/// <param name="p_ses">Session que contiene este Connection Manager</param>
/// <param name="p_connectionReleaseMode">Pues eso...</param>
internal CnnManager(ISessionTX p_ses, ConnectionReleaseMode p_connectionReleaseMode)
{
IDbConnection suppliedConnection = null;
TraceLog.LogEntry("CnnManager(p_ses= {0} p_connectionReleaseMode= {1})", p_ses.SessionId, p_connectionReleaseMode);
this.m_session = p_ses;
this.m_connection = suppliedConnection;
this.connectionReleaseMode = p_connectionReleaseMode;
ownConnection = (suppliedConnection == null); // De esta forma, siempre será True.
//SharpLogger.CallerOut();
}
/// <summary>
/// Test with NO conversation and "connection.release_mode"
/// "auto"(<see cref="ConnectionReleaseMode.AfterTransaction"/>)
/// on block within the scope of "transaction boundary".
/// </summary>
/// <remarks>
/// Here we can see that only a IDbConnection is open, even
/// with the execution of various statements. This is because
/// the statements are made within a "transaction boundary".
/// </remarks>
private void connection_release_mode_auto_transaction_boundary()
{
//with conversation and "connection.release_mode" "auto"(AfterTransaction)
//forcing "auto" by reflection.
Settings settings = ((SessionFactoryImpl)this.SessionFactory).Settings;
ConnectionReleaseMode connReleaseModeOriginal = settings.ConnectionReleaseMode;
this.setConnectionReleaseModeByReflection(settings, ConnectionReleaseMode.AfterTransaction);
ConnectionCreationTrackingDbProvider.Count = 0;
this.ConnectionReleaseModeIssueBsn.Test();
this.setConnectionReleaseModeByReflection(settings, connReleaseModeOriginal);
}
public static string ToString(ConnectionReleaseMode value)
{
switch (value)
{
case ConnectionReleaseMode.AfterStatement:
return "after_statement";
case ConnectionReleaseMode.AfterTransaction:
return "after_transaction" ;
case ConnectionReleaseMode.OnClose:
return "on_close";
default:
throw new ArgumentOutOfRangeException("value");
}
}
/// <summary>
/// Constructor used for OpenSession(...) processing, as well as construction
/// of sessions for GetCurrentSession().
/// </summary>
/// <param name="connection">The user-supplied connection to use for this session.</param>
/// <param name="factory">The factory from which this session was obtained</param>
/// <param name="timestamp">The timestamp for this session</param>
/// <param name="autoCloseSessionEnabled">Should we auto close after completion of transaction</param>
/// <param name="connectionReleaseMode">The mode by which we should release JDBC connections.</param>
internal SessionImpl(IDbConnection connection, ISessionFactoryImplementor factory, long timestamp, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode)
: base(factory)
{
using (new SessionIdLoggingContext(SessionId))
{
//if (interceptor == null) throw new AssertionFailure("The interceptor can not be null.");
rootSession = null;
this.timestamp = timestamp;
this.autoCloseSessionEnabled = autoCloseSessionEnabled;
this.connectionReleaseMode = connectionReleaseMode;
connectionManager = new ConnectionManager(this, connection, connectionReleaseMode);// new ConnectionManager(this, connection, connectionReleaseMode, interceptor);
CheckAndUpdateSessionStatus();
}
}
public ConnectionManager(
ISessionImplementor session,
IDbConnection suppliedConnection,
ConnectionReleaseMode connectionReleaseMode,
IInterceptor interceptor)
{
this.session = session;
connection = suppliedConnection;
this.connectionReleaseMode = connectionReleaseMode;
this.interceptor = interceptor;
batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor);
ownConnection = suppliedConnection == null;
}
public ConnectionManager(
ISessionImplementor session,
DbConnection suppliedConnection,
ConnectionReleaseMode connectionReleaseMode,
IInterceptor interceptor)
{
this.session = session;
connection = suppliedConnection;
this.connectionReleaseMode = connectionReleaseMode;
this.interceptor = interceptor;
batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor);
ownConnection = suppliedConnection == null;
}
public ConnectionManager(
ISessionImplementor session,
DbConnection suppliedConnection,
ConnectionReleaseMode connectionReleaseMode,
IInterceptor interceptor,
bool shouldAutoJoinTransaction)
{
Session = session;
_connection = suppliedConnection;
_connectionReleaseMode = connectionReleaseMode;
_interceptor = interceptor;
_batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor);
_ownConnection = suppliedConnection == null;
ShouldAutoJoinTransaction = shouldAutoJoinTransaction;
}
public static string ToString(ConnectionReleaseMode value)
{
switch (value)
{
case ConnectionReleaseMode.AfterStatement:
return("after_statement");
case ConnectionReleaseMode.AfterTransaction:
return("after_transaction");
case ConnectionReleaseMode.OnClose:
return("on_close");
default:
throw new ArgumentOutOfRangeException("value");
}
}
public ConnectionManager(
ISessionImplementor session,
DbConnection suppliedConnection,
ConnectionReleaseMode connectionReleaseMode,
IInterceptor interceptor,
bool shouldAutoJoinTransaction,
IConnectionAccess connectionAccess)
{
Session = session;
_connection = suppliedConnection;
_connectionReleaseMode = connectionReleaseMode;
_interceptor = interceptor;
_batcher = session.Factory.Settings.BatcherFactory.CreateBatcher(this, interceptor);
_ownConnection = suppliedConnection == null;
ShouldAutoJoinTransaction = shouldAutoJoinTransaction;
_connectionAccess = connectionAccess ?? throw new ArgumentNullException(nameof(connectionAccess));
}
public ISession OpenSession(IDbConnection connection, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode)
{
return new SessionImpl(connection, this, 0, autoCloseSessionEnabled, connectionReleaseMode);
}
/// <summary>
/// Not supported
/// </summary>
public ISession OpenSession(IDbConnection connection, ConnectionReleaseMode connectionReleaseMode)
{
throw new NotSupportedException();
}
ISession ISessionFactoryImplementor.OpenSession(
IDbConnection connection,
bool flushBeforeCompletionEnabled,
bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
throw new NotSupportedException();
}
/// <summary>
/// Sets the <see cref="Settings.ConnectionReleaseMode"/> by reflection.
/// </summary>
/// <param name="settings">The settings.</param>
/// <param name="mode">The mode.</param>
private void setConnectionReleaseModeByReflection(Settings settings, ConnectionReleaseMode mode)
{
PropertyInfo pInfoConnectionReleaseMode =
settings.GetType().GetProperty(
"ConnectionReleaseMode",
BindingFlags.Public |
BindingFlags.NonPublic |
BindingFlags.SetProperty |
BindingFlags.Instance);
pInfoConnectionReleaseMode.SetValue(settings, mode, null);
}
/// <summary>
/// Builds a session from the factory, when initialized...
/// </summary>
/// <returns></returns>
public ISession OpenSession(bool p_autoCloseSessionEnabled,ConnectionReleaseMode p_connectionReleaseMode)
{
TraceLog.LogEntry("OpenSession(): p_autoCloseSessionEnabled {0} p_connectionReleaseMode {1}", p_autoCloseSessionEnabled, p_connectionReleaseMode);
ISessionTX res = null;
if (this.m_cnnStr == String.Empty)
throw new Exception("Session Factory without connection string, can't get it from configuration!");
else
if (this.m_closed)
throw new Exception("Session Factory is closed!");
else
{
if (SharpCore.Data.CurrentSessionContext.HasBind(this))
{
res = this.GetCurrentSession();
TraceLog.LogEntry("Existe una Sesión ya ligada, GetCurrentSession() Id {0}", res.SessionId);
}
else
SharpCore.Data.CurrentSessionContext.Bind(res = new SessionExt(this, p_autoCloseSessionEnabled, p_connectionReleaseMode));
}
// SharpLogger.CallerOut();
return res;
}
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
#pragma warning disable 618
var isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled = settings.IsInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled;
#pragma warning restore 618
return
new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor,
settings.DefaultEntityMode, flushBeforeCompletionEnabled, autoCloseSessionEnabled,
isInterceptorsBeforeTransactionCompletionIgnoreExceptionsEnabled, connectionReleaseMode, settings.DefaultFlushMode);
}
public IConnectionConfiguration Releasing(ConnectionReleaseMode releaseMode)
{
dbc.Configuration.SetProperty(Environment.ReleaseConnections, ConnectionReleaseModeParser.ToString(releaseMode));
return(this);
}
/// <inheritdoc />
ISharedSessionBuilder ISessionBuilder <ISharedSessionBuilder> .ConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode)
{
return(ConnectionReleaseMode(connectionReleaseMode));
}
public ISession OpenSession(IDbConnection connection, bool autoCloseSessionEnabled, ConnectionReleaseMode connectionReleaseMode)
{
return(new SessionImpl(connection, this, 0, autoCloseSessionEnabled, connectionReleaseMode));
}
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
throw new NotImplementedException();
}
/// <summary>
/// Not supported
/// </summary>
public ISession OpenSession(IDbConnection connection, ConnectionReleaseMode connectionReleaseMode)
{
throw new NotSupportedException();
}
public ISession OpenSession(IDbConnection connection, bool flushBeforeCompletionEnabled, bool autoCloseSessionEnabled,
ConnectionReleaseMode connectionReleaseMode)
{
return
new SessionImpl(connection, this, true, settings.CacheProvider.NextTimestamp(), interceptor,
settings.DefaultEntityMode, flushBeforeCompletionEnabled, autoCloseSessionEnabled,
connectionReleaseMode);
}
private ISession OpenSession(IDbConnection connection, long timestamp, IInterceptor interceptor,
ConnectionReleaseMode connectionReleaseMode)
{
SessionImpl sessionImpl = new SessionImpl(connection, this, timestamp, interceptor, connectionReleaseMode);
bool isSessionScopedInterceptor = this.interceptor!=interceptor;
if(isSessionScopedInterceptor)
interceptor.SetSession(sessionImpl);
return sessionImpl;
}
public TShardedBuilder ConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode)
{
ApplyActionToShards(b => b.ConnectionReleaseMode(connectionReleaseMode));
return((TShardedBuilder)this);
}
public ISession OpenSession(IDbConnection connection, ConnectionReleaseMode connectionReleaseMode)
{
return OpenSession(connection, Timestamper.Next(), interceptor, connectionReleaseMode);
}
ISessionBuilder ISessionBuilder <ISessionBuilder> .ConnectionReleaseMode(ConnectionReleaseMode connectionReleaseMode)
{
_actualBuilder.ConnectionReleaseMode(connectionReleaseMode);
return(this);
}
IConnectionConfiguration IConnectionConfiguration.Releasing(ConnectionReleaseMode releaseMode)
{
return(Releasing(releaseMode));
}
