if err != nil {
		return nil, fmt.Errorf("error initializing kube client: %w", err)
	}

	cfg := &iptables.Config{
		RestoreFormat: true,
		RedirectDNS:   args.DNSCapture,
		EnableIPv6:    args.EnableIPv6,
	}

	log.Debug("creating ipsets in the node netns")
	set, err := createHostsideProbeIpset(cfg.EnableIPv6)
	if err != nil {
		return nil, fmt.Errorf("error initializing hostside probe ipset: %w", err)
	}

		return nil, fmt.Errorf("error initializing debug server: %v", err)
	}
	if err := s.serveHTTP(); err != nil {
		return nil, fmt.Errorf("error serving http: %v", err)
	}

	// Apply the arguments to the configuration.
	if err := s.initKubeClient(args); err != nil {
		return nil, fmt.Errorf("error initializing kube client: %v", err)
	}

	s.initMeshConfiguration(args, s.fileWatcher)

                    // The very first event starts the Initializing phase
                    // TODO - should use BuildRequestMetaData to determine the build start time
                    buildStartTimestamp = startEvent.getTimestamp();
                    buildProgressOperationId = startEvent.getProgressOperationId();
                    phaseStarted(startEvent, Phase.Initializing);

spiffe://cluster.local/ns/istio-system/sa/istiod         Root     Available        false          8a516645c40ce76c2c0d27ab4e2461c1     2022-03-18T13:04:49Z     2022-03-21T13:04:49Z
spiffe://cluster.local/ns/istio-system/sa/ztunnel        NA       Initializing     false          NA                                   NA                       NA

 * main thread in order of arrival.
 */
public class TestWorker implements Action<WorkerProcessContext>, RemoteTestClassProcessor, Serializable, Stoppable {
    private enum State { INITIALIZING, STARTED, STOPPED }

    private static final Logger LOGGER = LoggerFactory.getLogger(TestWorker.class);
    public static final String WORKER_ID_SYS_PROPERTY = "org.gradle.test.worker";

		Creds:     cr.NewStaticV4(value.AccessKeyID, value.SecretAccessKey, value.SessionToken),
		Secure:    s.secure,
		Transport: s.TestSuiteCommon.client.Transport,
	})
	if err != nil {
		c.Fatalf("Error initializing client: %v", err)
	}

	// Validate that the client from sts creds can access the bucket.
	c.mustListObjects(ctx, minioClient, bucket)

	// Create an madmin client with user creds

import spock.lang.Specification

import javax.inject.Inject
import java.lang.reflect.Constructor

class NativeServicesInitializationTest extends Specification {

    def "cannot get an instance of NativeServices without initializing first" () {
        // Construct an isolated classloader so we can load a pristine NativeServices class
        // that's guaranteed not to have been initialized before
        URL[] jars = [
            jar(NativeServices),

)

var (
	htmlTemplates    *template.Template // Lazily loaded templates
	htmlTemplateInit sync.Once
)

// getHTMLTemplates returns the set of HTML templates used by pprof,
// initializing them if necessary.
func getHTMLTemplates() *template.Template {
	htmlTemplateInit.Do(func() {
		htmlTemplates = template.New("templategroup")
		addTemplates(htmlTemplates)
		report.AddSourceTemplates(htmlTemplates)
	})

		CipherSuites:   args.ServerOptions.TLSOptions.CipherSuits,
	}
	// Compliance for control plane validation and injection webhook server.
	sec_model.EnforceGoCompliance(tlsConfig)

	istiolog.Info("initializing secure webhook server for istiod webhooks")
	// create the https server for hosting the k8s injectionWebhook handlers.
	s.httpsMux = http.NewServeMux()
	s.httpsServer = &http.Server{
		Addr:      args.ServerOptions.HTTPSAddr,

[sidebar]
_Training level_: **Beginner** +
_Training time_: **55 minutes**

The tutorial covers:

<<part1_gradle_init#part1_begin,Part 1.>> Initializing the Project +
<<part2_gradle_tasks#part2_begin,Part 2.>> Running Tasks +
<<part3_gradle_dep_man#part3_begin,Part 3.>> Understanding Dependencies +
<<part4_gradle_plugins#part4_begin,Part 4.>> Applying Plugins +