ExecutionResult result = run "publish", '--info'

        then:
        verifyPublications()
        outputContains("Waiting 1000ms before next retry, 2 retries left")
        outputContains("Waiting 2000ms before next retry, 1 retries left")
        outputContains("after 2 retries")
    }


    def expectPublication() {

}

// DefaultKVS - default KV config for heal settings
var DefaultKVS = config.KVS{
	config.KV{
		Key:   Bitrot,
		Value: config.EnableOff,
	},
	config.KV{
		Key:   Sleep,
		Value: "250ms",
	},
	config.KV{
		Key:   IOCount,
		Value: "100",
	},
	config.KV{
		Key:   DriveWorkers,
		Value: "",
	},
}

const minimumBitrotCycleInMonths = 1

      http_server_read_timeout: 600s
      http_server_write_timeout: 600s
    storage_config:
      boltdb_shipper:
        index_gateway_client:
          server_address: ""
      hedging:
        at: 250ms
        max_per_second: 20
        up_to: 3
      tsdb_shipper:
        index_gateway_client:
          server_address: ""
    tracing:
      enabled: false
---
# Source: loki/templates/runtime-configmap.yaml

---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: external-service-locality
spec:
  host: {{.Host}}
  trafficPolicy:
    connectionPool:
      tcp:
        connectTimeout: 250ms
    loadBalancer:
      simple: ROUND_ROBIN
      localityLbSetting:
{{.LocalitySetting | indent 8 }}
    outlierDetection:
      interval: 1s
      baseEjectionTime: 10m
      maxEjectionPercent: 100`

		return nil, nil
	}

	buf, err := r.MarshalMsg(nil)
	if err != nil {
		return nil, err
	}

	// We do not want Gets to take so much time, anything
	// beyond 250ms we should cut it, remote cache is too
	// busy already.
	ctx, cancel := context.WithTimeout(context.Background(), 250*time.Millisecond)
	defer cancel()

			Subsystem: SchedulerSubsystem,
			Name:      "framework_extension_point_duration_seconds",
			Help:      "Latency for running all plugins of a specific extension point.",
			// Start with 0.1ms with the last bucket being [~200ms, Inf)
			Buckets:        metrics.ExponentialBuckets(0.0001, 2, 12),
			StabilityLevel: metrics.STABLE,
		},
		[]string{"extension_point", "status", "profile"})

	PluginExecutionDuration = metrics.NewHistogramVec(

        when:
        succeeds("theTask", "-D${StartParameterBuildOptions.ContinuousBuildQuietPeriodOption.PROPERTY_NAME}=5000")
        inputFile1.createFile()
        // The regular 250ms quiet period would pick up two changes.
        Thread.sleep(1000)
        inputFile2.createFile()

        then:
        buildTriggeredAndSucceeded()
        sendEOT()

	if err != nil {
		t.Fatalf("failed to get secrets: %v", err)
	}

	// First update will trigger root cert immediately, then workload cert once it expires in 200ms
	u.Expect(map[string]int{security.WorkloadKeyCertResourceName: 1, security.RootCertReqResourceName: 1})

	_, err = sc.GenerateSecret(security.WorkloadKeyCertResourceName)
	if err != nil {

func MilliCPUToQuota(milliCPU int64, period int64) (quota int64) {
	// CFS quota is measured in two values:
	//  - cfs_period_us=100ms (the amount of time to measure usage across given by period)
	//  - cfs_quota=20ms (the amount of cpu time allowed to be used across a period)
	// so in the above example, you are limited to 20% of a single CPU
	// for multi-cpu environments, you just scale equivalent amounts

    val startNanos = System.nanoTime()
    assertFailsWith<InterruptedIOException> {
      stream.takeHeaders()
    }
    val elapsedNanos = System.nanoTime() - startNanos
    awaitWatchdogIdle()
    // 200ms delta
    assertThat(TimeUnit.NANOSECONDS.toMillis(elapsedNanos).toDouble())
      .isCloseTo(500.0, 200.0)
    assertThat(connection.openStreamCount()).isEqualTo(0)