public void ModelGet_WithHandler_ModelGetFlagSet()
{
var handler = new DynamicHandler().ModelGet(r => { });
Assert.Equal(HandlerTypes.Get, handler.EnabledHandlers);
Assert.Equal(ResourceType.Model, handler.Type);
}
public static void Main(string[] args)
{
var executor = new BasicExecutor(TaskScheduler.Current);
var disruptor = new Disruptor <StubEvent>(() => new StubEvent(-1), 1024, TaskScheduler.Current);
var ringBuffer = disruptor.Start();
// Construct 2 batch event processors.
var handler1 = new DynamicHandler();
var processor1 = new BatchEventProcessor <StubEvent>(ringBuffer, ringBuffer.NewBarrier(), handler1);
var handler2 = new DynamicHandler();
var processor2 = new BatchEventProcessor <StubEvent>(ringBuffer, ringBuffer.NewBarrier(processor1.Sequence), handler2);
// Dynamically add both sequences to the ring buffer
ringBuffer.AddGatingSequences(processor1.Sequence, processor2.Sequence);
// Start the new batch processors.
executor.Execute(processor1.Run);
executor.Execute(processor2.Run);
// Remove a processor.
// Stop the processor
processor2.Halt();
// Wait for shutdown the complete
handler2.WaitShutdown();
// Remove the gating sequence from the ring buffer
ringBuffer.RemoveGatingSequence(processor2.Sequence);
}
public void ModelGet_WithAsyncHandler_ModelGetFlagSet()
{
var handler = new DynamicHandler().ModelGet(async r => await Task.Yield());
Assert.Equal(HandlerTypes.Get, handler.EnabledHandlers);
Assert.Equal(ResourceType.Model, handler.Type);
}
public void CollectionGet_WithHandler_CollectionGetFlagSet()
{
var handler = new DynamicHandler().CollectionGet(r => { });
Assert.Equal(HandlerTypes.Get, handler.EnabledHandlers);
Assert.Equal(ResourceType.Collection, handler.Type);
}
public static void Main(string[] args)
{
var disruptor = new Disruptor <DynamicEvent>(() => new DynamicEvent(), 1024, TaskScheduler.Current);
var ringBuffer = disruptor.Start();
// Construct 2 batch event processors.
var handler1 = new DynamicHandler();
var processor1 = EventProcessorFactory.Create(ringBuffer, ringBuffer.NewBarrier(), handler1);
var handler2 = new DynamicHandler();
var processor2 = EventProcessorFactory.Create(ringBuffer, ringBuffer.NewBarrier(processor1.Sequence), handler2);
// Dynamically add both sequences to the ring buffer
ringBuffer.AddGatingSequences(processor1.Sequence, processor2.Sequence);
// Start the new batch processors.
var t1 = processor1.Start();
var t2 = processor2.Start();
Thread.Sleep(5000);
// Remove a processor.
// Stop the processor
processor2.Halt();
// Wait for shutdown the complete
handler2.WaitShutdown(); // Or simply t2.Wait()
// Remove the gating sequence from the ring buffer
ringBuffer.RemoveGatingSequence(processor2.Sequence);
}
public async Task AuthMethod_WithAsyncHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().AuthMethod("foo", async r => await Task.Run(() => called++));
await handler.Handle(new MockRequest { Type = RequestType.Auth, Method = "foo" });
Assert.Equal(1, called);
}
public async Task CallMethod_WithNewMethodHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().CallMethod("new", r => called++);
await handler.Handle(new MockRequest { Type = RequestType.Call, Method = "new" });
Assert.Equal(1, called);
}
public async Task Access_WithHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().Access(r => called++);
await handler.Handle(new MockRequest { Type = RequestType.Access });
Assert.Equal(1, called);
}
public async Task Get_WithAsyncHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().Get(async r => await Task.Run(() => called++));
await handler.Handle(new MockRequest { Type = RequestType.Get });
Assert.Equal(1, called);
}
public void EnabledHandlers_WithMultipleHandlers_FlagsAreSet()
{
var handler = new DynamicHandler()
.Access(r => { })
.Get(r => { });
Assert.Equal(HandlerTypes.Access | HandlerTypes.Get, handler.EnabledHandlers);
}
public async Task ApplyCustom_WithAsyncHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().ApplyCustom(async(r, ev) => await Task.Run(() => called++));
await handler.Apply(null, new CustomEventArgs("foo", null));
Assert.Equal(1, called);
}
public async Task ApplyCreate_WithHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().ApplyCreate((r, ev) => called++);
await handler.Apply(null, new CreateEventArgs(null));
Assert.Equal(1, called);
}
public async Task ApplyDelete_WithAsyncHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().ApplyDelete(async(r, ev) => await Task.Run(() => called++));
await handler.Apply(null, new DeleteEventArgs());
Assert.Equal(1, called);
}
public async Task New_CallHandlerWithoutNewHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().Call(r => called++);
await handler.Handle(new MockRequest { Type = RequestType.Call, Method = "new" });
Assert.Equal(1, called);
}
public async Task New_WithAsyncHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().New(async r => await Task.Run(() => called++));
await handler.Handle(new MockRequest { Type = RequestType.Call, Method = "new" });
Assert.Equal(1, called);
}
public async Task ModelGet_WithHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().ModelGet(r => called++);
await handler.Handle(new MockRequest { Type = RequestType.Get });
Assert.Equal(1, called);
}
public async Task Auth_WithHandler_IsCalled()
{
int called = 0;
var handler = new DynamicHandler().Auth(r => called++);
await handler.Handle(new MockRequest { Type = RequestType.Auth, Method = "foo" });
Assert.Equal(1, called);
}
public async Task AuthMethod_MethodWithoutHandler_CallsMethodNotFound()
{
int called = 0;
var handler = new DynamicHandler().AuthMethod("foo", r => called++);
var mock = new MockRequest {
Type = RequestType.Auth, Method = "bar"
};
await handler.Handle(mock);
Assert.Equal(0, called);
Assert.Single(mock.Calls);
Assert.Equal("MethodNotFound", mock.Calls[0].Method);
}
public async Task CallMethod_WithoutMethodWithCallHandler_CallHandlerIsCalled()
{
int methodCalled = 0;
int callCalled = 0;
var handler = new DynamicHandler()
.CallMethod("bar", r => methodCalled++)
.Call(r => callCalled++);
var mock = new MockRequest {
Type = RequestType.Call, Method = "foo"
};
await handler.Handle(mock);
Assert.Equal(0, methodCalled);
Assert.Equal(1, callCalled);
}
public void RemoveWorkHandlerLostEventExample()
{
int eventSize = 8;
var countdownEvent = new CountdownEvent(eventSize);
var workSequence = new Sequence();
var disruptor = new Disruptor <StubEvent>(StubEvent.EventFactory, 4);
var ringBuffer = disruptor.Start();
var handler1 = new DynamicHandler(1, countdownEvent);
var processor1 = new WorkProcessor <StubEvent>(ringBuffer, ringBuffer.NewBarrier(), handler1, new FatalExceptionHandler(), workSequence);
var handler2 = new DynamicHandler(2, countdownEvent);
var processor2 = new WorkProcessor <StubEvent>(ringBuffer, ringBuffer.NewBarrier(), handler2, new FatalExceptionHandler(), workSequence);
ringBuffer.AddGatingSequences(processor1.Sequence);
Task.Run(() => processor1.Run());
ringBuffer.AddGatingSequences(processor2.Sequence);
Task.Run(() => processor2.Run());
handler1.AwaitStart();
handler2.AwaitStart();
Thread.Sleep(10);
// processor1 should own an unavailable work sequence
// => this sequence will be dropped by Halt
processor1.Halt();
var producer = new MessageProducer(disruptor, InitData(0, eventSize));
Task.Run(() => producer.Run());
producer.AwaitStart();
handler1.AwaitShutdown();
ringBuffer.RemoveGatingSequence(processor1.Sequence);
// countdownEvent should not reach zero because of the dropped sequence
var await = countdownEvent.Wait(TimeSpan.FromMilliseconds(500));
Assert.IsFalse(await);
}
public void RemoveWorkHandlerLaterTest()
{
var eventSize = 8;
var countdownEvent = new CountdownEvent(eventSize);
var workSequence = new Sequence();
var disruptor = new Disruptor <StubEvent>(StubEvent.EventFactory, 4);
var ringBuffer = disruptor.Start();
var handler1 = new DynamicHandler(1, countdownEvent);
var processor1 = new WorkProcessor <StubEvent>(ringBuffer, ringBuffer.NewBarrier(), handler1, new FatalExceptionHandler(), workSequence);
var handler2 = new DynamicHandler(2, countdownEvent);
var processor2 = new WorkProcessor <StubEvent>(ringBuffer, ringBuffer.NewBarrier(), handler2, new FatalExceptionHandler(), workSequence);
ringBuffer.AddGatingSequences(processor1.Sequence);
Task.Run(() => processor1.Run());
ringBuffer.AddGatingSequences(processor2.Sequence);
Task.Run(() => processor2.Run());
handler1.AwaitStart();
handler2.AwaitStart();
Thread.Sleep(10);
// processor1 should own an unavailable work sequence
// => this sequence should not be dropped by HaltLater
processor1.HaltLater();
var producer = new MessageProducer(disruptor, InitData(0, eventSize));
Task.Run(() => producer.Run());
producer.AwaitStart();
handler1.AwaitShutdown();
ringBuffer.RemoveGatingSequence(processor1.Sequence);
Assert.IsTrue(countdownEvent.Wait(TimeSpan.FromSeconds(3)));
}
public void Access_WithHandler_AccessFlagSet()
{
var handler = new DynamicHandler().Access(r => { });
Assert.Equal(HandlerTypes.Access, handler.EnabledHandlers);
}
public MoviesController(DynamicHandler handler, MovieStoreDbContext db, IMovieFilter filter)
{
_handler = handler;
_db = db;
_filter = filter;
}
public void RemoveEventListener <T>(string name, DynamicHandler <T> handler) where T : Event_
{
_RemoveEventListener(name, handler);
}
public EventListener AddEventListener <T>(string name, DynamicHandler <T> handler) where T : Event_
{
return(_AddEventListener(name, handler));
}
private DynamicHandler GetMethodInvoker(MethodInfo methodInfo)
{
DynamicMethod dynamicMethod = new DynamicMethod(string.Empty,
typeof(object), new Type[] { typeof(object),
typeof(object[]) },
methodInfo.DeclaringType.Module);
ILGenerator il = dynamicMethod.GetILGenerator();
ParameterInfo[] ps = methodInfo.GetParameters();
Type[] paramTypes = new Type[ps.Length];
for (int i = 0; i < paramTypes.Length; i++)
{
if (ps[i].ParameterType.IsByRef)
{
paramTypes[i] = ps[i].ParameterType.GetElementType();
}
else
{
paramTypes[i] = ps[i].ParameterType;
}
}
LocalBuilder[] locals = new LocalBuilder[paramTypes.Length];
for (int i = 0; i < paramTypes.Length; i++)
{
locals[i] = il.DeclareLocal(paramTypes[i], true);
}
for (int i = 0; i < paramTypes.Length; i++)
{
il.Emit(OpCodes.Ldarg_1);
EmitFastInt(il, i);
il.Emit(OpCodes.Ldelem_Ref);
EmitCastToReference(il, paramTypes[i]);
il.Emit(OpCodes.Stloc, locals[i]);
}
if (!methodInfo.IsStatic)
{
il.Emit(OpCodes.Ldarg_0);
}
for (int i = 0; i < paramTypes.Length; i++)
{
if (ps[i].ParameterType.IsByRef)
{
il.Emit(OpCodes.Ldloca_S, locals[i]);
}
else
{
il.Emit(OpCodes.Ldloc, locals[i]);
}
}
if (methodInfo.IsStatic)
{
il.EmitCall(OpCodes.Call, methodInfo, null);
}
else
{
il.EmitCall(OpCodes.Callvirt, methodInfo, null);
}
if (methodInfo.ReturnType == typeof(void))
{
il.Emit(OpCodes.Ldnull);
}
else
{
EmitBoxIfNeeded(il, methodInfo.ReturnType);
}
for (int i = 0; i < paramTypes.Length; i++)
{
if (ps[i].ParameterType.IsByRef)
{
il.Emit(OpCodes.Ldarg_1);
EmitFastInt(il, i);
il.Emit(OpCodes.Ldloc, locals[i]);
if (locals[i].LocalType.IsValueType)
{
il.Emit(OpCodes.Box, locals[i].LocalType);
}
il.Emit(OpCodes.Stelem_Ref);
}
}
il.Emit(OpCodes.Ret);
DynamicHandler invoder = (DynamicHandler)
dynamicMethod.CreateDelegate(typeof(DynamicHandler));
return(invoder);
}
/// <summary>
/// 初始实例
/// </summary>
/// <param name="method"></param>
public DynamicInvoke(MethodInfo method)
{
handler = GetMethodInvoker(method);
MethodInfo = method;
Parameters = method.GetParameters();
}
public void SetType_WithModel_TypeIsSet()
{
var handler = new DynamicHandler().SetType(ResourceType.Model);
Assert.Equal(ResourceType.Model, handler.Type);
}
public ImpostorPlugin(HtmlGenerator generator, HttpServer server)
{
server.AddHandler(new DynamicHandler("/shame",
() => ("text/html", Encoding.UTF8.GetBytes(generator.Generate()))));
}
public void ProcessRequest(HttpContext context)
{
DynamicHandler.ProcessRequest(context);
}