/// <summary>
/// Puts the value from the mapped class into the <see cref="IDbCommand"/>.
/// </summary>
/// <param name="cmd">The <see cref="IDbCommand"/> to put the values into.</param>
/// <param name="value">The object that contains the values.</param>
/// <param name="index">The index of the <see cref="IDbDataParameter"/> to write the value to.</param>
/// <remarks>
/// <para>
/// This method checks to see if value is null, if it is then the value of
/// <see cref="DBNull"/> is written to the <see cref="IDbCommand"/>.
/// </para>
/// <para>
/// If the value is not null, then the method <see cref="Set(IDbCommand, object, int)"/>
/// is called and that method is responsible for setting the value.
/// </para>
/// </remarks>
public void NullSafeSet(IDbCommand cmd, object value, int index)
{
if (value == null)
{
if (IsDebugEnabled)
{
Log.Debug("binding null to parameter: " + index);
}
//Do we check IsNullable?
// TODO: find out why a certain Parameter would not take a null value...
// From reading the .NET SDK the default is to NOT accept a null value.
// I definitely need to look into this more...
((IDataParameter)cmd.Parameters[index]).Value = DBNull.Value;
}
else
{
if (IsDebugEnabled)
{
Log.Debug("binding '" + ToString(value) + "' to parameter: " + index);
}
Set(cmd, value, index);
}
}
static ByteBufferUtil()
{
Logger = InternalLoggerFactory.GetInstance(typeof(ByteBufferUtil));
string allocType = SystemPropertyUtil.Get("io.netty.allocator.type", "pooled");
allocType = allocType.Trim();
IByteBufferAllocator alloc;
if ("unpooled".Equals(allocType, StringComparison.OrdinalIgnoreCase))
{
alloc = UnpooledByteBufferAllocator.Default;
Logger.Debug("-Dio.netty.allocator.type: {}", allocType);
}
else if ("pooled".Equals(allocType, StringComparison.OrdinalIgnoreCase))
{
alloc = PooledByteBufferAllocator.Default;
Logger.Debug("-Dio.netty.allocator.type: {}", allocType);
}
else if ("arraypooled".Equals(allocType, StringComparison.OrdinalIgnoreCase))
{
alloc = ArrayPooledByteBufferAllocator.Default;
Logger.Debug("-Dio.netty.allocator.type: {}", allocType);
}
else
{
alloc = PooledByteBufferAllocator.Default;
Logger.Debug("-Dio.netty.allocator.type: pooled (unknown: {})", allocType);
}
DefaultAllocator = alloc;
MaxBytesPerCharUtf8 = Encoding.UTF8.GetMaxByteCount(1);
AsciiByteProcessor = new FindNonAscii();
}
public virtual void OnSaveOrUpdate(SaveOrUpdateEvent @event)
{
ISessionImplementor source = @event.Session;
object obj = @event.Entity;
object requestedId = @event.RequestedId;
if (requestedId != null)
{
//assign the requested id to the proxy, *before*
//reassociating the proxy
if (obj.IsProxy())
{
((INHibernateProxy)obj).HibernateLazyInitializer.Identifier = requestedId;
}
}
if (ReassociateIfUninitializedProxy(obj, source))
{
log.Debug("reassociated uninitialized proxy");
// an uninitialized proxy, noop, don't even need to
// return an id, since it is never a save()
}
else
{
//initialize properties of the event:
object entity = source.PersistenceContext.UnproxyAndReassociate(obj);
@event.Entity = entity;
@event.Entry = source.PersistenceContext.GetEntry(entity);
//return the id in the event object
@event.ResultId = PerformSaveOrUpdate(@event);
}
}
public void LoadMappings(IList <MappingConfiguration> configurationMappings)
{
if (configurationMappings == null)
{
throw new ArgumentNullException("configurationMappings");
}
foreach (MappingConfiguration mc in configurationMappings)
{
if (!string.IsNullOrEmpty(mc.Assembly) && string.IsNullOrEmpty(mc.Resource))
{
log.Debug("Assembly " + mc.Assembly);
AddAssembly(mc.Assembly);
}
else if (!string.IsNullOrEmpty(mc.Assembly) && !string.IsNullOrEmpty(mc.Resource))
{
log.Debug("Resource " + mc.Resource + " in " + mc.Assembly);
AddResource(Assembly.Load(mc.Assembly), mc.Resource);
}
else if (!string.IsNullOrEmpty(mc.File))
{
log.Debug("File " + mc.File);
AddFile(mc.File);
}
else
{
log.Warn(string.Format("Mapping configuration ignored: Assembly>{0}< Resource>{1}< File>{2}<", mc.Assembly,
mc.Resource, mc.File));
}
}
}
protected virtual void EntityIsPersistent(PersistEvent @event, IDictionary createCache)
{
log.Debug("ignoring persistent instance");
IEventSource source = @event.Session;
//TODO: check that entry.getIdentifier().equals(requestedId)
object entity = source.PersistenceContext.Unproxy(@event.Entity);
/* NH-2565: the UnProxy may return a "field interceptor proxy". When EntityName is null the session.GetEntityPersister will try to guess it.
* Instead change a session's method I'll try to guess the EntityName here.
* Because I'm using a session's method perhaps could be better if each session's method, which implementation forward to a method having the EntityName as parameter,
* use the BestGuessEntityName directly instead do "70 turns" before call it.
*/
if (@event.EntityName == null)
{
@event.EntityName = source.BestGuessEntityName(entity);
}
IEntityPersister persister = source.GetEntityPersister(@event.EntityName, entity);
object tempObject;
tempObject = createCache[entity];
createCache[entity] = entity;
if (tempObject == null)
{
//TODO: merge into one method!
CascadeBeforeSave(source, persister, entity, createCache);
CascadeAfterSave(source, persister, entity, createCache);
}
}
public ICache BuildCache(string regionName, IDictionary <string, string> properties)
{
ICache result;
if (caches.TryGetValue(regionName, out result))
{
return(result);
}
if (_clientManagerStatic == null)
{
if (ConnectionSettings == null)
{
ConnectionSettings = RedisCacheConnection.Default();
}
_clientManagerStatic = ConnectionMultiplexer.Connect(ConnectionSettings.Render());
}
if (Log.IsDebugEnabled)
{
var sb = new StringBuilder();
foreach (var pair in properties)
{
sb.Append(pair.Key);
sb.Append(" = '");
sb.Append(pair.Value);
sb.AppendLine("';");
}
Log.Debug(String.Format("building cache with region: {0}, properties: \n{1}", regionName, sb));
}
result = new RedisCache(regionName, properties, _clientManagerStatic, ConnectionSettings);
caches.Add(regionName, result);
return(result);
}
/// <summary> Log a IDbCommand. </summary>
/// <param name="message">Title</param>
/// <param name="command">The SQL statement. </param>
/// <param name="style">The requested formatting style. </param>
public virtual void LogCommand(string message, IDbCommand command, FormatStyle style)
{
if (!log.IsDebugEnabled && !LogToStdout || string.IsNullOrEmpty(command.CommandText))
{
return;
}
style = DetermineActualStyle(style);
string statement = style.Formatter.Format(GetCommandLineWithParameters(command));
string logMessage;
if (string.IsNullOrEmpty(message))
{
logMessage = statement;
}
else
{
logMessage = message + statement;
}
log.Debug(logMessage);
if (LogToStdout)
{
Console.Out.WriteLine("NHibernate: " + statement);
}
}
private static void CleanupAnyOrphanedSession(ISessionFactory factory)
{
ISession orphan = DoUnbind(factory, false);
if (orphan != null)
{
log.Warn("Already session bound on call to bind(); make sure you clean up your sessions!");
try
{
if (orphan.Transaction != null && orphan.Transaction.IsActive)
{
try
{
orphan.Transaction.Rollback();
}
catch (Exception ex)
{
log.Debug("Unable to rollback transaction for orphaned session", ex);
}
}
orphan.Close();
}
catch (Exception ex)
{
log.Debug("Unable to close orphaned session", ex);
}
}
}
static DefaultChannelId()
{
int processId = -1;
string customProcessId = SystemPropertyUtil.Get("io.netty.processId");
if (customProcessId is object)
{
if (!int.TryParse(customProcessId, out processId))
{
processId = -1;
}
if (processId < 0 || processId > MaxProcessId)
{
processId = -1;
Logger.Warn("-Dio.netty.processId: {} (malformed)", customProcessId);
}
else if (Logger.DebugEnabled)
{
Logger.Debug("-Dio.netty.processId: {} (user-set)", processId);
}
}
if (processId < 0)
{
processId = DefaultProcessId();
if (Logger.DebugEnabled)
{
Logger.Debug("-Dio.netty.processId: {} (auto-detected)", processId);
}
}
ProcessId = processId;
byte[] machineId = null;
string customMachineId = SystemPropertyUtil.Get("io.netty.machineId");
if (customMachineId is object)
{
if (MachineIdPattern.Match(customMachineId).Success)
{
machineId = ParseMachineId(customMachineId);
if (Logger.DebugEnabled)
{
Logger.Debug("-Dio.netty.machineId: {} (user-set)", customMachineId);
}
}
else
{
Logger.Warn("-Dio.netty.machineId: {} (malformed)", customMachineId);
}
}
if (machineId is null)
{
machineId = DefaultMachineId();
if (Logger.DebugEnabled)
{
Logger.Debug("-Dio.netty.machineId: {} (auto-detected)", MacAddressUtil.FormatAddress(machineId));
}
}
MachineId = machineId;
}
/// <summary>
/// Clear the Cache
/// </summary>
/// <exception cref="T:NHibernate.Cache.CacheException"></exception>
public void Clear()
{
//remove the root cache item, this will cause all of the individual items to be removed from the cache
_webCache.Remove(_rootCacheKey);
_isRootItemCached = false;
log.Debug("All items cleared from the cache.");
}
public void ReportError(RecognitionException e)
{
ReportError( e.ToString() );
_recognitionExceptions.Add( e );
if ( log.IsDebugEnabled ) {
log.Debug( e.ToString(), e );
}
}
public void Handshake(IChannel channel, IFullHttpRequest req, HttpHeaders responseHeaders, TaskCompletionSource completion)
{
if (Logger.DebugEnabled)
{
Logger.Debug("{} WebSocket version {} server handshake", channel, this.version);
}
IFullHttpResponse response = this.NewHandshakeResponse(req, responseHeaders);
IChannelPipeline p = channel.Pipeline;
if (p.Get <HttpObjectAggregator>() != null)
{
p.Remove <HttpObjectAggregator>();
}
if (p.Get <HttpContentCompressor>() != null)
{
p.Remove <HttpContentCompressor>();
}
IChannelHandlerContext ctx = p.Context <HttpRequestDecoder>();
string encoderName;
if (ctx == null)
{
// this means the user use a HttpServerCodec
ctx = p.Context <HttpServerCodec>();
if (ctx == null)
{
completion.TrySetException(new InvalidOperationException("No HttpDecoder and no HttpServerCodec in the pipeline"));
return;
}
p.AddBefore(ctx.Name, "wsdecoder", this.NewWebsocketDecoder());
p.AddBefore(ctx.Name, "wsencoder", this.NewWebSocketEncoder());
encoderName = ctx.Name;
}
else
{
p.Replace(ctx.Name, "wsdecoder", this.NewWebsocketDecoder());
encoderName = p.Context <HttpResponseEncoder>().Name;
p.AddBefore(encoderName, "wsencoder", this.NewWebSocketEncoder());
}
channel.WriteAndFlushAsync(response).ContinueWith(t =>
{
if (t.Status == TaskStatus.RanToCompletion)
{
p.Remove(encoderName);
completion.TryComplete();
}
else
{
completion.TrySetException(t.Exception);
}
});
}
private void AddPersister(string alias, IDictionary <string, string[]> propertyResult, ISqlLoadable persister)
{
alias2Persister[alias] = persister;
string suffix = GenerateEntitySuffix();
log.Debug("mapping alias [" + alias + "] to entity-suffix [" + suffix + "]");
alias2Suffix[alias] = suffix;
entityPropertyResultMaps[alias] = propertyResult;
}
public void AddJoinByPathMap(string path, FromElement destination)
{
if (Log.IsDebugEnabled)
{
Log.Debug("addJoinByPathMap() : " + path + " -> " + destination);
}
_fromElementsByPath.Add(path, destination);
}
public object Get(CacheKey key, long timestamp)
{
object result = cache.Get(key);
if (result != null && log.IsDebugEnabled)
{
log.Debug("Cache hit: " + key);
}
return(result);
}
protected DefaultCookie InitCookie(string header, int nameBegin, int nameEnd, int valueBegin, int valueEnd)
{
if (nameBegin == -1 || nameBegin == nameEnd)
{
Logger.Debug("Skipping cookie with null name");
return(null);
}
if (valueBegin == -1)
{
Logger.Debug("Skipping cookie with null value");
return(null);
}
var sequence = new StringCharSequence(header, valueBegin, valueEnd - valueBegin);
ICharSequence unwrappedValue = UnwrapValue(sequence);
if (unwrappedValue == null)
{
Logger.Debug("Skipping cookie because starting quotes are not properly balanced in '{}'", sequence);
return(null);
}
string name = header.Substring(nameBegin, nameEnd - nameBegin);
int invalidOctetPos;
if (this.Strict && (invalidOctetPos = FirstInvalidCookieNameOctet(name)) >= 0)
{
if (Logger.DebugEnabled)
{
Logger.Debug("Skipping cookie because name '{}' contains invalid char '{}'",
name, name[invalidOctetPos]);
}
return(null);
}
bool wrap = unwrappedValue.Count != valueEnd - valueBegin;
if (this.Strict && (invalidOctetPos = FirstInvalidCookieValueOctet(unwrappedValue)) >= 0)
{
if (Logger.DebugEnabled)
{
Logger.Debug("Skipping cookie because value '{}' contains invalid char '{}'",
unwrappedValue, unwrappedValue[invalidOctetPos]);
}
return(null);
}
var cookie = new DefaultCookie(name, unwrappedValue.ToString());
cookie.Wrap = wrap;
return(cookie);
}
static void Close(IntPtr handle)
{
if (handle == IntPtr.Zero)
{
return;
}
// Get gc handle before close loop
IntPtr pHandle = ((uv_loop_t *)handle)->data;
// Fully close the loop, similar to
//https://github.com/libuv/libuv/blob/v1.x/test/task.h#L190
int count = 0;
while (true)
{
Logger.Debug($"Loop {handle} walking handles, count = {count}.");
NativeMethods.uv_walk(handle, WalkCallback, handle);
Logger.Debug($"Loop {handle} running default to call close callbacks, count = {count}.");
NativeMethods.uv_run(handle, uv_run_mode.UV_RUN_DEFAULT);
int result = NativeMethods.uv_loop_close(handle);
Logger.Debug($"Loop {handle} close result = {result}, count = {count}.");
if (result == 0)
{
break;
}
count++;
if (count >= 20)
{
Logger.Warn($"Loop {handle} close all handles limit 20 times exceeded.");
break;
}
}
Logger.Info($"Loop {handle} closed, count = {count}.");
// Free GCHandle
if (pHandle != IntPtr.Zero)
{
GCHandle nativeHandle = GCHandle.FromIntPtr(pHandle);
if (nativeHandle.IsAllocated)
{
nativeHandle.Free();
((uv_loop_t *)handle)->data = IntPtr.Zero;
Logger.Info($"Loop {handle} GCHandle released.");
}
}
// Release memory
NativeMethods.FreeMemory(handle);
Logger.Info($"Loop {handle} memory released.");
}
public SqlString ToSqlString()
{
// will for sure have 3 parts and then each item in the WhereStrings
int initialCapacity = 3;
// add an "AND" for each whereString except the first one.
initialCapacity += (whereStrings.Count - 1);
for (int i = 0; i < whereStrings.Count; i++)
{
initialCapacity += whereStrings[i].Count;
}
if (!string.IsNullOrEmpty(comment))
{
initialCapacity++;
}
SqlStringBuilder sqlBuilder = new SqlStringBuilder(initialCapacity + 2);
if (!string.IsNullOrEmpty(comment))
{
sqlBuilder.Add("/* " + comment + " */ ");
}
sqlBuilder.Add("DELETE FROM ")
.Add(tableName)
.Add(" WHERE ");
if (whereStrings.Count > 1)
{
sqlBuilder.Add(whereStrings.ToArray(), null, "AND", null, false);
}
else
{
sqlBuilder.Add(whereStrings[0]);
}
if (log.IsDebugEnabled)
{
if (initialCapacity < sqlBuilder.Count)
{
log.Debug(
"The initial capacity was set too low at: " + initialCapacity + " for the DeleteSqlBuilder " +
"that needed a capacity of: " + sqlBuilder.Count + " for the table " + tableName);
}
else if (initialCapacity > 16 && ((float)initialCapacity / sqlBuilder.Count) > 1.2)
{
log.Debug(
"The initial capacity was set too high at: " + initialCapacity + " for the DeleteSqlBuilder " +
"that needed a capacity of: " + sqlBuilder.Count + " for the table " + tableName);
}
}
return(sqlBuilder.ToSqlString());
}
private static void ProcessDereferencedCollection(IPersistentCollection coll, ISessionImplementor session)
{
IPersistenceContext persistenceContext = session.PersistenceContext;
CollectionEntry entry = persistenceContext.GetCollectionEntry(coll);
ICollectionPersister loadedPersister = entry.LoadedPersister;
if (log.IsDebugEnabled && loadedPersister != null)
{
log.Debug("Collection dereferenced: " + MessageHelper.CollectionInfoString(loadedPersister, coll, entry.LoadedKey, session));
}
// do a check
bool hasOrphanDelete = loadedPersister != null && loadedPersister.HasOrphanDelete;
if (hasOrphanDelete)
{
object ownerId = loadedPersister.OwnerEntityPersister.GetIdentifier(coll.Owner);
// TODO NH Different behavior
//if (ownerId == null)
//{
// // the owning entity may have been deleted and its identifier unset due to
// // identifier-rollback; in which case, try to look up its identifier from
// // the persistence context
// if (session.Factory.Settings.IsIdentifierRollbackEnabled)
// {
// EntityEntry ownerEntry = persistenceContext.GetEntry(coll.Owner);
// if (ownerEntry != null)
// {
// ownerId = ownerEntry.Id;
// }
// }
// if (ownerId == null)
// {
// throw new AssertionFailure("Unable to determine collection owner identifier for orphan-delete processing");
// }
//}
EntityKey key = session.GenerateEntityKey(ownerId, loadedPersister.OwnerEntityPersister);
object owner = persistenceContext.GetEntity(key);
if (owner == null)
{
throw new AssertionFailure("collection owner not associated with session: " + loadedPersister.Role);
}
EntityEntry e = persistenceContext.GetEntry(owner);
//only collections belonging to deleted entities are allowed to be dereferenced in the case of orphan delete
if (e != null && e.Status != Status.Deleted && e.Status != Status.Gone)
{
throw new HibernateException("A collection with cascade=\"all-delete-orphan\" was no longer referenced by the owning entity instance: " + loadedPersister.Role);
}
}
// do the work
entry.CurrentPersister = null;
entry.CurrentKey = null;
PrepareCollectionForUpdate(coll, entry, session.Factory);
}
/// <summary>
/// Reads all of the contents into memory because another <see cref="IDataReader"/>
/// needs to be opened.
/// </summary>
/// <remarks>
/// This will result in a no op if the reader is closed or is already in memory.
/// </remarks>
public void ReadIntoMemory()
{
if (_reader.IsClosed == false && _reader.GetType() != typeof(NDataReader))
{
if (log.IsDebugEnabled)
{
log.Debug("Moving IDataReader into an NDataReader. It was converted in midstream " + _isMidstream.ToString());
}
_reader = new NDataReader(_reader, _isMidstream);
}
}
/// <summary>
/// Register the "hydrated" state of an entity instance, after the first step of 2-phase loading.
///
/// Add the "hydrated state" (an array) of an uninitialized entity to the session. We don't try
/// to resolve any associations yet, because there might be other entities waiting to be
/// read from the JDBC result set we are currently processing
/// </summary>
public static void PostHydrate(IEntityPersister persister, object id, object[] values, object rowId, object obj, LockMode lockMode, bool lazyPropertiesAreUnfetched, ISessionImplementor session)
{
object version = Versioning.GetVersion(values, persister);
session.PersistenceContext.AddEntry(obj, Status.Loading, values, rowId, id, version, lockMode, true, persister, false, lazyPropertiesAreUnfetched);
if (log.IsDebugEnabled && version != null)
{
System.String versionStr = persister.IsVersioned ? persister.VersionType.ToLoggableString(version, session.Factory) : "null";
log.Debug("Version: " + versionStr);
}
}
/// <summary>
/// Closes the <see cref="IDbConnection"/>.
/// </summary>
/// <param name="conn">The <see cref="IDbConnection"/> to clean up.</param>
public virtual void CloseConnection(IDbConnection conn)
{
log.Debug("Closing connection");
try
{
conn.Close();
}
catch (Exception e)
{
throw new ADOException("Could not close " + conn.GetType() + " connection", e);
}
}
/// <summary>
/// Increment the given version number
/// </summary>
/// <param name="version">The value of the current version.</param>
/// <param name="versionType">The <see cref="IVersionType"/> of the versioned property.</param>
/// <param name="session">The current <see cref="ISession" />.</param>
/// <returns>Returns the next value for the version.</returns>
public static object Increment(object version, IVersionType versionType, ISessionImplementor session)
{
object next = versionType.Next(version, session);
if (log.IsDebugEnabled)
{
log.Debug(
string.Format("Incrementing: {0} to {1}", versionType.ToLoggableString(version, session.Factory),
versionType.ToLoggableString(next, session.Factory)));
}
return(next);
}
private static string GetRegionPrefix(IDictionary <string, string> props)
{
if (props.TryGetValue("regionPrefix", out var result))
{
Log.DebugFormat("new regionPrefix: {0}", result);
}
else
{
result = DefaultRegionPrefix;
Log.Debug("no regionPrefix value given, using defaults");
}
return(result);
}
protected override IInstantiator BuildInstantiator(PersistentClass persistentClass)
{
if (optimizer == null)
{
log.Debug("Create Instantiator without optimizer for:" + persistentClass.MappedClass.FullName);
return(new PocoInstantiator(persistentClass, null, ProxyFactory, EntityMetamodel.HasLazyProperties || EntityMetamodel.HasUnwrapProxyForProperties));
}
else
{
log.Debug("Create Instantiator using optimizer for:" + persistentClass.MappedClass.FullName);
return(new PocoInstantiator(persistentClass, optimizer.InstantiationOptimizer, ProxyFactory, EntityMetamodel.HasLazyProperties || EntityMetamodel.HasUnwrapProxyForProperties));
}
}
internal IByteBuffer Allocate(PooledByteBufferAllocator allocator)
{
Debug.Assert(allocator is object);
#if DEBUG
if (Log.DebugEnabled)
{
Log.Debug("{} allocate, estimated size = {}", nameof(ReceiveBufferSizeEstimate), _receiveBufferSize);
}
#endif
return(allocator.Buffer(_receiveBufferSize));
}
/// <summary>
/// Enlist the <see cref="IDbCommand"/> in the current <see cref="ITransaction"/>.
/// </summary>
/// <param name="command">The <see cref="IDbCommand"/> to enlist in this Transaction.</param>
/// <remarks>
/// <para>
/// This takes care of making sure the <see cref="IDbCommand"/>'s Transaction property
/// contains the correct <see cref="IDbTransaction"/> or <see langword="null" /> if there is no
/// Transaction for the ISession - ie <c>BeginTransaction()</c> not called.
/// </para>
/// <para>
/// This method may be called even when the transaction is disposed.
/// </para>
/// </remarks>
public void Enlist(IDbCommand command)
{
if (trans == null)
{
if (log.IsWarnEnabled)
{
if (command.Transaction != null)
{
log.Warn("set a nonnull IDbCommand.Transaction to null because the Session had no Transaction");
}
}
command.Transaction = null;
return;
}
else
{
if (log.IsWarnEnabled)
{
// got into here because the command was being initialized and had a null Transaction - probably
// don't need to be confused by that - just a normal part of initialization...
if (command.Transaction != null && command.Transaction != trans)
{
log.Warn("The IDbCommand had a different Transaction than the Session. This can occur when " +
"Disconnecting and Reconnecting Sessions because the PreparedCommand Cache is Session specific.");
}
}
log.Debug("Enlist Command");
// If you try to assign a disposed transaction to a command with MSSQL, it will leave the command's
// transaction as null and not throw an error. With SQLite, for example, it will throw an exception
// here instead. Because of this, we set the trans field to null in when Dispose is called.
command.Transaction = trans;
}
}
public object Get(object key)
{
if (key == null)
{
return(null);
}
var cacheKey = GetCacheKey(key);
if (log.IsDebugEnabled)
{
log.Debug(string.Format("Fetching object '{0}' from the cache.", cacheKey));
}
var obj = cache.Get(cacheKey);
if (obj == null)
{
return(null);
}
var de = (DictionaryEntry)obj;
if (key.Equals(de.Key))
{
return(de.Value);
}
return(null);
}
public void LogParameters(ISessionFactoryImplementor factory)
{
var print = new Printer(factory);
if (_positionalParameterValues.Length != 0)
{
log.Debug("parameters: " + print.ToString(_positionalParameterTypes, _positionalParameterValues));
}
if (_namedParameters != null)
{
log.Debug("named parameters: " + print.ToString(_namedParameters));
}
}
/// <summary>
/// Creates the metadata document.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="sign">if set to <c>true</c> sign the document.</param>
public string CreateMetadataDocument(Encoding encoding, bool sign)
{
logger.Debug(TraceMessages.MetadataDocumentBeingCreated);
var keyinfo = new System.Security.Cryptography.Xml.KeyInfo();
var keyClause = new System.Security.Cryptography.Xml.KeyInfoX509Data(configuration.ServiceProvider.SigningCertificate, X509IncludeOption.EndCertOnly);
keyinfo.AddClause(keyClause);
var doc = new Saml20MetadataDocument(configuration, keyinfo, sign);
logger.Debug(TraceMessages.MetadataDocumentCreated);
return(doc.ToXml(encoding, configuration.ServiceProvider.SigningCertificate));
}
public static void LogMapped(this Mapping.Property property, IInternalLogger log)
{
if (log.IsDebugEnabled)
{
string msg = "Mapped property: " + property.Name;
string columns = string.Join(",", property.Value.ColumnIterator.Select(c => c.Text).ToArray());
if (columns.Length > 0)
msg += " -> " + columns;
if (property.Type != null)
msg += ", type: " + property.Type.Name;
log.Debug(msg);
}
}
/// <summary></summary>
static SessionFactoryObjectFactory()
{
log = LoggerProvider.LoggerFor(typeof(SessionFactoryObjectFactory));
log.Debug("initializing class SessionFactoryObjectFactory");
}
