Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: GRAILS-10826
Fetching contributors…

Cannot retrieve contributors at this time

153 lines (128 sloc) 5.174 kb
/*
* Copyright 2004-2005 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
import org.codehaus.groovy.grails.cli.interactive.InteractiveMode
import org.codehaus.groovy.grails.compiler.GrailsProjectWatcher
import org.codehaus.groovy.grails.project.container.GrailsProjectRunner
/**
* Executes Grails using an embedded server.
*
* @author Graeme Rocher
*
* @since 0.4
*/
includeTargets << grailsScript("_GrailsWar")
SCHEME_HTTP = GrailsProjectRunner.SCHEME_HTTP
SCHEME_HTTPS = GrailsProjectRunner.SCHEME_HTTPS
projectRunner = new GrailsProjectRunner(projectPackager, warCreator, classLoader)
// Keep track of whether we're running in HTTPS mode in case we need
// to restart the server.
usingSecureServer = false
grailsServer = null
grailsContext = null
autoRecompile = System.getProperty("disable.auto.recompile") ? !(System.getProperty("disable.auto.recompile").toBoolean()) : true
// How often should recompilation occur while the application is running (in seconds)?
// Defaults to 3s.
recompileFrequency = System.getProperty("recompile.frequency")
recompileFrequency = recompileFrequency ? recompileFrequency.toInteger() : 3
// Should the reloading agent be enabled? By default, yes...
isReloading = System.getProperty("grails.reload.enabled")
isReloading = isReloading != null ? isReloading.toBoolean() : true
// This isn't used within this script but may come in handy for scripts
// that depend on this one.
ant.path(id: "grails.runtime.classpath", runtimeClasspath)
/**
* Runs the application in dev mode, i.e. with class-reloading.
*/
target(runApp: "Main implementation that executes a Grails application") {
grailsServer = projectRunner.runApp()
}
/**
* Runs the application in dev mode over HTTPS.
*/
target(runAppHttps: "Main implementation that executes a Grails application with an HTTPS listener") {
grailsServer = projectRunner.runAppHttps()
}
/**
* Runs the application using the WAR file directly.
*/
target(runWar: "Main implementation that executes a Grails application WAR") {
grailsServer = projectRunner.runWar()
}
/**
* Runs the application over HTTPS using the WAR file directly.
*/
target(runWarHttps: "Main implementation that executes a Grails application WAR") {
grailsServer = projectRunner.runWarHttps()
}
/**
* Starts the plugin scanner. Call this after starting the server if you
* want changes to artifacts automatically detected and loaded.
*/
target(startPluginScanner: "Starts the plugin manager's scanner that detects changes to artifacts.") {
if (!GrailsProjectWatcher.isReloadingAgentPresent() || GrailsProjectWatcher.isActive()) {
return
}
if (isReloading) {
new GrailsProjectWatcher(projectCompiler, pluginManager).with {
reloadExcludes = (config?.grails?.reload?.excludes instanceof List) ? config?.grails?.reload?.excludes : []
reloadIncludes = (config?.grails?.reload?.includes instanceof List) ? config?.grails?.reload?.includes : []
start()
}
}
}
target(stopPluginScanner: "Stops the plugin manager's scanner that detects changes to artifacts.") {
// do nothing, here for compatibility
}
/**
* Keeps the server alive and checks for changes in domain classes or
* source files under "src". If any changes are detected, the servlet
* container is restarted.
*/
target(watchContext: "Watches the WEB-INF/classes directory for changes and restarts the server if necessary") {
depends(classpath)
def im = InteractiveMode.current
if (!im) {
keepServerAlive()
return
}
Thread.start {
im.grailsServer = grailsServer
im.run()
}
keepServerAlive()
}
target(keepServerAlive: "Idles the script, ensuring that the server stays running.") {
boolean keepRunning = true
def killFile = new File(basedir, '.kill-run-app')
if (killFile.exists()) {
grailsConsole.warning ".kill-run-app file exists - perhaps a previous server stop didn't work?. Deleting and continuing anyway."
killFile.delete()
}
while (keepRunning || Boolean.getBoolean("TomcatKillSwitch.active")) {
sleep(recompileFrequency * 1000)
// Check whether the kill file exists. This is a hack for the functional
// tests so that we can stop the servers that are started.
if (killFile.exists()) {
grailsConsole.updateStatus "Stopping server..."
grailsServer.stop()
killFile.delete()
keepRunning = false
}
}
}
target(stopServer: "Stops the Grails servlet container") {
projectWatcher?.stopServer()
}
Jump to Line
Something went wrong with that request. Please try again.