By ✨ [**sponsoring FastAPI**](../help-fastapi.md#sponsor-the-author) ✨, these companies help ensure the framework and its **ecosystem** remain healthy and **sustainable**.

			}
		}()
	}
	wg.Wait()

	var scanningDisks, healingDisks []StorageAPI
	var scanningInfos, healingInfos []DiskInfo

	for i, info := range infos {
		// Check if one of the drives in the set is being healed.
		// this information is used by scanner to skip healing
		// this erasure set while it calculates the usage.
		if info.Error != "" || disks[i] == nil {
			continue
		}
		if info.Healing {
			healing++

            buildContext.getReactorBuildStatus().halt();
        } else {
            logger.error("invalid reactor failure behavior " + rootSession.getReactorFailureBehavior());
            buildContext.getReactorBuildStatus().halt();
        }
    }

    public static void attachToThread(MavenProject currentProject) {

		return err
	}

	disk.SetDiskID(format.Erasure.This)
	if healID != "" {
		ctx := context.Background()
		ht := initHealingTracker(disk, healID)
		return ht.save(ctx)
	}
	return nil
}

// loadFormatErasure - loads format.json from disk.
func loadFormatErasure(disk StorageAPI, heal bool) (format *formatErasureV3, err error) {

			float64(v), string(k),
		)
	}
	for k, v := range bgSeq.getHealedItemsMap() {
		ch <- prometheus.MustNewConstMetric(
			prometheus.NewDesc(
				prometheus.BuildFQName(healMetricsNamespace, "objects", "healed"),
				"Objects healed since uptime",
				[]string{"type"}, nil),
			prometheus.CounterValue,
			float64(v), string(k),
		)
	}
	for k, v := range bgSeq.getHealFailedItemsMap() {
		ch <- prometheus.MustNewConstMetric(

    @Test
    @DisplayName("reauthenticate throws CIFSException when underlying call fails")
    void reauthenticate_throws() throws CIFSException {
        doThrow(new CIFSException("reauth failed")).when(session).reauthenticate();
        CIFSException ex = assertThrows(CIFSException.class, () -> session.reauthenticate());
        assertTrue(ex.getMessage().contains("failed"));

    try {
      while (true) {
        Request request = requestQueue.take();
        Object result;
        try {
          result = invokeMethod(request.methodName, request.arguments);
        } catch (ThreadDeath death) {
          return;
        } catch (InvocationTargetException exception) {
          responseQueue.put(new Response(request.methodName, null, exception.getTargetException()));
          continue;

    assert200Http2Response(execute(url), server.hostName)
    assertThat(client.connectionPool.connectionCount()).isEqualTo(1)
  }

  /** Test a previously coalesced connection that's no longer healthy.  */
  @Test
  fun staleCoalescedConnection() {
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    val connection = AtomicReference<Connection?>()
    client =
      client

		if _, ok := diskFailures[diskIndex]; ok {
			if !partNeedsHealing(dataErrsPerDisk[diskIndex]) {
				t.Errorf("Disk expected to be healed, driveIndex: %d", diskIndex)
			}
		} else {
			if partNeedsHealing(dataErrsPerDisk[diskIndex]) {
				t.Errorf("Disk not expected to be healed, driveIndex: %d", diskIndex)
			}
		}
	}
}

func TestCommonParities(t *testing.T) {

			logger.Info("Waiting for a minimum of %d drives to come online (elapsed %s)\n",
				(len(endpoints)/2)+1, getElapsedTime())
		case errors.Is(err, errErasureV3ThisEmpty):
			// need to wait for this error to be healed, so continue.
		default:
			// For all other unhandled errors we exit and fail.
			return nil, nil, err
		}

		select {
		case <-ticker.C:
		case <-globalOSSignalCh: