/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <returns>True if the lock was obtained.</returns>
public virtual bool ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lock (this)
{
lockName = String.Intern(lockName);
if (!IsLockOwner(conn, lockName))
{
while (locks.Contains(lockName))
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
}
}
ThreadLocks.Add(lockName);
locks.Add(lockName);
}
return(true);
}
}
public async Task TestSelectSimpleTriggerWithDeleteBeforeSelectExtendedProps()
{
var dbProvider = A.Fake <IDbProvider>();
var connection = A.Fake <DbConnection>();
var transaction = A.Fake <DbTransaction>();
var command = (DbCommand)A.Fake <StubCommand>();
var dbMetadata = new DbMetadata();
A.CallTo(() => dbProvider.Metadata).Returns(dbMetadata);
A.CallTo(() => dbProvider.CreateCommand()).Returns(command);
var dataReader = A.Fake <DbDataReader>();
A.CallTo(command).Where(x => x.Method.Name == "ExecuteDbDataReaderAsync")
.WithReturnType <Task <DbDataReader> >()
.Returns(Task.FromResult(dataReader));
A.CallTo(command).Where(x => x.Method.Name == "get_DbParameterCollection")
.WithReturnType <DbParameterCollection>()
.Returns(new StubParameterCollection());
A.CallTo(() => command.CommandText).Returns("");
A.CallTo(command).Where(x => x.Method.Name == "CreateDbParameter")
.WithReturnType <DbParameter>()
.Returns(new SqlParameter());
var persistenceDelegate = A.Fake <ITriggerPersistenceDelegate>();
var exception = new InvalidOperationException();
A.CallTo(() => persistenceDelegate.LoadExtendedTriggerProperties(A <ConnectionAndTransactionHolder> .Ignored, A <TriggerKey> .Ignored, CancellationToken.None)).Throws(exception);
StdAdoDelegate adoDelegate = new TestStdAdoDelegate(persistenceDelegate);
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
// First result set has results, second has none
A.CallTo(() => dataReader.ReadAsync(CancellationToken.None)).Returns(true).Once();
A.CallTo(() => dataReader[AdoConstants.ColumnTriggerType]).Returns(AdoConstants.TriggerTypeSimple);
A.CallTo(() => dataReader[A <string> ._]).Returns("1");
var conn = new ConnectionAndTransactionHolder(connection, transaction);
IOperableTrigger trigger = await adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.That(trigger, Is.Null);
A.CallTo(() => persistenceDelegate.LoadExtendedTriggerProperties(A <ConnectionAndTransactionHolder> .Ignored, A <TriggerKey> .Ignored, CancellationToken.None)).MustHaveHappened();
}
void Udpate()
{
// Initial setting
List<DbMetadata> list = Query<DbMetadata>($"SELECT * FROM {DbMetadata.TableName} LIMIT 1");
DbMetadata meta;
if (list.Count == 0)
{
meta = new DbMetadata();
meta.Version = CurrentVersion;
InsertOrReplace(meta);
}
else
{
meta = list[0];
}
//Update from the version 1 to the version 2
if (meta.Version == 1)
{
meta.Version = 2;
InsertOrReplace(meta);
}
}
/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <param name="metadata"></param>
/// <param name="conn"></param>
/// <param name="lockName"></param>
/// <returns>true if the lock was obtained.</returns>
public bool ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lockName = string.Intern(lockName);
if (Log.IsDebugEnabled)
{
Log.DebugFormat("Lock '{0}' is desired by: {1}", lockName, Thread.CurrentThread.Name);
}
if (!IsLockOwner(conn, lockName))
{
ExecuteSQL(conn, lockName, expandedSQL, expandedInsertSQL);
if (Log.IsDebugEnabled)
{
Log.DebugFormat("Lock '{0}' given to: {1}", lockName, Thread.CurrentThread.Name);
}
ThreadLocks.Add(lockName);
//getThreadLocksObtainer().put(lockName, new
// Exception("Obtainer..."));
}
else if (log.IsDebugEnabled)
{
Log.DebugFormat("Lock '{0}' Is already owned by: {1}", lockName, Thread.CurrentThread.Name);
}
return(true);
}
/// <summary>
/// Gets or Sets the MySql Metadata object, provided to validate the MySql Columns issued from MySql
/// </summary>
/// <summary>
/// Gets or sets the Metadata object which parse Sql server types
/// </summary>
public override DbMetadata GetMetadata()
{
if (dbMetadata == null)
{
dbMetadata = new MySqlDbMetadata();
}
return(dbMetadata);
}
public void TestSelectSimpleTriggerWithExceptionWithExtendedProps()
{
var dbProvider = MockRepository.GenerateMock <IDbProvider>();
var connection = MockRepository.GenerateMock <IDbConnection>();
var transaction = MockRepository.GenerateMock <IDbTransaction>();
var command = (IDbCommand)MockRepository.GenerateMock <StubCommand>();
var dbMetadata = new DbMetadata();
dbProvider.Stub(x => x.Metadata).Repeat.Any().Return(dbMetadata);
dbProvider.Stub(x => x.CreateCommand()).Return(command);
var dataReader = MockRepository.GenerateMock <IDataReader>();
command.Stub(x => x.ExecuteReader()).Return(dataReader);
command.Stub(x => x.Parameters).Repeat.Any().Return(new StubParameterCollection());
command.Stub(x => x.CommandText).Return("").Repeat.Any();
command.Stub(x => x.CreateParameter()).Repeat.Any().Return(new StubDataParameter());
var persistenceDelegate = MockRepository.GenerateMock <ITriggerPersistenceDelegate>();
var exception = new InvalidOperationException();
persistenceDelegate.Stub(x => x.LoadExtendedTriggerProperties(Arg <ConnectionAndTransactionHolder> .Is.Anything, Arg <TriggerKey> .Is.Anything)).Throw(exception);
StdAdoDelegate adoDelegate = new TestStdAdoDelegate(persistenceDelegate);
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
Logger = LogManager.GetLogger(GetType()),
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
// Mock basic trigger data
dataReader.Stub(x => x.Read()).Return(true).Repeat.Any();
dataReader.Stub(x => x[AdoConstants.ColumnTriggerType]).Return(AdoConstants.TriggerTypeSimple);
try
{
var conn = new ConnectionAndTransactionHolder(connection, transaction);
adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.Fail("Trigger selection should result in exception");
}
catch (InvalidOperationException e)
{
Assert.That(e, Is.SameAs(exception));
}
persistenceDelegate.AssertWasCalled(x => x.LoadExtendedTriggerProperties(Arg <ConnectionAndTransactionHolder> .Is.Anything, Arg <TriggerKey> .Is.Anything));
}
public async Task TestSelectBlobTriggerWithNoBlobContent()
{
var dbProvider = A.Fake <IDbProvider>();
var connection = A.Fake <DbConnection>();
var transaction = A.Fake <DbTransaction>();
var command = (DbCommand)A.Fake <StubCommand>();
var dbMetadata = new DbMetadata();
A.CallTo(() => dbProvider.Metadata).Returns(dbMetadata);
A.CallTo(() => dbProvider.CreateCommand()).Returns(command);
var dataReader = A.Fake <DbDataReader>();
A.CallTo(command).Where(x => x.Method.Name == "ExecuteDbDataReaderAsync")
.WithReturnType <Task <DbDataReader> >()
.Returns(dataReader);
A.CallTo(command).Where(x => x.Method.Name == "get_DbParameterCollection")
.WithReturnType <DbParameterCollection>()
.Returns(new StubParameterCollection());
A.CallTo(() => command.CommandText).Returns("");
A.CallTo(command).Where(x => x.Method.Name == "CreateDbParameter")
.WithReturnType <DbParameter>()
.Returns(new SqlParameter());
var adoDelegate = new StdAdoDelegate();
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
Logger = LogProvider.GetLogger(GetType()),
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
var conn = new ConnectionAndTransactionHolder(connection, transaction);
// First result set has results, second has none
A.CallTo(() => dataReader.ReadAsync(CancellationToken.None)).Returns(true).Once();
A.CallTo(() => dataReader.ReadAsync(CancellationToken.None)).Returns(false);
A.CallTo(() => dataReader[AdoConstants.ColumnTriggerType]).Returns(AdoConstants.TriggerTypeBlob);
IOperableTrigger trigger = await adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.That(trigger, Is.Null);
}
private string[] GetStoreProcedures()
{
List <string> relations;
using (var conn = new DbConnection(ConnectionString))
{
conn.Open();
relations = DbMetadata.GetListOfStoreProcedures(conn);
conn.Close();
}
return(relations.ToArray());
}
private static void TestDbMetadata(string dbname)
{
DbProvider dbp = new DbProvider(dbname, "foo");
DbMetadata md = dbp.Metadata;
Assert.IsNotNull(md.AssemblyName);
Assert.IsNotNull(md.BindByName);
Assert.IsNotNull(md.CommandType);
Assert.IsNotNull(md.ConnectionType);
Assert.IsNotNull(md.ParameterType);
Assert.IsNotNull(md.DbBinaryType);
Assert.IsNotNull(md.ParameterDbTypeProperty);
}
/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <param name="metadata"></param>
/// <param name="conn"></param>
/// <param name="lockName"></param>
/// <returns>true if the lock was obtained.</returns>
public bool ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lockName = string.Intern(lockName);
if (!IsLockOwner(conn, lockName))
{
ExecuteSQL(conn, lockName, expandedSQL, expandedInsertSQL);
ThreadLocks.Add(lockName);
//getThreadLocksObtainer().put(lockName, new
// Exception("Obtainer..."));
}
return(true);
}
/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <returns>True if the lock was obtained.</returns>
public virtual bool ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lock (this)
{
lockName = String.Intern(lockName);
if (log.IsDebugEnabled)
{
log.Debug("Lock '" + lockName + "' is desired by: " + Thread.CurrentThread.Name);
}
if (!IsLockOwner(conn, lockName))
{
if (log.IsDebugEnabled)
{
log.Debug("Lock '" + lockName + "' is being obtained: " + Thread.CurrentThread.Name);
}
while (locks.Contains(lockName))
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
if (log.IsDebugEnabled)
{
log.Debug("Lock '" + lockName + "' was not obtained by: " + Thread.CurrentThread.Name);
}
}
}
if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' given to: {1}", lockName, Thread.CurrentThread.Name));
}
ThreadLocks.Add(lockName);
locks.Add(lockName);
}
else if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' already owned by: {1} -- but not owner!", lockName, Thread.CurrentThread.Name), new Exception("stack-trace of wrongful returner"));
}
return(true);
}
}
private static DbProvider TestDbMetadata(string dbname, bool hashCustomBinaryType = true)
{
DbProvider dbp = new DbProvider(dbname, "foo");
DbMetadata md = dbp.Metadata;
Assert.IsNotNull(md.AssemblyName);
Assert.IsNotNull(md.BindByName);
Assert.IsNotNull(md.CommandType);
Assert.IsNotNull(md.ConnectionType);
Assert.IsNotNull(md.ParameterType);
if (hashCustomBinaryType)
{
Assert.IsNotNull(md.DbBinaryType);
Assert.IsNotNull(md.ParameterDbTypeProperty);
}
return(dbp);
}
/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <returns>True if the lock was obtained.</returns>
public virtual Task <bool> ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lock (this)
{
if (log.IsDebugEnabled())
{
log.Debug($"Lock '{lockName}' is desired by: {Thread.CurrentThread.Name}");
}
if (!IsLockOwner(lockName))
{
if (log.IsDebugEnabled())
{
log.Debug($"Lock '{lockName}' is being obtained: {Thread.CurrentThread.Name}");
}
while (locks.Contains(lockName))
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
if (log.IsDebugEnabled())
{
log.Debug($"Lock '{lockName}' was not obtained by: {Thread.CurrentThread.Name}");
}
}
}
if (log.IsDebugEnabled())
{
log.Debug($"Lock '{lockName}' given to: {Thread.CurrentThread.Name}");
}
GetThreadLocks().Add(lockName);
locks.Add(lockName);
}
else if (log.IsDebugEnabled())
{
log.DebugException($"Lock '{lockName}' already owned by: {Thread.CurrentThread.Name} -- but not owner!", new Exception("stack-trace of wrongful returner"));
}
return(Task.FromResult(true));
}
}
public void TestSelectBlobTriggerWithNoBlobContent()
{
var dbProvider = MockRepository.GenerateMock <IDbProvider>();
var connection = MockRepository.GenerateMock <IDbConnection>();
var transaction = MockRepository.GenerateMock <IDbTransaction>();
var command = (IDbCommand)MockRepository.GenerateMock <StubCommand>();
var dbMetadata = new DbMetadata();
dbProvider.Stub(x => x.Metadata).Repeat.Any().Return(dbMetadata);
dbProvider.Stub(x => x.CreateCommand()).Return(command);
var dataReader = MockRepository.GenerateMock <IDataReader>();
command.Stub(x => x.ExecuteReader()).Return(dataReader);
command.Stub(x => x.Parameters).Repeat.Any().Return(new StubParameterCollection());
command.Stub(x => x.CommandText).Return("").Repeat.Any();
command.Stub(x => x.CreateParameter()).Repeat.Any().Return(new StubDataParameter());
var adoDelegate = new StdAdoDelegate();
var delegateInitializationArgs = new DelegateInitializationArgs
{
TablePrefix = "QRTZ_",
InstanceId = "TESTSCHED",
InstanceName = "INSTANCE",
TypeLoadHelper = new SimpleTypeLoadHelper(),
UseProperties = false,
InitString = "",
Logger = LogManager.GetLogger(GetType()),
DbProvider = dbProvider
};
adoDelegate.Initialize(delegateInitializationArgs);
var conn = new ConnectionAndTransactionHolder(connection, transaction);
// First result set has results, second has none
dataReader.Stub(x => x.Read()).Return(true).Repeat.Once();
dataReader.Stub(x => x.Read()).Return(false);
dataReader.Stub(x => x[AdoConstants.ColumnTriggerType]).Return(AdoConstants.TriggerTypeBlob);
IOperableTrigger trigger = adoDelegate.SelectTrigger(conn, new TriggerKey("test"));
Assert.That(trigger, Is.Null);
}
/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <returns>True if the lock was obtained.</returns>
public virtual bool ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lock (this)
{
lockName = String.Intern(lockName);
if (log.IsDebugEnabled)
log.Debug("Lock '" + lockName + "' is desired by: " + Thread.CurrentThread.Name);
if (!IsLockOwner(conn, lockName))
{
if (log.IsDebugEnabled)
{
log.Debug("Lock '" + lockName + "' is being obtained: " + Thread.CurrentThread.Name);
}
while (locks.Contains(lockName))
{
try
{
Monitor.Wait(this);
}
catch (ThreadInterruptedException)
{
if (log.IsDebugEnabled)
{
log.Debug("Lock '" + lockName + "' was not obtained by: " + Thread.CurrentThread.Name);
}
}
}
if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' given to: {1}", lockName, Thread.CurrentThread.Name));
}
ThreadLocks.Add(lockName);
locks.Add(lockName);
}
else if (log.IsDebugEnabled)
{
log.Debug(string.Format(CultureInfo.InvariantCulture, "Lock '{0}' already owned by: {1} -- but not owner!", lockName, Thread.CurrentThread.Name), new Exception("stack-trace of wrongful returner"));
}
return true;
}
}
/// <summary>
/// Grants a lock on the identified resource to the calling thread (blocking
/// until it is available).
/// </summary>
/// <param name="metadata"></param>
/// <param name="conn"></param>
/// <param name="lockName"></param>
/// <returns>true if the lock was obtained.</returns>
public bool ObtainLock(DbMetadata metadata, ConnectionAndTransactionHolder conn, string lockName)
{
lockName = string.Intern(lockName);
if (Log.IsDebugEnabled)
{
Log.Debug(
"Lock '" + lockName + "' is desired by: "
+ Thread.CurrentThread.Name);
}
if (!IsLockOwner(conn, lockName)) {
ExecuteSQL(conn, lockName, expandedSQL);
if (Log.IsDebugEnabled)
{
Log.Debug(
"Lock '" + lockName + "' given to: "
+ Thread.CurrentThread.Name);
}
ThreadLocks.Add(lockName);
//getThreadLocksObtainer().put(lockName, new
// Exception("Obtainer..."));
} else if(log.IsDebugEnabled) {
Log.Debug(
"Lock '" + lockName + "' Is already owned by: "
+ Thread.CurrentThread.Name);
}
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="SpringDbProviderAdapter"/> class.
/// </summary>
/// <param name="dbProvider">The Spring db provider.</param>
public SpringDbProviderAdapter(Data.Common.IDbProvider dbProvider)
{
this.dbProvider = dbProvider;
metadata = new SpringMetadataAdapter(dbProvider.DbMetadata);
}
public IDb CreateDb(string directoryPath, string name)
{
return WriterLock(() =>
{
var dirInfo = new DirectoryInfo(Path.Combine(directoryPath, name));
if (!dirInfo.Exists)
{
dirInfo.Create();
}
var metaData = new DbMetadata
{
Name = name,
DbPath = dirInfo.FullName,
Id = Guid.NewGuid()
};
InitDbFromMetadata(name, metaData);
return GetDb(name);
});
}
private void InitDbFromMetadata(string name, DbMetadata metaData)
{
_dbNames[name] = metaData.DbMetadataPath;
Serialize();
var db = new Db(metaData);
_loadedDbs[name] = db;
db.SaveMetadata();
}
