private View createGrailsView(String viewName) throws Exception {
// try GSP if res is null
GrailsWebRequest webRequest = WebUtils.retrieveGrailsWebRequest();
HttpServletRequest request = webRequest.getCurrentRequest();
GroovyObject controller = webRequest.getAttributes().getController(request);
if (grailsApplication == null) {
grailsApplication =
getApplicationContext()
.getBean(GrailsApplication.APPLICATION_ID, GrailsApplication.class);
}
ResourceLoader loader = establishResourceLoader(grailsApplication);
String format =
request.getAttribute(GrailsApplicationAttributes.CONTENT_FORMAT) != null
? request.getAttribute(GrailsApplicationAttributes.CONTENT_FORMAT).toString()
: null;
String gspView = localPrefix + viewName + DOT + format + GSP_SUFFIX;
Resource res = null;
if (format != null) {
res = loader.getResource(gspView);
if (!res.exists()) {
View v = lookupBinaryPluginView(webRequest, controller, gspView);
if (v != null) {
return v;
}
gspView = resolveViewForController(controller, grailsApplication, viewName, loader);
res = loader.getResource(gspView);
}
}
if (res == null || !res.exists()) {
gspView = localPrefix + viewName + GSP_SUFFIX;
res = loader.getResource(gspView);
if (!res.exists()) {
View v = lookupBinaryPluginView(webRequest, controller, gspView);
if (v != null) {
return v;
}
gspView = resolveViewForController(controller, grailsApplication, viewName, loader);
res = loader.getResource(gspView);
}
}
if (res.exists()) {
return createGroovyPageView(webRequest, gspView);
}
AbstractUrlBasedView view = buildView(viewName);
view.setApplicationContext(getApplicationContext());
view.afterPropertiesSet();
return view;
}
private void validatePaths(
String path, ResourcePatternResolver resourceLoader, boolean shouldExist) throws IOException {
Resource res = resourceLoader.getResource(path);
if (shouldExist) {
Assert.isTrue(res.exists(), "The input path [" + path + "] does not exist");
} else {
Assert.isTrue(!res.exists(), "The output path [" + path + "] already exists");
}
}
public void testNonExistentFileOutsideOSGi() throws Exception {
String nonExistingLocation = thisClass.getURL().toExternalForm().concat("-bogus-extension");
Resource nonExistingFile = defaultLoader.getResource(nonExistingLocation);
assertNotNull(nonExistingFile);
assertFalse(nonExistingFile.exists());
Resource nonExistingFileOutsideOsgi = resourceLoader.getResource(nonExistingLocation);
assertNotNull(nonExistingFileOutsideOsgi);
assertFalse(nonExistingFileOutsideOsgi.exists());
}
// adapted from DefaultGrailsApplication
private static Map loadMetadata() {
Resource r = new ClassPathResource(PROJECT_META_FILE);
if (r.exists()) {
return loadMetadata(r);
}
String basedir = System.getProperty("base.dir");
if (basedir != null) {
r = new FileSystemResource(new File(basedir, PROJECT_META_FILE));
if (r.exists()) {
return loadMetadata(r);
}
}
return null;
}
/**
* Attempts to retrieve a reference to a GSP as a Spring Resource instance for the given URI.
*
* @param uri The URI to check
* @return A Resource instance
*/
private Resource getResourceForUri(String uri) {
Resource r;
r = getResourceWithinContext(uri);
if (r == null || !r.exists()) {
// try plugin
String pluginUri = GrailsResourceUtils.WEB_INF + uri;
r = getResourceWithinContext(pluginUri);
if (r == null || !r.exists()) {
uri = getUriWithinGrailsViews(uri);
return getResourceWithinContext(uri);
}
}
return r;
}
public void testFileOutsideOSGi() throws Exception {
String fileLocation = "file:///" + thisClass.getFile().getAbsolutePath();
// use file system resource defaultLoader
Resource fileResource = defaultLoader.getResource(fileLocation);
assertTrue(fileResource.exists());
// try loading the file using OsgiBundleResourceLoader
Resource osgiResource = resourceLoader.getResource(fileLocation);
// check existence of the same file when loading through the
// OsgiBundleRL
// NOTE andyp -- we want this to work!!
assertTrue(osgiResource.exists());
assertEquals(fileResource.getURL(), osgiResource.getURL());
}
public void setAdsResource(Resource resource)
throws ParserConfigurationException, IOException, SAXException {
advertisementBlocks.clear();
if (resource != null && resource.exists() && resource.isReadable()) {
final DocumentBuilder builder = BUILDER_FACTORY.newDocumentBuilder();
final Document document = builder.parse(resource.getInputStream());
final Element root = document.getDocumentElement();
final String client = root.getAttribute("client");
final NodeList blocks = root.getElementsByTagName("block");
for (int i = 0; i < blocks.getLength(); i++) {
final Element block = (Element) blocks.item(i);
final String name = block.getAttribute("name");
final NodeList items = block.getElementsByTagName("item");
for (int j = 0; j < items.getLength(); j++) {
final Element item = (Element) items.item(j);
final String slot = item.getAttribute("slot");
final Language language = Language.byCode(item.getAttribute("language"));
final int width = Integer.valueOf(item.getAttribute("width"));
final int height = Integer.valueOf(item.getAttribute("height"));
advertisementBlocks.put(
new AdsBlockKey(name, language),
new AdvertisementBlock(client, slot, width, height, AdvertisementProvider.GOOGLE));
}
}
}
}
private boolean renderTemplate(
Object target, GroovyObject controller, GrailsWebRequest webRequest, Map argMap, Writer out) {
boolean renderView;
String templateName = argMap.get(ARGUMENT_TEMPLATE).toString();
String contextPath = getContextPath(webRequest, argMap);
String var = (String) argMap.get(ARGUMENT_VAR);
// get the template uri
String templateUri = GroovyPageUtils.getTemplateURI(controller, templateName);
// retrieve gsp engine
GroovyPagesTemplateEngine engine =
(GroovyPagesTemplateEngine)
webRequest.getApplicationContext().getBean(GroovyPagesTemplateEngine.BEAN_ID);
try {
Resource r = engine.getResourceForUri(contextPath + templateUri);
if (!r.exists()) {
r = engine.getResourceForUri(contextPath + "/grails-app/views/" + templateUri);
}
Template t = engine.createTemplate(r); // templateUri);
if (t == null) {
throw new ControllerExecutionException(
"Unable to load template for uri [" + templateUri + "]. Template not found.");
}
Map binding = new HashMap();
if (argMap.containsKey(ARGUMENT_BEAN)) {
Object bean = argMap.get(ARGUMENT_BEAN);
if (argMap.containsKey(ARGUMENT_MODEL)) {
Object modelObject = argMap.get(ARGUMENT_MODEL);
if (modelObject instanceof Map) binding.putAll((Map) modelObject);
}
renderTemplateForBean(t, binding, bean, var, out);
} else if (argMap.containsKey(ARGUMENT_COLLECTION)) {
Object colObject = argMap.get(ARGUMENT_COLLECTION);
if (argMap.containsKey(ARGUMENT_MODEL)) {
Object modelObject = argMap.get(ARGUMENT_MODEL);
if (modelObject instanceof Map) binding.putAll((Map) modelObject);
}
renderTemplateForCollection(t, binding, colObject, var, out);
} else if (argMap.containsKey(ARGUMENT_MODEL)) {
Object modelObject = argMap.get(ARGUMENT_MODEL);
renderTemplateForModel(t, modelObject, target, out);
} else {
Writable w = t.make(new BeanMap(target));
w.writeTo(out);
}
renderView = false;
} catch (GroovyRuntimeException gre) {
throw new ControllerExecutionException(
"Error rendering template [" + templateName + "]: " + gre.getMessage(), gre);
} catch (IOException ioex) {
throw new ControllerExecutionException(
"I/O error executing render method for arguments [" + argMap + "]: " + ioex.getMessage(),
ioex);
}
return renderView;
}
/** Find extended mime.types from the spring-context-support module. */
private static FileTypeMap initFileTypeMap() {
Resource resource = new ClassPathResource("org/springframework/mail/javamail/mime.types");
if (resource.exists()) {
if (logger.isTraceEnabled()) {
logger.trace("Loading JAF FileTypeMap from " + resource);
}
InputStream inputStream = null;
try {
inputStream = resource.getInputStream();
return new MimetypesFileTypeMap(inputStream);
} catch (IOException ex) {
// ignore
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException ex) {
// ignore
}
}
}
}
if (logger.isTraceEnabled()) {
logger.trace("Loading default Java Activation Framework FileTypeMap");
}
return FileTypeMap.getDefaultFileTypeMap();
}
private void doExecuteScript(final Resource scriptResource) {
if (scriptResource == null || !scriptResource.exists()) return;
final JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
String[] scripts;
try {
String[] list =
StringUtils.delimitedListToStringArray(
stripComments(IOUtils.readLines(scriptResource.getInputStream())), ";");
scripts = list;
} catch (IOException e) {
throw new BeanInitializationException("Cannot load script from [" + scriptResource + "]", e);
}
for (int i = 0; i < scripts.length; i++) {
final String script = scripts[i].trim();
TransactionTemplate transactionTemplate =
new TransactionTemplate(new DataSourceTransactionManager(dataSource));
transactionTemplate.execute(
new TransactionCallback<Void>() {
@Override
public Void doInTransaction(TransactionStatus status) {
if (StringUtils.hasText(script)) {
try {
jdbcTemplate.execute(script);
} catch (DataAccessException e) {
if (!script.toUpperCase().startsWith("DROP")) {
throw e;
}
}
}
return null;
}
});
}
}
public final void afterPropertiesSet() throws GeneralSecurityException, IOException {
if (StringUtils.hasLength(provider) && StringUtils.hasLength(type)) {
keyStore = KeyStore.getInstance(type, provider);
} else if (StringUtils.hasLength(type)) {
keyStore = KeyStore.getInstance(type);
} else {
keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
}
InputStream is = null;
try {
if (location != null && location.exists()) {
is = location.getInputStream();
if (logger.isInfoEnabled()) {
logger.info("Loading key store from " + location);
}
} else if (logger.isWarnEnabled()) {
logger.warn("Creating empty key store");
}
keyStore.load(is, password);
} finally {
if (is != null) {
is.close();
}
}
}
@Override
protected void doOpen() throws Exception {
Assert.notNull(resource, "Input resource must be set");
Assert.notNull(recordSeparatorPolicy, "RecordSeparatorPolicy must be set");
noInput = true;
if (!resource.exists()) {
if (strict) {
throw new IllegalStateException(
"Input resource must exist (reader is in 'strict' mode): " + resource);
}
logger.warn("Input resource does not exist " + resource.getDescription());
return;
}
if (!resource.isReadable()) {
if (strict) {
throw new IllegalStateException(
"Input resource must be readable (reader is in 'strict' mode): " + resource);
}
logger.warn("Input resource is not readable " + resource.getDescription());
return;
}
reader = bufferedReaderFactory.create(resource, encoding);
for (int i = 0; i < linesToSkip; i++) {
String line = readLine();
if (skippedLinesCallback != null) {
skippedLinesCallback.handleLine(line);
}
}
noInput = false;
}
private ModuleOptionsMetadata resolveNormalMetadata(ModuleDefinition definition) {
try {
ClassLoader classLoaderToUse =
definition.getClasspath() != null
? new ParentLastURLClassLoader(
definition.getClasspath(), ModuleOptionsMetadataResolver.class.getClassLoader())
: ModuleOptionsMetadataResolver.class.getClassLoader();
Resource propertiesResource =
definition.getResource().createRelative(definition.getName() + ".properties");
if (!propertiesResource.exists()) {
return inferModuleOptionsMetadata(definition, classLoaderToUse);
} else {
Properties props = new Properties();
props.load(propertiesResource.getInputStream());
String pojoClass = props.getProperty(OPTIONS_CLASS);
if (pojoClass != null) {
try {
Class<?> clazz = Class.forName(pojoClass, true, classLoaderToUse);
return new PojoModuleOptionsMetadata(
clazz, resourceLoader, environment, conversionService);
} catch (ClassNotFoundException e) {
throw new IllegalStateException(
"Unable to load class used by ModuleOptionsMetadata: " + pojoClass, e);
}
}
return makeSimpleModuleOptions(props);
}
} catch (IOException e) {
return new PassthruModuleOptionsMetadata();
}
}
private static FileTypeMap loadFileTypeMapFromContextSupportModule() {
// see if we can find the extended mime.types from the context-support module
Resource mappingLocation =
new ClassPathResource("org/springframework/mail/javamail/mime.types");
if (mappingLocation.exists()) {
if (logger.isTraceEnabled()) {
logger.trace("Loading Java Activation Framework FileTypeMap from " + mappingLocation);
}
InputStream inputStream = null;
try {
inputStream = mappingLocation.getInputStream();
return new MimetypesFileTypeMap(inputStream);
} catch (IOException ex) {
// ignore
} finally {
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException ex) {
// ignore
}
}
}
}
if (logger.isTraceEnabled()) {
logger.trace("Loading default Java Activation Framework FileTypeMap");
}
return FileTypeMap.getDefaultFileTypeMap();
}
@Override
public PageResponse process(RackRequest request) {
RouteMatchResult matchResult = routeMatcher.matches(request);
if (matchResult.matched) {
// try {
String[] templates = this.fileExtensions(matchResult.matchedParams.splats().last());
Resource template =
loader.getResource("classpath:templates/" + matchResult.matchedParams.splats().join("/"));
if (template.exists()) {
try {
StringExpression rawContent = ExpressionFactory.string(template.getInputStream());
StringExpression rendered =
templateEngine.render(new Context(request), rawContent, templates);
return PageResponseFactory.html(rendered);
} catch (IOException e) {
return PageResponseFactory.internalError();
}
} else {
return PageResponseFactory.notFound();
}
} else {
return null;
}
}
protected Set<String> getTemplateNamesFromPath(String path) throws IOException {
if (resourceLoader != null && grailsApplication.isWarDeployed()) {
try {
PathMatchingResourcePatternResolver resolver =
new PathMatchingResourcePatternResolver(resourceLoader);
return extractNames(
resolver.getResources("/WEB-INF/templates/angular-scaffolding/" + path + "/*.gsp"));
} catch (Exception e) {
return Collections.emptySet();
}
}
PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
Set<String> resources = new HashSet<String>();
String templatesDirPath = basedir + "/src/templates/angular-scaffolding/" + path;
Resource templatesDir = new FileSystemResource(templatesDirPath);
if (templatesDir.exists()) {
try {
resources.addAll(
extractNames(resolver.getResources("file:" + templatesDirPath + "/*.gsp")));
} catch (Exception e) {
log.error("Error while loading views from " + basedir, e);
}
}
return resources;
}
public Template createTemplateForUri(String[] uri) {
Template t;
if (!isReloadEnabled()) {
for (String anUri : uri) {
t = createTemplateFromPrecompiled(anUri);
if (t != null) {
return t;
}
}
}
Resource resource = null;
for (String anUri : uri) {
Resource r = getResourceForUri(anUri);
if (r.exists()) {
resource = r;
break;
}
}
if (resource != null) {
if (precompiledGspMap != null && precompiledGspMap.size() > 0) {
if (LOG.isWarnEnabled()) {
LOG.warn(
"Precompiled GSP not found for uri: "
+ Arrays.asList(uri)
+ ". Using resource "
+ resource);
}
}
return createTemplate(resource);
}
return null;
}
/**
* Return the path to a service's design-time service definition xml.
*
* @param serviceId
* @return
*/
@Deprecated
public Resource getServiceDefXml(String serviceId, boolean fallbackToClassPath) {
try {
Resource serviceDef =
getServiceDesigntimeDirectory(serviceId).createRelative(SERVICE_DEF_XML);
if (!serviceDef.exists() && fallbackToClassPath) {
Resource runtimeServiceDef =
new ClassPathResource(SERVICES_DIR + serviceId + "/" + SERVICE_DEF_XML);
if (runtimeServiceDef.exists()) {
return runtimeServiceDef;
}
}
return serviceDef;
} catch (IOException ex) {
throw new WMRuntimeException(ex);
}
}
public void testFileResource() {
File file = new File("d:/test.txt");
Resource resource = new FileSystemResource(file);
if (resource.exists()) {
dumpStream(resource);
}
Assert.assertEquals(false, resource.isOpen());
}
public void testClasspathResourceByDefaultClassLoader() throws IOException {
Resource resource = new ClassPathResource("com/iss/expense/demo/chapter4/test1.properties");
if (resource.exists()) {
dumpStream(resource);
}
System.out.println("path:--->" + resource.getFile().getAbsolutePath());
Assert.assertEquals(false, resource.isOpen());
}
/**
* Set the temporary directory where uploaded files get stored. Default is the servlet container's
* temporary directory for the web application.
*
* @see org.springframework.web.util.WebUtils#TEMP_DIR_CONTEXT_ATTRIBUTE
*/
public void setUploadTempDir(Resource uploadTempDir) throws IOException {
if (!uploadTempDir.exists() && !uploadTempDir.getFile().mkdirs()) {
throw new IllegalArgumentException(
"Given uploadTempDir [" + uploadTempDir + "] could not be created");
}
this.fileItemFactory.setRepository(uploadTempDir.getFile());
this.uploadTempDirSpecified = true;
}
public JMSPropertyPlaceholderConfigurer(Resource defaultFile, JMSConfiguration config)
throws IOException {
if (!defaultFile.exists()) {
throw new IOException("Unable to locate the default properties file at:" + defaultFile);
}
this.defaults = defaultFile;
this.config = config;
}
public InputStream loadInputStream() throws IOException {
InputStream in = null;
Resource r = applicationContext.getResource("classpath*:" + path);
if (r != null && r.exists()) {
in = r.getInputStream();
}
return in;
}
public void testInputStreamResource() {
ByteArrayInputStream bis = new ByteArrayInputStream("Hello World!".getBytes());
Resource resource = new InputStreamResource(bis);
if (resource.exists()) {
dumpStream(resource);
}
Assert.assertEquals(true, resource.isOpen());
}
@Override
public void initialize(ConfigurableWebApplicationContext applicationContext) {
Resource resource = null;
ServletContext servletContext = applicationContext.getServletContext();
WebApplicationContextUtils.initServletPropertySources(
applicationContext.getEnvironment().getPropertySources(),
servletContext,
applicationContext.getServletConfig());
ServletConfig servletConfig = applicationContext.getServletConfig();
String locations =
servletConfig == null
? null
: servletConfig.getInitParameter(PROFILE_CONFIG_FILE_LOCATIONS);
resource = getResource(servletContext, applicationContext, locations);
if (resource == null) {
servletContext.log(
"No YAML environment properties from servlet. Defaulting to servlet context.");
locations = servletContext.getInitParameter(PROFILE_CONFIG_FILE_LOCATIONS);
resource = getResource(servletContext, applicationContext, locations);
}
try {
servletContext.log("Loading YAML environment properties from location: " + resource);
YamlMapFactoryBean factory = new YamlMapFactoryBean();
factory.setResolutionMethod(ResolutionMethod.OVERRIDE_AND_IGNORE);
List<Resource> resources = new ArrayList<Resource>();
String defaultLocation =
servletConfig == null
? null
: servletConfig.getInitParameter(PROFILE_CONFIG_FILE_DEFAULT);
if (defaultLocation != null) {
Resource defaultResource = new ClassPathResource(defaultLocation);
if (defaultResource.exists()) {
resources.add(defaultResource);
}
}
resources.add(resource);
factory.setResources(resources.toArray(new Resource[resources.size()]));
Map<String, Object> map = factory.getObject();
String yamlStr = (new Yaml()).dump(map);
map.put(rawYamlKey, yamlStr);
NestedMapPropertySource properties = new NestedMapPropertySource("servletConfigYaml", map);
applicationContext.getEnvironment().getPropertySources().addLast(properties);
applySpringProfiles(applicationContext.getEnvironment(), servletContext);
applyLog4jConfiguration(applicationContext.getEnvironment(), servletContext);
} catch (Exception e) {
servletContext.log("Error loading YAML environment properties from location: " + resource, e);
}
}
public Resource findResourceForClassName(String className) {
if (className.contains(CLOSURE_MARKER)) {
className = className.substring(0, className.indexOf(CLOSURE_MARKER));
}
Resource resource = classNameToResourceCache.get(className);
if (resource == null) {
String classNameWithPathSeparator = className.replace(".", FILE_SEPARATOR);
for (String pathPattern :
getSearchPatternForExtension(classNameWithPathSeparator, ".groovy", ".java")) {
resource = resolveExceptionSafe(pathPattern);
if (resource != null && resource.exists()) {
classNameToResourceCache.put(className, resource);
break;
}
}
}
return resource != null && resource.exists() ? resource : null;
}
private Resource getLocalTestSitePropertyResouce() {
ResourceLoader testResourceLoader = new FileSystemResourceLoader();
Resource testResource =
testResourceLoader.getResource("classpath:com/enonic/cms/business/test.site.properties");
if (!testResource.exists()) {
fail("Could not load test resource: " + testResource);
}
return testResource;
}
protected Resource findSchemaResource() {
for (String location : SCHEMA_RESOURCE_LOCATIONS) {
Resource schemaLocation = new ClassPathResource(location);
if (schemaLocation.exists()) {
return schemaLocation;
}
}
return null;
}
public static Resource[] getPropertyResources() {
List<Resource> resources = Lists.newArrayList(getDefaultProperties());
Resource envResource = getEnvProperties();
if (envResource.exists()) {
resources.add(envResource);
}
return resources.toArray(new Resource[resources.size()]);
}
@Override
public Resource getResource(String location) {
Resource r = super.getResource(location);
if (!r.exists() && isNotPrefixed(location)) {
if (!location.startsWith("/")) {
location = "/" + location;
}
r = new FileSystemResource(new File("./web-app/WEB-INF" + location));
}
return r;
}
