func main(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } tok, err := AddClient(c, u.Id) if err != nil { http.Error(w, err.String(), 500) return } err = mainTemplate.Execute(w, map[string]string{ "token": tok, "client_id": u.Id, "client_email": u.Email, }) if err != nil { c.Errorf("mainTemplate: %v", err) } }
func homeHandler(w http.ResponseWriter, r *http.Request) { w.Header().Add("Content-Type", "text/html") url1 := router.NamedRoutes["hello"].URL("salutation", "hello", "name", "world") url2 := router.NamedRoutes["datastore-session"].URL() url3 := router.NamedRoutes["memcache-session"].URL() fmt.Fprintf(w, "Try a <a href='%s'>hello</a>. Or a <a href='%s'>datastore</a> or <a href='%s'>memcache</a> session.", url1, url2, url3) }
func handle(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) item, err := memcache.Get(c, r.URL.Path) if err != nil && err != memcache.ErrCacheMiss { serveError(c, w, err) return } n := 0 if err == nil { n, err = strconv.Atoi(string(item.Value)) if err != nil { serveError(c, w, err) return } } n++ item = &memcache.Item{ Key: r.URL.Path, Value: []byte(strconv.Itoa(n)), } err = memcache.Set(c, item) if err != nil { serveError(c, w, err) return } w.Header().Set("Content-Type", "text/plain") fmt.Fprintf(w, "%q has been visited %d times", r.URL.Path, n) }
func handle(w http.ResponseWriter, r *http.Request) { params, err := url.ParseQuery(r.URL.RawQuery) check(err) w.Header().Add("Access-Control-Allow-Origin", "*") w.Header().Add( "Access-Control-Allow-Methods", "OPTIONS, HEAD, GET, POST, PUT, DELETE", ) switch r.Method { case "OPTIONS": case "HEAD": case "GET": get(w, r) case "POST": if len(params["_method"]) > 0 && params["_method"][0] == "DELETE" { delete(w, r) } else { post(w, r) } case "DELETE": delete(w, r) default: http.Error(w, "501 Not Implemented", http.StatusNotImplemented) } }
func (v *tplView) handle(w http.ResponseWriter, req *http.Request, s *session) { if v.checkUniqueURL != "" && req.URL.Path != v.checkUniqueURL { w.WriteHeader(http.StatusNotFound) fmt.Fprintf(w, "<pre>404 page not found</pre>") return } defer func() { if e := recover(); e != nil { fmt.Fprintf(w, "%v", e) log.Printf("Error in handling %v : %v", req.RawURL, e) } }() d := v.getData(req, s) // fmt.Printf("%#v\n", d) // DEBUG if ee, ok := d.(getDataError); ok { w.WriteHeader(ee.Code) e := tpl["error"].Execute(w, giveTplData{"Sess": s, "Error": ee, "Request": req}) if e != nil { w.Write([]byte(e.String())) } } else if rurl, ok := d.(redirectResponse); ok { w.Header().Add("Location", string(rurl)) w.WriteHeader(http.StatusFound) } else { e := tpl[v.tpl].Execute(w, giveTplData{"Sess": s, "Data": d, "Request": req}) if e != nil { w.Write([]byte(e.String())) } } }
// hello world, the web server func PageExecuteJS(w http.ResponseWriter, req *http.Request) { url := req.FormValue("url") js := req.FormValue("js") header := w.Header() if url == "" { log.Printf("ERROR: url is required. (%s)\n", url) w.WriteHeader(http.StatusInternalServerError) header.Set("Content-Type", "text/plian;charset=UTF-8;") io.WriteString(w, "Internal Server Error: please input url.\n") return } if strings.Index(url, "http") != 0 { log.Printf("ERROR: url is invalid. (%s)\n", url) w.WriteHeader(http.StatusInternalServerError) header.Set("Content-Type", "text/plian;charset=UTF-8;") io.WriteString(w, "Internal Server Error: please input valid url.\n") return } if js == "" { log.Printf("ERROR: js is required. (%s)\n", url) w.WriteHeader(http.StatusInternalServerError) header.Set("Content-Type", "text/plian;charset=UTF-8;") io.WriteString(w, "Internal Server Error: please input js.\n") return } json := ExecuteJS(url, js) if len(json) == 0 { log.Printf("ERROR: failed to execute. (%s)\n", url) json = []byte("{}") } header.Set("Content-Type", "application/json;charset=UTF-8;") w.Write(json) }
func ReturnJson(conn http.ResponseWriter, data interface{}) { conn.Header().Set("Content-Type", "text/javascript") if m, ok := data.(map[string]interface{}); ok { statusCode := 0 if t, ok := m["error"].(string); ok && len(t) > 0 { statusCode = http.StatusInternalServerError } if t, ok := m["errorType"].(string); ok { switch t { case "server": statusCode = http.StatusInternalServerError case "input": statusCode = http.StatusBadRequest } } if statusCode != 0 { conn.WriteHeader(statusCode) } } bytes, err := json.MarshalIndent(data, "", " ") if err != nil { BadRequestError(conn, fmt.Sprintf( "JSON serialization error: %v", err)) return } conn.Write(bytes) conn.Write([]byte("\n")) }
func solutionsHandler(w http.ResponseWriter, r *http.Request) { hint := r.FormValue("hint") if hint == "" { w.WriteHeader(http.StatusInternalServerError) w.Header().Set("Content-Type", "text/plain;charset=UTF-8;") io.WriteString(w, "Required parameter 'hint' not received.\n") return } // Use a regexp to find all actual characters // we already know about realCharExp := regexp.MustCompile("[^*]") realChars := realCharExp.FindAllString(hint, -1) // Replace all '_' in the hint expression for // 'any character that's not currently known' newr_str := strings.Replace(hint, "*", fmt.Sprintf("[^%s]", strings.Join(realChars, "")), -1) finalExp := regexp.MustCompile(fmt.Sprintf("^%s$", newr_str)) io.WriteString(w, fmt.Sprintf(`<html> <head><title>Possible Solutions for %s</title></head> <body><h1>Possible Solutions for %s</h1><ul>`, hint, hint)) // Now go through the word list looking for matches for i := range wordList.Words() { if finalExp.MatchString(wordList.Word(i)) { io.WriteString(w, fmt.Sprintf("<li>%s</li>", wordList.Word(i))) } } io.WriteString(w, "</ul></body></html>") }
func handle_http(responseWrite http.ResponseWriter, request *http.Request) { var proxyResponse *http.Response var proxyResponseError os.Error proxyHost := strings.Split(request.URL.Path[6:], "/")[0] fmt.Printf("%s %s %s\n", request.Method, request.RawURL, request.RemoteAddr) //TODO https url := "http://" + request.URL.Path[6:] proxyRequest, _ := http.NewRequest(request.Method, url, nil) proxy := &http.Client{} proxyResponse, proxyResponseError = proxy.Do(proxyRequest) if proxyResponseError != nil { http.NotFound(responseWrite, request) return } for header := range proxyResponse.Header { responseWrite.Header().Add(header, proxyResponse.Header.Get(header)) } contentType := strings.Split(proxyResponse.Header.Get("Content-Type"), ";")[0] if proxyResponseError != nil { fmt.Fprintf(responseWrite, "pizda\n") } else if ReplacemendContentType[contentType] { body, _ := ioutil.ReadAll(proxyResponse.Body) defer proxyResponse.Body.Close() bodyString := replace_url(string(body), "/http/", proxyHost) responseWrite.Write([]byte(bodyString)) } else { io.Copy(responseWrite, proxyResponse.Body) } }
func printSpamHamJSON(w http.ResponseWriter, r *http.Request, key string) { c := appengine.NewContext(r) w.Header().Set("Content-Type", "application/json; charset=utf-8") q := datastore.NewQuery(key) fmt.Fprintf(w, "[") first := true for t := q.Run(c); ; { var x Entity _, err := t.Next(&x) if err == datastore.Done { break } if err != nil { return } if !first { fmt.Fprintf(w, ", %s", x.Value) } else { fmt.Fprintf(w, "%s", x.Value) first = false } } fmt.Fprintf(w, "]") }
func registration(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := User{ Name: "TestHendrik", StartDate: datastore.SecondsToTime(time.Seconds()), } if g := user.Current(c); g != nil { var u2 User u.Account = g.String() if err := datastore.Get(c, datastore.NewKey("user", g.String(), 0, nil), &u2); err == datastore.ErrNoSuchEntity { key, err := datastore.Put(c, datastore.NewKey("user", u.Account, 0, nil), &u) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } fmt.Fprintf(w, "User %q stored %q", u.Account, key) return } else { fmt.Fprintf(w, "User %q is already logged in", g.String()) return } } else { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } }
// hello world, the web server func Capture(w http.ResponseWriter, req *http.Request) { url := req.FormValue("url") header := w.Header() if url == "" { log.Printf("ERROR: url is required. (%s)\n", url) w.WriteHeader(http.StatusInternalServerError) header.Set("Content-Type", "text/plian;charset=UTF-8;") io.WriteString(w, "Internal Server Error: please input url.\n") return } if strings.Index(url, "http") != 0 { log.Printf("ERROR: url is invalid. (%s)\n", url) w.WriteHeader(http.StatusInternalServerError) header.Set("Content-Type", "text/plian;charset=UTF-8;") io.WriteString(w, "Internal Server Error: please input valid url.\n") return } image := CaptureUrl(url) if len(image) == 0 { log.Printf("ERROR: failed to capture. (%s)\n", url) w.WriteHeader(http.StatusInternalServerError) header.Set("Content-Type", "text/plian;charset=UTF-8;") io.WriteString(w, "Internal Server Error: Failed to capture.\n") return } header.Set("Content-Type", "image/png") w.Write(image) }
func handleGet(w http.ResponseWriter) { w.Header().Set("Content-Type", "text/plain") w.WriteHeader(405) fmt.Fprintf(w, "405 Method Not Allowed\n\n"+ "To access this amf.go gateway you must use POST requests "+ "(%s received))") }
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 uploadUser(w http.ResponseWriter, r *http.Request) { if r.Method != "POST" { // No upload; show the upload form. uploadUserTemplate.Execute(w, nil) return } f, _, err := r.FormFile("image") errors.Check(err) defer f.Close() // Grab the image data i, _, err := image.Decode(f) errors.Check(err) var key string = keyOf() // store image i = picstore.Store(key, i, 320, "userimg") i = picstore.Store(key, i, 180, "userthumb") // generate result w.Header().Set("Content-Type", "application/json") w.Header().Set("cache-control", "no-cache") w.Header().Set("Expires", "-1") fmt.Fprintf(w, "{\"profilePicUrl\":\"uimg?id="+key+"\",\"profileThumbUrl\":\"utmb?id="+key+"\"}") }
func GCServer(w http.ResponseWriter, req *http.Request) { w.Header().Set("Content-Type", "text/plain; charset=utf-8") StatsServer(w, req) io.WriteString(w, "=============================\n") runtime.GC() StatsServer(w, req) }
// Symbol looks up the program counters listed in the request, // responding with a table mapping program counters to function names. // The package initialization registers it as /debug/pprof/symbol. func Symbol(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/plain; charset=utf-8") // We don't know how many symbols we have, but we // do have symbol information. Pprof only cares whether // this number is 0 (no symbols available) or > 0. fmt.Fprintf(w, "num_symbols: 1\n") var b *bufio.Reader if r.Method == "POST" { b = bufio.NewReader(r.Body) } else { b = bufio.NewReader(strings.NewReader(r.URL.RawQuery)) } for { word, err := b.ReadSlice('+') if err == nil { word = word[0 : len(word)-1] // trim + } pc, _ := strconv.Btoui64(string(word), 0) if pc != 0 { f := runtime.FuncForPC(uintptr(pc)) if f != nil { fmt.Fprintf(w, "%#x %s\n", pc, f.Name()) } } // Wait until here to check for err; the last // symbol will have an err because it doesn't end in +. if err != nil { break } } }
func (ui *UIHandler) ServeHTTP(rw http.ResponseWriter, req *http.Request) { base := req.Header.Get("X-PrefixHandler-PathBase") suffix := req.Header.Get("X-PrefixHandler-PathSuffix") rw.Header().Set("Vary", "Accept") switch { case wantsDiscovery(req): ui.serveDiscovery(rw, req) case wantsUploadHelper(req): ui.serveUploadHelper(rw, req) case strings.HasPrefix(suffix, "download/"): ui.serveDownload(rw, req) case strings.HasPrefix(suffix, "thumbnail/"): ui.serveThumbnail(rw, req) default: file := "" if m := staticFilePattern.FindStringSubmatch(suffix); m != nil { file = m[1] } else { switch { case wantsPermanode(req): file = "permanode.html" case wantsBlobInfo(req): file = "blobinfo.html" case req.URL.Path == base: file = "index.html" default: http.Error(rw, "Illegal URL.", 404) return } } vfs.ServeFileFromFS(rw, req, uiFiles, file) } }
func PageInternalUpdateJson(w http.ResponseWriter, req *http.Request) { id := req.FormValue("id") updateJson := req.FormValue("json") header := w.Header() conn, err := GetConnection() c := GetExecuteCollection(conn) var ( rs ExecuteRs jsonb []byte ) execId, err := mongo.NewObjectIdHex(id) log.Printf("Search ExecuteId=%s", execId) err = c.Find(map[string]interface{}{"_id": execId}).One(&rs) if err != nil { jsonb = []byte(`{error: "Not found."}`) } else { rs.Json = updateJson err = c.Update(mongo.M{"_id": execId}, rs) if err != nil { jsonb = []byte(`{result: "failed"}`) } else { jsonb = []byte(`{result: "success"}`) } } conn.Close() header.Set("Access-Control-Allow-Origin", "*") header.Set("Content-Type", "application/json") w.Write(jsonb) }
func (ui *UIHandler) serveDiscovery(rw http.ResponseWriter, req *http.Request) { rw.Header().Set("Content-Type", "text/javascript") inCb := false if cb := req.FormValue("cb"); identPattern.MatchString(cb) { fmt.Fprintf(rw, "%s(", cb) inCb = true } pubRoots := map[string]interface{}{} for key, pubh := range ui.PublishRoots { pubRoots[key] = map[string]interface{}{ "name": pubh.RootName, // TODO: include gpg key id } } bytes, _ := json.Marshal(map[string]interface{}{ "blobRoot": ui.BlobRoot, "searchRoot": ui.SearchRoot, "jsonSignRoot": ui.JSONSignRoot, "uploadHelper": "?camli.mode=uploadhelper", // hack; remove with better javascript "downloadHelper": "./download/", "publishRoots": pubRoots, }) rw.Write(bytes) if inCb { rw.Write([]byte{')'}) } }
func join(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } r.ParseForm() // TODO check table arg state, err := joinTable(c, r.Form["table"][0], u.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } var b []byte b, err = json.Marshal(state) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } fmt.Fprintf(w, "%s", b) }
func handleCreate(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { return } r.ParseForm() url := r.FormValue("url") title := r.FormValue("title") tagString := r.FormValue("tags") if url == "" { output(c, w, "create") return } tags := strings.Split(tagString, ",") bm := bookmarks.NewBookmark(u, url, title, tags) _, err := bm.Save(c) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } w.Header().Set("Location", rootURL(c)) w.WriteHeader(http.StatusFound) return }
func ServeDataItemPage(writer http.ResponseWriter, request *http.Request) { if strings.Contains(request.Header.Get("Accept"), "application/json") { writer.Header().Set("Content-Type", "applicaton/json") } else { writer.Header().Set("Content-Type", "text/plain") } stream := StreamByName("ranger") log.Printf("Serving full data for '%s'", request.FormValue("q")) data := stream.LookupData(request.FormValue("q")) if data == nil { log.Printf("Failed to find %s", request.FormValue("q")) writer.WriteHeader(http.StatusNotFound) return } outputBytes, err := json.MarshalIndent(data, "", " ") if err != nil { log.Printf("Failed to format data") writer.WriteHeader(http.StatusInternalServerError) return } writer.Write(outputBytes) }
// exec a program, redirecting output func DateServer(rw http.ResponseWriter, req *http.Request) { rw.Header().Set("Content-Type", "text/plain; charset=utf-8") r, w, err := os.Pipe() if err != nil { fmt.Fprintf(rw, "pipe: %s\n", err) return } p, err := os.StartProcess("/bin/date", []string{"date"}, &os.ProcAttr{Files: []*os.File{nil, w, w}}) defer r.Close() w.Close() if err != nil { fmt.Fprintf(rw, "fork/exec: %s\n", err) return } defer p.Release() io.Copy(rw, r) wait, err := p.Wait(0) if err != nil { fmt.Fprintf(rw, "wait: %s\n", err) return } if !wait.Exited() || wait.ExitStatus() != 0 { fmt.Fprintf(rw, "date: %v\n", wait) return } }
func (v *redirectView) handle(w http.ResponseWriter, req *http.Request, s *session) { if v.checkUniqueURL != "" && req.URL.Path != v.checkUniqueURL { w.WriteHeader(http.StatusNotFound) fmt.Fprintf(w, "<pre>404 page not found</pre>") return } defer func() { if e := recover(); e != nil { fmt.Fprintf(w, "%v", e) log.Printf("Error in handling %v : %v", req.RawURL, e) gde, ok := e.(getDataError) if !ok { if ose, ok := e.(os.Error); ok { gde = getDataError{http.StatusInternalServerError, ose} } else { gde = getDataError{http.StatusInternalServerError, os.NewError(fmt.Sprintf("%v", e))} } } w.WriteHeader(gde.Code) e2 := tpl["error"].Execute(w, giveTplData{"Sess": s, "Error": gde, "Request": req}) if e2 != nil { w.Write([]byte(e2.String())) } } }() rurl := v.process(req, s) if rurl == "" { rurl = "/" } w.Header().Add("Location", rurl) w.WriteHeader(http.StatusFound) }
func myWidgets(w http.ResponseWriter, r *http.Request) { var err os.Error ctx := appengine.NewContext(r) page, err := template.Parse(myWidgetTemplate, nil) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } data := myWidgetData{ CSS: commonCSS(), Header: header(ctx), } data.Widget, err = LoadWidgets(ctx) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } if len(r.FormValue("ids_only")) > 0 { w.Header().Set("Content-Type", "text/plain") for _, widget := range data.Widget { fmt.Fprintln(w, widget.ID) } return } page.Execute(w, data) }
func (session *Session) SetCookie(w http.ResponseWriter, context appengine.Context) { cookie := &http.Cookie{ Name: "session", Value: session.Key, } w.Header().Add("Set-Cookie", cookie.String()) }
func serveObject(val reflect.Value, w http.ResponseWriter, r *http.Request) os.Error { switch r.Method { case "HEAD", "GET", "PUT": default: return nil return &BadMethod{r.URL.Path, r.Method, val.Interface()} } ctype := "application/json" // TODO(kevlar): Content type negotiation w.Header().Set("Content-Type", ctype) if r.Method == "HEAD" { return nil } js, err := json.Marshal(val.Interface()) if err != nil { return &FailedEncode{err, ctype, val.Interface()} } if _, err := w.Write(js); err != nil { return err } return nil }
// tileHandler implements a tile renderer for use with the Google Maps JavaScript API. // See http://code.google.com/apis/maps/documentation/javascript/maptypes.html#ImageMapTypes func tileHandler(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) x, _ := strconv.Atoi(r.FormValue("x")) y, _ := strconv.Atoi(r.FormValue("y")) z, _ := strconv.Atoi(r.FormValue("z")) w.Header().Set("Content-Type", "image/png") // Try memcache first. key := fmt.Sprintf("mandelbrot:%d/%d/%d", x, y, z) if z < maxMemcacheLevel { if item, err := memcache.Get(c, key); err == nil { w.Write(item.Value) return } } b := render(x, y, z) if z < maxMemcacheLevel { memcache.Set(c, &memcache.Item{ Key: key, Value: b, Expiration: 3600, // TTL = 1 hour }) } w.Header().Set("Content-Length", strconv.Itoa(len(b))) w.Write(b) }
func gamesPost(w http.ResponseWriter, r *http.Request, u *user.User, c appengine.Context) { game := Game{ P1: r.FormValue("player1"), P2: r.FormValue("player2"), Played: datastore.SecondsToTime(time.Seconds()), } scorefields := map[string]int{ "Player1score": 0, "Player2score": 0, } for k, _ := range scorefields { score, err := strconv.Atoi(r.FormValue(k)) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } scorefields[k] = score } game.P1score = scorefields["Player1score"] game.P2score = scorefields["Player2score"] _, err := datastore.Put(c, datastore.NewIncompleteKey("Game"), &game) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } rurl := fmt.Sprintf("http://%v/", r.Host) w.Header().Set("Location", rurl) w.WriteHeader(http.StatusFound) }