when: "the build runs until it enters continuous build"
        succeeds("runPlay")

        then:
        appIsRunningAndDeployed()
    }

    def "can run play app multiple times with continuous build" () {
        when:
        succeeds("runPlay")

        then:
        appIsRunningAndDeployed()

        when:
        file("conf/routes") << "\n# changed"

    }

    TestFile getPlayRunBuildFile() {
        buildFile
    }

    def writeSources() {
        playApp.writeSources(testDirectory)

        playRunBuildFile << """
            runPlay {
                httpPort = 0
                ${jpmsForkOptions()}
            }
        """

        settingsFile << """
            rootProject.name = '${playApp.name}'
        """
    }

	if runway > goal {
		trigger = minTrigger
	} else {
		trigger = goal - runway
	}
	trigger = max(trigger, minTrigger)
	trigger = min(trigger, maxTrigger)
	if trigger > goal {
		print("trigger=", trigger, " heapGoal=", goal, "\n")
		print("minTrigger=", minTrigger, " maxTrigger=", maxTrigger, "\n")
		throw("produced a trigger greater than the heap goal")
	}
	return trigger, goal
}

		Name:           name,
		CurrentVersion: currentVersion,
		NewVersion:     newVersion,
		NodeName:       nodeName,
	}
}

// runPlan takes care of outputting available versions to upgrade to for the user
func runPlan(flagSet *pflag.FlagSet, flags *planFlags, args []string, printer output.Printer) error {

        //(SF) this is a workaround until this story is completed. I'm hardcoding setting the idle timeout to be max X mins.
        //this way we avoid potential runaway daemons that steal resources on linux and break builds on windows.
        //We might leave that in if we decide it's a good idea for an extra safety net.
        int maxTimeout = 2 * 60 * 1000;

	}
	deadline := time.Now().Add(time.Second * 5)
	for {
		// If another process is holding a write lock, this call will exit
		// with an error. F_SETLK is used instead of F_SETLKW to avoid
		// the case where a runaway process grabs the exclusive lock and
		// blocks this call indefinitely.
		// https://man7.org/linux/man-pages/man2/fcntl.2.html
		lock := syscall.Flock_t{Type: syscall.F_WRLCK}