// handler is the main demo entry point that calls the GCS operations. func handler(w http.ResponseWriter, r *http.Request) { if r.URL.Path != "/" { http.NotFound(w, r) return } ctx := appengine.NewContext(r) if bucket == "" { var err error if bucket, err = file.DefaultBucketName(ctx); err != nil { log.Errorf(ctx, "failed to get default GCS bucket name: %v", err) return } } client, err := storage.NewClient(ctx) if err != nil { log.Errorf(ctx, "failed to get default GCS bucket name: %v", err) return } defer client.Close() w.Header().Set("Content-Type", "text/plain; charset=utf-8") fmt.Fprintf(w, "Demo GCS Application running from Version: %v\n", appengine.VersionID(ctx)) fmt.Fprintf(w, "Using bucket name: %v\n\n", bucket) d := &demo{ w: w, ctx: ctx, client: client, bucket: client.Bucket(bucket), } n := "demo-testfile-go" d.createFile(n) d.readFile(n) d.copyFile(n) d.statFile(n) d.createListFiles() d.listBucket() d.listBucketDirMode() d.defaultACL() d.putDefaultACLRule() d.deleteDefaultACLRule() d.bucketACL() d.putBucketACLRule() d.deleteBucketACLRule() d.acl(n) d.putACLRule(n) d.deleteACLRule(n) d.deleteFiles() if d.failed { io.WriteString(w, "\nDemo failed.\n") } else { io.WriteString(w, "\nDemo succeeded.\n") } }
func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) { if e := fn(w, r); e != nil { ctx := appengine.NewContext(r) aelog.Errorf(ctx, "%v", e.Error) http.Error(w, e.Message, e.Code) } }
func runFunc(c context.Context, w http.ResponseWriter, req *http.Request) { defer req.Body.Close() var inv invocation if err := gob.NewDecoder(req.Body).Decode(&inv); err != nil { log.Errorf(c, "delay: failed decoding task payload: %v", err) log.Warningf(c, "delay: dropping task") return } f := funcs[inv.Key] if f == nil { log.Errorf(c, "delay: no func with key %q found", inv.Key) log.Warningf(c, "delay: dropping task") return } ft := f.fv.Type() in := []reflect.Value{reflect.ValueOf(c)} for _, arg := range inv.Args { var v reflect.Value if arg != nil { v = reflect.ValueOf(arg) } else { // Task was passed a nil argument, so we must construct // the zero value for the argument here. n := len(in) // we're constructing the nth argument var at reflect.Type if !ft.IsVariadic() || n < ft.NumIn()-1 { at = ft.In(n) } else { at = ft.In(ft.NumIn() - 1).Elem() } v = reflect.Zero(at) } in = append(in, v) } out := f.fv.Call(in) if n := ft.NumOut(); n > 0 && ft.Out(n-1) == errorType { if errv := out[n-1]; !errv.IsNil() { log.Errorf(c, "delay: func failed (will retry): %v", errv.Interface()) w.WriteHeader(http.StatusInternalServerError) return } } }
func handleMainPage(w http.ResponseWriter, r *http.Request) { if r.Method != "GET" { http.Error(w, "GET requests only", http.StatusMethodNotAllowed) return } if r.URL.Path != "/" { http.NotFound(w, r) return } ctx := appengine.NewContext(r) tic := time.Now() q := datastore.NewQuery("Greeting").Ancestor(guestbookKey(ctx)).Order("-Date").Limit(10) var gg []*Greeting if _, err := q.GetAll(ctx, &gg); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) log.Errorf(ctx, "GetAll: %v", err) return } log.Infof(ctx, "Datastore lookup took %s", time.Since(tic).String()) log.Infof(ctx, "Rendering %d greetings", len(gg)) var email, logout, login string if u := user.Current(ctx); u != nil { logout, _ = user.LogoutURL(ctx, "/") email = u.Email } else { login, _ = user.LoginURL(ctx, "/") } data := struct { Greetings []*Greeting Login, Logout, Email string }{ Greetings: gg, Login: login, Logout: logout, Email: email, } w.Header().Set("Content-Type", "text/html; charset=utf-8") if err := tpl.ExecuteTemplate(w, "guestbook.html", data); err != nil { log.Errorf(ctx, "%v", err) } }
// Enabled returns whether an API's capabilities are enabled. // The wildcard "*" capability matches every capability of an API. // If the underlying RPC fails (if the package is unknown, for example), // false is returned and information is written to the application log. func Enabled(ctx context.Context, api, capability string) bool { req := &pb.IsEnabledRequest{ Package: &api, Capability: []string{capability}, } res := &pb.IsEnabledResponse{} if err := internal.Call(ctx, "capability_service", "IsEnabled", req, res); err != nil { log.Warningf(ctx, "capability.Enabled: RPC failed: %v", err) return false } switch *res.SummaryStatus { case pb.IsEnabledResponse_ENABLED, pb.IsEnabledResponse_SCHEDULED_FUTURE, pb.IsEnabledResponse_SCHEDULED_NOW: return true case pb.IsEnabledResponse_UNKNOWN: log.Errorf(ctx, "capability.Enabled: unknown API capability %s/%s", api, capability) return false default: return false } }
func handle(w http.ResponseWriter, req *http.Request) { c := appengine.NewContext(req) u := user.Current(c) if u == nil { u, _ = user.CurrentOAuth(c, "https://www.googleapis.com/auth/cloud-platform", "https://www.googleapis.com/auth/appengine.apis", ) } if u == nil || !u.Admin { w.Header().Set("Content-Type", "text/plain; charset=utf-8") w.WriteHeader(http.StatusUnauthorized) io.WriteString(w, "You must be logged in as an administrator to access this.\n") return } if req.Header.Get("X-Appcfg-Api-Version") == "" { w.Header().Set("Content-Type", "text/plain; charset=utf-8") w.WriteHeader(http.StatusForbidden) io.WriteString(w, "This request did not contain a necessary header.\n") return } if req.Method != "POST" { // Response must be YAML. rtok := req.FormValue("rtok") if rtok == "" { rtok = "0" } w.Header().Set("Content-Type", "text/yaml; charset=utf-8") fmt.Fprintf(w, `{app_id: %q, rtok: %q}`, internal.FullyQualifiedAppID(c), rtok) return } defer req.Body.Close() body, err := ioutil.ReadAll(req.Body) if err != nil { w.WriteHeader(http.StatusBadRequest) log.Errorf(c, "Failed reading body: %v", err) return } remReq := &pb.Request{} if err := proto.Unmarshal(body, remReq); err != nil { w.WriteHeader(http.StatusBadRequest) log.Errorf(c, "Bad body: %v", err) return } service, method := *remReq.ServiceName, *remReq.Method if !requestSupported(service, method) { w.WriteHeader(http.StatusBadRequest) log.Errorf(c, "Unsupported RPC /%s.%s", service, method) return } rawReq := &rawMessage{remReq.Request} rawRes := &rawMessage{} err = internal.Call(c, service, method, rawReq, rawRes) remRes := &pb.Response{} if err == nil { remRes.Response = rawRes.buf } else if ae, ok := err.(*internal.APIError); ok { remRes.ApplicationError = &pb.ApplicationError{ Code: &ae.Code, Detail: &ae.Detail, } } else { // This shouldn't normally happen. log.Errorf(c, "appengine/remote_api: Unexpected error of type %T: %v", err, err) remRes.ApplicationError = &pb.ApplicationError{ Code: proto.Int32(0), Detail: proto.String(err.Error()), } } out, err := proto.Marshal(remRes) if err != nil { // This should not be possible. w.WriteHeader(500) log.Errorf(c, "proto.Marshal: %v", err) return } log.Infof(c, "Spooling %d bytes of response to /%s.%s", len(out), service, method) w.Header().Set("Content-Type", "application/octet-stream") w.Header().Set("Content-Length", strconv.Itoa(len(out))) w.Write(out) }
func (d *demo) errorf(format string, args ...interface{}) { d.failed = true log.Errorf(d.ctx, format, args...) }