func (sh *Handler) serveSignerAttrValue(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
signer := httputil.MustGetBlobRef(req, "signer")
attr := httputil.MustGet(req, "attr")
value := httputil.MustGet(req, "value")
pn, err := sh.index.PermanodeOfSignerAttrValue(signer, attr, value)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
dr := sh.NewDescribeRequest()
dr.Describe(pn, 2)
metaMap, err := dr.metaMap()
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, &SignerAttrValueResponse{
Permanode: pn,
Meta: metaMap,
})
}
func (ui *UIHandler) serveUploadHelper(rw http.ResponseWriter, req *http.Request) {
if ui.root.Storage == nil {
httputil.ServeJSONError(rw, httputil.ServerError("No BlobRoot configured"))
return
}
mr, err := req.MultipartReader()
if err != nil {
httputil.ServeJSONError(rw, httputil.ServerError("reading body: "+err.Error()))
return
}
var got []*uploadHelperGotItem
var modTime types.Time3339
for {
part, err := mr.NextPart()
if err == io.EOF {
break
}
if err != nil {
httputil.ServeJSONError(rw, httputil.ServerError("reading body: "+err.Error()))
break
}
if part.FormName() == "modtime" {
payload, err := ioutil.ReadAll(part)
if err != nil {
log.Printf("ui uploadhelper: unable to read part for modtime: %v", err)
continue
}
modTime = types.ParseTime3339OrZero(string(payload))
continue
}
fileName := part.FileName()
if fileName == "" {
continue
}
br, err := schema.WriteFileFromReaderWithModTime(ui.root.Storage, fileName, modTime.Time(), part)
if err != nil {
httputil.ServeJSONError(rw, httputil.ServerError("writing to blobserver: "+err.Error()))
return
}
got = append(got, &uploadHelperGotItem{
FileName: part.FileName(),
ModTime: modTime,
FormName: part.FormName(),
FileRef: br,
})
}
httputil.ReturnJSON(rw, &uploadHelperResponse{Got: got})
}
func (sh *Handler) serveQuery(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var sq SearchQuery
if err := sq.fromHTTP(req); err != nil {
httputil.ServeJSONError(rw, err)
return
}
sr, err := sh.Query(&sq)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, sr)
}
func (sh *Handler) serveClaims(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var cr ClaimsRequest
cr.fromHTTP(req)
res, err := sh.GetClaims(&cr)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
}
// servePermanodesWithAttr uses the indexer to search for the permanodes matching
// the request.
// The valid values for the "attr" key in the request (i.e the only attributes
// for a permanode which are actually indexed as such) are "tag" and "title".
func (sh *Handler) servePermanodesWithAttr(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var wr WithAttrRequest
wr.fromHTTP(req)
res, err := sh.GetPermanodesWithAttr(&wr)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
}
func (sh *Handler) serveRecentPermanodes(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var rr RecentRequest
rr.fromHTTP(req)
res, err := sh.GetRecentPermanodes(&rr)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
}
// Unlike the index interface's EdgesTo method, the "edgesto" Handler
// here additionally filters out since-deleted permanode edges.
func (sh *Handler) serveEdgesTo(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var er EdgesRequest
er.fromHTTP(req)
res, err := sh.EdgesTo(&er)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
}
// handleSearch runs the requested search query against the search handler, and
// if the results are within the domain allowed by the master query, forwards them
// back to the client.
func (a *Handler) handleSearch(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost {
camhttputil.BadRequestError(w, camhttputil.InvalidMethodError{}.Error())
return
}
if a.sh == nil {
http.Error(w, "app proxy has no search handler", 500)
return
}
a.masterQueryMu.RLock()
if a.masterQuery == nil {
http.Error(w, "search is not allowed", http.StatusForbidden)
a.masterQueryMu.RUnlock()
return
}
a.masterQueryMu.RUnlock()
var sq search.SearchQuery
if err := sq.FromHTTP(r); err != nil {
camhttputil.ServeJSONError(w, err)
return
}
sr, err := a.sh.Query(&sq)
if err != nil {
camhttputil.ServeJSONError(w, err)
return
}
// check this search is in the allowed domain
if !a.allowProxySearchResponse(sr) {
// there's a chance our domainBlobs cache is expired so let's
// refresh it and retry, but no more than once per minute.
if err := a.refreshDomainBlobs(); err != nil {
http.Error(w, "search scope is forbidden", http.StatusForbidden)
return
}
if !a.allowProxySearchResponse(sr) {
http.Error(w, "search scope is forbidden", http.StatusForbidden)
return
}
}
camhttputil.ReturnJSON(w, sr)
}
func (sh *Handler) serveSignerPaths(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var sr SignerPathsRequest
sr.fromHTTP(req)
res, err := sh.GetSignerPaths(&sr)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
}
func (sh *Handler) serveDescribe(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var dr DescribeRequest
dr.fromHTTP(req)
res, err := sh.Describe(&dr)
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, res)
}
func (ui *UIHandler) serveUploadHelper(rw http.ResponseWriter, req *http.Request) {
if ui.root.Storage == nil {
httputil.ServeJSONError(rw, httputil.ServerError("No BlobRoot configured"))
return
}
mr, err := req.MultipartReader()
if err != nil {
httputil.ServeJSONError(rw, httputil.ServerError("reading body: "+err.Error()))
return
}
var got []*uploadHelperGotItem
for {
part, err := mr.NextPart()
if err == io.EOF {
break
}
if err != nil {
httputil.ServeJSONError(rw, httputil.ServerError("reading body: "+err.Error()))
break
}
fileName := part.FileName()
if fileName == "" {
continue
}
br, err := schema.WriteFileFromReader(ui.root.Storage, fileName, part)
if err != nil {
httputil.ServeJSONError(rw, httputil.ServerError("writing to blobserver: "+err.Error()))
return
}
got = append(got, &uploadHelperGotItem{
FileName: part.FileName(),
FormName: part.FormName(),
FileRef: br,
})
}
httputil.ReturnJSON(rw, &uploadHelperResponse{Got: got})
}
func (sh *Handler) serveDescribe(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
br := httputil.MustGetBlobRef(req, "blobref")
dr := sh.NewDescribeRequest()
dr.Describe(br, 4)
metaMap, err := dr.metaMapThumbs(thumbnailSize(req))
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, &DescribeResponse{metaMap})
}
func discoveryHelper(rw http.ResponseWriter, req *http.Request, dr *camtypes.Discovery) {
rw.Header().Set("Content-Type", "text/javascript")
if cb := req.FormValue("cb"); identOrDotPattern.MatchString(cb) {
fmt.Fprintf(rw, "%s(", cb)
defer rw.Write([]byte(");\n"))
} else if v := req.FormValue("var"); identOrDotPattern.MatchString(v) {
fmt.Fprintf(rw, "%s = ", v)
defer rw.Write([]byte(";\n"))
}
bytes, err := json.MarshalIndent(dr, "", " ")
if err != nil {
httputil.ServeJSONError(rw, httputil.ServerError("encoding discovery information: "+err.Error()))
return
}
rw.Write(bytes)
}
func (sh *Handler) serveDescribe(rw http.ResponseWriter, req *http.Request) {
defer httputil.RecoverJSON(rw, req)
var dr DescribeRequest
dr.fromHTTP(req)
sh.initDescribeRequest(&dr)
if dr.BlobRef.Valid() {
dr.Describe(dr.BlobRef, dr.depth())
}
for _, br := range dr.BlobRefs {
dr.Describe(br, dr.depth())
}
metaMap, err := dr.metaMapThumbs(thumbnailSize(req))
if err != nil {
httputil.ServeJSONError(rw, err)
return
}
httputil.ReturnJSON(rw, &DescribeResponse{metaMap})
}
