| /* |
| * 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.apache.log4j.LogManager |
| import org.codehaus.groovy.grails.commons.ConfigurationHolder |
| import org.codehaus.groovy.grails.commons.cfg.ConfigurationHelper |
| import org.codehaus.groovy.grails.plugins.logging.Log4jConfig |
| import org.springframework.core.io.FileSystemResource |
| |
| /** |
| * Gant script that packages a Grails application (note: does not create WAR) |
| * |
| * @author Graeme Rocher |
| * |
| * @since 0.4 |
| */ |
| |
| includeTargets << grailsScript("_GrailsCompile") |
| includeTargets << grailsScript("_PackagePlugins") |
| |
| |
| target( createConfig: "Creates the configuration object") { |
| if(configFile.exists()) { |
| def configClass |
| try { |
| configClass = classLoader.loadClass("Config") |
| } catch (ClassNotFoundException cnfe) { |
| println "WARNING: No config found for the application." |
| } |
| if(configClass) { |
| try { |
| config = configSlurper.parse(configClass) |
| config.setConfigFile(configFile.toURI().toURL()) |
| |
| ConfigurationHolder.setConfig(config) |
| } |
| catch(Exception e) { |
| logError("Failed to compile configuration file",e) |
| exit(1) |
| } |
| } |
| } |
| def dataSourceFile = new File("${basedir}/grails-app/conf/DataSource.groovy") |
| if(dataSourceFile.exists()) { |
| try { |
| def dataSourceConfig = configSlurper.parse(classLoader.loadClass("DataSource")) |
| config.merge(dataSourceConfig) |
| ConfigurationHolder.setConfig(config) |
| } |
| catch(ClassNotFoundException e) { |
| println "WARNING: DataSource.groovy not found, assuming dataSource bean is configured by Spring..." |
| } |
| catch(Exception e) { |
| logError("Error loading DataSource.groovy",e) |
| exit(1) |
| } |
| } |
| ConfigurationHelper.initConfig(config, null, classLoader) |
| } |
| |
| target( packageApp : "Implementation of package target") { |
| depends(createStructure, packagePlugins, packageTlds) |
| |
| try { |
| profile("compile") { |
| compile() |
| } |
| } |
| catch(Exception e) { |
| logError("Compilation error",e) |
| exit(1) |
| } |
| profile("creating config") { |
| createConfig() |
| } |
| |
| configureServerContextPath() |
| |
| String i18nDir = "${resourcesDirPath}/grails-app/i18n" |
| ant.mkdir(dir:i18nDir) |
| |
| def files = ant.fileScanner { |
| fileset(dir:"${basedir}/grails-app/views", includes:"**/*.jsp") |
| } |
| |
| if(files.iterator().hasNext()) { |
| ant.mkdir(dir:"${basedir}/web-app/WEB-INF/grails-app/views") |
| ant.copy(todir:"${basedir}/web-app/WEB-INF/grails-app/views") { |
| fileset(dir:"${basedir}/grails-app/views", includes:"**/*.jsp") |
| } |
| } |
| |
| if(config.grails.enable.native2ascii) { |
| profile("converting native message bundles to ascii") { |
| ant.native2ascii(src:"${basedir}/grails-app/i18n", |
| dest:i18nDir, |
| includes:"*.properties", |
| encoding:"UTF-8") |
| } |
| } |
| else { |
| ant.copy(todir:i18nDir) { |
| fileset(dir:"${basedir}/grails-app/i18n", includes:"*.properties") |
| } |
| } |
| ant.copy(todir:classesDirPath) { |
| fileset(dir:"${basedir}", includes:metadataFile.name) |
| } |
| |
| // Copy resources from various directories to the target "resources" dir. |
| packageFiles(basedir) |
| |
| startLogging() |
| |
| loadPlugins() |
| generateWebXml() |
| event("PackagingEnd",[]) |
| } |
| |
| target(configureServerContextPath: "Configuring server context path") { |
| // Get the application context path by looking for a property named 'app.context' in the following order of precedence: |
| // System properties |
| // application.properties |
| // config |
| // default to grailsAppName if not specified |
| |
| serverContextPath = System.getProperty("app.context") |
| serverContextPath = serverContextPath ?: metadata.'app.context' |
| serverContextPath = serverContextPath ?: config.grails.app.context |
| serverContextPath = serverContextPath ?: grailsAppName |
| |
| if(!serverContextPath.startsWith('/')) { |
| serverContextPath = "/${serverContextPath}" |
| } |
| } |
| |
| |
| target(startLogging:"Bootstraps logging") { |
| LogManager.resetConfiguration() |
| if(config.log4j instanceof Closure) { |
| profile("configuring log4j") { |
| new Log4jConfig().configure(config.log4j) |
| } |
| } |
| else { |
| // setup default logging |
| new Log4jConfig().configure() |
| } |
| } |
| |
| target( generateWebXml : "Generates the web.xml file") { |
| depends(classpath) |
| |
| if(buildConfig.grails.config.base.webXml) { |
| def customWebXml = resolveResources(buildConfig.grails.config.base.webXml) |
| if(customWebXml) |
| webXml = customWebXml[0] |
| else { |
| event("StatusError", [ "Custom web.xml defined in config [${buildConfig.grails.config.base.webXml}] could not be found." ]) |
| exit(1) |
| } |
| } |
| else { |
| webXml = new FileSystemResource("${basedir}/src/templates/war/web.xml") |
| def tmpWebXml = "${projectWorkDir}/web.xml.tmp" |
| if(!webXml.exists()) { |
| copyGrailsResource(tmpWebXml, grailsResource("src/war/WEB-INF/web${servletVersion}.template.xml")) |
| } |
| else { |
| ant.copy(file:webXml.file, tofile:tmpWebXml, overwrite:true) |
| } |
| webXml = new FileSystemResource(tmpWebXml) |
| ant.replace(file:tmpWebXml, token:"@grails.project.key@", value:"${grailsAppName}-${grailsEnv}-${grailsAppVersion}") |
| } |
| def sw = new StringWriter() |
| |
| try { |
| profile("generating web.xml from $webXml") { |
| event("WebXmlStart", [webXml.filename]) |
| pluginManager.doWebDescriptor(webXml, sw) |
| webXmlFile.withWriter { |
| it << sw.toString() |
| } |
| event("WebXmlEnd", [webXml.filename]) |
| } |
| } |
| catch(Exception e) { |
| logError("Error generating web.xml file",e) |
| exit(1) |
| } |
| |
| } |
| |
| target(packageTemplates: "Packages templates into the app") { |
| ant.mkdir(dir:scaffoldDir) |
| if(new File("${basedir}/src/templates/scaffolding").exists()) { |
| ant.copy(todir:scaffoldDir, overwrite:true) { |
| fileset(dir:"${basedir}/src/templates/scaffolding", includes:"**") |
| } |
| } |
| else { |
| copyGrailsResources(scaffoldDir, "src/grails/templates/scaffolding/*") |
| } |
| } |
| |
| target(packageTlds:"packages tld definitions for the correct servlet version") { |
| // We don't know until runtime what servlet version to use, so |
| // install the relevant TLDs now. |
| copyGrailsResources("${basedir}/web-app/WEB-INF/tld", "src/war/WEB-INF/tld/${servletVersion}/*") |
| } |
| |
| // Checks whether the project's sources have changed since the last |
| // compilation, and then performs a recompilation if this is the case. |
| // Returns the updated 'lastModified' value. |
| recompileCheck = { lastModified, callback -> |
| try { |
| def ant = new AntBuilder() |
| def classpathId = "grails.compile.classpath" |
| ant.taskdef (name: 'groovyc', classname : 'org.codehaus.groovy.grails.compiler.GrailsCompiler') |
| ant.path(id:classpathId,compileClasspath) |
| |
| ant.groovyc(destdir:classesDirPath, |
| classpathref:classpathId, |
| encoding:"UTF-8", |
| projectName:baseName) { |
| src(path:"${basedir}/src/groovy") |
| src(path:"${basedir}/grails-app/domain") |
| src(path:"${basedir}/grails-app/utils") |
| src(path:"${basedir}/src/java") |
| javac(classpathref:classpathId, debug:"yes") |
| |
| } |
| ant = null |
| } |
| catch(Exception e) { |
| compilationError = true |
| logError("Error automatically restarting container",e) |
| } |
| |
| def tmp = classesDir.lastModified() |
| if(lastModified < tmp) { |
| |
| // run another compile JIT |
| try { |
| callback() |
| } |
| catch(Exception e) { |
| logError("Error automatically restarting container",e) |
| } |
| |
| finally { |
| lastModified = classesDir.lastModified() |
| } |
| } |
| |
| return lastModified |
| } |
