# flood reviews with unnecessary requests to demonstrate Istio rate limiting, asynchoronously


async def floodReviewsAsynchronously(product_id, headers):
    # the response is disregarded
    await asyncio.gather(*(getProductReviewsIgnoreResponse(product_id, headers) for _ in range(flood_factor)))

# flood reviews with unnecessary requests to demonstrate Istio rate limiting


def floodReviews(product_id, headers):

=== Listing projects
Running the `projects` task gives you a list of the subprojects of the selected project, displayed in a hierarchy:

----
$ gradle projects
----

You also get a project report within https://scans.gradle.com/[Build Scans].

[[sec:listing_tasks]]
=== Listing tasks

	// listing 1 - everything ok, infra container set up for pod
	pleg.Relist()
	actualEvents := getEventsFromChannel(ch)
	actualStatus, actualErr := pleg.cache.Get(podID)
	assert.Equal(t, goodStatus, actualStatus)
	assert.Equal(t, nil, actualErr)
	assert.Exactly(t, []*PodLifecycleEvent{goodEvent}, actualEvents)

Go 1.22 adds a configurable limit to control the maximum acceptable RSA key size
that can be used in TLS handshakes, controlled by the [`tlsmaxrsasize` setting](/pkg/crypto/tls#Conn.Handshake).
The default is tlsmaxrsasize=8192, limiting RSA to 8192-bit keys. To avoid
denial of service attacks, this setting and default was backported to Go
1.19.13, Go 1.20.8, and Go 1.21.1.

Go 1.22 made it an error for a request or response read by a net/http

It can be set with the environment variable `GRADLE_USER_HOME`.

TIP: Not to be confused with the `GRADLE_HOME`, the optional installation directory for Gradle.

It is roughly structured as follows:

[listing]
----
├── caches // <1>
│   ├── 4.8 // <2>
│   ├── 4.9 // <2>
│   ├── ⋮
│   ├── jars-3 // <3>
│   └── modules-2 // <3>
├── daemon // <4>
│   ├── ⋮
│   ├── 4.8
│   └── 4.9
├── init.d // <5>

	if err != nil {
		// Since we're getting stuff from a local cache, it is basically
		// impossible to get this error.
		c.eventRecorder.Eventf(service, v1.EventTypeWarning, "FailedToListPods",
			"Error listing Pods for Service %s/%s: %v", service.Namespace, service.Name, err)
		return err
	}

	esLabelSelector := labels.Set(map[string]string{
		discovery.LabelServiceName: service.Name,

   *     wait on each method call to the proxy
   * @param timeoutUnit with timeoutDuration, the maximum length of time that callers are willing to
   *     wait on each method call to the proxy
   * @return a time-limiting proxy
   * @throws IllegalArgumentException if {@code interfaceType} is a regular class, enum, or
   *     annotation type, rather than an interface
   */
  @SuppressWarnings("GoodTime") // should accept a java.time.Duration

- new versions of dynamic dependencies
- new versions of changing modules (modules which use the same version string but can have different contents)

--
Refreshing dependencies will cause Gradle to invalidate its listing caches.
However:

- it will perform HTTP HEAD requests on metadata files but _will not re-download them_ if they are identical

that is, they do not share state. Yet by default, Gradle only runs one task at a time.
To execute tasks belonging to different subprojects in parallel, use the `parallel` flag:

====
[listing.terminal]
----
$ gradle <task> --parallel
----
====

To execute project tasks in parallel by default, add the following setting to the `gradle.properties` file in the project root or your Gradle home:

====

        failure.assertHasErrorOutput("- testCredentialsUsername")
        failure.assertHasErrorOutput("- testCredentialsPassword")
    }

    def "missing credentials declared as task inputs do not break tasks listing"() {
        when:
        buildFile << """
            tasks.register('lazyTask', TaskWithCredentials) {
                credentials.set(providers.credentials(PasswordCredentials, 'testCredentials'))
            }