import org.gradle.internal.service.scopes.Scope
import java.io.File


@EventScope(Scope.BuildTree::class)
interface UndeclaredBuildInputListener {
    /**
     * Called when an undeclared system property read happens.
     */
    fun systemPropertyRead(key: String, value: Any?, consumer: String?)

    fun envVariableRead(key: String, value: String?, consumer: String?)

    fun fileOpened(file: File, consumer: String?)

            return instrumentingLoader.instrumentClass(className, protectionDomain, classfileBuffer);
        } catch (Throwable th) {
            // Throwing exception from the ClassFileTransformer has no effect - if it happens, the class is loaded unchanged silently.
            // This is not something we want, so we notify the class loader about this.
            instrumentingLoader.transformFailed(className, th);
            return null;
        }

            return ClassLoader.getSystemClassLoader().loadClass(agentClassName);
        } catch (ClassNotFoundException e) {
            // This typically means that the agent is not loaded at all.
            // For now, this happens when running in a no-daemon mode, or when the Gradle distribution is not available.
            LoggerFactory.getLogger(AgentControl.class).debug("Agent {} is not loaded", agentClassName);
        }
        return null;
    }

            fileChanged("libs/build.gradle")
            projectConfigured(":plugins")
            projectsConfigured(":libs:a", ":libs:b") // TODO - should not be configured, but this currently happens to calculate the dependency substitutions
            modelsCreated(":libs")
            modelsReused(":", ":plugins", ":libs:a", ":libs:b")
        }
    }

 * builds with the configuration phase. The second mode applies the restored state to the environment and doesn't
 * track anything. This mode is used when the configuration is restored from the configuration cache.
 * Mode selection happens upon the first use of the class. Calling an operation that isn't supported in the current
 * mode results in the IllegalStateException.
 */

@ServiceScope(Scope.BuildTree::class)

        val nodeCount = nodes.size
        writeSmallInt(nodeCount)
        val scheduledNodeIds = HashMap<Node, Int>(nodeCount)
        // Not all entry nodes are always scheduled.
        // In particular, it happens when the entry node is a task of the included plugin build that runs as part of building the plugin.
        // Such tasks do not rerun when configuration cache is re-used, even if specified on the command line.

        return when {
            // TODO - always include this as a build failure;
            //  currently it is disabled when a serialization problem happens
            failDueToProblems -> {
                ConfigurationCacheProblemsException(summary.causes, summaryText)
            }

            hasTooManyProblems -> {

            // serialize the value directly as it will be part of the
            // cached state fingerprint.
            // Currently not necessary due to the unpacking that happens
            // to the TypeSanitizingProvider put around the ValueSourceProvider.
            throw IllegalStateException("build logic input")
        }
    }

                if (!containsModule(moduleName)) {
                    /*
                     * Not patching an existing module. This case should be unusual. If it nevertheless
                     * happens, add on class-path or module-path if allowed, or keep patching otherwise.
                     * The latter case (keep patching) is okay if the main module will be defined later.
                     */

	// would clear it shortly after anyways.
	e.clearCacheForService(hostname, namespace)

	return pushType
}

// updateShardServiceAccount updates the service endpoints' sa when service/endpoint event happens.
// Note: it is not concurrent safe.
func updateShardServiceAccount(shards *EndpointShards, serviceName string) bool {
	oldServiceAccount := shards.ServiceAccounts
	serviceAccounts := sets.String{}