/// <summary>
/// Creates a cache implementation for the strategy as defined by the cache descriptor.
/// </summary>
/// <param name="cacheDesc">cache descriptor</param>
/// <param name="epStatementAgentInstanceHandle">statement handle for timer invocations</param>
/// <param name="schedulingService">scheduling service for time-based caches</param>
/// <param name="scheduleBucket">for ordered timer invokation</param>
/// <returns>data cache implementation</returns>
public DataCache GetDataCache(
ConfigurationDataCache cacheDesc,
StatementContext statementContext,
EPStatementAgentInstanceHandle epStatementAgentInstanceHandle,
SchedulingService schedulingService,
ScheduleBucket scheduleBucket,
int streamNum)
{
if (cacheDesc == null)
{
return(new DataCacheNullImpl());
}
if (cacheDesc is ConfigurationLRUCache)
{
var lruCache = (ConfigurationLRUCache)cacheDesc;
return(new DataCacheLRUImpl(lruCache.Size));
}
if (cacheDesc is ConfigurationExpiryTimeCache)
{
var expCache = (ConfigurationExpiryTimeCache)cacheDesc;
return(MakeTimeCache(expCache, statementContext, epStatementAgentInstanceHandle, schedulingService, scheduleBucket, streamNum));
}
throw new IllegalStateException("Cache implementation class not configured");
}
/// <summary>Creates a cache implementation for the strategy as defined by the cache descriptor. </summary>
/// <param name="cacheDesc">cache descriptor</param>
/// <param name="epStatementAgentInstanceHandle">statement handle for timer invocations</param>
/// <param name="schedulingService">scheduling service for time-based caches</param>
/// <param name="scheduleBucket">for ordered timer invokation</param>
/// <returns>data cache implementation</returns>
public static DataCache GetDataCache(ConfigurationDataCache cacheDesc,
EPStatementAgentInstanceHandle epStatementAgentInstanceHandle,
SchedulingService schedulingService,
ScheduleBucket scheduleBucket)
{
if (cacheDesc == null)
{
return(new DataCacheNullImpl());
}
if (cacheDesc is ConfigurationLRUCache)
{
ConfigurationLRUCache lruCache = (ConfigurationLRUCache)cacheDesc;
return(new DataCacheLRUImpl(lruCache.Size));
}
if (cacheDesc is ConfigurationExpiryTimeCache)
{
ConfigurationExpiryTimeCache expCache = (ConfigurationExpiryTimeCache)cacheDesc;
return(new DataCacheExpiringImpl(expCache.MaxAgeSeconds, expCache.PurgeIntervalSeconds, expCache.CacheReferenceType,
schedulingService, scheduleBucket.AllocateSlot(), epStatementAgentInstanceHandle));
}
throw new IllegalStateException("Cache implementation class not configured");
}
/// <summary>
/// Returns a new cache implementation for this database.
/// </summary>
/// <param name="databaseName">the name of the database to return a new cache implementation for for</param>
/// <param name="epStatementAgentInstanceHandle">is the statements-own handle for use in registering callbacks with services</param>
/// <returns>cache implementation</returns>
/// <throws> DatabaseConfigException is thrown to indicate database configuration errors </throws>
public virtual DataCache GetDataCache(String databaseName, EPStatementAgentInstanceHandle epStatementAgentInstanceHandle)
{
ConfigurationDBRef config;
if (!_mapDatabaseRef.TryGetValue(databaseName, out config))
{
throw new DatabaseConfigException("Cannot locate configuration information for database '" + databaseName + "'");
}
ConfigurationDataCache dataCacheDesc = config.DataCacheDesc;
return(DataCacheFactory.GetDataCache(dataCacheDesc, epStatementAgentInstanceHandle, _schedulingService, _scheduleBucket));
}
/// <summary>
/// Configures an expiry-time cache of the given maximum age in seconds and purge interval in seconds. Also allows
/// setting the reference type indicating whether garbage collection may remove entries from cache.
/// </summary>
/// <param name="maxAgeSeconds">the maximum number of seconds before a query result is considered stale (also known as time-to-live)</param>
/// <param name="purgeIntervalSeconds">the interval at which the engine purges stale data from the cache.</param>
/// <param name="cacheReferenceType">specifies the reference type to use</param>
public virtual void SetExpiryTimeCache(double maxAgeSeconds, double purgeIntervalSeconds, ConfigurationCacheReferenceType cacheReferenceType)
{
dataCacheDesc = new ConfigurationExpiryTimeCache(maxAgeSeconds, purgeIntervalSeconds, cacheReferenceType);
}
/// <summary>
/// Configures an expiry-time cache of the given maximum age in seconds and purge interval in seconds.
/// <para>
/// Specifies the cache reference type to be weak references. Weak reference cache entries become
/// eligible for garbage collection and are removed from cache when the garbage collection requires so.
/// </para>
/// </summary>
/// <param name="maxAgeSeconds">is the maximum number of seconds before a query result is considered stale (also known as time-to-live)
/// </param>
/// <param name="purgeIntervalSeconds">is the interval at which the engine purges stale data from the cache
/// </param>
public virtual void SetExpiryTimeCache(double maxAgeSeconds, double purgeIntervalSeconds)
{
dataCacheDesc = new ConfigurationExpiryTimeCache(maxAgeSeconds, purgeIntervalSeconds, ConfigurationCacheReferenceTypeHelper.GetDefault());
}
public KondutoService(ConfigurationDataCache configurationDataCache, IKondutoProxy kondutoProxy)
{
_configurationDataCache = configurationDataCache;
_kondutoProxy = kondutoProxy;
}
/// <summary>
/// Creates a method-invocation polling view for use as a stream that calls a method, or pulls results from cache.
/// </summary>
/// <param name="streamNumber">the stream number</param>
/// <param name="methodStreamSpec">defines the class and method to call</param>
/// <param name="eventAdapterService">for creating event types and events</param>
/// <param name="epStatementAgentInstanceHandle">for time-based callbacks</param>
/// <param name="engineImportService">for resolving configurations</param>
/// <param name="schedulingService">for scheduling callbacks in expiry-time based caches</param>
/// <param name="scheduleBucket">for schedules within the statement</param>
/// <param name="exprEvaluatorContext">expression evaluation context</param>
/// <param name="variableService">variable service</param>
/// <param name="statementContext">statement context</param>
/// <param name="contextName">context name</param>
/// <param name="dataCacheFactory">factory for cache</param>
/// <exception cref="ExprValidationException">
/// if the expressions cannot be validated or the method descriptor
/// has incorrect class and method names, or parameter number and types don't match
/// </exception>
/// <returns>pollable view</returns>
public static HistoricalEventViewable CreatePollMethodView(
int streamNumber,
MethodStreamSpec methodStreamSpec,
EventAdapterService eventAdapterService,
EPStatementAgentInstanceHandle epStatementAgentInstanceHandle,
EngineImportService engineImportService,
SchedulingService schedulingService,
ScheduleBucket scheduleBucket,
ExprEvaluatorContext exprEvaluatorContext,
VariableService variableService,
string contextName,
DataCacheFactory dataCacheFactory,
StatementContext statementContext)
{
VariableMetaData variableMetaData = variableService.GetVariableMetaData(methodStreamSpec.ClassName);
MethodPollingExecStrategyEnum strategy;
VariableReader variableReader = null;
string variableName = null;
MethodInfo methodReflection = null;
object invocationTarget = null;
string eventTypeNameProvidedUDFOrScript = null;
// see if this is a script in the from-clause
ExprNodeScript scriptExpression = null;
if (methodStreamSpec.ClassName == null && methodStreamSpec.MethodName != null)
{
var scriptsByName = statementContext.ExprDeclaredService.GetScriptsByName(methodStreamSpec.MethodName);
if (scriptsByName != null)
{
scriptExpression =
ExprDeclaredHelper.GetExistsScript(
statementContext.ConfigSnapshot.EngineDefaults.Scripts.DefaultDialect,
methodStreamSpec.MethodName, methodStreamSpec.Expressions, scriptsByName,
statementContext.ExprDeclaredService);
}
}
try
{
if (scriptExpression != null)
{
eventTypeNameProvidedUDFOrScript = scriptExpression.EventTypeNameAnnotation;
strategy = MethodPollingExecStrategyEnum.TARGET_SCRIPT;
ExprNodeUtility.ValidateSimpleGetSubtree(
ExprNodeOrigin.METHODINVJOIN, scriptExpression, statementContext, null, false);
}
else if (variableMetaData != null)
{
variableName = variableMetaData.VariableName;
if (variableMetaData.ContextPartitionName != null)
{
if (contextName == null || !contextName.Equals(variableMetaData.ContextPartitionName))
{
throw new ExprValidationException(
"Variable by name '" + variableMetaData.VariableName +
"' has been declared for context '" + variableMetaData.ContextPartitionName +
"' and can only be used within the same context");
}
strategy = MethodPollingExecStrategyEnum.TARGET_VAR_CONTEXT;
variableReader = null;
invocationTarget = null;
}
else
{
variableReader = variableService.GetReader(
methodStreamSpec.ClassName, EPStatementStartMethodConst.DEFAULT_AGENT_INSTANCE_ID);
if (variableMetaData.IsConstant)
{
invocationTarget = variableReader.Value;
if (invocationTarget is EventBean)
{
invocationTarget = ((EventBean)invocationTarget).Underlying;
}
strategy = MethodPollingExecStrategyEnum.TARGET_CONST;
}
else
{
invocationTarget = null;
strategy = MethodPollingExecStrategyEnum.TARGET_VAR;
}
}
methodReflection = engineImportService.ResolveNonStaticMethodOverloadChecked(
variableMetaData.VariableType, methodStreamSpec.MethodName);
}
else if (methodStreamSpec.ClassName == null)
{
// must be either UDF or script
Pair <Type, EngineImportSingleRowDesc> udf = null;
try
{
udf = engineImportService.ResolveSingleRow(methodStreamSpec.MethodName);
}
catch (EngineImportException ex)
{
throw new ExprValidationException(
"Failed to find user-defined function '" + methodStreamSpec.MethodName + "': " + ex.Message,
ex);
}
methodReflection = engineImportService.ResolveMethodOverloadChecked(udf.First, methodStreamSpec.MethodName);
invocationTarget = null;
variableReader = null;
variableName = null;
strategy = MethodPollingExecStrategyEnum.TARGET_CONST;
eventTypeNameProvidedUDFOrScript = udf.Second.OptionalEventTypeName;
}
else
{
methodReflection = engineImportService.ResolveMethodOverloadChecked(methodStreamSpec.ClassName, methodStreamSpec.MethodName);
invocationTarget = null;
variableReader = null;
variableName = null;
strategy = MethodPollingExecStrategyEnum.TARGET_CONST;
}
}
catch (ExprValidationException)
{
throw;
}
catch (Exception e)
{
throw new ExprValidationException(e.Message, e);
}
Type methodProviderClass = null;
Type beanClass;
IDictionary <string, object> oaType = null;
IDictionary <string, object> mapType = null;
bool isCollection = false;
bool isIterator = false;
EventType eventType;
EventType eventTypeWhenMethodReturnsEventBeans = null;
bool isStaticMethod = false;
if (methodReflection != null)
{
methodProviderClass = methodReflection.DeclaringType;
isStaticMethod = variableMetaData == null;
// Determine object type returned by method
beanClass = methodReflection.ReturnType;
if ((beanClass == typeof(void)) || (beanClass.IsBuiltinDataType()))
{
throw new ExprValidationException(
"Invalid return type for static method '" + methodReflection.Name + "' of class '" +
methodStreamSpec.ClassName + "', expecting a class");
}
if (methodReflection.ReturnType.IsArray &&
methodReflection.ReturnType.GetElementType() != typeof(EventBean))
{
beanClass = methodReflection.ReturnType.GetElementType();
}
Type collectionClass = null;
Type iteratorClass = null;
if (!beanClass.IsGenericDictionary())
{
isCollection = beanClass.IsGenericCollection();
if (isCollection)
{
collectionClass = TypeHelper.GetGenericReturnType(methodReflection, true);
beanClass = collectionClass;
}
isIterator = beanClass.IsGenericEnumerator() && !beanClass.IsGenericDictionary();
if (isIterator)
{
iteratorClass = TypeHelper.GetGenericReturnType(methodReflection, true);
beanClass = iteratorClass;
}
}
// If the method returns a Map, look up the map type
string mapTypeName = null;
if ((methodReflection.ReturnType.IsGenericStringDictionary()) ||
(methodReflection.ReturnType.IsArray && methodReflection.ReturnType.GetElementType().IsGenericStringDictionary()) ||
(isCollection && collectionClass.IsImplementsInterface(typeof(Map))) ||
(isIterator && iteratorClass.IsImplementsInterface(typeof(Map))))
{
MethodMetadataDesc metadata;
if (variableMetaData != null)
{
metadata = GetCheckMetadataVariable(
methodStreamSpec.MethodName, variableMetaData, variableReader, engineImportService,
typeof(Map));
}
else
{
metadata = GetCheckMetadataNonVariable(
methodStreamSpec.MethodName, methodStreamSpec.ClassName, engineImportService, typeof(Map));
}
mapTypeName = metadata.TypeName;
mapType = (IDictionary <string, object>)metadata.TypeMetadata;
}
// If the method returns an object[] or object[][], look up the type information
string oaTypeName = null;
if (methodReflection.ReturnType == typeof(object[]) ||
methodReflection.ReturnType == typeof(object[][]) ||
(isCollection && collectionClass == typeof(object[])) ||
(isIterator && iteratorClass == typeof(object[])))
{
MethodMetadataDesc metadata;
if (variableMetaData != null)
{
metadata = GetCheckMetadataVariable(
methodStreamSpec.MethodName, variableMetaData, variableReader, engineImportService,
typeof(IDictionary <string, object>));
}
else
{
metadata = GetCheckMetadataNonVariable(
methodStreamSpec.MethodName, methodStreamSpec.ClassName, engineImportService,
typeof(IDictionary <string, object>));
}
oaTypeName = metadata.TypeName;
oaType = (IDictionary <string, object>)metadata.TypeMetadata;
}
// Determine event type from class and method name
// If the method returns EventBean[], require the event type
if ((methodReflection.ReturnType.IsArray &&
methodReflection.ReturnType.GetElementType() == typeof(EventBean)) ||
(isCollection && collectionClass == typeof(EventBean)) ||
(isIterator && iteratorClass == typeof(EventBean)))
{
string typeName = methodStreamSpec.EventTypeName == null
? eventTypeNameProvidedUDFOrScript
: methodStreamSpec.EventTypeName;
eventType = EventTypeUtility.RequireEventType(
"Method", methodReflection.Name, eventAdapterService, typeName);
eventTypeWhenMethodReturnsEventBeans = eventType;
}
else if (mapType != null)
{
eventType = eventAdapterService.AddNestableMapType(
mapTypeName, mapType, null, false, true, true, false, false);
}
else if (oaType != null)
{
eventType = eventAdapterService.AddNestableObjectArrayType(
oaTypeName, oaType, null, false, true, true, false, false, false, null);
}
else
{
eventType = eventAdapterService.AddBeanType(beanClass.GetDefaultTypeName(), beanClass, false, true, true);
}
// the @type is only allowed in conjunction with EventBean return types
if (methodStreamSpec.EventTypeName != null && eventTypeWhenMethodReturnsEventBeans == null)
{
throw new ExprValidationException(EventTypeUtility.DisallowedAtTypeMessage());
}
}
else
{
string eventTypeName = methodStreamSpec.EventTypeName == null
? scriptExpression.EventTypeNameAnnotation
: methodStreamSpec.EventTypeName;
eventType = EventTypeUtility.RequireEventType(
"Script", scriptExpression.Script.Name, eventAdapterService, eventTypeName);
}
// get configuration for cache
string configName = methodProviderClass != null ? methodProviderClass.FullName : methodStreamSpec.MethodName;
ConfigurationMethodRef configCache = engineImportService.GetConfigurationMethodRef(configName);
if (configCache == null)
{
configCache = engineImportService.GetConfigurationMethodRef(configName);
}
ConfigurationDataCache dataCacheDesc = (configCache != null) ? configCache.DataCacheDesc : null;
DataCache dataCache = dataCacheFactory.GetDataCache(
dataCacheDesc, statementContext, epStatementAgentInstanceHandle, schedulingService, scheduleBucket,
streamNumber);
// metadata
var meta = new MethodPollingViewableMeta(
methodProviderClass, isStaticMethod, mapType, oaType, invocationTarget, strategy, isCollection,
isIterator, variableReader, variableName, eventTypeWhenMethodReturnsEventBeans, scriptExpression);
return(new MethodPollingViewable(methodStreamSpec, dataCache, eventType, exprEvaluatorContext, meta, statementContext.ThreadLocalManager));
}
/// <summary>
/// Configures a LRU cache of the given size for the method invocation.
/// </summary>
/// <param name="size">is the maximum number of entries before method invocation results are evicted</param>
public void SetLRUCache(int size)
{
DataCacheDesc = new ConfigurationLRUCache(size);
}
