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
Exemple #4
0
  @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();
    }
  }
Exemple #5
0
 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;
  }
Exemple #8
0
 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);
 }
Exemple #9
0
 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));
 }
Exemple #10
0
  @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()));
    }
  }
Exemple #11
0
  /**
   * 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;
    }
  }
Exemple #12
0
  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;
    }
  }
Exemple #13
0
    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);
      }
    }
Exemple #14
0
  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)
Exemple #16
0
  @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?");
      }
    }
  }
Exemple #17
0
  /**
   * 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;
  }