}()

		clog, _, _, err := getLog(runner, resources, config, namespace, pod, "")
		appendGlobalErr(err)
		writeFile(filepath.Join(archive.CniPath(tempDir, pod), "cni.log"), clog, config.DryRun)
		log.Infof("Done with CNI logs %v", pod)
	}()
}

// getLog fetches the logs for the given namespace/pod/container and returns the log text and stats for it.

    protected final String sourceClass;

    protected final Log logger;

    public JclLoggerAdapter(final Class<?> clazz) {
        sourceClass = clazz.getName();
        logger = LogFactory.getLog(clazz);
    }

    @Override
    public boolean isFatalEnabled() {
        return logger.isFatalEnabled();
    }

    @Override
    public void fatal(final String message) {
        logger.fatal(message);

	if !ok {
		err = fmt.Errorf("error reading plugin list from CNI config")
		return
	}
	return
}

// Given the raw plugin interface, return the plugin asserted as a map[string]interface{}
func GetPlugin(rawPlugin any) (plugin map[string]any, err error) {
	plugin, ok := rawPlugin.(map[string]any)
	if !ok {
		err = fmt.Errorf("error reading plugin from CNI config plugin list")
		return
	}
	return
}

    void killDaemonOnly() {
        new ProcessFixture(context.pid).kill(false)
    }

    @Override
    String toString() {
        "Daemon with context $context"
    }

    @Override
    String getLog() {
        return daemonLog.text
    }

    @Override
    File getLogFile() {
        return daemonLog.file
    }

			plugins, err := util.GetPlugins(cniConfigMap)
			if err != nil {
				return fmt.Errorf("%s: %w", in.cniConfigFilepath, err)
			}
			for i, rawPlugin := range plugins {
				plugin, err := util.GetPlugin(rawPlugin)
				if err != nil {
					return fmt.Errorf("%s: %w", in.cniConfigFilepath, err)
				}
				if plugin["type"] == "istio-cni" {
					cniConfigMap["plugins"] = append(plugins[:i], plugins[i+1:]...)

public interface DaemonFixture {
    /**
     * Returns the context information of this daemon.
     */
    DaemonContext getContext();

    /**
     * Returns the log for this daemon.
     */
    String getLog();

    /**
     * Returns the log file for this daemon.
     */
    File getLogFile();

    /**
     * Returns whether the log file contains a given String.
     *

        assert actual == version
    }

    void hasPlugin(String alias, String id, String version) {
        assert model.hasPlugin(alias)
        def plugin = model.getPlugin(alias)
        assert plugin != null : "Expected a plugin with alias '$alias' but it wasn't found"
        assert plugin.id == id
        assert plugin.version.requiredVersion == version
    }

        when:
        plugin.apply(project)

        then:
        project.plugins.hasPlugin(JavaPlugin.class)

        project.convention.getPlugin(ApplicationPluginConvention.class) != null
        project.applicationName == project.name
        project.mainClassName == null
        project.applicationDefaultJvmArgs == []

    }

    @Test
    void canExecuteExternalScriptAgainstAnArbitraryObject() {
        createBuildSrc()

        testFile('external.gradle') << '''
println 'quiet message'
getLogging().captureStandardOutput(LogLevel.ERROR)
println 'error message'
new BuildSrcClass()
assert 'doStuff' == name
assert buildscript.classLoader == getClass().classLoader.parent

org.apache.maven.plugin; public abstract synchronized class AbstractMojo implements Mojo, ContextEnabled { private logging.Log log; private java.util.Map pluginContext; public void AbstractMojo(); public void setLog(logging.Log); public logging.Log getLog(); public java.util.Map getPluginContext(); public void setPluginContext(java.util.Map); } org/apache/maven/plugin/AbstractMojoExecutio.class package org.apache.maven.plugin; public abstract synchronized class AbstractMojoExecutio extends Exception...