public PipelineFunctionFactory(HandlerInfo handlerInfo)
{
_handlerInfo = handlerInfo;
_handlerType = handlerInfo.HandlerType;
_context = Expression.Parameter(typeof (IContext));
_scopedHandler = Expression.Variable(typeof (IScopedHandler));
_handler = Expression.Variable(_handlerType);
}
public SimpleAsyncHandlerResult(IContext context, HandlerInfo handlerInfo, AsyncCallback callback, object asyncState)
{
_context = context;
_handlerInfo = handlerInfo;
_callback = callback;
AsyncState = asyncState;
_helper = new ErrorHelper(context);
}
private static IHttpHandler CreateHandler(IContext context, HandlerInfo handlerInfo)
{
IHttpHandler instance;
if (handlerInfo.IsAsync)
{
instance = CreateAsyncHttpHandler(context, handlerInfo);
}
else
{
instance = CreateHttpHandler(context, handlerInfo);
}
return instance;
}
protected void WriteBase(HandlerInfo info, XmlWriter writer)
{
writer.WriteAttributeString("name", info.Name);
foreach (var obj in info.Objects.Values)
{
if (!_objectWriters.ContainsKey(obj.GetType()))
throw new Exception("No writer found for handler object: " + obj.GetType().Name);
var objWriter = _objectWriters[obj.GetType()];
objWriter.Write(obj, writer);
}
}
private void DoUnregisterEvents(object eventSender)
{
if (eventHandlerDictionary.ContainsKey(eventSender))
{
for (int i = eventHandlerDictionary[eventSender].Count - 1; i >= 0; --i)
{
HandlerInfo handlerInfo = eventHandlerDictionary[eventSender][i];
handlerInfo.EventInfo.RemoveEventHandler(handlerInfo.EventSender, handlerInfo.Handler);
}
}
else
{
System.Diagnostics.Debug.Print("Event source '{0}' not registered.", eventSender);
}
}
private static IHttpHandler CreateHttpHandler(IContext context, HandlerInfo handlerInfo)
{
IHttpHandler instance;
if (handlerInfo.RequiresAuthentication)
{
var authenticationProvider = SimpleWeb.Configuration.Container.Get<IAuthenticationProvider>() ??
new DefaultAuthenticationProvider();
instance = new SimpleHttpHandler(context, handlerInfo);
}
else
{
instance = new SimpleHttpHandler(context, handlerInfo);
}
return instance;
}
private static object Invoke(object[] args, HandlerInfo info)
{
// Use reflection invoke instead of delegate because we have optional parameters
if (info.Instance != null)
{
// Instance function
return(info.Method.Invoke(info.Instance,
BindingFlags.OptionalParamBinding | BindingFlags.InvokeMethod | BindingFlags.CreateInstance, null, args, null));
}
else
{
// Static function
return(info.Method.Invoke(null, BindingFlags.OptionalParamBinding | BindingFlags.InvokeMethod, null, args, null));
}
}
private void DoRegisterEvent(object eventSender, EventInfo eventInfo)
{
string eventName = eventInfo.Name;
Delegate handler = new EventHandler <EventArgs>((s, e) => LogRaisedEvent(s, e, eventName));
Delegate eventHandler = Delegate.CreateDelegate(eventInfo.EventHandlerType, handler.Target, handler.Method);
eventInfo.AddEventHandler(eventSender, eventHandler);
if (!eventHandlerDictionary.ContainsKey(eventSender))
{
eventHandlerDictionary.Add(eventSender, new List <HandlerInfo>());
}
eventHandlerDictionary[eventSender].Add(HandlerInfo.Create(eventSender, eventInfo, eventHandler));
}
protected void WriteBase(HandlerInfo info, XmlWriter writer)
{
writer.WriteAttributeString("name", info.Name);
foreach (var obj in info.Objects.Values)
{
if (!_objectWriters.ContainsKey(obj.GetType()))
{
throw new Exception("No writer found for handler object: " + obj.GetType().Name);
}
var objWriter = _objectWriters[obj.GetType()];
objWriter.Write(obj, writer);
}
}
public Task Run(IContext context)
{
Startup();
IDictionary<string, string> variables;
var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, context.Request.ContentType, context.Request.AcceptTypes, out variables);
if (handlerType == null) return null;
var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod);
foreach (var key in context.Request.QueryString.Select(g => g.Key))
{
handlerInfo.Variables.Add(key, context.Request.QueryString[key].FirstOrDefault());
}
if (handlerInfo.IsAsync)
{
var handler = HandlerFactory.Instance.GetHandler(handlerInfo);
if (handler != null)
{
var runner = HandlerRunnerFactory.Instance.GetAsync(handlerInfo.HandlerType, context.Request.HttpMethod);
return runner.Start(handler.Handler, context).ContinueWith(t => RunContinuation(t, handler, context, runner));
}
throw new InvalidOperationException("Could not create handler.");
}
else
{
var tcs = new TaskCompletionSource<object>();
try
{
using (var handler = HandlerFactory.Instance.GetHandler(handlerInfo))
{
if (handler == null)
{
throw new InvalidOperationException("Could not create handler.");
}
var run = HandlerRunnerFactory.Instance.Get(handler.Handler.GetType(),
context.Request.HttpMethod);
run(handler.Handler, context);
}
tcs.SetResult(null);
}
catch (Exception ex)
{
tcs.SetException(ex);
}
return tcs.Task;
}
}
public ControllerAction(HandlerInfo handler, string name,
string responseType,
HttpVerb verb,
bool isResponseCollection,
string route,
params Argument[] requestArguments) : this(name,
requestArguments,
responseType,
verb,
isResponseCollection,
route,
handler.HandlerIType,
handler.RequestType,
handler.ResponseType)
{
}
public HandlerInfoViewModel(HandlerInfo handlerInfo)
{
_handlerInfo = handlerInfo;
Name = String.Format("{0}/{1}/{2}", _handlerInfo.PackageName, _handlerInfo.HandlerName, _handlerInfo.JobName);
StartCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Start, _handlerInfo.Id))
, o => HandlerState == HandlerState.Stopped || HandlerState == HandlerState.Paused || HandlerState == HandlerState.Idle);
StopCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Stop, _handlerInfo.Id))
, o => HandlerState == HandlerState.Running);
PauseCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Pause, _handlerInfo.Id))
, o => HandlerState == HandlerState.Running);
DisableCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Disable, _handlerInfo.Id))
, o => HandlerState != HandlerState.Disabled);
EnableCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Enable, _handlerInfo.Id))
, o => HandlerState == HandlerState.Disabled);
DeleteCommand = new RelayCommand(param => OnHandlerEvent(new HandlerEventArgs(HandlerEventType.Delete, _handlerInfo.Id)));
}
/// <summary>
/// InsertInfo
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public long InsertInfo(HandlerInfo info)
{
int cnt = dal.GetCounts("[AJAX_METHOD_NAME] = N'" + info.AjaxMethodName + "'");
if (cnt > 0)
{
throw new Exception("MC:1x00000024");///客户端函数名不允许重复
}
cnt = dal.GetCounts("[SERVER_METHOD_NAME] = N'" + info.ServerMethodName + "'");
if (cnt > 0)
{
throw new Exception("MC:1x00000023");///服务端函数名不允许重复
}
///TODO:考虑增加启用
return(dal.Add(info));
}
protected static void LoadHandlerBase(HandlerInfo handler, XElement node, string basePath)
{
handler.Name = node.RequireAttribute("name").Value;
foreach (var spriteNode in node.Elements("Sprite"))
{
var info = new HandlerSpriteInfo();
info.Sprite = LoadSprite(spriteNode, basePath);
handler.Objects.Add(info.Name, info);
}
foreach (var meterNode in node.Elements("Meter"))
{
var meter = LoadMeter(meterNode, basePath);
handler.Objects.Add(meter.Name, meter);
}
}
public void OnRemoteInvoked(HandlerInfo handlerInfo, object[] args)
{
var entry = new QueueEntry
{
HandlerInfo = handlerInfo,
InvocationArguments = args,
};
if (handlerInfo.Mode == EventQueueMode.Synchronous)
{
TriggerEvent(entry);
}
else
{
_queue.Add(entry);
}
}
private async Task Save(MessageContext messageContext, HandlerInfo handler, object[] parameters)
{
foreach (var p in parameters)
{
switch (p)
{
case IAggregate a:
var repository = serviceProvider.GetRequiredService <IRepository>();
await repository.Save(messageContext, a);
break;
default:
break;
}
}
}
void RemoveDuplicatesBasedOnQueueMode(HandlerInfo handlerInfo, List <QueueEntry> queue)
{
switch (handlerInfo.Mode)
{
case EventQueueMode.Synchronous:
{
// Should not have been queued in the first place
Assert.IsEqual(queue.Where(x => x.HandlerInfo == handlerInfo).Count(), 0);
break;
}
case EventQueueMode.All:
{
// Do nothing, trigger all events
break;
}
case EventQueueMode.LatestOnly:
{
// Remove all but the last one
foreach (var item in queue.Where(x => x.HandlerInfo == handlerInfo).Reverse().Skip(1).ToList())
{
queue.Remove(item);
}
break;
}
case EventQueueMode.FirstOnly:
{
// Remove all but the first one
foreach (var item in queue.Where(x => x.HandlerInfo == handlerInfo).Skip(1).ToList())
{
queue.Remove(item);
}
break;
}
default:
{
Assert.That(false);
break;
}
}
}
public void Generate_calls_generator_for_IHandler_with_correct_parameters()
{
// arrange
var methodInfo = GetMethodInfo(nameof(ValidMethodForHandler));
var expectedHandlerInfo = new HandlerInfo(null, null);
A.CallTo(() => _handlerStore.Find(typeof(string), typeof(IServerStreamHandler <int, string>), nameof(ValidMethodForHandler)))
.Returns(expectedHandlerInfo);
// act
var result = _generator.Generate(typeof(string), methodInfo);
// assert
A.CallTo(() => _methodCodeGen.GenerateMethod(Code.MethodServerStreamHandlerCode, nameof(ValidMethodForHandler), typeof(int), typeof(string), expectedHandlerInfo))
.MustHaveHappenedOnceExactly();
}
public void Add_finds_multiple_implementations_using_attribute_on_method()
{
// arrange
_builder.Add(typeof(MultipleWithAttributesHandler), null, null);
// expected
var expected1 = new HandlerInfo(typeof(MultipleWithAttributesHandler), null);
var expected2 = new HandlerInfo(typeof(MultipleWithAttributesHandler), null);
// act trying to find by default name
var result1 = _builder.Find(typeof(string), typeof(IHandler <string, int>), "OneMethod");
var result2 = _builder.Find(typeof(int), typeof(IHandler <int, string>), "TwoMethod");
// assert
result1.Should().BeEquivalentTo(expected1);
result2.Should().BeEquivalentTo(expected2);
}
public void RegisterHandlers()
{
var methods = typeof(Test).GetMethods();
var info1 = new HandlerInfo(methods[0]);
var info2 = new HandlerInfo(methods[1]);
var registry = new HandlerRegistry();
registry.Register(typeof(string), info1);
registry.Register(typeof(int), info2);
var handlers1 = registry.GetHandlers(typeof(string));
Assert.AreEqual(1, handlers1.Count());
Assert.AreEqual(info1, handlers1.First());
var handlers2 = registry.GetHandlers(typeof(int));
Assert.AreEqual(1, handlers2.Count());
Assert.AreEqual(info2, handlers2.First());
}
private void RegisterMethod(string className, string prefix, MethodInfo m, object instance = null)
{
var name = prefix + m.Name;
if (_handlers.TryGetValue(name, out var existing))
{
throw new JsonRpcException($"The method '{name}' is already handled by the class {existing.Instance.GetType().Name}");
}
var info = new HandlerInfo {
Instance = instance,
Method = m,
Parameters = m.GetParameters()
};
_handlers.TryAdd(name, info);
Debug.WriteLine($"Added handler for '{name}' on {className}.{m.Name}");
}
/// <summary>
/// Subscribes an instance to events.
/// </summary>
/// <param name="instance">The instance to subscribe for event publication.</param>
public virtual bool Subscribe(object instance)
{
Should.NotBeNull(instance, "instance");
var handlerInfo = HandlerInfo.GetOrCreate(instance);
if (handlerInfo.IsEmpty)
{
return(false);
}
lock (_handlerReferences)
{
if (!Contains(instance, false))
{
_handlerReferences.Add(ServiceProvider.WeakReferenceFactory(handlerInfo, true));
}
}
return(true);
}
/// <summary>
/// Notifies listener about an event.
/// </summary>
/// <param name="target">The specified listener to notify.</param>
/// <param name="sender">The object that raised the event.</param>
/// <param name="message">The message instance.</param>
public static void Publish([NotNull] object target, [NotNull] object sender, [NotNull] object message)
{
Should.NotBeNull(target, "target");
Should.NotBeNull(sender, "sender");
Should.NotBeNull(message, "message");
var handlerInfo = HandlerInfo.GetOrCreate(target);
if (!handlerInfo.IsEmpty)
{
handlerInfo.Handle(sender, message, message is ITracebleMessage);
}
var customAction = PublishCustomAction;
if (customAction != null)
{
customAction(target, sender, message);
}
}
public void UnRegisteEvent(EVENT_TYPE eventType, EventDelegate handler)
{
if (_HandleList.ContainsKey(eventType))
{
HandlerInfo handleInfo = null;
foreach (var handle in _HandleList[eventType])
{
if (handler == handle._EventDelegate)
{
handleInfo = handle;
}
}
_HandleList[eventType].Remove(handleInfo);
if (_HandleList[eventType].Count == 0)
{
_HandleList.Remove(eventType);
}
}
}
bool checkHandlerV41(HandlerInfo info, out Data41 data41)
{
data41 = new Data41();
data41.resolveHandler2 = info.handler;
data41.resourceField = getLdtokenField(info.handler);
if (data41.resourceField == null)
{
return(false);
}
bool isOtherRetail;
int magicArgIndex = getMagicArgIndex41Retail(info.handler, out isOtherRetail);
if (magicArgIndex < 0)
{
magicArgIndex = getMagicArgIndex41Trial(info.handler);
data41.isTrial = true;
}
var asmVer = module.Assembly.Version;
if (magicArgIndex < 0 || magicArgIndex >= info.args.Count)
{
return(false);
}
var val = info.args[magicArgIndex];
if (!(val is int))
{
return(false);
}
if (data41.isTrial)
{
data41.magic = (int)val >> 3;
}
else if (isOtherRetail)
{
data41.magic = data41.resourceField.InitialValue.Length - (int)val;
}
else
{
data41.magic = ((asmVer.Major << 3) | (asmVer.Minor << 2) | asmVer.Revision) - (int)val;
}
return(true);
}
private void GenerateReadAction(ControllerSourceUnit srcUnit, HandlerInfo handler, CqrsControllerBuilder builder)
{
if (handler.RequestType.GetProperties().Any(x => x.Name == "Id" || x.Name == $"{handler.Service.Name}Id"))
{
// this seems to be a query for one record
if (!handler.IsResponseCollection)
{
}
else
{
// this is query for many records
}
}
else
{
// this seems to be a query for many records.
if (!handler.IsResponseCollection)
{
}
else
{
ArgumentCollection arguments = new ArgumentCollection();
var queryArg = arguments.Add(handler.RequestType.Name.EndsWithSingleSuffix("Request", "Query"), "request", "FromQuery");
// this is query for many records
var responseType = handler.ResponseType.Name.EndsWithSingleSuffix("Response", "Result");
builder.AppendAction(handler, "Get", responseType,
HttpVerb.Get, handler.IsResponseCollection, $"api/{handler.Service.Name}",
arguments.ToArray());
srcUnit.Responses.Append(GenerateResponseType(responseType, handler.ResponseType));
srcUnit.ResultToResponseMappers.Append(GenerateResultToResponseMapper(responseType, handler.ResponseType));
srcUnit.Requests.Append(GenerateRequestType(queryArg.Type, handler.RequestType));
srcUnit.RequestToCommandMappers.Append(GenerateRequestToCommandMapper(queryArg.Type, handler.RequestType));
builder.AddUsing(handler.ResponseType.Namespace + ".WebApi");
builder.AddUsing(handler.RequestType.Namespace + ".WebApi");
builder.AddUsing(handler.ResponseType.Namespace);
builder.AddUsing(handler.RequestType.Namespace);
}
}
}
public static IHttpHandler TryCreate(IContext context)
{
// If it's OPTIONS, we can handle that without any help.
if (context.Request.HttpMethod.Equals("OPTIONS", StringComparison.OrdinalIgnoreCase))
{
return CreateOptionsHandler(context);
}
IDictionary<string, string> variables;
var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, context.Request.ContentType, context.Request.AcceptTypes, out variables);
if (handlerType == null) return null;
var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod);
foreach (var key in context.Request.QueryString.Select(g => g.Key))
{
handlerInfo.Variables.Add(key, context.Request.QueryString[key].FirstOrDefault());
}
return CreateHandler(context, handlerInfo);
}
public void RemoveInputHandler(KInputHandler handler)
{
if (mChildren != null)
{
int num = 0;
while (true)
{
if (num >= mChildren.Count)
{
return;
}
HandlerInfo handlerInfo = mChildren[num];
if (handlerInfo.handler == handler)
{
break;
}
num++;
}
mChildren.RemoveAt(num);
}
}
protected void LoadBase(HandlerInfo handler, XElement node, string basePath)
{
handler.Name = node.RequireAttribute("name").Value;
var spriteLoader = new SpriteXmlReader();
foreach (var spriteNode in node.Elements("Sprite"))
{
var info = new HandlerSpriteInfo();
info.Sprite = spriteLoader.LoadSprite(spriteNode, basePath);
handler.Objects.Add(info.Name, info);
}
var meterLoader = new MeterXmlReader(new SceneBindingXmlReader());
foreach (var meterNode in node.Elements("Meter"))
{
var meter = meterLoader.LoadMeter(meterNode, basePath);
handler.Objects.Add(meter.Name, meter);
}
}
private void okButton_Click(object sender, EventArgs e)
{
// init things
_hi = null;
Guid id = Guid.Empty;
string location = Path.GetDirectoryName(handlerModuleTextBox.Text);
string module = Path.GetFileName(handlerModuleTextBox.Text);
string paramts = handlerParametersTextBox.Text;
// special handling for python modules.
if (0 == string.Compare(Path.GetExtension(handlerModuleTextBox.Text), ".py", true))
{
location = "";
module = "Najm.Handler.IPython.dll";
paramts = handlerModuleTextBox.Text;
}
// try to load handler assembly and get its id
try
{
HandlerAssembly ha = new HandlerAssembly();
ha.Load(location, module, paramts);
id = ha.Handler.ID;
ha.Unload();
}
catch (Exception ex)
{
string msg = ex.Message + ((ex.InnerException != null && string.IsNullOrEmpty(ex.InnerException.Message)) ? "" : "\n" + ex.InnerException.Message);
MessageBox.Show(msg);
}
finally
{
if (!id.Equals(Guid.Empty))
{
// create handler info
_hi = new HandlerInfo(id, location, module, paramts, true);
}
}
}
/// <summary>
/// T型のメッセージを処理するハンドラを追加します。
/// </summary>
public void AddCommandHandler <TCmd>(PbCommandHandler <TCmd> handler,
bool isOutLog = true)
{
if (handler == null)
{
return;
}
lock (this.handlerDic)
{
var handlerInfo = new HandlerInfo()
{
Type = typeof(TCmd),
ResponseType = null,
Handler = (_ =>
HandleCommandInternal(handler, _)),
IsOutLog = isOutLog,
};
this.handlerDic.Add(typeof(TCmd), handlerInfo);
}
}
private static HandlerInfo CreateDefaultHandler()
{
var info = new HandlerInfo
{
Namespace = "HelloWorld",
Function = "Execute",
Entrypoint = "HelloWorld.Main",
Code = @"
namespace HelloWorld
{
public class Main
{
public static string Execute()
{
return ""Hello, World!"";
}
}
}"
};
return(info);
}
internal static Task Run(IContext context)
{
Startup();
if (TryHandleAsStaticContent(context))
{
return MakeCompletedTask();
}
IDictionary<string, string[]> variables;
var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, context.Request.GetContentType(), context.Request.GetAccept(), out variables);
if (handlerType == null) return null;
var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod);
foreach (var key in context.Request.QueryString.Keys)
{
handlerInfo.Variables.Add(key, context.Request.QueryString[key]);
}
var task = PipelineFunctionFactory.Get(handlerInfo)(context);
return task ?? MakeCompletedTask();
}
/// <summary>
/// T型のリクエストを処理するハンドラを追加します。
/// </summary>
public void AddRequestHandler <TReq, TRes>(PbRequestHandler <TReq, TRes>
handler,
bool isOutLog = true)
where TRes : class
{
if (handler == null)
{
return;
}
lock (this.handlerDic)
{
var handlerInfo = new HandlerInfo()
{
Type = typeof(TReq),
ResponseType = typeof(TRes),
Handler = (requestObj) =>
HandleRequestInternal(handler, requestObj),
IsOutLog = isOutLog,
};
this.handlerDic.Add(typeof(TReq), handlerInfo);
}
}
public void HandleKeyUp(KButtonEvent e)
{
lastConsumedEventUp = null;
foreach (Action <KButtonEvent> mOnKeyUpDelegate in mOnKeyUpDelegates)
{
mOnKeyUpDelegate(e);
if (e.Consumed)
{
lastConsumedEventUp = e;
}
}
if (!e.Consumed && mChildren != null)
{
foreach (HandlerInfo mChild in mChildren)
{
HandlerInfo current2 = mChild;
current2.handler.HandleKeyUp(e);
if (e.Consumed)
{
break;
}
}
}
}
public HandlerInfo GetInfo()
{
var info = new HandlerInfo();
if (_handlerProxy != null)
{
// Additional statistics about the running part of the handler
var stats = _handlerProxy.GetInfo();
info.JobsAvailable = stats.JobsAvailable;
info.JobsPending = stats.JobsPending;
info.TotalJobsAvailable = stats.TotalJobsAvailable;
info.TotalJobsFailed = stats.TotalJobsFailed;
info.TotalJobsProcessed = stats.TotalJobsProcessed;
}
// General information about the handler
info.Id = Id;
info.PackageName = JobScript.PackageName;
info.HandlerName = HandlerSettings.HandlerName;
info.JobName = HandlerSettings.JobName;
info.HandlerState = _handlerState;
info.LastStartTime = _lastStartTime;
info.NextStartTime = NextStartTime;
return(info);
}
public void AppendAction(HandlerInfo handler,
string name,
string responseType,
HttpVerb verb,
bool isResponseCollection,
string route,
params Argument[] requestArguments)
{
if (_actions.Any(x => x.Route == route && x.Verb == verb))
{
throw new ArgumentException("Route");
}
if (string.IsNullOrWhiteSpace(name))
{
name = verb.ToString();
}
if (string.IsNullOrWhiteSpace(responseType))
{
throw new ArgumentNullException("responseType");
}
// TODO: add validation and UT
_actions.Add(new ControllerAction(handler, name, responseType, verb, isResponseCollection, route, requestArguments));
}
internal SimpleHttpHandler(IContext context, HandlerInfo handlerInfo)
{
_context = context;
_handlerInfo = handlerInfo;
}
public RPCStorageFile(string Name) : base(Name) {
Info = new RPCStorageInfo();
Cache = DefaultStorageCache;
}
static HandlerInfo()
{
TypeHandlers = new Dictionary <Type, Dictionary <Type, Func <object, object[], object> > >();
EmptyHandler = new HandlerInfo();
CreateDelegate = Create;
}
private static IHttpHandler CreateAsyncHttpHandler(IContext context, HandlerInfo handlerInfo)
{
var instance = new SimpleHttpAsyncHandler(context, handlerInfo);
return instance;
}
internal static Task Run(IContext context)
{
Startup();
if (LegacyStaticContentSupport && StaticContent.TryHandleAsStaticContent(context))
{
return MakeCompletedTask();
}
IDictionary<string, string> variables;
var handlerType = TableFor(context.Request.HttpMethod).Get(context.Request.Url.AbsolutePath, out variables, context.Request.GetContentType(), context.Request.GetAccept());
if (handlerType == null) return null;
var handlerInfo = new HandlerInfo(handlerType, variables, context.Request.HttpMethod);
foreach (var key in context.Request.QueryString.Keys.Where(k => !string.IsNullOrWhiteSpace(k)))
{
handlerInfo.Variables.Add(key, CombineQueryStringValues(context.Request.QueryString[key]));
}
var task = PipelineFunctionFactory.Get(handlerInfo.HandlerType, handlerInfo.HttpMethod)(context, handlerInfo);
return task ?? MakeCompletedTask();
}
public static Func<IContext, Task> Get(HandlerInfo handlerInfo)
{
return new PipelineFunctionFactory(handlerInfo).BuildAsyncRunMethod();
}
internal SimpleHttpAsyncHandler(IContext context, HandlerInfo handlerInfo) : this(context, handlerInfo, null)
{
}
bool CheckHandlerV41(HandlerInfo info, out Data41 data41) {
data41 = new Data41();
data41.resolveHandler2 = info.handler;
data41.resourceField = GetLdtokenField(info.handler);
if (data41.resourceField == null)
return false;
bool isOtherRetail;
int magicArgIndex = GetMagicArgIndex41Retail(info.handler, out isOtherRetail);
if (magicArgIndex < 0) {
magicArgIndex = GetMagicArgIndex41Trial(info.handler);
data41.isTrial = true;
}
var asmVer = module.Assembly.Version;
if (magicArgIndex < 0 || magicArgIndex >= info.args.Count)
return false;
var val = info.args[magicArgIndex];
if (!(val is int))
return false;
if (data41.isTrial)
data41.magic = (int)val >> 3;
else if (isOtherRetail)
data41.magic = data41.resourceField.InitialValue.Length - (int)val;
else
data41.magic = ((asmVer.Major << 3) | (asmVer.Minor << 2) | asmVer.Revision) - (int)val;
return true;
}
internal SimpleHttpAsyncHandler(IContext context, HandlerInfo handlerInfo, IAuthenticationProvider authenticationProvider)
{
_context = context;
_handlerInfo = handlerInfo;
_authenticationProvider = authenticationProvider;
}
