docs: private void handleUIDMeta(final TSDB tsdb, final HttpQuery query) {
  
      final HttpMethod method = query.getAPIMethod();
      // GET
      if (method == HttpMethod.GET) {
        
        final String uid = query.getRequiredQueryStringParam("uid");
        final UniqueIdType type = UniqueId.stringToUniqueIdType(
            query.getRequiredQueryStringParam("type"));
        try {
          final UIDMeta meta = UIDMeta.getUIDMeta(tsdb, type, uid)
          .joinUninterruptibly();
          query.sendReply(query.serializer().formatUidMetaV1(meta));
        } catch (NoSuchUniqueId e) {
          throw new BadRequestException(HttpResponseStatus.NOT_FOUND, 
              "Could not find the requested UID", e);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      // POST
      } else if (method == HttpMethod.POST || method == HttpMethod.PUT) {
        
        final UIDMeta meta;
        if (query.hasContent()) {
          meta = query.serializer().parseUidMetaV1();
        } else {
          meta = this.parseUIDMetaQS(query);
        }
        
        /**
         * Storage callback used to determine if the storage call was successful
         * or not. Also returns the updated object from storage.
         */
        class SyncCB implements Callback<Deferred<UIDMeta>, Boolean> {
          
          @Override
          public Deferred<UIDMeta> call(Boolean success) throws Exception {
            if (!success) {
              throw new BadRequestException(
                  HttpResponseStatus.INTERNAL_SERVER_ERROR,
                  "Failed to save the UIDMeta to storage", 
                  "This may be caused by another process modifying storage data");
            }
            
            return UIDMeta.getUIDMeta(tsdb, meta.getType(), meta.getUID());
          }
          
        }
        
        try {
          final Deferred<UIDMeta> process_meta = meta.syncToStorage(tsdb, 
              method == HttpMethod.PUT).addCallbackDeferring(new SyncCB());
          final UIDMeta updated_meta = process_meta.joinUninterruptibly();
          tsdb.indexUIDMeta(updated_meta);
          query.sendReply(query.serializer().formatUidMetaV1(updated_meta));
        } catch (IllegalStateException e) {
          query.sendStatusOnly(HttpResponseStatus.NOT_MODIFIED);
        } catch (IllegalArgumentException e) {
          throw new BadRequestException(e);
        } catch (NoSuchUniqueId e) {
          throw new BadRequestException(HttpResponseStatus.NOT_FOUND, 
              "Could not find the requested UID", e);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
      // DELETE    
      } else if (method == HttpMethod.DELETE) {
        
        final UIDMeta meta;
        if (query.hasContent()) {
          meta = query.serializer().parseUidMetaV1();
        } else {
          meta = this.parseUIDMetaQS(query);
        }
        try {        
          meta.delete(tsdb).joinUninterruptibly();
          tsdb.deleteUIDMeta(meta);
        } catch (IllegalArgumentException e) {
          throw new BadRequestException("Unable to delete UIDMeta information", e);
        } catch (NoSuchUniqueId e) {
          throw new BadRequestException(HttpResponseStatus.NOT_FOUND, 
              "Could not find the requested UID", e);
        } catch (Exception e) {
          throw new RuntimeException(e);
        }
        query.sendStatusOnly(HttpResponseStatus.NO_CONTENT);
        
      } else {
        throw new BadRequestException(HttpResponseStatus.METHOD_NOT_ALLOWED, 
            "Method not allowed", "The HTTP method [" + method.getName() +
            "] is not permitted for this endpoint");
      }
    }