static async Task StartServerAsync()
{
DateTime lastConfigRefresh = DateTime.UtcNow;
UniverseInfoServers = new MUIS[Settings.Ports.Length];
for (int i = 0; i < UniverseInfoServers.Length; ++i)
{
Logger.Info($"Starting MUIS on port {Settings.Ports[i]}.");
UniverseInfoServers[i] = new MUIS(Settings.Ports[i]);
UniverseInfoServers[i].Start();
Logger.Info($"MUIS started.");
}
try
{
while (true)
{
// Tick
await Task.WhenAll(UniverseInfoServers.Select(x => x.Tick()));
// Reload config
if ((DateTime.UtcNow - lastConfigRefresh).TotalMilliseconds > Settings.RefreshConfigInterval)
{
RefreshConfig();
lastConfigRefresh = DateTime.UtcNow;
}
await Task.Delay(100);
}
}
finally
{
await Task.WhenAll(UniverseInfoServers.Select(x => x.Stop()));
}
}
public override void ChannelActive(IChannelHandlerContext ctx)
{
IChannelGroup g = Group;
if (g == null)
{
lock (this)
{
if (Group == null)
{
Group = g = new DefaultChannelGroup(ctx.Executor);
}
}
}
// Detect when client disconnects
ctx.Channel.CloseCompletion.ContinueWith((x) =>
{
Logger.Info("Channel Closed");
OnChannelInactive?.Invoke(ctx.Channel);
});
// Add to channels list
g.Add(ctx.Channel);
// Send event upstream
OnChannelActive?.Invoke(ctx.Channel);
}
public void InfoTest1()
{
IInternalLogger target = CreateLogger();
target.SetLevel(LogLevel.Always);
calls = 0;
target.Info(message, id);
Assert.AreEqual(calls, 0);
calls = 0;
target.SetLevel(LogLevel.All);
target.Info(message, ids);
Assert.AreEqual(calls, 1);
Assert.AreEqual(lastItem.Category, category);
Assert.AreEqual(lastItem.Level, LogLevel.Info);
Assert.IsNull(lastItem.Ex);
Assert.AreEqual(lastItem.Message, message);
Assert.IsNotNull(lastItem.Ids);
Assert.AreEqual(ids, lastItem.Ids);
calls = 0;
target.SetLevel(LogLevel.Info);
target.Info(message, id);
Assert.AreEqual(calls, 1);
}
void StartLoop()
{
IntPtr handle = this.loop.Handle;
try
{
this.UpdateLastExecutionTime();
this.Initialize();
if (Interlocked.CompareExchange(ref this.executionState, StartedState, NotStartedState) != NotStartedState)
{
throw new InvalidOperationException($"Invalid {nameof(LoopExecutor)} state {this.executionState}");
}
this.loopRunStart.Set();
this.loop.Run(uv_run_mode.UV_RUN_DEFAULT);
}
catch (Exception ex)
{
this.loopRunStart.Set();
Logger.Error("Loop {}:{} run default error.", this.thread.Name, handle, ex);
this.terminationCompletionSource.TrySetException(ex);
}
finally
{
Logger.Info("Loop {}:{} thread finished.", this.thread.Name, handle);
this.CleanupAndTerminate();
}
}
// cannot be instantiated
public static IConnectionProvider NewConnectionProvider(IDictionary <string, string> settings)
{
IConnectionProvider connections;
string providerClass;
if (settings.TryGetValue(Environment.ConnectionProvider, out providerClass))
{
try
{
log.Info("Initializing connection provider: " + providerClass);
connections =
(IConnectionProvider)
Environment.BytecodeProvider.ObjectsFactory.CreateInstance(ReflectHelper.ClassForName(providerClass));
}
catch (Exception e)
{
log.Fatal("Could not instantiate connection provider", e);
throw new HibernateException("Could not instantiate connection provider: " + providerClass, e);
}
}
else if (settings.ContainsKey(Environment.ConnectionString) || settings.ContainsKey(Environment.ConnectionStringName))
{
connections = new DriverConnectionProvider();
}
else
{
log.Info("No connection provider specified, UserSuppliedConnectionProvider will be used.");
connections = new UserSuppliedConnectionProvider();
}
connections.Configure(settings);
return(connections);
}
public Loop()
{
int size = NativeMethods.uv_loop_size().ToInt32();
this.Handle = Marshal.AllocHGlobal(size);
try
{
int result = NativeMethods.uv_loop_init(this.Handle);
if (result < 0)
{
throw NativeMethods.CreateError((uv_err_code)result);
}
}
catch
{
Marshal.FreeHGlobal(this.Handle);
throw;
}
GCHandle gcHandle = GCHandle.Alloc(this, GCHandleType.Normal);
((uv_loop_t *)this.Handle)->data = GCHandle.ToIntPtr(gcHandle);
if (Logger.InfoEnabled)
{
Logger.Info($"Loop {this.Handle} allocated.");
}
}
protected override void Initialize()
{
clazz =
ReflectHelper.ClassForFullName(
TypeNameParser.Parse(meta.name, meta.rootMapping.@namespace, meta.rootMapping.assembly).ToString());
classAttributes = meta.attributename == null
? new List <Attribute>(0)
: new List <Attribute>(meta.attributename.Length);
List <MemberInfo> lmembers = meta.property == null
? new List <MemberInfo>(0)
: new List <MemberInfo>(meta.property.Length);
if (meta.attributename != null)
{
log.Debug("Looking for class attributes");
foreach (NhvmClassAttributename attributename in meta.attributename)
{
log.Info("Attribute to look for = " + GetText(attributename));
Attribute classAttribute = RuleAttributeFactory.CreateAttributeFromClass(clazz, attributename);
classAttributes.Add(classAttribute);
}
}
if (meta.property != null)
{
foreach (NhvmProperty property in meta.property)
{
MemberInfo currentMember = TypeUtils.GetPropertyOrField(clazz, property.name);
if (currentMember == null)
{
throw new InvalidPropertyNameException(property.name, clazz);
}
log.Info("Looking for rules for property : " + property.name);
lmembers.Add(currentMember);
// creation of member attributes
foreach (object rule in property.Items)
{
Attribute thisAttribute = RuleAttributeFactory.CreateAttributeFromRule(rule, meta.rootMapping.assembly,
meta.rootMapping.@namespace);
if (thisAttribute != null)
{
log.Info(string.Format("Adding member {0} to dictionary with attribute {1}", currentMember.Name, thisAttribute));
if (!membersAttributesDictionary.ContainsKey(currentMember))
{
membersAttributesDictionary.Add(currentMember, new List <Attribute>());
}
membersAttributesDictionary[currentMember].Add(thisAttribute);
}
}
}
}
members = lmembers.ToArray();
}
/// <inheritdoc />
public void Clear()
{
if (log.IsInfoEnabled)
{
log.Info("clearing all objects from system");
}
system.Clear();
}
private IByteBuffer EncodeMetaData()
{
logger.Info($"Metadata:{Metadata}");
var buffer = Unpooled.Buffer();
List <Object> meta = new List <object>();
meta.Add("onMetaData");
meta.Add(Metadata);
AMF0.Encode(buffer, meta);
return(buffer);
}
public override void ChannelActive(IChannelHandlerContext ctx)
{
// Detect when client disconnects
ctx.Channel.CloseCompletion.ContinueWith((x) =>
{
Logger.Info("Channel Closed");
OnChannelInactive?.Invoke(ctx.Channel);
});
// Send event upstream
OnChannelActive?.Invoke(ctx.Channel);
}
static void Main(string[] args)
{
//
Initialize();
Logger.Info($"Starting NAT on port {NATServer.Port}.");
Task.WaitAll(NATServer.Start());
Logger.Info($"NAT started.");
while (NATServer.IsRunning)
{
Thread.Sleep(500);
}
}
public ITableMetadata GetTableMetadata(string name, string schema, string catalog, bool isQuoted)
{
string identifier = Identifier(catalog, schema, name);
ITableMetadata table;
tables.TryGetValue(identifier, out table);
if (table != null)
{
return(table); // EARLY exit
}
try
{
DataTable metaInfo;
if ((isQuoted && meta.StoresMixedCaseQuotedIdentifiers))
{
metaInfo = meta.GetTables(catalog, schema, name, Types);
}
else
{
if ((isQuoted && meta.StoresUpperCaseQuotedIdentifiers) || (!isQuoted && meta.StoresUpperCaseIdentifiers))
{
metaInfo =
meta.GetTables(StringHelper.ToUpperCase(catalog), StringHelper.ToUpperCase(schema),
StringHelper.ToUpperCase(name), Types);
}
else
{
if ((isQuoted && meta.StoresLowerCaseQuotedIdentifiers) || (!isQuoted && meta.StoresLowerCaseIdentifiers))
{
metaInfo =
meta.GetTables(StringHelper.ToLowerCase(catalog), StringHelper.ToLowerCase(schema),
StringHelper.ToLowerCase(name), Types);
}
else
{
metaInfo = meta.GetTables(catalog, schema, name, Types);
}
}
}
DataRowCollection rows = metaInfo.Rows;
foreach (DataRow tableRow in rows)
{
string tableName = Convert.ToString(tableRow[meta.ColumnNameForTableName]);
if (name.Equals(tableName, StringComparison.InvariantCultureIgnoreCase))
{
table = meta.GetTableMetadata(tableRow, extras);
tables[identifier] = table;
return(table);
}
}
log.Info("table not found: " + name);
return(null);
}
catch (DbException sqle)
{
throw ADOExceptionHelper.Convert(sqlExceptionConverter, sqle, "could not get table metadata: " + name);
}
}
/// <summary>
/// Initializes the <see cref="SysCacheProvider"/> class.
/// </summary>
static SysCacheProvider()
{
Log = LoggerProvider.LoggerFor(typeof(SysCacheProvider));
// We need to determine which cache regions are configured in the configuration file, but we cant create the
// cache regions at this time because there could be nhibernate configuration values
// that we need for the cache regions such as connection info to be used for data dependencies. But this info
// isn't available until build cache is called. So allocate space but only create them on demand.
var configSection = SysCacheSection.GetSection();
if (configSection != null && configSection.CacheRegions.Count > 0)
{
CacheRegionSettings = new Dictionary <string, CacheRegionElement>(configSection.CacheRegions.Count);
foreach (var cacheRegion in configSection.CacheRegions)
{
if (cacheRegion is CacheRegionElement element)
{
CacheRegionSettings.Add(element.Name, element);
}
}
}
else
{
CacheRegionSettings = new Dictionary <string, CacheRegionElement>(0);
Log.Info(
"No cache regions specified. Cache regions can be specified in sysCache configuration section with custom settings.");
}
}
static void RunLoop(object state)
{
var loop = (LoopExecutor)state;
loop.SetCurrentExecutor(loop);
Task.Factory.StartNew(
() =>
{
try
{
loop.Initialize();
loop.executionState = StartedState;
loop.loop.Run(uv_run_mode.UV_RUN_DEFAULT);
Logger.Info("{}: {} run finished.", loop.thread.Name, loop.loop.Handle);
loop.terminationCompletionSource.TryComplete();
}
catch (Exception ex)
{
Logger.Error("{}: execution loop failed", loop.thread.Name, ex);
loop.terminationCompletionSource.TrySetException(ex);
}
loop.executionState = TerminatedState;
},
CancellationToken.None,
TaskCreationOptions.None,
loop.scheduler);
}
public static void IgnoringFrameForStreamRst(this IInternalLogger logger, IChannelHandlerContext ctx, Http2FrameTypes frameName, bool isResetSent, int lastStreamKnownByPeer)
{
logger.Info("{} ignoring {} frame for stream {}", ctx.Channel, frameName,
isResetSent ? "RST_STREAM sent." :
("Stream created after GOAWAY sent. Last known stream by peer " +
lastStreamKnownByPeer));
}
/// <summary> Build a SQLExceptionConverter instance. </summary>
/// <param name="dialect">The defined dialect. </param>
/// <param name="properties">The configuration properties. </param>
/// <returns> An appropriate <see cref="ISQLExceptionConverter"/> instance. </returns>
/// <remarks>
/// First, looks for a <see cref="Cfg.Environment.SqlExceptionConverter"/> property to see
/// if the configuration specified the class of a specific converter to use. If this
/// property is set, attempt to construct an instance of that class. If not set, or
/// if construction fails, the converter specific to the dialect will be used.
/// </remarks>
public static ISQLExceptionConverter BuildSQLExceptionConverter(Dialect.Dialect dialect, IDictionary <string, string> properties)
{
ISQLExceptionConverter converter = null;
string converterClassName;
properties.TryGetValue(Cfg.Environment.SqlExceptionConverter, out converterClassName);
if (!string.IsNullOrEmpty(converterClassName))
{
converter = ConstructConverter(converterClassName, dialect.ViolatedConstraintNameExtracter);
}
if (converter == null)
{
log.Info("Using dialect defined converter");
converter = dialect.BuildSQLExceptionConverter();
}
IConfigurable confConv = converter as IConfigurable;
if (confConv != null)
{
try
{
confConv.Configure(properties);
}
catch (HibernateException e)
{
log.Warn("Unable to configure SQLExceptionConverter", e);
throw;
}
}
return(converter);
}
/// <summary>
/// Initializes the index at the given index
/// </summary>
protected FSDirectory InitializeIndex(DirectoryInfo path, string indexName = null)
{
try
{
var directory = FSDirectory.Open(path.FullName);
// Exit if the index already exists
if (IndexReader.IndexExists(directory))
{
return(directory);
}
// TODO:RB: re-add logging
log.DebugFormat("Initialize index: '{0}'", path);
var maxFieldLength = IndexWriter.MaxFieldLength.UNLIMITED;
var policy = new KeepOnlyLastCommitDeletionPolicy();
using (var analyzer = new StandardAnalyzer(Environment.LuceneVersion))
using (var indexWriter = new IndexWriter(directory, analyzer, true, policy, maxFieldLength))
{
// Do nothing, index writer's constructor has initialized the index
log.Info("Index writer called to create directory" + path.FullName);
indexWriter.Close();
}
return(directory);
}
catch (IOException e)
{
throw new HibernateException("Unable to initialize index: " + indexName ?? path.FullName, e);
}
}
static void Main(string[] args)
{
ConfigurationHelper.SetConsoleLogger();
Logger.Info("test info logger");
Logger.Error(new Exception("测试"));
Console.WriteLine("当前线程ID：" + Thread.CurrentThread.ManagedThreadId.ToString());
AsyncHelper.Run(async() =>
{
await new TaskFactory().StartNew(() =>
{
Console.WriteLine("当前线程ID：" + Thread.CurrentThread.ManagedThreadId.ToString());
});
// throw new Exception("异常报错");
}
);
//User info = new User() { UserID = 1, userName = "******" };
//var jsonString = Json.GetJsonByObj(info);
//// Console.WriteLine(jsonString);
//Logger.Info("test info Json {0}", jsonString);
Console.ReadLine();
Task.Factory.StartNew(() =>
{
return(true);
});
}
private static void PopulateResult(
string fieldName, IFieldBridge fieldBridge, Attributes.Store fieldStore,
string[] fields, object[] result, Document document
)
{
int matchingPosition = GetFieldPosition(fields, fieldName);
if (matchingPosition != -1)
{
//TODO make use of an isTwoWay() method
if (fieldStore != Attributes.Store.No && fieldBridge is ITwoWayFieldBridge)
{
result[matchingPosition] = ((ITwoWayFieldBridge)fieldBridge).Get(fieldName, document);
if (logger.IsInfoEnabled)
{
logger.Info("Field " + fieldName + " projected as " + result[matchingPosition]);
}
}
else
{
if (fieldStore == Attributes.Store.No)
{
throw new SearchException("Projecting an unstored field: " + fieldName);
}
throw new SearchException("IFieldBridge is not a ITwoWayFieldBridge: " + fieldBridge.GetType());
}
}
}
/// <summary>
/// Adds an import to allow for the full class name <c>Namespace.Entity (AssemblyQualifiedName)</c>
/// to be referenced as <c>Entity</c> or some other name in HQL.
/// </summary>
/// <param name="className">The name of the type that is being renamed.</param>
/// <param name="rename">The new name to use in HQL for the type.</param>
/// <exception cref="MappingException">Thrown when the rename already identifies another type.</exception>
public void AddImport(string className, string rename)
{
if (rename == null)
{
throw new ArgumentNullException("rename");
}
// if the imports dictionary already contains the rename, then make sure
// the rename is not for a different className. If it is a different className
// then we probably have 2 classes with the same name in a different namespace. To
// prevent this error one of the classes needs to have the attribute "
string existing;
imports.TryGetValue(rename, out existing);
imports[rename] = className;
if (existing != null)
{
if (existing.Equals(className))
{
log.Info("duplicate import: " + className + "->" + rename);
}
else
{
throw new DuplicateMappingException(
"duplicate import: " + rename + " refers to both " + className + " and " + existing
+ " (try using auto-import=\"false\")", "import", rename);
}
}
}
public virtual void Configure(IType type, IDictionary <string, string> parms, Dialect.Dialect dialect)
{
IdentifierType = type;
bool forceTableUse = PropertiesHelper.GetBoolean(ForceTableParam, parms, false);
string sequenceName = DetermineSequenceName(parms, dialect);
int initialValue = DetermineInitialValue(parms);
int incrementSize = DetermineIncrementSize(parms);
string optimizationStrategy = DetermineOptimizationStrategy(parms, incrementSize);
incrementSize = DetermineAdjustedIncrementSize(optimizationStrategy, incrementSize);
Optimizer = OptimizerFactory.BuildOptimizer(
optimizationStrategy,
IdentifierType.ReturnedClass,
incrementSize,
PropertiesHelper.GetInt32(InitialParam, parms, -1)); // Use -1 as default initial value here to signal that it's not set.
if (!forceTableUse && RequiresPooledSequence(initialValue, incrementSize, Optimizer) && !dialect.SupportsPooledSequences)
{
// force the use of a table (overriding whatever the user configured) since the dialect
// doesn't support the sequence features we need.
forceTableUse = true;
Log.Info("Forcing table use for sequence-style generator due to optimizer selection where db does not support pooled sequences.");
}
DatabaseStructure = BuildDatabaseStructure(type, parms, dialect, forceTableUse, sequenceName, initialValue, incrementSize);
DatabaseStructure.Prepare(Optimizer);
}
public virtual void Configure(IDictionary <string, string> settings)
{
// Command timeout
commandTimeout = PropertiesHelper.GetInt32(Environment.CommandTimeout, settings, -1);
if (commandTimeout > -1 && log.IsInfoEnabled)
{
log.Info(string.Format("setting ADO.NET command timeout to {0} seconds", commandTimeout));
}
// Prepare SQL
prepareSql = PropertiesHelper.GetBoolean(Environment.PrepareSql, settings, false);
if (prepareSql && SupportsPreparingCommands)
{
log.Info("preparing SQL enabled");
}
}
public void AddAssembly(string assemblyName)
{
log.Info("Searching for mapped documents in assembly: " + assemblyName);
Assembly assembly;
try
{
assembly = Assembly.Load(assemblyName);
}
catch (Exception e)
{
throw new ValidatorConfigurationException("Could not add assembly " + assemblyName, e);
}
AddAssembly(assembly);
}
void ChannelReadImpl(IChannelHandlerContext ctx, string msg)
{
if (msg.HasUpperChar())
{
Logger.Info("The message has upper chars.");
ctx.WriteAsync("Your message has upper chars." + System.Environment.NewLine);
}
}
private async Task <TResponse> SendRequest <TResponse>(HttpMethod method, string endpoint, object payload = null)
where TResponse : class, new()
{
var jsonContent = payload != null?payload.ToHttpContent() : null;
var requestMessage = new HttpRequestMessage(method, endpoint)
{
Content = jsonContent
};
_logger.Info(() => string.Concat(
"Request",
Environment.NewLine,
requestMessage,
Environment.NewLine,
payload != null ? JsonForCastle.SerializeObject(payload) : ""
));
try
{
var response = await _httpClient.SendAsync(requestMessage);
var content = response.Content != null ? await response.Content.ReadAsStringAsync() : "";
_logger.Info(() => string.Concat(
"Response",
Environment.NewLine,
response,
Environment.NewLine,
content
));
if (response.IsSuccessStatusCode)
{
return(JsonForCastle.DeserializeObject <TResponse>(content));
}
throw await response.ToCastleException(requestMessage.RequestUri.AbsoluteUri);
}
catch (OperationCanceledException)
{
throw new CastleTimeoutException(
requestMessage.RequestUri.AbsoluteUri,
(int)_httpClient.Timeout.TotalMilliseconds);
}
}
public UpdateTimestampsCache(Settings settings, IDictionary <string, string> props)
{
string prefix = settings.CacheRegionPrefix;
regionName = prefix == null ? regionName : prefix + '.' + regionName;
log.Info("starting update timestamps cache at region: " + regionName);
updateTimestamps = settings.CacheProvider.BuildCache(regionName, props);
}
/// <summary>
/// Start the Dme Tcp Server.
/// </summary>
public virtual async void Start()
{
//
_bossGroup = new MultithreadEventLoopGroup(1);
_workerGroup = new MultithreadEventLoopGroup();
_scertHandler = new ScertServerHandler();
// Add client on connect
_scertHandler.OnChannelActive += (channel) =>
{
string key = channel.Id.AsLongText();
_channelDatas.TryAdd(key, new ChannelData());
};
// Remove client on disconnect
_scertHandler.OnChannelInactive += (channel) =>
{
string key = channel.Id.AsLongText();
_channelDatas.TryRemove(key, out var data);
};
// Queue all incoming messages
_scertHandler.OnChannelMessage += (channel, message) =>
{
string key = channel.Id.AsLongText();
if (_channelDatas.TryGetValue(key, out var data))
{
data.RecvQueue.Enqueue(message);
}
// Log if id is set
if (message.CanLog())
{
Logger.Info($"TCP RECV {channel}: {message}");
}
};
var bootstrap = new ServerBootstrap();
bootstrap
.Group(_bossGroup, _workerGroup)
.Channel <TcpServerSocketChannel>()
.Option(ChannelOption.SoBacklog, 100)
.Handler(new LoggingHandler(LogLevel.INFO))
.ChildHandler(new ActionChannelInitializer <ISocketChannel>(channel =>
{
IChannelPipeline pipeline = channel.Pipeline;
pipeline.AddLast(new WriteTimeoutHandler(15));
pipeline.AddLast(new ScertEncoder());
pipeline.AddLast(new ScertIEnumerableEncoder());
pipeline.AddLast(new ScertTcpFrameDecoder(DotNetty.Buffers.ByteOrder.LittleEndian, 1024, 1, 2, 0, 0, false));
pipeline.AddLast(new ScertDecoder(_sessionCipher, AuthKey));
pipeline.AddLast(_scertHandler);
}));
_boundChannel = await bootstrap.BindAsync(Port);
}
/// <summary>
/// Cascade an action from the parent entity instance to all its children. This
/// form is typicaly called from within cascade actions.
/// </summary>
/// <param name="persister">The parent's entity persister </param>
/// <param name="parent">The parent reference. </param>
/// <param name="anything">
/// Typically some form of cascade-local cache
/// which is specific to each CascadingAction type
/// </param>
public void CascadeOn(IEntityPersister persister, object parent, object anything)
{
if (persister.HasCascades || action.RequiresNoCascadeChecking)
{
log.Info("processing cascade " + action + " for: " + persister.EntityName);
IType[] types = persister.PropertyTypes;
CascadeStyle[] cascadeStyles = persister.PropertyCascadeStyles;
EntityMode entityMode = eventSource.EntityMode;
bool hasUninitializedLazyProperties = persister.HasUninitializedLazyProperties(parent, entityMode);
for (int i = 0; i < types.Length; i++)
{
CascadeStyle style = cascadeStyles[i];
if (hasUninitializedLazyProperties && persister.PropertyLaziness[i] && !action.PerformOnLazyProperty)
{
//do nothing to avoid a lazy property initialization
continue;
}
if (style.DoCascade(action))
{
CascadeProperty(parent, persister.GetPropertyValue(parent, i, entityMode), types[i], style, anything, false);
}
else if (action.RequiresNoCascadeChecking)
{
action.NoCascade(eventSource, persister.GetPropertyValue(parent, i, entityMode), parent, persister, i);
}
}
log.Info("done processing cascade " + action + " for: " + persister.EntityName);
}
}
public PocoInstantiator(Mapping.Component component, IInstantiationOptimizer optimizer)
{
mappedClass = component.ComponentClass;
this.optimizer = optimizer;
proxyInterface = null;
embeddedIdentifier = false;
try
{
constructor = ReflectHelper.GetDefaultConstructor(mappedClass);
}
catch (PropertyNotFoundException)
{
log.Info(string.Format("no default (no-argument) constructor for class: {0} (class must be instantiated by Interceptor)", mappedClass.FullName));
constructor = null;
}
}
public void HandlePropertyBeingDereferenced(IType propertySource, string propertyName)
{
if (QueryableCollection != null && CollectionProperties.IsCollectionProperty(propertyName))
{
// propertyName refers to something like collection.size...
return;
}
if (propertySource.IsComponentType)
{
// property name is a sub-path of a component...
return;
}
IQueryable persister = Queryable;
if (persister != null)
{
try
{
Declarer propertyDeclarer = persister.GetSubclassPropertyDeclarer(propertyName);
if (Log.IsInfoEnabled)
{
Log.Info("handling property dereference [" + persister.EntityName + " (" + ClassAlias + ") -> " + propertyName + " (" + propertyDeclarer + ")]");
}
if (propertyDeclarer == Declarer.SubClass)
{
_dereferencedBySubclassProperty = true;
_includeSubclasses = true;
}
else if (propertyDeclarer == Declarer.SuperClass)
{
_dereferencedBySuperclassProperty = true;
}
}
catch (QueryException)
{
// ignore it; the incoming property could not be found so we
// cannot be sure what to do here. At the very least, the
// safest is to simply not apply any dereference toggling...
}
}
}
static RedisProvider()
{
Log = LoggerProvider.LoggerFor(typeof (RedisProvider));
Config = ConfigurationManager.GetSection("redis") as RedisConfig;
if (Config == null)
{
Log.Info("redis configuration section not found, using default configuration (127.0.0.1:6379).");
Config = new RedisConfig("localhost",6379);
}
}
static CouchbaseCacheProvider()
{
log = LoggerProvider.LoggerFor(typeof (CouchbaseCacheProvider));
config = ConfigurationManager.GetSection("couchbase") as ICouchbaseClientConfiguration;
if (config == null)
{
log.Info("couchbase configuration section not found, using default configuration (127.0.0.1:8091).");
config = new CouchbaseClientConfiguration();
config.Urls.Add(new UriBuilder("http://", IPAddress.Loopback.ToString(),8091, "pools").Uri);
}
}
static MemCacheProvider()
{
log = LoggerProvider.LoggerFor(typeof (MemCacheProvider));
config = ConfigurationManager.GetSection("enyim.com/memcached") as IMemcachedClientConfiguration;
if (config == null)
{
log.Info("enyim.com/memcached configuration section not found, using default configuration (127.0.0.1:11211).");
config = new MemcachedClientConfiguration();
config.Servers.Add(new IPEndPoint(IPAddress.Loopback, 11211));
}
}
