// Creates call the the executed event
private void EmitOnMethodExecuted(ILGenerator emitIl, StackIndex index, CustomAttributeContainer[] attributes, CustomParameterInfo[] parameters)
{
var len = attributes.Length;
var paramCount = parameters.Length;
for (var i = 0; i < len; i++)
{
emitIl.Emit(OpCodes.Ldloc, i);
emitIl.Emit(OpCodes.Ldloc, index.Context);
emitIl.Emit(OpCodes.Ldc_I4, paramCount);
emitIl.Emit(OpCodes.Newarr, typeof(object));
emitIl.Emit(OpCodes.Stloc, index.Store);
for (var j = 0; j < paramCount; j++)
{
emitIl.Emit(OpCodes.Ldloc, index.Store);
emitIl.Emit(OpCodes.Ldc_I4, j);
emitIl.Emit(OpCodes.Ldarg, j + 1);
var parameterType = parameters[j].ParameterType;
if (parameterType.GetTypeInfo().IsValueType) //not reference
{
emitIl.Emit(OpCodes.Box, parameterType);
}
emitIl.Emit(OpCodes.Stelem_Ref);
}
emitIl.Emit(OpCodes.Ldloc, index.Store);
emitIl.EmitCall(OpCodes.Callvirt, typeof(BaseAspect).GetMethod("OnMethodExecuted"), new Type[] { typeof(object[]) });
}
}
// Creates call the the returning event
private void EmitOnMethodReturning(AspectAction action, ILGenerator emitIl, StackIndex index, Type returnType, CustomAttributeContainer[] attributes)
{
var len = attributes.Length;
var returnInfo = returnType.GetTypeInfo();
for (var i = 0; i < len; i++)
{
emitIl.Emit(OpCodes.Ldloc_S, i);
emitIl.Emit(OpCodes.Ldloc_S, index.Context);
emitIl.Emit(OpCodes.Ldloc_S, index.Output);
if (returnInfo.IsValueType)
{
emitIl.Emit(OpCodes.Box, returnType);
}
emitIl.EmitCall(OpCodes.Callvirt, typeof(BaseAspect).GetMethod(action.ToString()), new Type[] { typeof(AspectEventContext), returnType });
if (returnInfo.IsValueType)
{
emitIl.Emit(OpCodes.Unbox_Any, returnType);
}
emitIl.Emit(OpCodes.Stloc_S, index.Output);
emitIl.Emit(OpCodes.Nop);
}
}
// Creates block wrapping the setter execution
private void EmitOnPropertySetting(ILGenerator emitIl, Type baseType, Type propertyType, string propertyName, CustomAttributeContainer[] attributes, CustomParameterInfo[] parameters)
{
var index = new StackIndex();
EmitAspectObjects(emitIl, attributes);
EmitAspectSetterInterception(emitIl, index, baseType.GetMethod(propertyName), propertyName, new Type[] { propertyType }, attributes, parameters);
emitIl.Emit(OpCodes.Ret);
}
// Creates block wrapping the execution and return events
private void EmitOnMethodExecution(ILGenerator emitIl, Type baseType, MethodInfo method, CustomAttributeContainer[] attributes, CustomParameterInfo[] parameters)
{
var index = new StackIndex();
EmitAspectObjects(emitIl, attributes);
EmitAspectMethodInterception(emitIl, index, method, new Type[] { method.ReturnType }, attributes, parameters);
if (method.ReturnType != typeof(void))
{
EmitOnMethodReturning(AspectAction.OnMethodReturning, emitIl, index, method.ReturnType, attributes);
EmitOnMethodReturned(emitIl, index, method.ReturnType, attributes);
emitIl.Emit(OpCodes.Ldloc_S, index.Output);
}
emitIl.Emit(OpCodes.Ret);
}
// Creates block wrapping the getter execution
private void EmitOnPropertyGetting(ILGenerator emitIl, Type baseType, Type propertyType, string propertyName, CustomAttributeContainer[] attributes)
{
var index = new StackIndex();
EmitAspectObjects(emitIl, attributes);
index.Store = index.Output = emitIl.DeclareLocal(propertyType);
index.Context = emitIl.DeclareLocal(typeof(AspectEventContext));
EmitEventParameters(emitIl, propertyName, index.Context);
emitIl.Emit(OpCodes.Ldarg_0);
emitIl.EmitCall(OpCodes.Call, baseType.GetMethod(propertyName), null);
emitIl.Emit(OpCodes.Stloc_S, index.Store);
EmitOnMethodReturning(AspectAction.OnPropertyGetting, emitIl, index, propertyType, attributes);
emitIl.Emit(OpCodes.Ldloc_S, index.Output);
emitIl.Emit(OpCodes.Ret);
}
// Creates call the the returned event
private void EmitOnMethodReturned(ILGenerator emitIl, StackIndex index, Type returnType, CustomAttributeContainer[] attributes)
{
var len = attributes.Length;
var returnInfo = returnType.GetTypeInfo();
for (var i = 0; i < len; i++)
{
emitIl.Emit(OpCodes.Ldloc_S, i);
emitIl.Emit(OpCodes.Ldloc_S, index.Context);
emitIl.Emit(OpCodes.Ldloc_S, index.Output);
if (returnInfo.IsValueType) //not reference
{
emitIl.Emit(OpCodes.Box, returnType);
}
emitIl.EmitCall(OpCodes.Callvirt, typeof(BaseAspect).GetMethod("OnMethodReturned"), new Type[] { returnType });
emitIl.Emit(OpCodes.Nop);
}
}
[TestMethod] public void Test()
{
using (var l = new Lua())
{
var L = luanet.getstate(l);
GC.KeepAlive(L[1].DebuggerValue);
Assert.AreEqual(0, L.Length);
Assert.AreEqual(2, L.Count);
Assert.AreEqual(2, L.Sum(si => si.Type == LUA.T.NONE ? 0 : 1));
lua.createtable(L, 1, 0);
Assert.AreEqual(1, L.Length);
foreach (var x in L)
{
}
StackIndex i1 = L[1];
Assert.AreEqual(1, i1.Index);
Assert.AreEqual(0UL, i1.Length);
Assert.AreEqual(LUA.T.TABLE, i1.Type);
GC.KeepAlive(i1.Value);
lua.pushnumber(L, 12);
lua.rawseti(L, -2, 1);
StackIndexChild i11 = i1[1];
Assert.AreEqual(i1, i11.Parent);
Assert.AreEqual(LUA.T.NUMBER, i11.Type);
Assert.AreEqual(0UL, i11.Length);
GC.KeepAlive(i11.Value);
lua.settop(L, 0);
Assert.AreEqual(0, L.Length);
try { GC.KeepAlive(i11.Type); Assert.Fail(); } catch (LuaScriptException) {}
GC.KeepAlive(L[LUA.REGISTRYINDEX].Value);
Assert.AreEqual(0, L.Length);
}
}
public ExceptionlessElasticConfiguration(
AppOptions appOptions,
IQueue <WorkItemData> workItemQueue,
JsonSerializerSettings serializerSettings,
ICacheClient cacheClient,
IMessageBus messageBus,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory
) : base(workItemQueue, cacheClient, messageBus, loggerFactory)
{
_appOptions = appOptions;
_serializerSettings = serializerSettings;
_logger.LogInformation("All new indexes will be created with {ElasticsearchNumberOfShards} Shards and {ElasticsearchNumberOfReplicas} Replicas", _appOptions.ElasticsearchOptions.NumberOfShards, _appOptions.ElasticsearchOptions.NumberOfReplicas);
AddIndex(Stacks = new StackIndex(this));
AddIndex(Events = new EventIndex(this, serviceProvider, appOptions));
AddIndex(Migrations = new MigrationIndex(this, _appOptions.ElasticsearchOptions.ScopePrefix + "migrations", appOptions.ElasticsearchOptions.NumberOfReplicas));
AddIndex(Organizations = new OrganizationIndex(this));
AddIndex(Projects = new ProjectIndex(this));
AddIndex(Tokens = new TokenIndex(this));
AddIndex(Users = new UserIndex(this));
AddIndex(WebHooks = new WebHookIndex(this));
}
public StackRepository(IElasticClient elasticClient, StackIndex index, IEventRepository eventRepository, IValidator <Stack> validator = null, ICacheClient cacheClient = null, IMessagePublisher messagePublisher = null)
: base(elasticClient, index, validator, cacheClient, messagePublisher)
{
_eventRepository = eventRepository;
DocumentChanging.AddHandler(OnDocumentChangingAsync);
}
// Creates the "AND" condition test that all executing aspects must return true from for root property setter execution
private void EmitAspectSetterInterception(ILGenerator emitIl, StackIndex index, MethodInfo method, string methodName, Type[] types, CustomAttributeContainer[] attributes, CustomParameterInfo[] parameters)
{
var len = attributes.Length;
var setterType = parameters.First().ParameterType;
var setterInfo = setterType.GetTypeInfo();
var trueLabel = emitIl.DefineLabel();
var falseLabel = emitIl.DefineLabel();
var endLabel = emitIl.DefineLabel();
index.Context = emitIl.DeclareLocal(typeof(AspectEventContext));
index.Store = emitIl.DeclareLocal(typeof(bool));
EmitEventParameters(emitIl, methodName, index.Context);
for (var i = 0; i < len; i++)
{
emitIl.Emit(OpCodes.Ldloc, i);
emitIl.Emit(OpCodes.Ldloc, index.Context);
emitIl.Emit(OpCodes.Ldarg, 1);
if (setterInfo.IsValueType) //not reference
{
emitIl.Emit(OpCodes.Box, setterType);
}
emitIl.EmitCall(OpCodes.Callvirt, typeof(BaseAspect).GetMethod("OnPropertySetting"), new Type[] { typeof(AspectEventContext), typeof(object) });
if (len > 1)
{
if (i < len - 1)
{
emitIl.Emit(OpCodes.Brfalse, falseLabel);
}
else
{
emitIl.Emit(OpCodes.Ldc_I4_0);
emitIl.Emit(OpCodes.Ceq);
emitIl.Emit(OpCodes.Br, trueLabel);
}
}
else
{
emitIl.Emit(OpCodes.Ldc_I4_0);
emitIl.Emit(OpCodes.Ceq);
}
}
if (len > 1)
{
emitIl.MarkLabel(falseLabel);
emitIl.Emit(OpCodes.Ldc_I4_1);
emitIl.MarkLabel(trueLabel);
}
emitIl.Emit(OpCodes.Stloc, index.Store);
emitIl.Emit(OpCodes.Ldloc, index.Store);
emitIl.Emit(OpCodes.Brtrue, endLabel);
emitIl.Emit(OpCodes.Nop);
emitIl.Emit(OpCodes.Ldarg_0);
emitIl.Emit(OpCodes.Ldarg_1);
emitIl.EmitCall(OpCodes.Call, method, types);
emitIl.Emit(OpCodes.Nop);
emitIl.MarkLabel(endLabel);
}
// Creates the "AND" condition test that all executing aspects must return true from for root method execution
private void EmitAspectMethodInterception(ILGenerator emitIl, StackIndex index, MethodInfo method, Type[] types, CustomAttributeContainer[] attributes, CustomParameterInfo[] parameters)
{
var paramCount = parameters.Length;
var len = attributes.Length;
var isVoid = method.ReturnType == typeof(void);
var trueLabel = emitIl.DefineLabel();
var falseLabel = emitIl.DefineLabel();
var endLabel = emitIl.DefineLabel();
index.Context = emitIl.DeclareLocal(typeof(AspectEventContext));
index.Store = emitIl.DeclareLocal(typeof(object[]));
index.Bool = emitIl.DeclareLocal(typeof(bool));
if (!isVoid)
{
index.Output = emitIl.DeclareLocal(method.ReturnType);
}
EmitEventParameters(emitIl, method.Name, index.Context);
if (!isVoid)
{
if (method.ReturnType.GetTypeInfo().IsValueType)
{
emitIl.LoadForValueType(0);
}
else
{
emitIl.LoadForValueType(null);
}
emitIl.Emit(OpCodes.Stloc, index.Output);
}
for (var i = 0; i < len; i++)
{
emitIl.Emit(OpCodes.Ldloc, i);
emitIl.Emit(OpCodes.Ldloc, index.Context);
emitIl.Emit(OpCodes.Ldc_I4, paramCount);
emitIl.Emit(OpCodes.Newarr, typeof(object));
emitIl.Emit(OpCodes.Stloc, index.Store);
for (var j = 0; j < paramCount; j++)
{
emitIl.Emit(OpCodes.Ldloc, index.Store);
emitIl.Emit(OpCodes.Ldc_I4, j);
emitIl.Emit(OpCodes.Ldarg, j + 1);
var parameterType = parameters[j].ParameterType;
if (parameterType.GetTypeInfo().IsValueType) //not reference
{
emitIl.Emit(OpCodes.Box, parameterType);
}
emitIl.Emit(OpCodes.Stelem_Ref);
}
emitIl.Emit(OpCodes.Ldloc, index.Store);
emitIl.EmitCall(OpCodes.Callvirt, typeof(BaseAspect).GetMethod("OnMethodExecuting"), new Type[] { typeof(AspectEventContext), typeof(object[]) });
if (len > 1)
{
if (i < len - 1)
{
emitIl.Emit(OpCodes.Brfalse, falseLabel);
}
else
{
emitIl.Emit(OpCodes.Ldc_I4_0);
emitIl.Emit(OpCodes.Ceq);
emitIl.Emit(OpCodes.Br, trueLabel);
}
}
else
{
emitIl.Emit(OpCodes.Ldc_I4_0);
emitIl.Emit(OpCodes.Ceq);
}
}
if (len > 1)
{
emitIl.MarkLabel(falseLabel);
emitIl.Emit(OpCodes.Ldc_I4_1);
emitIl.MarkLabel(trueLabel);
}
emitIl.Emit(OpCodes.Stloc, index.Bool);
emitIl.Emit(OpCodes.Ldloc, index.Bool);
emitIl.Emit(OpCodes.Brtrue, endLabel);
emitIl.Emit(OpCodes.Nop);
emitIl.Emit(OpCodes.Ldarg_0);
for (var i = 1; i <= parameters.Length; i++)
{
emitIl.Emit(OpCodes.Ldarg_S, i);
}
emitIl.EmitCall(OpCodes.Call, method, types);
if (!isVoid)
{
emitIl.Emit(OpCodes.Stloc, index.Output);
}
EmitOnMethodExecuted(emitIl, index, attributes, parameters);
emitIl.Emit(OpCodes.Nop);
emitIl.MarkLabel(endLabel);
}
public StackRepository(ElasticRepositoryContext <Stack> context, StackIndex index, IEventRepository eventRepository, ILoggerFactory loggerFactory = null) : base(context, index, loggerFactory)
{
_eventRepository = eventRepository;
DocumentsChanging.AddHandler(OnDocumentChangingAsync);
}
