}

// checkUploadIDExists - verify if a given uploadID exists and is valid.
func (er erasureObjects) checkUploadIDExists(ctx context.Context, bucket, object, uploadID string, write bool) (fi FileInfo, metArr []FileInfo, err error) {
	defer func() {
		if errors.Is(err, errFileNotFound) {
			err = errUploadIDNotFound
		}
	}()

	uploadIDPath := er.getUploadIDDir(bucket, object, uploadID)

Par défaut, **FastAPI** convertirait automatiquement cette valeur de retour en JSON en utilisant le `jsonable_encoder` expliqué dans [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}.

Ensuite, en arrière-plan, il mettra ces données JSON-compatible (par exemple un `dict`) à l'intérieur d'un `JSONResponse` qui sera utilisé pour envoyer la réponse au client.

Mais vous pouvez retourner une `JSONResponse` directement à partir de vos *opérations de chemin*.

	cancel context.CancelFunc
}

func (m *metaCacheRPC) setErr(err string) {
	m.mu.Lock()
	defer m.mu.Unlock()
	meta := *m.meta
	if meta.status != scanStateError {
		meta.error = err
		meta.status = scanStateError
	} else {
		// An error is already set.
		return
	}
	meta, _ = m.o.updateMetacacheListing(meta, m.rpc)
	*m.meta = meta
}

// getErr will return an error if the listing failed.

		fi.TransitionStatus = "complete"
		fi.Size = 1 << 20

		metaArr := make([]FileInfo, N)
		for i := range N {
			fi.Erasure.Index = i + 1
			metaArr[i] = fi
			if i < agree {
				continue
			}
			metaArr[i].TransitionTier, metaArr[i].TransitionedObjName = "", ""
			metaArr[i].TransitionStatus = ""
		}
		return metaArr
	}
	mkParities := func(N, agreedParity, disagreedParity, agree int) []int {

				retErr = err
				healingLogIf(ctx, err)
				continue
			}
			// Check if bucket is object locked.
			lr, err = globalBucketObjectLockSys.Get(bucket)
			if err != nil {
				retErr = err
				healingLogIf(ctx, err)
				continue
			}
			rcfg, err = getReplicationConfig(ctx, bucket)
			if err != nil {
				retErr = err
				healingLogIf(ctx, err)
				continue

	freeVersionID := fi.TierFreeVersionID()
	freeVersionMarker := fi.TierFreeVersion()

	// Update `xl.meta` content on each disks.
	for index := range metaArr {
		if metaArr[index].IsValid() {
			metaArr[index].ModTime = modTime
			metaArr[index].VersionID = versionID
			if !metaArr[index].InlineData() {
				// If the data is not inlined, we may end up incorrectly
				// inlining the data here, that leads to an inconsistent

	if len(p) == 0 {
		return 0, r.setErr(nil, false)
	}
	r.mu.Lock()
	defer r.mu.Unlock()
	if err := r.err; err != nil {
		if err == io.EOF {
			err = ErrWriteOnClosed
		}
		return 0, err
	}
	wrote := 0
	for len(p) > 0 {
		n, err = r.write(p)
		wrote += n
		if !r.block || err == nil {
			break
		}
		err = r.setErr(err, true)

	// Save listing...
	go func() {
		if err := saver.saveMetaCacheStream(listCtx, &meta, saveCh); err != nil {
			meta.setErr(err.Error())
		}
		cancel()
	}()

	// Do listing...
	go func(o listPathOptions) {
		err := z.listMerged(listCtx, o, inCh)
		if err != nil {
			meta.setErr(err.Error())
		}
		o.debugln("listAndSave: listing", o.ID, "finished with ", err)
	}(*o)

	var candidate FileInfo
	var found bool
	for i, hash := range metaHashes {
		if hash == maxHash {
			if metaArr[i].IsValid() {
				if !found {
					candidate = metaArr[i]
					found = true
				}
				props := objProps{
					succModTime: metaArr[i].SuccessorModTime,
					numVersions: metaArr[i].NumVersions,
				}
				otherPropsMap[props]++
			}
		}
	}

	if found {

    originalSystemErr = System.err

    System.setOut(object : PrintStream(OutputStream.nullOutputStream()) {})
    System.setErr(object : PrintStream(OutputStream.nullOutputStream()) {})
  }

  fun uninstall() {
    originalSystemOut.let {
      System.setOut(it)
    }
    originalSystemErr.let {
      System.setErr(it)
    }
  }