public AnswersModule(RouteHandlerFactory routeHandlerFactory) : base("answers")
{
var handler = routeHandlerFactory.CreateRouteHandler(this);
Get("/", _ => {
this.RequiresAuthentication();
return(handler.Get <GetAnswersByUserId, List <AnswerModel> >(new GetAnswersByUserId(User.UserId)));
});
Post("/", _ => {
this.RequiresAuthentication();
var createAnswer = this.Bind <CreateAnswer>();
createAnswer.UserId = User.UserId;
return(handler.Post(createAnswer, created => new { id = created.AnswerId }));
});
Put("/{id:int}", _ => {
this.RequiresAuthentication();
var updateAnswer = BindUpdateModel <IUpdateAnswer, UpdateAnswer>();
updateAnswer.UserId = User.UserId;
updateAnswer.AnswerId = _.id;
return(handler.Put(updateAnswer));
});
}
public QuestionsModule(RouteHandlerFactory routeHandlerFactory) : base("/questions")
{
var handler = routeHandlerFactory.CreateRouteHandler(this);
Get("/", _ => handler.Get <GetAllQuestions, List <QuestionModel> >(new GetAllQuestions()));
Post("/", _ => {
this.RequiresAuthentication();
var createQuestion = this.Bind <CreateQuestion>();
createQuestion.SavedById = User.UserId;
return(handler.Post(createQuestion, createResponse));
object createResponse(CreateQuestion created)
{
return(new { id = created.QuestionId });
}
});
Put("/{id:int}", _ => {
this.RequiresAuthentication();
var updateQuestion = BindUpdateModel <IUpdateQuestion, UpdateQuestion>();
updateQuestion.SavedById = User.UserId;
updateQuestion.QuestionId = _.id;
return(handler.Put(updateQuestion));
});
}
public void Start()
{
TcpListener listener = new TcpListener(Address, Port);
Console.WriteLine("Listening for HTTP on port {0}", Port);
listener.Start();
while (true)
{
try
{
using (var client = listener.AcceptTcpClient())
{
//some browsers like to hold onto the connection, so set a 1s timeout for sending and receiving
client.ReceiveTimeout = 15000;
client.SendTimeout = 15000;
//A using statement should automatically flush when it goes out of scope
using (BufferedStream stream = new BufferedStream(client.GetStream()))
{
while (true)
{
BinaryReader reader = new BinaryReader(stream);
//8K header limit seems to be the norm for most real web servers
//https://www.tutorialspoint.com/What-is-the-maximum-size-of-HTTP-header-values
byte[] buffer = new byte[8192];
int bytesRead = reader.Read(buffer, 0, buffer.Length);
string requestHeaderString = Encoding.UTF8.GetString(buffer, 0, bytesRead);
RequestHeader request = RequestHeader.FromString(requestHeaderString);
if (request.Method != RequestMethod.Unknown)
{
Console.WriteLine("Client {0} requests {1}", client.Client.RemoteEndPoint, request);
Response response = new Response();
IRouteHandler handler = null;
try
{
handler = RouteHandlerFactory.ConstructRouteHandler(request);
handler.HandleRoute(request, response);
}
catch (Exception ex)
{
//error constructing resonse
response.Header.ResponseCode = 500;
response.SetBody(File.ReadAllText(Constants.ERROR_500));
Console.WriteLine("error responding to client: {0}", ex.Message);
}
response.FlushToStream(client.GetStream());
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("error responding to client: {0}", ex.Message);
}
}
}
public UsersModule(RouteHandlerFactory routeHandlerFactory) : base("/Users")
{
var handler = routeHandlerFactory.CreateRouteHandler(this);
Post("/", _ => {
var createUser = this.Bind <CreateUser>();
return(handler.Post(createUser, createResponse));
object createResponse(CreateUser created)
{
return(new { id = created.UserId });
}
});
}
private void ImplementRegisterRoute(ILProcessor il, TypeDefinition functionType, FieldDefinition serviceField, VariableDefinition modelVariable, PluginMetadata service, RouteMetadata route)
{
var key = $"Handle_{serviceField.Name}_{route.Method.Name}";
var isRpc = RouteHandlerFactory.IsRpc(route);
// create private handler function
var method = functionType.Methods.SingleOrDefault(x => x.Name == key);
if (method == null)
{
var returnType = _module.ImportReference(isRpc ? _rpcReturnType : _busReturnType);
method = new MethodDefinition(key, MethodAttributes.Private | MethodAttributes.HideBySig, returnType);
method.Parameters.Add(new ParameterDefinition("message", ParameterAttributes.None, _messageType));
method.Parameters.Add(new ParameterDefinition("cancellationToken", ParameterAttributes.None, _cancellationTokenType));
functionType.Methods.Add(method);
ImplementRouteHandler(method, serviceField, route, isRpc);
}
il.Emit(OpCodes.Ldloc, modelVariable);
// RoutePatternParser.Parse("...")
il.Emit(OpCodes.Ldstr, RouterPatternParser.UnParse(route.Route));
var routePatternParserType = _routingModule.GetType("Toxon.Micro.RabbitBlog.Routing.Patterns.RouterPatternParser").Resolve();
var patternParse = _module.ImportReference(routePatternParserType.Methods.Single(x => x.Name == "Parse"));
il.Emit(OpCodes.Call, patternParse);
// new Func<...>(method)
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldftn, method);
il.Emit(OpCodes.Newobj, _module.ImportReference(isRpc ? _rpcFuncConstructor : _busFuncConstructor));
// ...
il.Emit(OpCodes.Ldc_I4, (int)(isRpc ? RouteExecution.Synchronous : RouteExecution.Asynchronous));
il.Emit(OpCodes.Ldc_I4, (int)(isRpc ? RouteMode.Capture : RouteMode.Observe));
var cancellationTokenNone = _module.ImportReference(_cancellationTokenType.Resolve().Properties.Single(x => x.Name == "None").GetMethod);
il.Emit(OpCodes.Call, cancellationTokenNone);
// model.RegisterAsync(...)
var registerMethod = _module.ImportReference(isRpc ? _rpcRegisterMethod : _busRegisterMethod);
il.Emit(OpCodes.Callvirt, registerMethod);
}
private RouterEntry ToRouterEntry(PluginMetadata plugin, RouteMetadata metadata)
{
RouteTargetType targetType;
string target;
if (RouteHandlerFactory.IsRpc(metadata))
{
targetType = RouteTargetType.Lambda;
target = _namingConventions.GetLambdaName(plugin);
}
else
{
targetType = RouteTargetType.Sqs;
target = _namingConventions.GetSqsName(plugin);
}
return(new RouterEntry(plugin.ServiceKey, metadata.Route, targetType, target));
}
public QuestionnairesModule(RouteHandlerFactory routeHandlerFactory) : base("/questionnaires")
{
var handler = routeHandlerFactory.CreateRouteHandler(this);
Get("/", _ => handler.Get <GetAllQuestionnaires, List <QuestionnaireModel> >(new GetAllQuestionnaires()));
Post("/", _ => {
this.RequiresAuthentication();
var createQuestionnaire = this.Bind <CreateQuestionnaire>();
createQuestionnaire.SavedById = User.UserId;
return(handler.Post(createQuestionnaire, createResponse));
object createResponse(CreateQuestionnaire created)
{
return(new { id = created.QuestionnaireId });
}
});
Put("/{id:int}", _ => {
this.RequiresAuthentication();
var updateQuestionnaire = this.Bind <UpdateQuestionnaire>();
updateQuestionnaire.QuestionnaireId = _.id;
updateQuestionnaire.SavedById = User.UserId;
return(handler.Put(updateQuestionnaire));
});
Delete("/{id:int}", _ => {
this.RequiresAuthentication();
var deleteQuestionnaire = new DeleteQuestionnaire {
DeletedById = User.UserId,
QuestionnaireId = _.id
};
return(handler.Delete(deleteQuestionnaire));
});
}
public OptionsModule(RouteHandlerFactory routeHandlerFactory) : base("/options")
{
var handler = routeHandlerFactory.CreateRouteHandler(this);
Get("/", _ => handler.Get <GetAllOptions, List <OptionModel> >(new GetAllOptions()));
Post("/", _ => {
this.RequiresAuthentication();
var createOption = this.Bind <CreateOption>();
createOption.SavedById = User.UserId;
return(handler.Post(createOption, (created) => new { id = created.OptionId }));
});
Put("/{id:int}", _ => {
this.RequiresAuthentication();
var model = BindUpdateModel <ISaveOption, UpdateOption>();
model.OptionId = _.id;
model.SavedById = User.UserId;
return(handler.Put(model));
});
}
private void AddService(YamlMappingNode functions, YamlMappingNode resources, ServiceProject service, PluginMetadata plugin)
{
var functionName = _namingConventions.GetLambdaName(plugin);
var env = new YamlMappingNode
{
{ "ROUTER_QUEUE_NAME", new YamlMappingNode {
{ "Fn::GetAtt", new YamlSequenceNode("RouterQueue", "QueueName") }
} },
{ "ROUTER_FUNCTION_NAME", new YamlMappingNode {
{ "Ref", "RouterLambdaFunction" }
} },
};
switch (plugin.ServiceType)
{
case ServiceType.MessageHandler:
var routes = RouteDiscoverer.Discover(plugin);
if (routes.Any(x => !RouteHandlerFactory.IsRpc(x)))
{
var queueName = _namingConventions.GetSqsName(plugin);
var queueRefName = ToTitleCase(plugin.ServiceKey.Replace('.', '-'));
functions.Add(functionName + "-queue", new YamlMappingNode
{
{ "name", functionName + "-queue" },
{ "handler", "Toxon.Micro.RabbitBlog.Serverless.ServiceEntry::Toxon.Micro.RabbitBlog.Serverless.ServiceEntry.FunctionImpl::HandleQueueAsync" },
{ "environment", env },
{ "memorySize", "512" },
{ "timeout", "60" },
{ "events", new YamlSequenceNode(BuildSqsEvent(queueRefName)) },
{
"package", new YamlMappingNode
{
{ "artifact", $"artifacts/{service.Name}-service.zip" },
}
},
});
resources.Add(queueRefName, BuildQueue(queueName));
}
if (routes.Any(RouteHandlerFactory.IsRpc))
{
functions.Add(functionName, new YamlMappingNode
{
{ "name", functionName },
{ "handler", "Toxon.Micro.RabbitBlog.Serverless.ServiceEntry::Toxon.Micro.RabbitBlog.Serverless.ServiceEntry.FunctionImpl::HandleDirectAsync" },
{ "environment", env },
{ "memorySize", "512" },
{ "timeout", "60" },
{
"package", new YamlMappingNode
{
{ "artifact", $"artifacts/{service.Name}-service.zip" },
}
},
});
}
break;
case ServiceType.Http:
functions.Add(functionName, new YamlMappingNode
{
{ "name", functionName },
{ "handler", "Toxon.Micro.RabbitBlog.Serverless.HttpEntry::Toxon.Micro.RabbitBlog.Serverless.HttpEntry.FunctionImpl::FunctionHandlerAsync" },
{ "environment", env },
{ "memorySize", "512" },
{ "timeout", "60" },
{ "events", new YamlSequenceNode(BuildHttpEvent()) },
{
"package", new YamlMappingNode
{
{ "artifact", $"artifacts/{service.Name}-http.zip" },
}
},
});
break;
default: throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// 指定用于创建路由处理程序的工厂类对象
/// </summary>
/// <param name="routes"></param>
/// <param name="routeHandlerFactory"></param>
public static void SetRouteHandlerFactory(this RouteCollection routes, IRouteHandlerFactory routeHandlerFactory)
{
RouteHandlerFactory.SetRouteHandlerFactory(routeHandlerFactory);
}
