Method handleQueue

src/bchttp/server.go:328–395

(w http.ResponseWriter, r *http.Request)

}

func (s *Server) handleQueue(w http.ResponseWriter, r *http.Request) {
	switch {
	case r.URL.Path == "/queue/":
		handleRequest(w, r, func(ctx context.Context, req CreateQueueReq) (*CreateQueueResp, error) {
			qh, err := s.Service.CreateQueue(ctx, req.Host, req.Spec)
			if err != nil {
				return nil, err
			}
			return &CreateQueueResp{Handle: *qh}, nil
		})
		return
	}
	var queueIDStr string
	var method string
	if _, err := fmt.Sscanf(r.URL.Path, "/queue/%34s.%s", &queueIDStr, &method); err != nil {
		http.Error(w, "could not parse path "+r.URL.Path, http.StatusBadRequest)
		return
	}
	var h blobcache.Handle
	if err := h.OID.UnmarshalText([]byte(queueIDStr)); err != nil {
		http.Error(w, "could not decode queue id", http.StatusBadRequest)
		return
	}
	secretStr := r.Header.Get("X-Secret")
	if _, err := hex.Decode(h.Secret[:], []byte(secretStr)); err != nil {
		http.Error(w, "could not decode secret", http.StatusBadRequest)
		return
	}
	switch method {
	case "Inspect":
		handleRequest(w, r, func(ctx context.Context, req InspectQueueReq) (*InspectQueueResp, error) {
			info, err := s.Service.InspectQueue(ctx, h)
			if err != nil {
				return nil, err
			}
			return &InspectQueueResp{Info: info}, nil
		})
	case "Dequeue":
		handleRequest(w, r, func(ctx context.Context, req NextReq) (*NextResp, error) {
			if req.Max < 0 {
				return nil, fmt.Errorf("max cannot be negative")
			}
			buf := make([]blobcache.Message, req.Max)
			n, err := s.Service.Dequeue(ctx, h, buf, req.Opts)
			if err != nil {
				return nil, err
			}
			return &NextResp{Messages: buf[:n]}, nil
		})
	case "Enqueue":
		handleRequest(w, r, func(ctx context.Context, req InsertReq) (*blobcache.InsertResp, error) {
			resp, err := s.Service.Enqueue(ctx, h, req.Messages)
			if err != nil {
				return nil, err
			}
			return resp, nil
		})
	case "SubToVolume":