if err != nil {
			return "", err
		}
	}

	if err = file.AtomicWrite(cniConfigFilepath, cniConfig, os.FileMode(0o644)); err != nil {
		installLog.Errorf("Failed to write CNI config file %v: %v", cniConfigFilepath, err)
		return cniConfigFilepath, err
	}

	if cfg.chainedCNIPlugin && strings.HasSuffix(cniConfigFilepath, ".conf") {

    enabled: false
resultsCache:
  enabled: false
chunksCache:
  enabled: false
singleBinary:
  replicas: 1
deploymentMode: SingleBinary
gateway:
  enabled: false
read:
  replicas: 0
write:
  replicas: 0
backend:

	data, err := os.ReadFile(src)
	if err != nil {
		t.Fatalf("Failed to read file %v, err: %v", src, err)
	}
	if err = os.WriteFile(dest, data, os.FileMode(defaultFileMode)); err != nil {
		t.Fatalf("Failed to write file %v, err: %v", dest, err)
	}
}

func rmDir(dir string, t *testing.T) {
	t.Helper()
	err := os.RemoveAll(dir)
	if err != nil {
		t.Fatalf("Failed to remove dir %v, err: %v", dir, err)
	}
}

It should be noted there is a circular dependency with mTLS authentication; in order to fetch a certificate we need
a certificate. This can be handled in various ways:
* `GenerateSecret` may additionally write any signed certificates to disk, with `OUTPUT_CERTS` configured.
* Users may have external CA setups that pre-configure certificates.
* The CaClient can use JWT token for the initial setup, then switch to mTLS certificates.

	if err != nil {
		log.Errorf("istio-cni failed with: %v", err)
		if err := err.Print(); err != nil {
			log.Errorf("istio-cni failed to write error JSON to stdout: %v", err)
		}

		return err
	}

	return nil

	@$(MAKE_DOCKER) $@

default:
	@$(MAKE_DOCKER)

shell:
	@$(RUN) /bin/bash

.PHONY: default shell

else

# If we are not in build container, we need a workaround to get environment properly set
# Write to file, then include
$(shell mkdir -p out)
$(shell $(shell pwd)/common/scripts/setup_env.sh envfile > out/.env)
include out/.env
# An export free of arguments in a Makefile places all variables in the Makefile into the

(absent(pilot_xds_lds_reject{app=\"istiod\"}) - 1)", "format": "time_series", "hide": false, "intervalFactor": 1, "legendFormat": "Rejected LDS Configs", "refId": "B" }, { "expr": "sum(rate(pilot_xds_write_timeout{app=\"istiod\"}[1m]))", "format": "time_series", "intervalFactor": 1, "legendFormat": "Write Timeouts", "refId": "F" }, { "expr": "sum(rate(pilot_total_xds_internal_errors{app=\"istiod\"}[1m]))", "format": "time_series", "hide": false, "intervalFactor": 1, "legendFormat": "Internal Errors",...

  // (whether or not they contain an Ingress section) are assumed to affect Ingress.
  // If you want to write an egress-only policy, you must explicitly specify policyTypes [ "Egress" ].
  // Likewise, if you want to write a policy that specifies that no egress is allowed,
  // you must specify a policyTypes value that include "Egress" (since such a policy would not include

	testServer := httptest.NewServer(http.HandlerFunc(func(res http.ResponseWriter, req *http.Request) {
		res.WriteHeader(http.StatusOK)
		res.Write([]byte("server happy"))
	}))
	defer func() { testServer.Close() }()

	cniC := fakeCNIEventClient(testServer.URL)

	err := PushCNIEvent(cniC, fakeCmdArgs, []*cniv1.IPConfig{&fakePrevResultIPConfig}, "testpod", "testns")

		t.Error("want error on local write failure")
	}

	w = &fakeOutputWriter{failAfter: 1, injectError: errors.New("error")}
	if err := writeEncodedObject(w, s); err == nil {
		t.Error("want error on remote write failure")
	}

	w = &fakeOutputWriter{failAfter: 2, injectError: errors.New("error")}
	if err := writeEncodedObject(w, s); err == nil {
		t.Error("want error on third write failure")
	}