)
        invokeApplyPluginsTo()
    }

    fun emitStage2ProgramFor(scriptFile: File, originalPath: String) {

        val scriptDefinition = stage2ScriptDefinition
        val compiledScriptClass = compileScript(
            scriptFile,
            originalPath,
            scriptDefinition,
            StableDisplayNameFor.stage2
        )

    compilerOptions: KotlinCompilerOptions,
    scriptFile: File,
    scriptDef: ScriptDefinition,
    classPath: List<File>,
    logger: Logger,
    pathTranslation: (String) -> String
): String {

    compileKotlinScriptModuleTo(
        outputDirectory,
        compilerOptions,
        "buildscript",
        listOf(scriptFile.path),
        scriptDef,
        classPath,

						</mapping>
					</mappings>
					<preinstallScriptlet>
						<scriptFile>${project.build.directory}/generated-packaging/rpm/scripts/preinst</scriptFile>
						<fileEncoding>utf-8</fileEncoding>
					</preinstallScriptlet>
					<postinstallScriptlet>
						<scriptFile>${project.build.directory}/generated-packaging/rpm/scripts/postinst</scriptFile>
						<fileEncoding>utf-8</fileEncoding>
					</postinstallScriptlet>

    fun `can apply Groovy script from url`() {
        withOwnGradleUserHomeDir("we need an empty external resource cache") {
            val server = HttpServer()
            server.start()

            val scriptFile = withFile(
                "script.gradle",
                """
                task hello {
                    doLast {
                        println "Hello!"
                    }

                        scriptSource.withLocationAwareExceptionHandling {

                            scriptHost.temporaryFileProvider.withTemporaryScriptFileFor(originalScriptPath, program.secondStageScriptText) { scriptFile ->

                                ResidualProgramCompiler(
                                    outputDir,
                                    host.compilerOptions,

        if (validationErrors.isNotEmpty()) {
            throw LocationAwareException(
                IllegalArgumentException(validationErrors.joinToString("\n")),
                plugin.scriptFile.path,
                requests.first().lineNumber
            )
        }
    }

    private
    fun validationErrorFor(pluginRequest: PluginRequestInternal): String? {

        given:
        def existingDslFixture = dslFixtureFor(existingScriptDsl as BuildInitDsl)
        def targetDslFixture = dslFixtureFor(targetScriptDsl as BuildInitDsl)

        and:
        existingDslFixture.scriptFile("build").createFile()

        when:
        initFailsWith targetScriptDsl as BuildInitDsl

        then:
        result.assertTasksExecuted(":init")

        throw PrecompiledScriptException(
            String.format(
                "The precompiled plugin (%s) cannot start with '%s' or be in the '%s' package.", this.relativePath(scriptPlugin.scriptFile),
                DefaultPluginManager.CORE_PLUGIN_NAMESPACE, DefaultPluginManager.CORE_PLUGIN_NAMESPACE
            ),
            null,
            PRECOMPILED_SCRIPT_MANUAL.getConsultDocumentationMessage()
        )

            writer.write(ProjectSpecificFingerprint.ProjectFingerprint(project, value), trace)
        }
    }

    override fun onScriptFileResolved(scriptFile: File) {
        fileObserved(scriptFile)
    }
}


internal
fun jvmFingerprint() = String.format(
    "%s|%s|%s",
    System.getProperty("java.vm.name"),
    System.getProperty("java.vm.vendor"),

import okio.Buffer
import okio.BufferedSink
import okio.BufferedSource
import okio.Sink
import okio.Timeout
import okio.buffer
import okio.sink
import okio.source

/**
 * A scriptable web server. Callers supply canned responses and the server replays them upon request
 * in sequence.
 */
@ExperimentalOkHttpApi
class MockWebServer : Closeable {
  private val taskRunnerBackend =