// Package-wide variables from generator "generated".
option go_package = "k8s.io/api/node/v1beta1";

// Overhead structure represents the resource overhead associated with running a pod.
message Overhead {
  // podFixed represents the fixed resource overhead associated with running a pod.
  // +optional
  map<string, .k8s.io.apimachinery.pkg.api.resource.Quantity> podFixed = 1;
}

 */
public class ServiceLifecycle implements AsyncStoppable {
    private enum State {RUNNING, STOPPING, STOPPED}

    private final String displayName;
    private final Lock lock = new ReentrantLock();
    private final Condition condition = lock.newCondition();
    private final Map<Thread, Integer> usages = new HashMap<>();
    private State state = State.RUNNING;

    public ServiceLifecycle(String displayName) {

		true, rdir, edir)

	// We expect an error here.
	if err == nil {
		t.Logf("%s", output)
		t.Fatalf("running 'harness -tp %s': did not get expected error", tp)
	}

	got := strings.TrimSpace(string(output))
	want := "WriteCountersDir invoked for program built"
	if !strings.Contains(got, want) {
		t.Errorf("running 'harness -tp %s': got:\n%s\nwant: %s",
			tp, got, want)
	}
	upmergeCoverData(t, edir, naMode)

// Package-wide variables from generator "generated".
option go_package = "k8s.io/api/node/v1";

// Overhead structure represents the resource overhead associated with running a pod.
message Overhead {
  // podFixed represents the fixed resource overhead associated with running a pod.
  // +optional
  map<string, k8s.io.apimachinery.pkg.api.resource.Quantity> podFixed = 1;
}

    + row.withPanels([
      panels.timeSeries.simple('Pilot Versions', queries.istioBuild, 'Version number of each running instance'),
    ]),
  ], panelHeight=5)
  + grid.makeGrid([
    row.new('Resource Usage')
    + row.withPanels([
      panels.timeSeries.bytes('Memory Usage', queries.goMemoryUsage, 'Memory usage of each running instance'),

	if r.runningTasks.IsEmpty() {
		return
	}
	common.LogAndPrintf("The following fetches are still running: \n")
	for t := range r.runningTasks {
		common.LogAndPrintf("  %s\n", t)
	}
	common.LogAndPrintf("\n")
}

func (r *Runner) addRunningTask(task string) {
	// Limit the concurrency of running tasks.
	r.taskSem <- struct{}{}

	r.runningTasksMu.Lock()
	defer r.runningTasksMu.Unlock()

  ~Coordinator();

  /// Registers a runner, i.e. a unit of running threads which is usually a
  /// QueueRunner. It takes the ownership of runner to avoid lifecycle-related
  /// problems. Note, the coordinator would not start these threads; they are
  /// supposed to be in running state when they are registered here.
  Status RegisterRunner(std::unique_ptr<RunnerInterface> runner);

    "initContainerStatuses": [
      {
        "name": "nameValue",
        "state": {
          "waiting": {
            "reason": "reasonValue",
            "message": "messageValue"
          },
          "running": {
            "startedAt": "2001-01-01T01:01:01Z"
          },
          "terminated": {
            "exitCode": 1,
            "signal": 2,
            "reason": "reasonValue",

    static class TestDeploymentHandle implements DeploymentHandle {
        boolean running

        @Override
        void start(Deployment deploymentActivity) {
            running = true
        }

        @Override
        boolean isRunning() {
            return running
        }

        @Override
        void stop() {
            running = false
        }
    }

    + row.withPanels([
      panels.timeSeries.base('Ztunnel Versions', queries.istioBuild, 'Version number of each running instance'),
      panels.timeSeries.bytes('Memory Usage', queries.memUsage, 'Memory usage of each running instance'),
      panels.timeSeries.base('CPU Usage', queries.cpuUsage, 'CPU usage of each running instance'),
    ]),
    row.new('Network')
    + row.withPanels([