public boolean existsCollection(String collectionName) throws SqlInjectionException {
if (Logger.isTraceEnabled()) Logger.trace("Method Start");
OIndex idx = db.getMetadata().getIndexManager().getIndex(COLLECTION_NAME_INDEX);
OIdentifiable record = (OIdentifiable) idx.get(collectionName);
if (Logger.isTraceEnabled()) Logger.trace("Method End");
return (record != null);
}
@Override
public F.Promise<SimpleResult> call(Context ctx) throws Throwable {
if (Logger.isTraceEnabled()) Logger.trace("Method Start");
Context.current.set(ctx);
if (Logger.isDebugEnabled())
Logger.debug("AnonymousLogin for resource " + Context.current().request());
String user = BBConfiguration.getBaasBoxUsername();
String password = BBConfiguration.getBaasBoxPassword();
// retrieve AppCode
String appCode = RequestHeaderHelper.getAppCode(ctx);
ctx.args.put("username", user);
ctx.args.put("password", password);
ctx.args.put("appcode", appCode);
if (Logger.isDebugEnabled()) Logger.debug("username (defined in conf file): " + user);
if (Logger.isDebugEnabled()) Logger.debug("password (defined in conf file): " + password);
if (Logger.isDebugEnabled()) Logger.debug("appcode (from header or querystring): " + appCode);
if (Logger.isDebugEnabled()) Logger.debug("token: N/A");
// executes the request
F.Promise<SimpleResult> tempResult = delegate.call(ctx);
WrapResponse wr = new WrapResponse();
// SimpleResult result=wr.wrap(ctx, tempResult);
F.Promise<SimpleResult> result = wr.wrapAsync(ctx, tempResult);
if (Logger.isTraceEnabled()) Logger.trace("Method End");
return result;
}
@Override
public ODocument create() throws Throwable {
if (Logger.isTraceEnabled()) Logger.trace("Method Start");
DbHelper.requestTransaction();
ODocument doc = super.create();
if (Logger.isTraceEnabled()) Logger.trace("Method End");
return doc;
} // getNewModelInstance
@Override
protected void service(
HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse)
throws ServletException, IOException {
if (!routerInitializedWithContext) {
loadRouter(httpServletRequest.getContextPath());
}
if (Logger.isTraceEnabled()) {
Logger.trace("ServletWrapper>service " + httpServletRequest.getRequestURI());
}
Request request = null;
try {
Response response = new Response();
response.out = new ByteArrayOutputStream();
Response.current.set(response);
request = parseRequest(httpServletRequest);
if (Logger.isTraceEnabled()) {
Logger.trace("ServletWrapper>service, request: " + request);
}
boolean raw = Play.pluginCollection.rawInvocation(request, response);
if (raw) {
copyResponse(
Request.current(), Response.current(), httpServletRequest, httpServletResponse);
} else {
Invoker.invokeInThread(
new ServletInvocation(request, response, httpServletRequest, httpServletResponse));
}
} catch (NotFound e) {
if (Logger.isTraceEnabled()) {
Logger.trace("ServletWrapper>service, NotFound: " + e);
}
serve404(httpServletRequest, httpServletResponse, e);
return;
} catch (RenderStatic e) {
if (Logger.isTraceEnabled()) {
Logger.trace("ServletWrapper>service, RenderStatic: " + e);
}
serveStatic(httpServletResponse, httpServletRequest, e);
return;
} catch (Throwable e) {
throw new ServletException(e);
} finally {
Request.current.remove();
Response.current.remove();
Scope.Session.current.remove();
Scope.Params.current.remove();
Scope.Flash.current.remove();
Scope.RenderArgs.current.remove();
Scope.RouteArgs.current.remove();
}
}
public static Route getRoute(
String method,
String path,
String action,
String params,
String headers,
String sourceFile,
int line) {
Route route = new Route();
route.method = method;
route.path = path.replace("//", "/");
route.action = action;
route.routesFile = sourceFile;
route.routesFileLine = line;
route.addFormat(headers);
route.addParams(params);
route.compute();
if (Logger.isTraceEnabled()) {
Logger.trace(
"Adding ["
+ route.toString()
+ "] with params ["
+ params
+ "] and headers ["
+ headers
+ "]");
}
return route;
}
public ODocument getByName(String collectionName) throws SqlInjectionException {
if (Logger.isTraceEnabled()) Logger.trace("Method Start");
OIndex idx = db.getMetadata().getIndexManager().getIndex(COLLECTION_NAME_INDEX);
OIdentifiable record = (OIdentifiable) idx.get(collectionName);
if (record == null) return null;
return db.load(record.getIdentity());
}
public static synchronized Stack<Evolution> listApplicationEvolutions() {
Stack<Evolution> evolutions = new Stack<Evolution>();
evolutions.add(new Evolution(0, "", "", true));
if (evolutionsDirectory.exists()) {
for (File evolution : evolutionsDirectory.listFiles()) {
if (evolution.getName().matches("^[0-9]+[.]sql$")) {
if (Logger.isTraceEnabled()) {
Logger.trace("Loading evolution %s", evolution);
}
int version =
Integer.parseInt(evolution.getName().substring(0, evolution.getName().indexOf(".")));
String sql = IO.readContentAsString(evolution);
StringBuffer sql_up = new StringBuffer();
StringBuffer sql_down = new StringBuffer();
StringBuffer current = new StringBuffer();
for (String line : sql.split("\r?\n")) {
if (line.trim().matches("^#.*[!]Ups")) {
current = sql_up;
} else if (line.trim().matches("^#.*[!]Downs")) {
current = sql_down;
} else if (line.trim().startsWith("#")) {
// skip
} else if (!StringUtils.isEmpty(line.trim())) {
current.append(line).append("\n");
}
}
evolutions.add(new Evolution(version, sql_up.toString(), sql_down.toString(), true));
}
}
Collections.sort(evolutions);
}
return evolutions;
}
public static Route route(Http.Request request) {
if (Logger.isTraceEnabled()) {
Logger.trace("Route: " + request.path + " - " + request.querystring);
}
// request method may be overriden if a x-http-method-override parameter is given
if (request.querystring != null && methodOverride.matches(request.querystring)) {
Matcher matcher = methodOverride.matcher(request.querystring);
if (matcher.matches()) {
if (Logger.isTraceEnabled()) {
Logger.trace(
"request method %s overriden to %s ", request.method, matcher.group("method"));
}
request.method = matcher.group("method");
}
}
for (Route route : routes) {
Map<String, String> args =
route.matches(request.method, request.path, request.format, request.domain);
if (args != null) {
request.routeArgs = args;
request.action = route.action;
if (args.containsKey("format")) {
request.format = args.get("format");
}
if (request.action.indexOf("{") > -1) { // more optimization ?
for (String arg : request.routeArgs.keySet()) {
request.action = request.action.replace("{" + arg + "}", request.routeArgs.get(arg));
}
}
if (request.action.equals("404")) {
throw new NotFound(route.path);
}
return route;
}
}
// Not found - if the request was a HEAD, let's see if we can find a corresponding GET
if (request.method.equalsIgnoreCase("head")) {
request.method = "GET";
Route route = route(request);
request.method = "HEAD";
if (route != null) {
return route;
}
}
throw new NotFound(request.method, request.path);
}
private static void registAuthoriable_(String key, RequireRight rr, RequirePrivilege rp) {
if (Logger.isTraceEnabled()) {
Plugin.trace(
"register authoriable [%s: (%s|%s)]",
key,
(null == rr) ? "null-right" : rr.value(),
(null == rp) ? "null-privilege" : rp.value());
}
reg_.put(key, new Authority(key, rr, rp));
}
@SuppressWarnings("unchecked")
public static void resolve(Http.Request request, Http.Response response)
throws NotFound, RenderStatic {
if (!Play.started) {
return;
}
Http.Request.current.set(request);
Http.Response.current.set(response);
Scope.Params.current.set(request.params);
Scope.RenderArgs.current.set(new Scope.RenderArgs());
Scope.RouteArgs.current.set(new Scope.RouteArgs());
Scope.Session.current.set(Scope.Session.restore());
Scope.Flash.current.set(Scope.Flash.restore());
CachedBoundActionMethodArgs.init();
ControllersEnhancer.currentAction.set(new Stack<String>());
if (request.resolved) {
return;
}
// Route and resolve format if not already done
if (request.action == null) {
Play.pluginCollection.routeRequest(request);
Route route = Router.route(request);
Play.pluginCollection.onRequestRouting(route);
}
request.resolveFormat();
// Find the action method
try {
Method actionMethod = null;
Object[] ca = getActionMethod(request.action);
actionMethod = (Method) ca[1];
request.controller = ((Class) ca[0]).getName().substring(12).replace("$", "");
request.controllerClass = ((Class) ca[0]);
request.actionMethod = actionMethod.getName();
request.action = request.controller + "." + request.actionMethod;
request.invokedMethod = actionMethod;
if (Logger.isTraceEnabled()) {
Logger.trace("------- %s", actionMethod);
}
request.resolved = true;
} catch (ActionNotFoundException e) {
// Logger.error(e, "%s action not found", e.getAction());
// bran: avoid excessive messages
Logger.error("%s action not found", e.getAction());
throw new NotFound(String.format("%s action not found", e.getAction()));
}
}
/**
* Force all java source and template compilation.
*
* @return success ?
*/
static boolean preCompile() {
if (usePrecompiled) {
if (Play.getFile("precompiled").exists()) {
classloader.getAllClasses();
Logger.info("Application is precompiled");
return true;
}
Logger.error("Precompiled classes are missing!!");
fatalServerErrorOccurred();
return false;
}
try {
Logger.info("Precompiling ...");
Thread.currentThread().setContextClassLoader(Play.classloader);
long start = System.currentTimeMillis();
classloader.getAllClasses();
if (Logger.isTraceEnabled()) {
Logger.trace("%sms to precompile the Java stuff", System.currentTimeMillis() - start);
}
if (!lazyLoadTemplates) {
start = System.currentTimeMillis();
TemplateLoader.getAllTemplate();
if (Logger.isTraceEnabled()) {
Logger.trace("%sms to precompile the templates", System.currentTimeMillis() - start);
}
}
return true;
} catch (Throwable e) {
Logger.error(e, "Cannot start in PROD mode with errors");
fatalServerErrorOccurred();
return false;
}
}
public boolean verify() {
try {
// Normalize
String claimedId = normalize(id);
String server = null;
String delegate = null;
// Discover
HttpResponse response = WS.url(claimedId).get();
// Try HTML (I know it's bad)
String html = response.getString();
server = discoverServer(html);
if (server == null) {
// Try YADIS
Document xrds = null;
if (response.getContentType().contains("application/xrds+xml")) {
xrds = getXml(html, response.getEncoding());
} else if (response.getHeader("X-XRDS-Location") != null) {
xrds = WS.url(response.getHeader("X-XRDS-Location")).get().getXml();
} else {
return false;
}
// Ok we have the XRDS file
server =
XPath.selectText(
"//Type[text()='http://specs.openid.net/auth/2.0/server']/following-sibling::URI/text()",
xrds);
claimedId =
XPath.selectText(
"//Type[text()='http://specs.openid.net/auth/2.0/signon']/following-sibling::LocalID/text()",
xrds);
if (claimedId == null) {
claimedId = "http://specs.openid.net/auth/2.0/identifier_select";
} else {
server =
XPath.selectText(
"//Type[text()='http://specs.openid.net/auth/2.0/signon']/following-sibling::URI/text()",
xrds);
}
if (server == null) {
return false;
}
} else {
// Delegate
Matcher openid2Localid =
Pattern.compile("<link[^>]+openid2[.]local_id[^>]+>", Pattern.CASE_INSENSITIVE)
.matcher(html);
Matcher openidDelegate =
Pattern.compile("<link[^>]+openid[.]delegate[^>]+>", Pattern.CASE_INSENSITIVE)
.matcher(html);
if (openid2Localid.find()) {
delegate = extractHref(openid2Localid.group());
} else if (openidDelegate.find()) {
delegate = extractHref(openidDelegate.group());
}
}
// Redirect
String url = server;
if (!server.contains("?")) {
url += "?";
}
if (!url.endsWith("?") && !url.endsWith("&")) {
url += "&";
}
url += "openid.ns=" + URLEncoder.encode("http://specs.openid.net/auth/2.0", "UTF-8");
url += "&openid.mode=checkid_setup";
url += "&openid.claimed_id=" + URLEncoder.encode(claimedId, "utf8");
url +=
"&openid.identity=" + URLEncoder.encode(delegate == null ? claimedId : delegate, "utf8");
if (returnAction != null
&& (returnAction.startsWith("http://") || returnAction.startsWith("https://"))) {
url += "&openid.return_to=" + URLEncoder.encode(returnAction, "utf8");
} else {
url +=
"&openid.return_to="
+ URLEncoder.encode(
Request.current().getBase() + Router.reverse(returnAction), "utf8");
}
if (realmAction != null
&& (realmAction.startsWith("http://") || realmAction.startsWith("https://"))) {
url += "&openid.realm=" + URLEncoder.encode(realmAction, "utf8");
} else {
url +=
"&openid.realm="
+ URLEncoder.encode(
Request.current().getBase() + Router.reverse(realmAction), "utf8");
}
if (!sregOptional.isEmpty() || !sregRequired.isEmpty()) {
url +=
"&openid.ns.sreg="
+ URLEncoder.encode("http://openid.net/extensions/sreg/1.1", "UTF-8");
}
String sregO = "";
for (String a : sregOptional) {
sregO += URLEncoder.encode(a, "UTF-8") + ",";
}
if (!StringUtils.isEmpty(sregO)) {
url += "&openid.sreg.optional=" + sregO.substring(0, sregO.length() - 1);
}
String sregR = "";
for (String a : sregRequired) {
sregR += URLEncoder.encode(a, "UTF-8") + ",";
}
if (!StringUtils.isEmpty(sregR)) {
url += "&openid.sreg.required=" + sregR.substring(0, sregR.length() - 1);
}
if (!axRequired.isEmpty() || !axOptional.isEmpty()) {
url += "&openid.ns.ax=http%3A%2F%2Fopenid.net%2Fsrv%2Fax%2F1.0";
url += "&openid.ax.mode=fetch_request";
for (String a : axOptional.keySet()) {
url += "&openid.ax.type." + a + "=" + URLEncoder.encode(axOptional.get(a), "UTF-8");
}
for (String a : axRequired.keySet()) {
url += "&openid.ax.type." + a + "=" + URLEncoder.encode(axRequired.get(a), "UTF-8");
}
if (!axRequired.isEmpty()) {
String r = "";
for (String a : axRequired.keySet()) {
r += "," + a;
}
r = r.substring(1);
url += "&openid.ax.required=" + r;
}
if (!axOptional.isEmpty()) {
String r = "";
for (String a : axOptional.keySet()) {
r += "," + a;
}
r = r.substring(1);
url += "&openid.ax.if_available=" + r;
}
}
if (Logger.isTraceEnabled()) {
// Debug
Logger.trace("Send request %s", url);
}
throw new Redirect(url);
} catch (Redirect e) {
throw e;
} catch (PlayException e) {
throw e;
} catch (Exception e) {
return false;
}
}
public void compute() {
this.host = "";
this.hostPattern = new Pattern(".*");
if (action.startsWith("staticDir:") || action.startsWith("staticFile:")) {
// Is there is a host argument, append it.
if (!path.startsWith("/")) {
String p = this.path;
this.path = p.substring(p.indexOf("/"));
this.host = p.substring(0, p.indexOf("/"));
if (this.host.contains("{")) {
Logger.warn("Static route cannot have a dynamic host name");
return;
}
}
if (!method.equalsIgnoreCase("*") && !method.equalsIgnoreCase("GET")) {
Logger.warn("Static route only support GET method");
return;
}
}
// staticDir
if (action.startsWith("staticDir:")) {
if (!this.path.endsWith("/") && !this.path.equals("/")) {
Logger.warn("The path for a staticDir route must end with / (%s)", this);
this.path += "/";
}
this.pattern = new Pattern("^" + path + "({resource}.*)$");
this.staticDir = action.substring("staticDir:".length());
} else if (action.startsWith("staticFile:")) {
this.pattern = new Pattern("^" + path + "$");
this.staticFile = true;
this.staticDir = action.substring("staticFile:".length());
} else {
// URL pattern
// Is there is a host argument, append it.
if (!path.startsWith("/")) {
String p = this.path;
this.path = p.substring(p.indexOf("/"));
this.host = p.substring(0, p.indexOf("/"));
String pattern = host.replaceAll("\\.", "\\\\.").replaceAll("\\{.*\\}", "(.*)");
if (Logger.isTraceEnabled()) {
Logger.trace("pattern [" + pattern + "]");
Logger.trace("host [" + host + "]");
}
Matcher m = new Pattern(pattern).matcher(host);
this.hostPattern = new Pattern(pattern);
if (m.matches()) {
if (this.host.contains("{")) {
String name = m.group(1).replace("{", "").replace("}", "");
if (!name.equals("_")) {
hostArg = new Arg();
hostArg.name = name;
if (Logger.isTraceEnabled()) {
Logger.trace("hostArg name [" + name + "]");
}
// The default value contains the route version of the host ie {client}.bla.com
// It is temporary and it indicates it is an url route.
// TODO Check that default value is actually used for other cases.
hostArg.defaultValue = host;
hostArg.constraint = new Pattern(".*");
if (Logger.isTraceEnabled()) {
Logger.trace("adding hostArg [" + hostArg + "]");
}
args.add(hostArg);
}
}
}
}
String patternString = path;
patternString = customRegexPattern.replacer("\\{<[^/]+>$1\\}").replace(patternString);
Matcher matcher = argsPattern.matcher(patternString);
while (matcher.find()) {
Arg arg = new Arg();
arg.name = matcher.group(2);
arg.constraint = new Pattern(matcher.group(1));
args.add(arg);
}
patternString = argsPattern.replacer("({$2}$1)").replace(patternString);
this.pattern = new Pattern(patternString);
// Action pattern
patternString = action;
patternString = patternString.replace(".", "[.]");
for (Arg arg : args) {
if (patternString.contains("{" + arg.name + "}")) {
patternString =
patternString.replace(
"{" + arg.name + "}", "({" + arg.name + "}" + arg.constraint.toString() + ")");
actionArgs.add(arg.name);
}
}
actionPattern = new Pattern(patternString, REFlags.IGNORE_CASE);
}
}
public static Request parseRequest(HttpServletRequest httpServletRequest) throws Exception {
URI uri = new URI(httpServletRequest.getRequestURI());
String method = httpServletRequest.getMethod().intern();
String path = uri.getRawPath();
if (path != null) {
path = URLDecoder.decode(path, "utf-8");
}
String querystring =
httpServletRequest.getQueryString() == null ? "" : httpServletRequest.getQueryString();
if (Logger.isTraceEnabled()) {
Logger.trace("httpServletRequest.getContextPath(): " + httpServletRequest.getContextPath());
Logger.trace("request.path: " + path + ", request.querystring: " + querystring);
}
String contentType = null;
if (httpServletRequest.getHeader("Content-Type") != null) {
contentType =
httpServletRequest.getHeader("Content-Type").split(";")[0].trim().toLowerCase().intern();
} else {
contentType = "text/html".intern();
}
if (httpServletRequest.getHeader("X-HTTP-Method-Override") != null) {
method = httpServletRequest.getHeader("X-HTTP-Method-Override").intern();
}
InputStream body = httpServletRequest.getInputStream();
boolean secure = httpServletRequest.isSecure();
String url =
uri.toString()
+ (httpServletRequest.getQueryString() == null
? ""
: "?" + httpServletRequest.getQueryString());
String host = httpServletRequest.getHeader("host");
int port = 0;
String domain = null;
if (host.contains(":")) {
port = Integer.parseInt(host.split(":")[1]);
domain = host.split(":")[0];
} else {
port = 80;
domain = host;
}
String remoteAddress = httpServletRequest.getRemoteAddr();
boolean isLoopback = host.matches("^127\\.0\\.0\\.1:?[0-9]*$");
final Request request =
Request.createRequest(
remoteAddress,
method,
path,
querystring,
contentType,
body,
url,
host,
isLoopback,
port,
domain,
secure,
getHeaders(httpServletRequest),
getCookies(httpServletRequest));
Request.current.set(request);
Router.routeOnlyStatic(request);
return request;
}
/**
* * Creates an entry into the ODocument-Collection and create a new Class named "collectionName"
*
* @param collectionName
* @return an ODocument instance representing the collection
* @throws CollectionAlreadyExistsException
* @throws OpenTransactionException, CollectionAlreadyExistsException, InvalidCollectionException,
* InvalidModelException, Throwable
*/
public ODocument create(String collectionName)
throws OpenTransactionException, CollectionAlreadyExistsException, InvalidCollectionException,
InvalidModelException, Throwable {
if (DbHelper.isInTransaction())
throw new OpenTransactionException("Cannot create a collection within an open transaction");
if (Logger.isTraceEnabled()) Logger.trace("Method Start");
if (Character.isDigit(collectionName.charAt(0))) {
throw new InvalidCollectionException("Collection names cannot start by a digit");
}
if (collectionName.contains(";")) {
throw new InvalidCollectionException("Collection cannot contain ;");
}
if (collectionName.contains(":")) {
throw new InvalidCollectionException("Collection cannot contain :");
}
if (collectionName.contains(".")) {
throw new InvalidCollectionException("Collection cannot contain .");
}
if (collectionName.contains("@")) {
throw new InvalidCollectionException("Collection cannot contain @");
}
if (collectionName.startsWith("_")) {
throw new InvalidCollectionException("Collection cannot start with _");
}
if (!collectionName.matches(COLLECTION_NAME_REGEX)) {
throw new InvalidCollectionException(
"Collection name must be complaint with the regular expression: "
+ COLLECTION_NAME_REGEX);
}
if (collectionName.toUpperCase().startsWith("_BB_")) {
throw new InvalidCollectionException(
"Collection name is not valid: it can't be prefixed with _BB_");
}
try {
if (existsCollection(collectionName))
throw new CollectionAlreadyExistsException(
"Collection " + collectionName + " already exists");
} catch (SqlInjectionException e) {
throw new InvalidCollectionException(e);
}
ODocument doc = super.create();
doc.field("name", collectionName);
save(doc);
// create new class
OClass documentClass = db.getMetadata().getSchema().getClass(CLASS_NODE_NAME);
db.getMetadata().getSchema().createClass(collectionName, documentClass);
// grants to the new class
ORole registeredRole = RoleDao.getRole(DefaultRoles.REGISTERED_USER.toString());
ORole anonymousRole = RoleDao.getRole(DefaultRoles.ANONYMOUS_USER.toString());
registeredRole.addRule(
ODatabaseSecurityResources.CLASS + "." + collectionName, ORole.PERMISSION_ALL);
registeredRole.addRule(
ODatabaseSecurityResources.CLUSTER + "." + collectionName, ORole.PERMISSION_ALL);
anonymousRole.addRule(
ODatabaseSecurityResources.CLASS + "." + collectionName, ORole.PERMISSION_READ);
anonymousRole.addRule(
ODatabaseSecurityResources.CLUSTER + "." + collectionName, ORole.PERMISSION_READ);
PermissionsHelper.grantRead(doc, registeredRole);
PermissionsHelper.grantRead(doc, anonymousRole);
if (Logger.isTraceEnabled()) Logger.trace("Method End");
return doc;
} // getNewModelInstance(String collectionName)
@Override
public void onApplicationStart() {
// must check and configure JPA for each DBConfig
for (DBConfig dbConfig : DB.getDBConfigs()) {
// check and enable JPA on this config
// is JPA already configured?
String configName = dbConfig.getDBConfigName();
if (JPA.getJPAConfig(configName, true) == null) {
// must configure it
// resolve prefix for hibernate config..
// should be nothing for default, and db_<name> for others
String propPrefix = "";
if (!DBConfig.defaultDbConfigName.equalsIgnoreCase(configName)) {
propPrefix = "db_" + configName + ".";
}
List<Class> classes = findEntityClassesForThisConfig(configName, propPrefix);
if (classes == null) continue;
// we're ready to configure this instance of JPA
final String hibernateDataSource =
Play.configuration.getProperty(propPrefix + "hibernate.connection.datasource");
if (StringUtils.isEmpty(hibernateDataSource) && dbConfig == null) {
throw new JPAException(
"Cannot start a JPA manager without a properly configured database"
+ getConfigInfoString(configName),
new NullPointerException("No datasource configured"));
}
Ejb3Configuration cfg = new Ejb3Configuration();
if (dbConfig.getDatasource() != null) {
cfg.setDataSource(dbConfig.getDatasource());
}
if (!Play.configuration
.getProperty(propPrefix + "jpa.ddl", Play.mode.isDev() ? "update" : "none")
.equals("none")) {
cfg.setProperty(
"hibernate.hbm2ddl.auto",
Play.configuration.getProperty(propPrefix + "jpa.ddl", "update"));
}
String driver = null;
if (StringUtils.isEmpty(propPrefix)) {
driver = Play.configuration.getProperty("db.driver");
} else {
driver = Play.configuration.getProperty(propPrefix + "driver");
}
cfg.setProperty("hibernate.dialect", getDefaultDialect(propPrefix, driver));
cfg.setProperty("javax.persistence.transaction", "RESOURCE_LOCAL");
cfg.setInterceptor(new PlayInterceptor());
// This setting is global for all JPAs - only configure if configuring default JPA
if (StringUtils.isEmpty(propPrefix)) {
if (Play.configuration.getProperty(propPrefix + "jpa.debugSQL", "false").equals("true")) {
org.apache.log4j.Logger.getLogger("org.hibernate.SQL").setLevel(Level.ALL);
} else {
org.apache.log4j.Logger.getLogger("org.hibernate.SQL").setLevel(Level.OFF);
}
}
// inject additional hibernate.* settings declared in Play! configuration
Properties additionalProperties =
(Properties)
Utils.Maps.filterMap(Play.configuration, "^" + propPrefix + "hibernate\\..*");
// We must remove prefix from names
Properties transformedAdditionalProperties = new Properties();
for (Map.Entry<Object, Object> entry : additionalProperties.entrySet()) {
Object key = entry.getKey();
if (!StringUtils.isEmpty(propPrefix)) {
key = ((String) key).substring(propPrefix.length()); // chop off the prefix
}
transformedAdditionalProperties.put(key, entry.getValue());
}
cfg.addProperties(transformedAdditionalProperties);
try {
// nice hacking :) I like it..
Field field = cfg.getClass().getDeclaredField("overridenClassLoader");
field.setAccessible(true);
field.set(cfg, Play.classloader);
} catch (Exception e) {
Logger.error(
e, "Error trying to override the hibernate classLoader (new hibernate version ???)");
}
for (Class<?> clazz : classes) {
cfg.addAnnotatedClass(clazz);
if (Logger.isTraceEnabled()) {
Logger.trace("JPA Model : %s", clazz);
}
}
String[] moreEntities =
Play.configuration.getProperty(propPrefix + "jpa.entities", "").split(", ");
for (String entity : moreEntities) {
if (entity.trim().equals("")) {
continue;
}
try {
cfg.addAnnotatedClass(Play.classloader.loadClass(entity));
} catch (Exception e) {
Logger.warn("JPA -> Entity not found: %s", entity);
}
}
for (ApplicationClass applicationClass : Play.classes.all()) {
if (applicationClass.isClass() || applicationClass.javaPackage == null) {
continue;
}
Package p = applicationClass.javaPackage;
Logger.info("JPA -> Adding package: %s", p.getName());
cfg.addPackage(p.getName());
}
String mappingFile = Play.configuration.getProperty(propPrefix + "jpa.mapping-file", "");
if (mappingFile != null && mappingFile.length() > 0) {
cfg.addResource(mappingFile);
}
if (Logger.isTraceEnabled()) {
Logger.trace("Initializing JPA" + getConfigInfoString(configName) + " ...");
}
try {
JPA.addConfiguration(configName, cfg);
} catch (PersistenceException e) {
throw new JPAException(
e.getMessage() + getConfigInfoString(configName),
e.getCause() != null ? e.getCause() : e);
}
}
}
// must look for Entity-objects referring to none-existing JPAConfig
List<Class> allEntityClasses = Play.classloader.getAnnotatedClasses(Entity.class);
for (Class clazz : allEntityClasses) {
String configName = Entity2JPAConfigResolver.getJPAConfigNameForEntityClass(clazz);
if (JPA.getJPAConfig(configName, true) == null) {
throw new JPAException(
"Found Entity-class ("
+ clazz.getName()
+ ") referring to none-existing JPAConfig"
+ getConfigInfoString(configName)
+ ". "
+ "Is JPA properly configured?");
}
}
}
/**
* Init the framework
*
* @param root The application path
* @param id The framework id to use
*/
public static void init(File root, String id) {
// Simple things
Play.id = id;
Play.started = false;
Play.applicationPath = root;
// load all play.static of exists
initStaticStuff();
guessFrameworkPath();
// Read the configuration file
readConfiguration();
Play.classes = new ApplicationClasses();
// Configure logs
Logger.init();
String logLevel = configuration.getProperty("application.log", "INFO");
// only override log-level if Logger was not configured manually
if (!Logger.configuredManually) {
Logger.setUp(logLevel);
}
Logger.recordCaller =
Boolean.parseBoolean(configuration.getProperty("application.log.recordCaller", "false"));
Logger.info("Starting %s", root.getAbsolutePath());
if (configuration.getProperty("play.tmp", "tmp").equals("none")) {
tmpDir = null;
Logger.debug("No tmp folder will be used (play.tmp is set to none)");
} else {
tmpDir = new File(configuration.getProperty("play.tmp", "tmp"));
if (!tmpDir.isAbsolute()) {
tmpDir = new File(applicationPath, tmpDir.getPath());
}
if (Logger.isTraceEnabled()) {
Logger.trace("Using %s as tmp dir", Play.tmpDir);
}
if (!tmpDir.exists()) {
try {
if (readOnlyTmp) {
throw new Exception("ReadOnly tmp");
}
tmpDir.mkdirs();
} catch (Throwable e) {
tmpDir = null;
Logger.warn("No tmp folder will be used (cannot create the tmp dir)");
}
}
}
// Mode
try {
mode = Mode.valueOf(configuration.getProperty("application.mode", "DEV").toUpperCase());
} catch (IllegalArgumentException e) {
Logger.error(
"Illegal mode '%s', use either prod or dev",
configuration.getProperty("application.mode"));
fatalServerErrorOccurred();
}
// Force the Production mode if forceProd or precompile is activate
// Set to the Prod mode must be done before loadModules call
// as some modules (e.g. DocViewver) is only available in DEV
if (usePrecompiled || forceProd || System.getProperty("precompile") != null) {
mode = Mode.PROD;
}
// Context path
ctxPath = configuration.getProperty("http.path", ctxPath);
// Build basic java source path
VirtualFile appRoot = VirtualFile.open(applicationPath);
roots.add(appRoot);
javaPath = new CopyOnWriteArrayList<VirtualFile>();
javaPath.add(appRoot.child("app"));
javaPath.add(appRoot.child("conf"));
// Build basic templates path
if (appRoot.child("app/views").exists()) {
templatesPath = new ArrayList<VirtualFile>(2);
templatesPath.add(appRoot.child("app/views"));
} else {
templatesPath = new ArrayList<VirtualFile>(1);
}
// Main route file
routes = appRoot.child("conf/routes");
// Plugin route files
modulesRoutes = new HashMap<String, VirtualFile>(16);
// Load modules
loadModules();
// Load the templates from the framework after the one from the modules
templatesPath.add(VirtualFile.open(new File(frameworkPath, "framework/templates")));
// Enable a first classloader
classloader = new ApplicationClassloader();
// Fix ctxPath
if ("/".equals(Play.ctxPath)) {
Play.ctxPath = "";
}
// Default cookie domain
Http.Cookie.defaultDomain = configuration.getProperty("application.defaultCookieDomain", null);
if (Http.Cookie.defaultDomain != null) {
Logger.info("Using default cookie domain: " + Http.Cookie.defaultDomain);
}
// Plugins
pluginCollection.loadPlugins();
// Done !
if (mode == Mode.PROD) {
if (preCompile() && System.getProperty("precompile") == null) {
start();
} else {
return;
}
} else {
Logger.warn("You're running Play! in DEV mode");
}
// Plugins
pluginCollection.onApplicationReady();
Play.initialized = true;
}
