mirror of
https://github.com/fnproject/fn.git
synced 2022-10-28 21:29:17 +03:00
2341456334
this adds `FN_` in front of env vars that we are injecting into calls, for namespacing reasons. this will break code relying on the current variables but if we want to do this, the chance is now really. alternatively, we could maintain both the old and new for a short period of time to ease the adjustment (speak now...). updated the docs, as well. this also adds tests for the notoriously finicky configuration of the env vars and headers when setting up a call. this won't test the container / request for the call is actually receiving them, but it's a decent start and will yell loudly enough upon formatting breakage. added back FXLB_WAIT to a couple places so the lb can ride again one thing for feedback: headers are a bit confusing at the moment (not from this change, but that behavior is kept here for now), we've a chance to fix them. currently, headers in the request __are not__ prefixed with `FN_HEADER_`, i.e. 'hot'+sync containers will receive `Content-Length` in the http request headers, yet a 'cold' container from the same request would receive `FN_HEADER_Content-Length` in its environment. This is additionally confusing because if this function were hot+async, it would receive `FN_HEADER_Content-Length` in the headers, where just changing it to sync goes back to `Content-Length`. If that was confusing, then point made ;) I propose to remove the `FN_HEADER_` prefix for request headers in the environment, so that the request headers and env will match, as request headers already are of this format (not prefixed). please lmk thoughts here Would be fine with going back to the 'plain' vars too, then this patch will mostly just be adding tests and changing `FN_FORMAT` to `FORMAT`. obviously, from the examples, it's a bit ingrained now. anyway, entirely up to y'all.
109 lines
2.9 KiB
Go
109 lines
2.9 KiB
Go
package server
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"net/http"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/fnproject/fn/api"
|
|
"github.com/fnproject/fn/api/agent"
|
|
"github.com/fnproject/fn/api/models"
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type runnerResponse struct {
|
|
RequestID string `json:"request_id,omitempty"`
|
|
Error *models.ErrorBody `json:"error,omitempty"`
|
|
}
|
|
|
|
func (s *Server) handleRequest(c *gin.Context) {
|
|
if strings.HasPrefix(c.Request.URL.Path, "/v1") {
|
|
c.Status(http.StatusNotFound)
|
|
return
|
|
}
|
|
|
|
ctx := c.Request.Context()
|
|
|
|
r, routeExists := c.Get(api.Path)
|
|
if !routeExists {
|
|
r = "/"
|
|
}
|
|
|
|
reqRoute := &models.Route{
|
|
AppName: c.MustGet(api.AppName).(string),
|
|
Path: path.Clean(r.(string)),
|
|
}
|
|
|
|
s.FireBeforeDispatch(ctx, reqRoute)
|
|
|
|
s.serve(c, reqRoute.AppName, reqRoute.Path)
|
|
|
|
s.FireAfterDispatch(ctx, reqRoute)
|
|
}
|
|
|
|
// TODO it would be nice if we could make this have nothing to do with the gin.Context but meh
|
|
// TODO make async store an *http.Request? would be sexy until we have different api format...
|
|
func (s *Server) serve(c *gin.Context, appName, path string) {
|
|
// GetCall can mod headers, assign an id, look up the route/app (cached),
|
|
// strip params, etc.
|
|
call, err := s.Agent.GetCall(
|
|
agent.WithWriter(c.Writer), // XXX (reed): order matters [for now]
|
|
agent.FromRequest(appName, path, c.Request),
|
|
)
|
|
if err != nil {
|
|
handleErrorResponse(c, err)
|
|
return
|
|
}
|
|
|
|
// TODO we could add FireBeforeDispatch right here with Call in hand
|
|
model := call.Model()
|
|
|
|
if model.Type == "async" {
|
|
// TODO we should push this into GetCall somehow (CallOpt maybe) or maybe agent.Queue(Call) ?
|
|
buf := bytes.NewBuffer(make([]byte, 0, c.Request.ContentLength)) // TODO sync.Pool me
|
|
_, err := buf.ReadFrom(c.Request.Body)
|
|
if err != nil {
|
|
handleErrorResponse(c, models.ErrInvalidPayload)
|
|
return
|
|
}
|
|
model.Payload = buf.String()
|
|
|
|
// TODO we should probably add this to the datastore too. consider the plumber!
|
|
_, err = s.MQ.Push(c.Request.Context(), model)
|
|
if err != nil {
|
|
handleErrorResponse(c, err)
|
|
return
|
|
}
|
|
|
|
c.JSON(http.StatusAccepted, map[string]string{"call_id": model.ID})
|
|
return
|
|
}
|
|
|
|
err = s.Agent.Submit(call)
|
|
if err != nil {
|
|
// NOTE if they cancel the request then it will stop the call (kind of cool),
|
|
// we could filter that error out here too as right now it yells a little
|
|
|
|
if err == context.DeadlineExceeded {
|
|
// TODO maneuver
|
|
// add this, since it means that start may not have been called [and it's relevant]
|
|
c.Writer.Header().Add("XXX-FXLB-WAIT", time.Now().Sub(time.Time(model.CreatedAt)).String())
|
|
|
|
err = models.ErrCallTimeout // 504 w/ friendly note
|
|
}
|
|
// NOTE: if the task wrote the headers already then this will fail to write
|
|
// a 5xx (and log about it to us) -- that's fine (nice, even!)
|
|
handleErrorResponse(c, err)
|
|
return
|
|
}
|
|
|
|
// TODO plumb FXLB-WAIT somehow (api?)
|
|
|
|
// TODO we need to watch the response writer and if no bytes written
|
|
// then write a 200 at this point?
|
|
// c.Data(http.StatusOK)
|
|
}
|