func writeFileResponse(filename string, bytes []byte, w http.ResponseWriter, r *http.Request) *model.AppError {
w.Header().Set("Cache-Control", "max-age=2592000, public")
w.Header().Set("Content-Length", strconv.Itoa(len(bytes)))
w.Header().Del("Content-Type") // Content-Type will be set automatically by the http writer
// attach extra headers to trigger a download on IE, Edge, and Safari
ua := user_agent.New(r.UserAgent())
bname, _ := ua.Browser()
parts := strings.Split(filename, "/")
filePart := strings.Split(parts[len(parts)-1], "?")[0]
w.Header().Set("Content-Disposition", "attachment;filename=\""+filePart+"\"")
if bname == "Edge" || bname == "Internet Explorer" || bname == "Safari" {
w.Header().Set("Content-Type", "application/octet-stream")
}
// prevent file links from being embedded in iframes
w.Header().Set("X-Frame-Options", "DENY")
w.Header().Set("Content-Security-Policy", "Frame-ancestors 'none'")
w.Write(bytes)
return nil
}
func (s *loggingSender) send(ctx context.Context, r *http.Request, message string) {
payload := map[string]interface{}{
"eventTime": time.Now().In(time.UTC).Format(time.RFC3339Nano),
"message": message,
"serviceContext": s.serviceContext,
}
if r != nil {
payload["context"] = map[string]interface{}{
"httpRequest": map[string]interface{}{
"method": r.Method,
"url": r.Host + r.RequestURI,
"userAgent": r.UserAgent(),
"referrer": r.Referer(),
"remoteIp": r.RemoteAddr,
},
}
}
e := logging.Entry{
Severity: logging.Error,
Payload: payload,
}
err := s.logger.LogSync(ctx, e)
if err != nil {
log.Println("Error writing error report:", err, "report:", payload)
}
}
func (c *Client) logInternal(ctx context.Context, r *http.Request, isPanic bool, msg string) {
payload := map[string]interface{}{
"eventTime": time.Now().In(time.UTC).Format(time.RFC3339Nano),
}
// limit the stack trace to 16k.
var buf [16384]byte
stack := buf[0:runtime.Stack(buf[:], false)]
payload["message"] = msg + "\n" + chopStack(stack, isPanic)
if r != nil {
payload["context"] = map[string]interface{}{
"httpRequest": map[string]interface{}{
"method": r.Method,
"url": r.Host + r.RequestURI,
"userAgent": r.UserAgent(),
"referrer": r.Referer(),
"remoteIp": r.RemoteAddr,
},
}
}
if c == nil {
log.Println("Error report used nil client:", payload)
return
}
payload["serviceContext"] = c.serviceContext
e := logging.Entry{
Level: logging.Error,
Payload: payload,
}
err := c.loggingClient.LogSync(e)
if err != nil {
log.Println("Error writing error report:", err, "report:", payload)
}
}
// buildLogLine creates a common log format
// in addittion to the common fields, we also append referrer, user agent and request ID
func buildLogLine(l *responseLogger, r *http.Request, start time.Time) string {
username := parseUsername(r)
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
host = r.RemoteAddr
}
uri := r.URL.RequestURI()
referer := r.Referer()
userAgent := r.UserAgent()
fields := []string{
host,
"-",
detect(username, "-"),
fmt.Sprintf("[%s]", start.Format("02/Jan/2006:15:04:05 -0700")),
r.Method,
uri,
r.Proto,
detect(strconv.Itoa(l.Status()), "-"),
strconv.Itoa(l.Size()),
detect(referer, "-"),
detect(userAgent, "-"),
r.Header.Get("Request-Id"),
}
return strings.Join(fields, " ")
}
func (handler *Handler) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
logMsg := &RequestLog{actualResponseWriter: writer}
logMsg.RequestHeaders = request.Header
logMsg.Method = request.Method
logMsg.Url = request.URL.String()
logMsg.Host = request.Host
logMsg.RemoteAddr = request.RemoteAddr
logMsg.Referer = request.Referer()
logMsg.UserAgent = request.UserAgent()
handler.wrappedHandler.ServeHTTP(logMsg, request)
// Get the resulting values
if logMsg.ResponseCode == 0 {
logMsg.ResponseCode = http.StatusOK
}
logMsg.ResponseHeaders = writer.Header()
// Fire off the event to Forest Bus
jsonMsg, err := json.Marshal(logMsg)
if err == nil {
sendErr := handler.msgBatcher.AsyncSendMessage(jsonMsg, nil, nil, handler.blockIfFull)
if sendErr != nil {
log.Printf("Warning: Error from AsyncSendMessage: %v\n", sendErr)
}
} else {
log.Printf("Warning: Unable to marshal request information to JSON: %v\n", err)
}
}
func (b *BouncerHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
reqParams := BouncerParamsFromValues(req.URL.Query())
if reqParams.Product == "" {
http.Redirect(w, req, "http://www.mozilla.org/", 302)
return
}
if reqParams.OS == "" {
reqParams.OS = DefaultOS
}
if reqParams.Lang == "" {
reqParams.Lang = DefaultLang
}
isWinXpClient := isWindowsXPUserAgent(req.UserAgent())
// If the client is not WinXP and attribution_code is set, redirect to the stub service
if b.StubRootURL != "" &&
reqParams.AttributionCode != "" &&
reqParams.AttributionSig != "" &&
!isWinXpClient {
stubURL := b.stubAttributionURL(reqParams)
http.Redirect(w, req, stubURL, 302)
return
}
// HACKS
// If the user is coming from windows xp or vista, send a sha1
// signed product
// HACKS
if reqParams.OS == "win" && isWinXpClient {
reqParams.Product = sha1Product(reqParams.Product)
}
url, err := b.URL(reqParams.Lang, reqParams.OS, reqParams.Product)
if err != nil {
http.Error(w, "Internal Server Error.", http.StatusInternalServerError)
log.Println(err)
return
}
if url == "" {
http.NotFound(w, req)
return
}
if b.CacheTime > 0 {
w.Header().Set("Cache-Control", fmt.Sprintf("max-age=%d", b.CacheTime/time.Second))
}
// If ?print=yes, print the resulting URL instead of 302ing
if reqParams.PrintOnly {
w.Header().Set("Content-Type", "text/plain")
w.Write([]byte(url))
return
}
http.Redirect(w, req, url, 302)
}
// ServeHTTP wraps the http.Request and http.ResponseWriter to log to standard
// output and pass through to the underlying http.Handler.
func (al *ApacheLogger) ServeHTTP(w http.ResponseWriter, r *http.Request) {
aw := &apacheLoggerResponseWriter{ResponseWriter: w}
al.handler.ServeHTTP(aw, r)
remoteAddr := r.RemoteAddr
if index := strings.LastIndex(remoteAddr, ":"); index != -1 {
remoteAddr = remoteAddr[:index]
}
referer := r.Referer()
if "" == referer {
referer = "-"
}
userAgent := r.UserAgent()
if "" == userAgent {
userAgent = "-"
}
username, _, _ := httpBasicAuth(r.Header)
if "" == username {
username = "******"
}
al.Printf(
"%s %s %s [%v] \"%s %s %s\" %d %d \"%s\" \"%s\"\n",
remoteAddr,
"-", // We're not supporting identd, sorry.
username,
time.Now().Format("02/Jan/2006:15:04:05 -0700"),
r.Method,
r.RequestURI,
r.Proto,
aw.StatusCode,
aw.Size,
referer,
userAgent,
)
}
func HandlerEiffageQueryPost(w http.ResponseWriter, r *http.Request) {
log.Printf("Content-Type %s & Content-Length %d \n", r.Header.Get("Content-Type"), r.ContentLength)
if r.Method == "POST" {
b, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Fatal("error handler: ", err)
}
//dont' write until you have read all the elements in the request
log.Printf("User-Agent %s\n", r.UserAgent())
log.Printf("Body %s\n", string(b))
defer r.Body.Close()
var resultFakeXml []byte
if strings.Contains(string(b), "FROM Opportunity") {
resultFakeXml = []byte(`
<result><records><sf:Id>123456</sf:Id><sf:OpportunityNumber__c>789012</sf:OpportunityNumber__c><sf:VP_ID__c>C3587C35-AFE8-4434-AD69-104C84025163</sf:VP_ID__c><sf:Name>Golang Salesforce Affaire</sf:Name></records></result>
`)
} else if strings.Contains(string(b), "FROM Ville__c") {
resultFakeXml = []byte(`
<result><records><sf:Id>555666</sf:Id><sf:Name>NANTES</sf:Name><sf:Departement__c>44 - Loire-Atlantique</sf:Departement__c></records></result>
`)
}
w.Write(resultFakeXml)
log.Printf("xml_data %s\n", resultFakeXml)
return
}
}
func (h *ApacheLoggingHandler) ServeHTTP(rw http.ResponseWriter, r *http.Request) {
clientIP := r.RemoteAddr
if colon := strings.LastIndex(clientIP, ":"); colon != -1 {
clientIP = clientIP[:colon]
}
record := &ApacheLogRecord{
ResponseWriter: rw,
ip: clientIP,
time: time.Time{},
method: r.Method,
uri: r.RequestURI,
protocol: r.Proto,
status: http.StatusOK,
referrer: r.Referer(),
userAgent: r.UserAgent(),
elapsedTime: time.Duration(0),
}
startTime := time.Now()
h.handler.ServeHTTP(record, r)
finishTime := time.Now()
record.time = finishTime.UTC()
record.elapsedTime = finishTime.Sub(startTime)
record.Log(h.out)
}
func IsMobile(r *http.Request) bool {
ua := r.UserAgent()
if strings.Index(ua, "Mobile") != -1 || strings.Index(ua, "Android") != -1 {
return true
}
return false
}
func (n *Notice) SetValueFromRequest(req *http.Request) {
if n.Request == nil {
n.Request = &Request{}
}
n.Request.Url = req.URL.String()
n.Request.AddCgiKeyValue("SERVER_SOFTWARE", "go")
n.Request.AddCgiKeyValue("PATH_INFO", req.URL.Path)
n.Request.AddCgiKeyValue("HTTP_HOST", req.Host)
n.Request.AddCgiKeyValue("GATEWAY_INTERFACE", "CGI/1.1")
n.Request.AddCgiKeyValue("REQUEST_METHOD", req.Method)
n.Request.AddCgiKeyValue("QUERY_STRING", req.URL.RawQuery)
n.Request.AddCgiKeyValue("REQUEST_URI", req.URL.RequestURI())
n.Request.AddCgiKeyValue("REMOTE_ADDR", req.RemoteAddr)
n.Request.AddCgiKeyValue("REMOTE_HOST", req.RemoteAddr)
n.Request.AddCgiKeyValue("HTTP_ACCEPT", req.Header.Get("Accept-Encoding"))
n.Request.AddCgiKeyValue("HTTP_USER_AGENT", req.UserAgent())
env := os.Environ()
for _, val := range env {
pair := strings.Split(val, "=")
if len(pair) < 2 {
continue
}
if strings.Index(pair[0], "_KEY") >= 0 {
continue
}
n.Request.AddCgiKeyValue(pair[0], pair[1])
}
}
func isBanned(r *http.Request) bool {
ctx := req2ctx(r)
cdb := complaintdb.NewDB(ctx)
u := user.Current(cdb.Ctx())
userWhitelist := map[string]int{
"*****@*****.**": 1,
"*****@*****.**": 1,
"*****@*****.**": 1,
"*****@*****.**": 1,
}
reqBytes, _ := httputil.DumpRequest(r, true)
cdb.Infof("remoteAddr: '%v'", r.RemoteAddr)
cdb.Infof("user: '******' (%s)", u, u.Email)
cdb.Infof("inbound IP determined as: '%v'", getIP(r))
cdb.Infof("HTTP req:-\n%s", string(reqBytes))
if strings.HasPrefix(r.UserAgent(), "python") {
cdb.Infof("User-Agent rejected")
return true
}
if _, exists := userWhitelist[u.Email]; !exists {
cdb.Infof("user not found in whitelist")
return true
}
return false
}
func (h handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
// From https://en.wikipedia.org/wiki/Common_Log_Format
//
// 127.0.0.1 user-identifier frank [10/Oct/2000:13:55:36 -0700] "GET /apache_pb.gif HTTP/1.0" 200 2326
const format = "%s - - [%s] \"%s %s %s\" %d %d \"%s\" \"%s\""
const layout = "2/Jan/2006:15:04:05 -0700"
userAgent := "-"
if agent := r.UserAgent(); agent != "" {
userAgent = agent
}
referer := "-"
if ref := r.Referer(); ref != "" {
referer = ref
}
shim := responseWriter{ResponseWriter: w}
//start := time.Now()
h.handler.ServeHTTP(&shim, r)
end := time.Now()
h.logf(format,
strings.Split(r.RemoteAddr, ":")[0],
end.Format(layout),
r.Method,
r.URL.RequestURI(),
r.Proto,
shim.status,
shim.n,
referer,
userAgent)
}
// LoggerMiddleware log each request using
// comman log format
func LoggerMiddleware(c *Container, rw http.ResponseWriter, r *http.Request, next func()) {
rw.(ResponseWriterExtra).SetLogger(c.MustGetLogger())
start := time.Now()
next()
// @see https://en.wikipedia.org/wiki/Common_Log_Format for log format
// @see http://httpd.apache.org/docs/1.3/logs.html#combined
c.MustGetLogger().Info(
fmt.Sprintf("%s %s %s [%s] \"%s %s %s\" %d %d \"%s\" \"%s\"",
r.RemoteAddr,
func() string {
if c.CurrentUser() != nil {
return fmt.Sprintf("%d", c.CurrentUser().ID)
}
return "-"
}(),
func() string {
if c.CurrentUser() != nil {
return c.CurrentUser().Username
}
return "-"
}(),
start.Format("Jan/02/2006:15:04:05 -0700 MST"),
r.Method,
r.RequestURI,
r.Proto,
c.ResponseWriter().Status(),
rw.(ResponseWriterExtra).GetCurrentSize(),
r.Referer(),
r.UserAgent(),
))
}
// Log is show viwer log.
func Log(req *http.Request) {
var userIP string
if userIP = req.Header.Get("X-FORWARDED-FOR"); userIP == "" {
userIP = req.RemoteAddr
}
log.Println(req.URL, userIP, req.UserAgent(), req.Form, req.Referer())
}
// PrefersHTML returns true if the request was made by something that looks like a browser, or can receive HTML
func PrefersHTML(req *http.Request) bool {
accepts := goautoneg.ParseAccept(req.Header.Get("Accept"))
acceptsHTML := false
acceptsJSON := false
for _, accept := range accepts {
if accept.Type == "text" && accept.SubType == "html" {
acceptsHTML = true
} else if accept.Type == "application" && accept.SubType == "json" {
acceptsJSON = true
}
}
// If HTML is accepted, return true
if acceptsHTML {
return true
}
// If JSON was specifically requested, return false
// This gives browsers a way to make requests and add an "Accept" header to request JSON
if acceptsJSON {
return false
}
// In Intranet/Compatibility mode, IE sends an Accept header that does not contain "text/html".
if strings.HasPrefix(req.UserAgent(), "Mozilla") {
return true
}
return false
}
// Creates a new session
func (store *BASessionStore) New(w http.ResponseWriter, r *http.Request) *BASession {
random := make([]byte, 16)
rand.Read(random)
currentTime := strconv.FormatInt(time.Now().UnixNano(), 10)
ip := net.ParseIP(r.Header["X-Real-Ip"][0]).String()
userAgent := r.UserAgent()
plaintext := []byte(cfg.HTTPServer.SessionIDSalt + "|" + fmt.Sprintf("%x", string(random[:])) + "|" + currentTime + "|" + ip + "|" + userAgent)
sessionID := fmt.Sprintf("%x", sha1.Sum(plaintext))
//log.Printf("BASessionStore New(): generated session ID: %s", sessionID)
cookie := &http.Cookie{
Name: SESSION_ID_COOKIE_NAME,
Value: sessionID,
Domain: SESSION_ID_COOKIE_DOMAIN,
Path: "/",
Expires: time.Now().Add(24 * time.Hour),
}
http.SetCookie(w, cookie)
return &BASession{
MemcachedClient: store.MemcachedClient,
Id: sessionID,
}
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
log.Println("Responsing to home request")
log.Println(r.UserAgent())
w.WriteHeader(http.StatusOK)
fmt.Fprintln(w, "Hello:")
}
// respond builds a Collection+JSON body and sends it to the client
func respond(code int, response interface{}, respWriter http.ResponseWriter, r *http.Request) (err error) {
defer func() {
if e := recover(); e != nil {
ctx.Channels.Log <- mig.Log{OpID: getOpID(r), Desc: fmt.Sprintf("%v", e)}.Err()
}
ctx.Channels.Log <- mig.Log{OpID: getOpID(r), Desc: "leaving respond()"}.Debug()
}()
var body []byte
// if the response is a cljs resource, marshal it, other treat it as a slice of bytes
if _, ok := response.(*cljs.Resource); ok {
body, err = response.(*cljs.Resource).Marshal()
if err != nil {
panic(err)
}
} else {
body = []byte(response.([]byte))
}
respWriter.Header().Set("Content-Type", "application/json")
respWriter.Header().Set("Cache-Control", "no-cache")
respWriter.WriteHeader(code)
respWriter.Write(body)
ctx.Channels.Log <- mig.Log{
OpID: getOpID(r),
Desc: fmt.Sprintf("src=%s auth=[%s %.0f] %s %s %s resp_code=%d resp_size=%d user-agent=%s",
remoteAddresses(r), getInvName(r), getInvID(r), r.Method, r.Proto,
r.URL.String(), code, len(body), r.UserAgent()),
}
return
}
func DeleteHandler(w http.ResponseWriter, r *http.Request) {
n := new(storage.Needle)
vid, fid, _ := parseURLPath(r.URL.Path)
volumeId, _ := strconv.ParseUint(vid, 10, 64)
n.ParsePath(fid)
if *IsDebug {
log.Info("deleting", n)
}
cookie := n.Cookie
count, ok := store.Read(volumeId, n)
if ok != nil {
m := make(map[string]uint32)
m["size"] = 0
writeJson(w, r, m)
return
}
if n.Cookie != cookie {
log.Info("delete with unmaching cookie from ", r.RemoteAddr, "agent", r.UserAgent())
return
}
n.Size = 0
store.Delete(volumeId, n)
m := make(map[string]uint32)
m["size"] = uint32(count)
writeJson(w, r, m)
}
func debugHandler(w http.ResponseWriter, r *http.Request) {
var (
err error
debug_info *DebugInfo
)
debug := r.PostFormValue("debug")
if len(debug) == 0 {
http.Error(w, "No debug information received.", http.StatusBadRequest)
return
}
debug_info = &DebugInfo{}
err = json.Unmarshal([]byte(debug), debug_info)
if err != nil {
http.Error(w, "Invalid debug information.", http.StatusBadRequest)
return
}
//set current time
debug_info.ReceivedAt = time.Now()
debug_info.UserAgent = r.UserAgent()
err = debug_collection.Insert(debug_info)
if err != nil {
log.Println(err)
}
//No need to return any content
http.Error(w, "No content", http.StatusNoContent)
}
func NewHttpStart(req *http.Request, peerType events.PeerType, requestId *uuid.UUID) *events.HttpStart {
httpStart := &events.HttpStart{
Timestamp: proto.Int64(time.Now().UnixNano()),
RequestId: NewUUID(requestId),
PeerType: &peerType,
Method: events.HttpStart_Method(events.HttpStart_Method_value[req.Method]).Enum(),
Uri: proto.String(fmt.Sprintf("%s%s", req.Host, req.URL.Path)),
RemoteAddress: proto.String(req.RemoteAddr),
UserAgent: proto.String(req.UserAgent()),
}
if applicationId, err := uuid.ParseHex(req.Header.Get("X-CF-ApplicationID")); err == nil {
httpStart.ApplicationId = NewUUID(applicationId)
}
if instanceIndex, err := strconv.Atoi(req.Header.Get("X-CF-InstanceIndex")); err == nil {
httpStart.InstanceIndex = proto.Int(instanceIndex)
}
if instanceId := req.Header.Get("X-CF-InstanceID"); instanceId != "" {
httpStart.InstanceId = &instanceId
}
return httpStart
}
func newRequest(hr *http.Request, hc http.ResponseWriter) *Request {
remoteAddr, _ := net.ResolveTCPAddr("tcp", hr.RemoteAddr)
maps := make(map[string]string)
for _, v := range hr.Cookies() {
maps[v.Name] = v.Value
}
req := Request{
Method: hr.Method,
URL: hr.URL,
Proto: hr.Proto,
ProtoMajor: hr.ProtoMajor,
ProtoMinor: hr.ProtoMinor,
Headers: hr.Header,
Body: hr.Body,
Close: hr.Close,
Host: hr.Host,
Referer: hr.Referer(),
UserAgent: hr.UserAgent(),
FullParams: hr.Form,
Cookie: hr.Cookies(),
Cookies: maps,
RemoteAddr: remoteAddr.IP.String(),
RemotePort: remoteAddr.Port,
}
return &req
}
func (c *AccountCtrl) Signin(w http.ResponseWriter, r *http.Request, _ map[string]string) {
var credentials Credentials
err := json.NewDecoder(r.Body).Decode(&credentials)
if err != nil {
c.render.JSONError(w, http.StatusBadRequest, apierrors.BodyDecodingError, err)
return
}
if credentials.Password == "" {
c.render.JSONError(w, http.StatusBadRequest, apierrors.BlankParam("password"), err)
return
}
if credentials.Email == "" {
c.render.JSONError(w, http.StatusBadRequest, apierrors.BlankParam("email"), err)
return
}
session, err := c.guestInter.Signin(r.RemoteAddr, r.UserAgent(), &credentials)
if err != nil {
c.render.JSONError(w, http.StatusUnauthorized, apierrors.InvalidCredentials, err)
return
}
cookie := http.Cookie{Name: "authToken", Value: session.AuthToken, Expires: session.ValidTo, Path: "/"}
http.SetCookie(w, &cookie)
session.BeforeRender()
c.render.JSON(w, http.StatusCreated, session)
}
func StatusHandler(w http.ResponseWriter, r *http.Request) {
var m = map[string]interface{}{
"status": "ok",
"ts": time.Now().UnixNano() / 1000000,
"version": "1.0",
"webStatus": map[string]interface{}{
"version": version,
"pid": os.Getpid(),
"proto": r.Proto,
"host": r.Host,
"path": r.URL.Path,
"agent": r.UserAgent(),
"remoteAddr": r.RemoteAddr,
"xForwardedFor": r.Header.Get("X-Forwarded-For"),
"xForwardedProto": r.Header.Get("X-Forwarded-Proto"),
},
}
json, err := json.Marshal(m)
if err != nil {
fmt.Fprintf(w, "json error\r\n")
} else {
headers := w.Header()
headers.Set("Content-Type", "application/json")
log.Debug("headers: %v", headers)
w.Write(json)
w.Write([]byte("\r\n"))
}
}
// buildLogLine creates a common log format
// in addition to the common fields, we also append referrer, user agent,
// request ID and response time (microseconds)
// ie, in apache mod_log_config terms:
// %h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-agent}i\"" %L %D
func buildLogLine(l *responseLogger, r *http.Request, start time.Time) string {
redactPassword(r)
username := parseUsername(r)
host, _, err := net.SplitHostPort(r.RemoteAddr)
if err != nil {
host = r.RemoteAddr
}
uri := r.URL.RequestURI()
referer := r.Referer()
userAgent := r.UserAgent()
return fmt.Sprintf(`%s - %s [%s] "%s %s %s" %s %s "%s" "%s" %s %d`,
host,
detect(username, "-"),
start.Format("02/Jan/2006:15:04:05 -0700"),
r.Method,
uri,
r.Proto,
detect(strconv.Itoa(l.Status()), "-"),
strconv.Itoa(l.Size()),
detect(referer, "-"),
detect(userAgent, "-"),
r.Header.Get("Request-Id"),
// response time, report in microseconds because this is consistent
// with apache's %D parameter in mod_log_config
int64(time.Since(start)/time.Microsecond))
}
func NewHttpStartStop(req *http.Request, statusCode int, contentLength int64, peerType events.PeerType, requestId *uuid.UUID) *events.HttpStartStop {
now := proto.Int64(time.Now().UnixNano())
httpStartStop := &events.HttpStartStop{
StartTimestamp: now,
StopTimestamp: now,
RequestId: NewUUID(requestId),
PeerType: &peerType,
Method: events.Method(events.Method_value[req.Method]).Enum(),
Uri: proto.String(fmt.Sprintf("%s://%s%s", scheme(req), req.Host, req.URL.Path)),
RemoteAddress: proto.String(req.RemoteAddr),
UserAgent: proto.String(req.UserAgent()),
StatusCode: proto.Int(statusCode),
ContentLength: proto.Int64(contentLength),
}
if applicationId, err := uuid.ParseHex(req.Header.Get("X-CF-ApplicationID")); err == nil {
httpStartStop.ApplicationId = NewUUID(applicationId)
}
if instanceIndex, err := strconv.Atoi(req.Header.Get("X-CF-InstanceIndex")); err == nil {
httpStartStop.InstanceIndex = proto.Int(instanceIndex)
}
if instanceId := req.Header.Get("X-CF-InstanceID"); instanceId != "" {
httpStartStop.InstanceId = proto.String(instanceId)
}
allForwards := req.Header[http.CanonicalHeaderKey("X-Forwarded-For")]
for _, forwarded := range allForwards {
httpStartStop.Forwarded = append(httpStartStop.Forwarded, parseXForwarded(forwarded)...)
}
return httpStartStop
}
func (h *TestHandler) ServeHTTP(w http.ResponseWriter, hr *http.Request) {
h.hit()
w.Header().Set("Access-Control-Allow-Origin", "*")
w.Header().Set("Access-Control-Request-Method", "GET")
fmt.Println("\n=== TestHandler : Requete reçue ====================")
fmt.Println(" Method : " + hr.Method)
//~ fmt.Println(" URL : " + hr.RawURL)
fmt.Println(" Proto : " + hr.Proto)
fmt.Printf(" ContentLength : %d\n", hr.ContentLength)
fmt.Println(" UserAgent : " + hr.UserAgent())
fmt.Println(" Header :")
for key, value := range hr.Header {
fmt.Printf(" %s=%v\n", key, value)
}
b, e := ioutil.ReadAll(hr.Body)
if e != nil {
fmt.Println("Erreur lecture :")
fmt.Println(e)
}
s := string(b)
fmt.Print(s)
fmt.Fprint(w, "Bien reçu")
}
func (s *errorApiSender) send(ctx context.Context, r *http.Request, message string) {
time := time.Now()
var errorContext *erpb.ErrorContext
if r != nil {
errorContext = &erpb.ErrorContext{
HttpRequest: &erpb.HttpRequestContext{
Method: r.Method,
Url: r.Host + r.RequestURI,
UserAgent: r.UserAgent(),
Referrer: r.Referer(),
RemoteIp: r.RemoteAddr,
},
}
}
req := erpb.ReportErrorEventRequest{
ProjectName: s.projectID,
Event: &erpb.ReportedErrorEvent{
EventTime: ×tamp.Timestamp{
Seconds: time.Unix(),
Nanos: int32(time.Nanosecond()),
},
ServiceContext: &s.serviceContext,
Message: message,
Context: errorContext,
},
}
_, err := s.apiClient.ReportErrorEvent(ctx, &req)
if err != nil {
log.Println("Error writing error report:", err, "report:", message)
}
}
func rootFunc(w http.ResponseWriter, r *http.Request) {
g := Load()
l := log551.New(&g.config.Framework.SystemLog)
l.Open()
defer l.Close()
cookie := cookie551.New(w, r)
sid := g.sid(cookie)
l.Debugf("%s SID: %s", sid[:10], sid)
session := memcache551.New(&g.config.Framework.Session.Server, sid)
route := g.router.FindRouteByPathMatch(r.Method, r.URL.Path)
response551.UrlFunction = g.router.Url
var data interface{} = nil
if route != nil {
mysql := mysql551.New(&g.config.Framework.Database)
mysql.Open()
defer mysql.Close()
l.Debugf("%s --[ Routing ]--", sid[:10])
l.Debugf("%s Path: %s", sid[:10], r.URL.Path)
l.Debugf("%s Neme: %s", sid[:10], route.Name())
c := container551.New()
c.SetSID(sid)
c.SetResponseWriter(w)
c.SetRequest(r)
c.SetLogger(l)
c.SetCookie(cookie)
c.SetDb(mysql)
c.SetSession(session)
c.SetModel(g.modelManager)
c.SetAuth(g.auth)
c.SetUrlFunc(g.router.Url)
baseUrl := "https://" + g.config.Framework.WebServerSSL.Host
if g.config.Framework.WebServerSSL.Port != "443" {
baseUrl = baseUrl + ":" + g.config.Framework.WebServerSSL.Port
}
c.SetBaseURL(baseUrl)
response551.BaseUrl = baseUrl
action := route.Action()
data = action(c)
response551.Response(w, r, data, route.PackageName(), route.Name(), c.User(), g.config.Application)
} else {
l.Errorf("%s --[ Route not found ]--", sid[:10])
l.Errorf("%s UA: %s", sid[:10], r.UserAgent())
l.Errorf("%s Method: %s", sid[:10], r.Method)
l.Errorf("%s Path: %s", sid[:10], r.URL.Path)
l.Errorf("%s --[/Route not found ]--", sid[:10])
data = response551.Error(404, "Route not found.")
response551.Response(w, r, data, "", "", nil, g.config.Application)
}
}