// Create a new label volume and post it to the test datastore. // Each voxel in volume has sequential labels in X, Y, then Z order. func (vol *labelVol) postLabelVolume(t *testing.T, uuid dvid.UUID, compression, roi string, startLabel uint64) { vol.makeLabelVolume(t, uuid, startLabel) apiStr := fmt.Sprintf("%snode/%s/%s/raw/0_1_2/%d_%d_%d/%d_%d_%d", server.WebAPIPath, uuid, vol.name, vol.nx, vol.ny, vol.nz, vol.offset[0], vol.offset[1], vol.offset[2]) query := true var data []byte var err error switch compression { case "lz4": apiStr += "?compression=lz4" compressed := make([]byte, lz4.CompressBound(vol.data)) var outSize int if outSize, err = lz4.Compress(vol.data, compressed); err != nil { t.Fatal(err) } data = compressed[:outSize] case "gzip": apiStr += "?compression=gzip" var buf bytes.Buffer gw := gzip.NewWriter(&buf) if _, err = gw.Write(vol.data); err != nil { t.Fatal(err) } data = buf.Bytes() if err = gw.Close(); err != nil { t.Fatal(err) } default: data = vol.data query = false } if roi != "" { if query { apiStr += "&roi=" + roi } else { apiStr += "?roi=" + roi } } server.TestHTTP(t, "POST", apiStr, bytes.NewBuffer(data)) }
// SerializeData serializes a slice of bytes using optional compression, checksum. // Checksum will be ignored if the underlying compression already employs // checksums, e.g., Gzip. func SerializeData(data []byte, compress Compression, checksum Checksum) ([]byte, error) { if data == nil || len(data) == 0 { return []byte{}, nil } var buffer bytes.Buffer // Don't duplicate checksum if using Gzip, which already has checksum & length checks. if compress.format == Gzip { checksum = NoChecksum } // Store the requested compression and checksum format := EncodeSerializationFormat(compress, checksum) if err := binary.Write(&buffer, binary.LittleEndian, format); err != nil { return nil, err } // Handle compression if requested var err error var byteData []byte switch compress.format { case Uncompressed: byteData = data case Snappy: byteData = snappy.Encode(nil, data) case LZ4: origSize := uint32(len(data)) byteData = make([]byte, lz4.CompressBound(data)+4) binary.LittleEndian.PutUint32(byteData[0:4], origSize) var outSize int outSize, err = lz4.Compress(data, byteData[4:]) if err != nil { return nil, err } byteData = byteData[:4+outSize] case Gzip: var b bytes.Buffer w, err := gzip.NewWriterLevel(&b, int(compress.level)) if err != nil { return nil, err } if _, err = w.Write(data); err != nil { return nil, err } if err = w.Close(); err != nil { return nil, err } byteData = b.Bytes() default: return nil, fmt.Errorf("Illegal compression (%s) during serialization", compress) } // Handle checksum if requested switch checksum { case NoChecksum: case CRC32: crcChecksum := crc32.ChecksumIEEE(byteData) if err := binary.Write(&buffer, binary.LittleEndian, crcChecksum); err != nil { return nil, err } default: return nil, fmt.Errorf("Illegal checksum (%s) in serialize.SerializeData()", checksum) } // Note the actual data is written last, after any checksum so we don't have to // worry about length when deserializing. if _, err := buffer.Write(byteData); err != nil { return nil, err } return buffer.Bytes(), nil }
func (d *Data) serveVolume(w http.ResponseWriter, r *http.Request, geom *GoogleSubvolGeom, noblanks bool) error { // If it's outside, write blank tile unless user wants no blanks. if geom.outside { if noblanks { http.NotFound(w, r) return fmt.Errorf("Requested subvolume is outside of available volume.") } return nil } // If we are within volume, get data from Google. url, err := geom.GetURL(d.VolumeID, "") if err != nil { return err } timedLog := dvid.NewTimeLog() client, err := d.GetClient() if err != nil { dvid.Errorf("Can't get OAuth2 connection to Google: %v\n", err) return err } resp, err := client.Get(url) if err != nil { return err } timedLog.Infof("PROXY HTTP to Google: %s, returned response %d", url, resp.StatusCode) defer resp.Body.Close() // If it's on edge, we need to pad the subvolume to the requested size. if geom.edge { return fmt.Errorf("Googlevoxels subvolume GET does not pad data on edge at this time") } // If we aren't on edge or outside, our return status should be OK. if resp.StatusCode != http.StatusOK { return fmt.Errorf("Unexpected status code %d on volume request (%q, volume id %q)", resp.StatusCode, d.DataName(), d.VolumeID) } w.Header().Set("Content-type", "application/octet-stream") queryStrings := r.URL.Query() compression := queryStrings.Get("compression") switch compression { case "lz4": // Decompress snappy sdata, err := ioutil.ReadAll(resp.Body) timedLog.Infof("Got snappy-encoded subvolume from Google, %d bytes\n", len(sdata)) if err != nil { return err } data, err := snappy.Decode(nil, sdata) if err != nil { return err } // Recompress and transmit as lz4 lz4data := make([]byte, lz4.CompressBound(data)) outSize, err := lz4.Compress(data, lz4data) if err != nil { return err } if _, err := w.Write(lz4data[:outSize]); err != nil { return err } timedLog.Infof("Sent lz4-encoded subvolume from DVID, %d bytes\n", outSize) default: // "snappy" // Just stream data from Google respBytes := 0 const BufferSize = 32 * 1024 buf := make([]byte, BufferSize) for { n, err := resp.Body.Read(buf) respBytes += n eof := (err == io.EOF) if err != nil && !eof { return err } if _, err = w.Write(buf[:n]); err != nil { return err } if f, ok := w.(http.Flusher); ok { f.Flush() } if eof { break } } timedLog.Infof("Proxied snappy-encoded subvolume from Google, %d bytes\n", respBytes) } return nil }
// ServeHTTP handles all incoming HTTP requests for this data. func (d *Data) ServeHTTP(uuid dvid.UUID, ctx *datastore.VersionedCtx, w http.ResponseWriter, r *http.Request) { // TODO -- Refactor this method to break it up and make it simpler. Use the web routing for the endpoints. timedLog := dvid.NewTimeLog() // Get the action (GET, POST) action := strings.ToLower(r.Method) switch action { case "get": case "post": case "delete": default: server.BadRequest(w, r, "labelblk only handles GET, POST, and DELETE HTTP verbs") return } // Break URL request into arguments url := r.URL.Path[len(server.WebAPIPath):] parts := strings.Split(url, "/") if len(parts[len(parts)-1]) == 0 { parts = parts[:len(parts)-1] } // Get query strings and possible roi var roiptr *imageblk.ROI queryValues := r.URL.Query() roiname := dvid.InstanceName(queryValues.Get("roi")) if len(roiname) != 0 { roiptr = new(imageblk.ROI) } // Handle POST on data -> setting of configuration if len(parts) == 3 && action == "post" { config, err := server.DecodeJSON(r) if err != nil { server.BadRequest(w, r, err) return } if err := d.ModifyConfig(config); err != nil { server.BadRequest(w, r, err) return } if err := datastore.SaveDataByUUID(uuid, d); err != nil { server.BadRequest(w, r, err) return } fmt.Fprintf(w, "Changed '%s' based on received configuration:\n%s\n", d.DataName(), config) return } if len(parts) < 4 { server.BadRequest(w, r, "Incomplete API request") return } // Process help and info. switch parts[3] { case "help": w.Header().Set("Content-Type", "text/plain") fmt.Fprintln(w, dtype.Help()) case "metadata": jsonStr, err := d.NdDataMetadata() if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-Type", "application/vnd.dvid-nd-data+json") fmt.Fprintln(w, jsonStr) case "info": jsonBytes, err := d.MarshalJSON() if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-Type", "application/json") fmt.Fprintf(w, string(jsonBytes)) case "label": // GET <api URL>/node/<UUID>/<data name>/label/<coord> if len(parts) < 5 { server.BadRequest(w, r, "DVID requires coord to follow 'label' command") return } coord, err := dvid.StringToPoint(parts[4], "_") if err != nil { server.BadRequest(w, r, err) return } label, err := d.GetLabelAtPoint(ctx.VersionID(), coord) if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-type", "application/json") jsonStr := fmt.Sprintf(`{"Label": %d}`, label) fmt.Fprintf(w, jsonStr) timedLog.Infof("HTTP %s: label at %s (%s)", r.Method, coord, r.URL) case "labels": // POST <api URL>/node/<UUID>/<data name>/labels if action != "post" { server.BadRequest(w, r, "Batch labels query must be a POST request") return } data, err := ioutil.ReadAll(r.Body) if err != nil { server.BadRequest(w, r, "Bad POSTed data for batch reverse query. Should be JSON.") return } var coords []dvid.Point3d if err := json.Unmarshal(data, &coords); err != nil { server.BadRequest(w, r, fmt.Sprintf("Bad labels request JSON: %v", err)) return } w.Header().Set("Content-type", "application/json") fmt.Fprintf(w, "[") sep := false for _, coord := range coords { label, err := d.GetLabelAtPoint(ctx.VersionID(), coord) if err != nil { server.BadRequest(w, r, err) return } if sep { fmt.Fprintf(w, ",") } fmt.Fprintf(w, "%d", label) sep = true } fmt.Fprintf(w, "]") timedLog.Infof("HTTP batch label-at-point query (%d coordinates)", len(coords)) case "blocks": // DELETE <api URL>/node/<UUID>/<data name>/blocks/<block coord>/<spanX> if len(parts) < 6 { server.BadRequest(w, r, "DVID requires starting block coord and # of blocks along X to follow 'blocks' endpoint.") return } blockCoord, err := dvid.StringToChunkPoint3d(parts[4], "_") if err != nil { server.BadRequest(w, r, err) return } span, err := strconv.Atoi(parts[5]) if err != nil { server.BadRequest(w, r, err) return } if action != "delete" { server.BadRequest(w, r, "DVID currently accepts only DELETE on the 'blocks' endpoint") return } if err := d.DeleteBlocks(ctx, blockCoord, span); err != nil { server.BadRequest(w, r, err) return } timedLog.Infof("HTTP %s: delete %d blocks from %s (%s)", r.Method, span, blockCoord, r.URL) case "pseudocolor": if len(parts) < 7 { server.BadRequest(w, r, "'%s' must be followed by shape/size/offset", parts[3]) return } shapeStr, sizeStr, offsetStr := parts[4], parts[5], parts[6] planeStr := dvid.DataShapeString(shapeStr) plane, err := planeStr.DataShape() if err != nil { server.BadRequest(w, r, err) return } switch plane.ShapeDimensions() { case 2: slice, err := dvid.NewSliceFromStrings(planeStr, offsetStr, sizeStr, "_") if err != nil { server.BadRequest(w, r, err) return } if action != "get" { server.BadRequest(w, r, "DVID does not permit 2d mutations, only 3d block-aligned stores") return } lbl, err := d.NewLabels(slice, nil) if err != nil { server.BadRequest(w, r, err) return } if roiptr != nil { roiptr.Iter, err = roi.NewIterator(roiname, ctx.VersionID(), lbl) if err != nil { server.BadRequest(w, r, err) return } } img, err := d.GetImage(ctx.VersionID(), lbl, roiptr) if err != nil { server.BadRequest(w, r, err) return } // Convert to pseudocolor pseudoColor, err := colorImage(img) if err != nil { server.BadRequest(w, r, err) return } //dvid.ElapsedTime(dvid.Normal, startTime, "%s %s upto image formatting", op, slice) var formatStr string if len(parts) >= 8 { formatStr = parts[7] } err = dvid.WriteImageHttp(w, pseudoColor, formatStr) if err != nil { server.BadRequest(w, r, err) return } timedLog.Infof("HTTP %s: %s (%s)", r.Method, plane, r.URL) default: server.BadRequest(w, r, "DVID currently supports only 2d pseudocolor image requests") return } case "raw", "isotropic": if len(parts) < 7 { server.BadRequest(w, r, "'%s' must be followed by shape/size/offset", parts[3]) return } var isotropic bool = (parts[3] == "isotropic") shapeStr, sizeStr, offsetStr := parts[4], parts[5], parts[6] planeStr := dvid.DataShapeString(shapeStr) plane, err := planeStr.DataShape() if err != nil { server.BadRequest(w, r, err) return } switch plane.ShapeDimensions() { case 2: slice, err := dvid.NewSliceFromStrings(planeStr, offsetStr, sizeStr, "_") if err != nil { server.BadRequest(w, r, err) return } if action != "get" { server.BadRequest(w, r, "DVID does not permit 2d mutations, only 3d block-aligned stores") return } rawSlice, err := dvid.Isotropy2D(d.Properties.VoxelSize, slice, isotropic) lbl, err := d.NewLabels(rawSlice, nil) if err != nil { server.BadRequest(w, r, err) return } if roiptr != nil { roiptr.Iter, err = roi.NewIterator(roiname, ctx.VersionID(), lbl) if err != nil { server.BadRequest(w, r, err) return } } img, err := d.GetImage(ctx.VersionID(), lbl, roiptr) if err != nil { server.BadRequest(w, r, err) return } if isotropic { dstW := int(slice.Size().Value(0)) dstH := int(slice.Size().Value(1)) img, err = img.ScaleImage(dstW, dstH) if err != nil { server.BadRequest(w, r, err) return } } var formatStr string if len(parts) >= 8 { formatStr = parts[7] } //dvid.ElapsedTime(dvid.Normal, startTime, "%s %s upto image formatting", op, slice) err = dvid.WriteImageHttp(w, img.Get(), formatStr) if err != nil { server.BadRequest(w, r, err) return } timedLog.Infof("HTTP %s: %s (%s)", r.Method, plane, r.URL) case 3: queryStrings := r.URL.Query() throttle := queryStrings.Get("throttle") if throttle == "true" || throttle == "on" { select { case <-server.Throttle: // Proceed with operation, returning throttle token to server at end. defer func() { server.Throttle <- 1 }() default: throttleMsg := fmt.Sprintf("Server already running maximum of %d throttled operations", server.MaxThrottledOps) http.Error(w, throttleMsg, http.StatusServiceUnavailable) return } } compression := queryValues.Get("compression") subvol, err := dvid.NewSubvolumeFromStrings(offsetStr, sizeStr, "_") if err != nil { server.BadRequest(w, r, err) return } if action == "get" { lbl, err := d.NewLabels(subvol, nil) if err != nil { server.BadRequest(w, r, err) return } if roiptr != nil { roiptr.Iter, err = roi.NewIterator(roiname, ctx.VersionID(), lbl) if err != nil { server.BadRequest(w, r, err) return } } data, err := d.GetVolume(ctx.VersionID(), lbl, roiptr) if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-type", "application/octet-stream") switch compression { case "": _, err = w.Write(data) if err != nil { server.BadRequest(w, r, err) return } case "lz4": compressed := make([]byte, lz4.CompressBound(data)) var n, outSize int if outSize, err = lz4.Compress(data, compressed); err != nil { server.BadRequest(w, r, err) return } compressed = compressed[:outSize] if n, err = w.Write(compressed); err != nil { server.BadRequest(w, r, err) return } if n != outSize { errmsg := fmt.Sprintf("Only able to write %d of %d lz4 compressed bytes\n", n, outSize) dvid.Errorf(errmsg) server.BadRequest(w, r, errmsg) return } case "gzip": gw := gzip.NewWriter(w) if _, err = gw.Write(data); err != nil { server.BadRequest(w, r, err) return } if err = gw.Close(); err != nil { server.BadRequest(w, r, err) return } default: server.BadRequest(w, r, "unknown compression type %q", compression) return } } else { if isotropic { server.BadRequest(w, r, "can only POST 'raw' not 'isotropic' images") return } // Make sure vox is block-aligned if !dvid.BlockAligned(subvol, d.BlockSize()) { server.BadRequest(w, r, "cannot store labels in non-block aligned geometry %s -> %s", subvol.StartPoint(), subvol.EndPoint()) return } var data []byte switch compression { case "": tlog := dvid.NewTimeLog() data, err = ioutil.ReadAll(r.Body) if err != nil { server.BadRequest(w, r, err) return } tlog.Debugf("read 3d uncompressed POST") case "lz4": tlog := dvid.NewTimeLog() data, err = ioutil.ReadAll(r.Body) if err != nil { server.BadRequest(w, r, err) return } if len(data) == 0 { server.BadRequest(w, r, "received 0 LZ4 compressed bytes") return } tlog.Debugf("read 3d lz4 POST") tlog = dvid.NewTimeLog() uncompressed := make([]byte, subvol.NumVoxels()*8) err = lz4.Uncompress(data, uncompressed) if err != nil { server.BadRequest(w, r, err) return } data = uncompressed tlog.Debugf("uncompressed 3d lz4 POST") case "gzip": tlog := dvid.NewTimeLog() gr, err := gzip.NewReader(r.Body) if err != nil { server.BadRequest(w, r, err) return } data, err = ioutil.ReadAll(gr) if err != nil { server.BadRequest(w, r, err) return } if err = gr.Close(); err != nil { server.BadRequest(w, r, err) return } tlog.Debugf("read and uncompress 3d gzip POST") default: server.BadRequest(w, r, "unknown compression type %q", compression) return } lbl, err := d.NewLabels(subvol, data) if err != nil { server.BadRequest(w, r, err) return } if roiptr != nil { roiptr.Iter, err = roi.NewIterator(roiname, ctx.VersionID(), lbl) if err != nil { server.BadRequest(w, r, err) return } } if err = d.PutVoxels(ctx.VersionID(), lbl.Voxels, roiptr); err != nil { server.BadRequest(w, r, err) return } } timedLog.Infof("HTTP %s: %s (%s)", r.Method, subvol, r.URL) default: server.BadRequest(w, r, "DVID currently supports shapes of only 2 and 3 dimensions") return } default: server.BadRequest(w, r, "Unrecognized API call %q for labelblk data %q. See API help.", parts[3], d.DataName()) } }
// ServeHTTP handles all incoming HTTP requests for this data. func (d *Data) ServeHTTP(uuid dvid.UUID, ctx *datastore.VersionedCtx, w http.ResponseWriter, r *http.Request) { timedLog := dvid.NewTimeLog() versionID := ctx.VersionID() // Get the action (GET, POST) action := strings.ToLower(r.Method) // Break URL request into arguments url := r.URL.Path[len(server.WebAPIPath):] parts := strings.Split(url, "/") if len(parts[len(parts)-1]) == 0 { parts = parts[:len(parts)-1] } // Handle POST on data -> setting of configuration if len(parts) == 3 && action == "put" { config, err := server.DecodeJSON(r) if err != nil { server.BadRequest(w, r, err) return } if err := d.ModifyConfig(config); err != nil { server.BadRequest(w, r, err) return } if err := datastore.SaveDataByUUID(uuid, d); err != nil { server.BadRequest(w, r, err) return } fmt.Fprintf(w, "Changed '%s' based on received configuration:\n%s\n", d.DataName(), config) return } if len(parts) < 4 { server.BadRequest(w, r, "Incomplete API request") return } // Process help and info. switch parts[3] { case "help": w.Header().Set("Content-Type", "text/plain") fmt.Fprintln(w, dtype.Help()) case "info": jsonBytes, err := d.MarshalJSON() if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-Type", "application/json") fmt.Fprintf(w, string(jsonBytes)) case "sparsevol": // GET <api URL>/node/<UUID>/<data name>/sparsevol/<label> // POST <api URL>/node/<UUID>/<data name>/sparsevol/<label> // HEAD <api URL>/node/<UUID>/<data name>/sparsevol/<label> if len(parts) < 5 { server.BadRequest(w, r, "ERROR: DVID requires label ID to follow 'sparsevol' command") return } label, err := strconv.ParseUint(parts[4], 10, 64) if err != nil { server.BadRequest(w, r, err) return } if label == 0 { server.BadRequest(w, r, "Label 0 is protected background value and cannot be used as sparse volume.\n") return } queryValues := r.URL.Query() var b Bounds b.VoxelBounds, err = dvid.BoundsFromQueryString(r) if err != nil { server.BadRequest(w, r, "Error parsing bounds from query string: %v\n", err) return } b.BlockBounds = b.VoxelBounds.Divide(d.BlockSize) b.Exact = true if queryValues.Get("exact") == "false" { b.Exact = false } compression := queryValues.Get("compression") switch action { case "get": data, err := GetSparseVol(ctx, label, b) if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-type", "application/octet-stream") switch compression { case "": _, err = w.Write(data) if err != nil { server.BadRequest(w, r, err) return } case "lz4": compressed := make([]byte, lz4.CompressBound(data)) var n, outSize int if outSize, err = lz4.Compress(data, compressed); err != nil { server.BadRequest(w, r, err) return } compressed = compressed[:outSize] if n, err = w.Write(compressed); err != nil { server.BadRequest(w, r, err) return } if n != outSize { errmsg := fmt.Sprintf("Only able to write %d of %d lz4 compressed bytes\n", n, outSize) dvid.Errorf(errmsg) server.BadRequest(w, r, errmsg) return } case "gzip": gw := gzip.NewWriter(w) if _, err = gw.Write(data); err != nil { server.BadRequest(w, r, err) return } if err = gw.Close(); err != nil { server.BadRequest(w, r, err) return } default: server.BadRequest(w, r, "unknown compression type %q", compression) return } case "head": w.Header().Set("Content-type", "text/html") found, err := FoundSparseVol(ctx, label, b) if err != nil { server.BadRequest(w, r, err) return } if found { w.WriteHeader(http.StatusOK) } else { w.WriteHeader(http.StatusNoContent) } return case "post": server.BadRequest(w, r, "POST of sparsevol not currently implemented\n") return // if err := d.PutSparseVol(versionID, label, r.Body); err != nil { // server.BadRequest(w, r, err) // return // } default: server.BadRequest(w, r, "Unable to handle HTTP action %s on sparsevol endpoint", action) return } timedLog.Infof("HTTP %s: sparsevol on label %d (%s)", r.Method, label, r.URL) case "sparsevol-by-point": // GET <api URL>/node/<UUID>/<data name>/sparsevol-by-point/<coord> if len(parts) < 5 { server.BadRequest(w, r, "ERROR: DVID requires coord to follow 'sparsevol-by-point' command") return } coord, err := dvid.StringToPoint(parts[4], "_") if err != nil { server.BadRequest(w, r, err) return } source, err := d.GetSyncedLabelblk(versionID) if err != nil { server.BadRequest(w, r, err) return } label, err := source.GetLabelAtPoint(ctx.VersionID(), coord) if err != nil { server.BadRequest(w, r, err) return } if label == 0 { server.BadRequest(w, r, "Label 0 is protected background value and cannot be used as sparse volume.\n") return } data, err := GetSparseVol(ctx, label, Bounds{}) if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-type", "application/octet-stream") _, err = w.Write(data) if err != nil { server.BadRequest(w, r, err) return } timedLog.Infof("HTTP %s: sparsevol-by-point at %s (%s)", r.Method, coord, r.URL) case "sparsevol-coarse": // GET <api URL>/node/<UUID>/<data name>/sparsevol-coarse/<label> if len(parts) < 5 { server.BadRequest(w, r, "DVID requires label ID to follow 'sparsevol-coarse' command") return } label, err := strconv.ParseUint(parts[4], 10, 64) if err != nil { server.BadRequest(w, r, err) return } if label == 0 { server.BadRequest(w, r, "Label 0 is protected background value and cannot be used as sparse volume.\n") return } data, err := GetSparseCoarseVol(ctx, label) if err != nil { server.BadRequest(w, r, err) return } w.Header().Set("Content-type", "application/octet-stream") _, err = w.Write(data) if err != nil { server.BadRequest(w, r, err) return } timedLog.Infof("HTTP %s: sparsevol-coarse on label %d (%s)", r.Method, label, r.URL) case "maxlabel": // GET <api URL>/node/<UUID>/<data name>/maxlabel w.Header().Set("Content-Type", "application/json") switch action { case "get": maxlabel, ok := d.MaxLabel[versionID] if !ok { server.BadRequest(w, r, "No maximum label found for %s version %d\n", d.DataName(), versionID) return } fmt.Fprintf(w, "{%q: %d}", "maxlabel", maxlabel) default: server.BadRequest(w, r, "Unknown action %q requested: %s\n", action, r.URL) return } timedLog.Infof("HTTP maxlabel request (%s)", r.URL) case "nextlabel": // GET <api URL>/node/<UUID>/<data name>/nextlabel // POST <api URL>/node/<UUID>/<data name>/nextlabel w.Header().Set("Content-Type", "application/json") switch action { case "get": fmt.Fprintf(w, "{%q: %d}", "nextlabel", d.MaxRepoLabel+1) case "post": server.BadRequest(w, r, "POST on maxlabel is not supported yet.\n") return default: server.BadRequest(w, r, "Unknown action %q requested: %s\n", action, r.URL) return } timedLog.Infof("HTTP maxlabel request (%s)", r.URL) case "split": // POST <api URL>/node/<UUID>/<data name>/split/<label> if action != "post" { server.BadRequest(w, r, "Split requests must be POST actions.") return } if len(parts) < 5 { server.BadRequest(w, r, "ERROR: DVID requires label ID to follow 'split' command") return } fromLabel, err := strconv.ParseUint(parts[4], 10, 64) if err != nil { server.BadRequest(w, r, err) return } if fromLabel == 0 { server.BadRequest(w, r, "Label 0 is protected background value and cannot be used as sparse volume.\n") return } toLabel, err := d.SplitLabels(ctx.VersionID(), fromLabel, r.Body) if err != nil { server.BadRequest(w, r, fmt.Sprintf("split: %v", err)) return } w.Header().Set("Content-Type", "application/json") fmt.Fprintf(w, "{%q: %d}", "label", toLabel) timedLog.Infof("HTTP split request (%s)", r.URL) case "split-coarse": // POST <api URL>/node/<UUID>/<data name>/split-coarse/<label> if action != "post" { server.BadRequest(w, r, "Split-coarse requests must be POST actions.") return } if len(parts) < 5 { server.BadRequest(w, r, "ERROR: DVID requires label ID to follow 'split' command") return } fromLabel, err := strconv.ParseUint(parts[4], 10, 64) if err != nil { server.BadRequest(w, r, err) return } if fromLabel == 0 { server.BadRequest(w, r, "Label 0 is protected background value and cannot be used as sparse volume.\n") return } toLabel, err := d.SplitCoarseLabels(ctx.VersionID(), fromLabel, r.Body) if err != nil { server.BadRequest(w, r, fmt.Sprintf("split-coarse: %v", err)) return } w.Header().Set("Content-Type", "application/json") fmt.Fprintf(w, "{%q: %d}", "label", toLabel) timedLog.Infof("HTTP split-coarse request (%s)", r.URL) case "merge": // POST <api URL>/node/<UUID>/<data name>/merge if action != "post" { server.BadRequest(w, r, "Merge requests must be POST actions.") return } data, err := ioutil.ReadAll(r.Body) if err != nil { server.BadRequest(w, r, "Bad POSTed data for merge. Should be JSON.") return } var tuple labels.MergeTuple if err := json.Unmarshal(data, &tuple); err != nil { server.BadRequest(w, r, fmt.Sprintf("Bad merge op JSON: %v", err)) return } mergeOp, err := tuple.Op() if err != nil { server.BadRequest(w, r, err) return } if err := d.MergeLabels(ctx.VersionID(), mergeOp); err != nil { server.BadRequest(w, r, fmt.Sprintf("Error on merge: %v", err)) return } timedLog.Infof("HTTP merge request (%s)", r.URL) default: server.BadRequest(w, r, "Unrecognized API call %q for labelvol data %q. See API help.", parts[3], d.DataName()) } }