- Creates a link:{groovyDslPath}/org.gradle.api.Project.html[`Project`] instance for every project.
Phase 2. Configuration::
- Evaluates the build scripts, `build.gradle(.kts)`, of every project participating in the build.
- Creates a task graph for requested tasks.
Phase 3. Execution::
- Schedules and executes the selected tasks.
- Dependencies between tasks determine execution order.

			ID:     i,
			Status: ps.Info.Status.String(),
			Used:   float64(diskStats[i].TotalSpace-diskStats[i].AvailableSpace) / float64(diskStats[i].TotalSpace),
		}
		if !ps.Participating {
			continue
		}
		// for participating pools, total bytes to be rebalanced by this pool is given by,
		// pf_c = (f_i + x)/c_i,
		// pf_c - percentage free space across pools, f_i - ith pool's free space, c_i - ith pool's capacity

public interface ConflictResolutionResult {

    /**
     * Performs an action on all conflicting modules.
     * @param action the action to execute on each participating module
     */
    void withParticipatingModules(Action<? super ModuleIdentifier> action);

    /**
     * The actual selected component.
     */
    ComponentState getSelected();

public interface PotentialConflict {
    /**
     * Executes an action with each module that participates in the conflict.
     * In a typical version conflict, e.g. org:foo:1.0 VS org:foo:2.0 there is only one participating module: org:foo.
     */
    void withParticipatingModules(Action<ModuleIdentifier> action);

    /**
     * informs whether the conflict exists
     */
    boolean conflictExists();

			}
		case "bs":
			z.Bytes, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Bytes")
				return
			}
		case "par":
			z.Participating, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Participating")
				return
			}
		case "inf":
			err = z.Info.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "Info")
				return
			}
		default:

	NumVersions       uint64        `json:"numVersions" msg:"nv"`        // Number of versions rebalanced
	Bytes             uint64        `json:"bytes" msg:"bs"`              // Number of bytes rebalanced
	Participating     bool          `json:"participating" msg:"par"`
	Info              rebalanceInfo `json:"info" msg:"inf"`
}

func (rs *rebalanceStats) update(bucket string, fi FileInfo) {
	if fi.IsLatest {
		rs.NumObjects++
	}

to contribute to Gradle or provide a patch/pull request, you can find more info [here](https://github.com/gradle/gradle/blob/master/CONTRIBUTING.md).

This project adheres to the [Gradle Code of Conduct](https://gradle.org/conduct/). By participating, you are expected to uphold this code....

  - Pool number the object operation was performed on.
  - Set number the object operation was performed on.
  - The list of drives participating in this operation belong to the set.

```json
{
  "version": "1",
  "deploymentid": "90e81272-45d9-4fe8-9c45-c9a7322bf4b5",
  "time": "2024-05-09T07:38:10.449688982Z",
  "event": "",
  "trigger": "incoming",

[[configuration_and_execution]]
= Configuration On Demand

Configuration-on-demand attempts to configure only the relevant projects for the requested tasks, i.e., it only evaluates the build script file of projects participating in the build.
This way, the configuration time of a large multi-project build can be reduced.

The configuration-on-demand feature is _incubating_, so only some builds are guaranteed to work correctly.

	if id, err = pools.initRebalanceMeta(ctx, buckets); err != nil {
		writeErrorResponseJSON(ctx, w, toAPIError(ctx, err), r.URL)
		return
	}

	// Rebalance routine is run on the first node of any pool participating in rebalance.
	pools.StartRebalance()

	b, err := json.Marshal(struct {
		ID string `json:"id"`
	}{ID: id})
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAPIError(ctx, err), r.URL)
		return