Пример #1
0
  public static void main(String... args) throws Exception {
    Main main = new Main();

    JCommander commander = new JCommander(main);
    commander.setProgramName(Main.class.getName());

    try {
      commander.parse(args);
    } catch (ParameterException pe) {
      commander.usage();

      System.exit(-1);
    }

    if (main.help) {
      commander.usage();

      System.exit(0);
    }

    main.run();
  }
Пример #2
0
  private void logOut(String browserId) throws Exception {
    // ttt2 the right way to do it is to go through all the sessions of the current browser, which
    // would require a new field and a new index;
    // not sure if it's worth it, but this would work: A logs in, forgets to log out, B delets the
    // cookies, logs in, A sees B is logged in, then B
    // restores the cookies and uses A's account
    if (browserId == null) {
      return;
    }

    List<LoginInfo> loginInfos = loginInfoDb.getLoginsForBrowser(browserId);
    long expireTarget = System.currentTimeMillis() - Utils.ONE_DAY;
    for (LoginInfo loginInfo : loginInfos) {
      if (loginInfo.expiresOn <= expireTarget) {
        LOG.info(String.format("LoginInfo %s is enough in the past", loginInfo));
      } else {
        LOG.info(String.format("Logging out: %s", loginInfo));
        loginInfoDb.updateExpireTime(browserId, loginInfo.sessionId, expireTarget);
      }
    }
  }
Пример #3
0
  protected void startServer() {

    if (server == null) {
      // stop excessive logging
      Log.setLog(null);
      System.setProperty("DEBUG", "false");
      System.setProperty("VERBOSE", "false");

      server = new Server();
    }

    Connector connector = null;
    if (useSSL) {
      SslContextFactory contextFactory = new SslContextFactory();
      contextFactory.setKeyStore(sslKeystore);
      contextFactory.setKeyStorePassword(sslPassword);
      contextFactory.setKeyManagerPassword(sslKeyPassword);
      contextFactory.setNeedClientAuth(needClientAuth);
      connector = new SslSelectChannelConnector(contextFactory);

      // Setup JSSE keystore and set parameters here correctly
      //			connector = new SslSocketConnector();
      //			((SslSocketConnector)connector).setKeystore(sslKeystore);
      //			((SslSocketConnector)connector).setPassword(sslPassword);
      //			((SslSocketConnector)connector).setKeyPassword(sslKeyPassword);
      //			((SslSocketConnector)connector).setNeedClientAuth(needClientAuth);
      // uses an entry in the keystore called "jetty"
    } else {
      // connector = new SocketConnector();
      connector = new SelectChannelConnector();
    }
    connector.setPort(port);
    server.addConnector(connector);

    // set the Server's HandlerCollection. Other handlers will be added to the HandlerCollection
    handlerCollection = new ContextHandlerCollection();
    server.setHandler(handlerCollection);

    // create servlet context
    servletContext =
        new ServletContextHandler(
            handlerCollection, servletContextString, ServletContextHandler.SESSIONS);
    //		servletContext = new ServletContextHandler(handlerCollection, servletContextString,
    // ServletContextHandler.SESSIONS);

    // create web app context
    // webAppContext = new Context(handlerCollection, webAppContextString, Context.SESSIONS);

    try {

      // add ResourceHandlers
      addResourceHandlers();

      // add servlets to the servlet context
      // servletContext.addHandler(new SecurityHandler());
      addServletsToContext(servletContext);

      //
      addWebApps();

      // add default handler to the server
      handlerCollection.addHandler(new DefaultHandler());

      // start a Jetty
      server.start();
    } catch (BindException ex) {
      logger.log(
          Level.INFO, "Could not start web server on port " + port + ": " + ex.getMessage(), ex);
      lifeCycleControlConduit.vote(meemContext.getWedgeIdentifier(), false);
      return;
    } catch (InstantiationException ex) {
      logger.log(Level.INFO, "Could not add servlet: ", ex);
      lifeCycleControlConduit.vote(meemContext.getWedgeIdentifier(), false);
      return;
    } catch (IllegalAccessException ex) {
      logger.log(Level.INFO, "Could not add servlet: ", ex);
      lifeCycleControlConduit.vote(meemContext.getWedgeIdentifier(), false);
      return;
    } catch (ClassNotFoundException ex) {
      logger.log(Level.INFO, "Could not add servlet: ", ex);
      lifeCycleControlConduit.vote(meemContext.getWedgeIdentifier(), false);
      return;
    } catch (MultiException ex) {
      logger.log(Level.INFO, "Problem while starting the web server: ", ex);
      lifeCycleControlConduit.vote(meemContext.getWedgeIdentifier(), false);
      return;
    } catch (Exception ex) {
      logger.log(Level.INFO, "Problem while starting the web server: ", ex);
      lifeCycleControlConduit.vote(meemContext.getWedgeIdentifier(), false);
      return;
    }

    lifeCycleControlConduit.vote(meemContext.getWedgeIdentifier(), true);
  }
Пример #4
0
  private void handleLoginPost(
      Request request, HttpServletResponse httpServletResponse, boolean secured) throws Exception {
    String userId = request.getParameter(PARAM_USER_ID);
    String password = request.getParameter(PARAM_PASSWORD);
    String rememberAccountStr = request.getParameter(PARAM_REMEMBER_ACCOUNT);
    boolean rememberAccount = Boolean.parseBoolean(rememberAccountStr);
    LoginInfo.SessionInfo sessionInfo = UserHelpers.getSessionInfo(request);

    logOut(sessionInfo.browserId);

    User user = userDb.get(userId);
    if (user == null) {
      WebUtils.redirectToError("User " + userId + " not found", request, httpServletResponse);
      return;
    }

    if (!user.checkPassword(password)) {
      WebUtils.redirectToError("Invalid password", request, httpServletResponse);
      return;
    }

    if (!user.active) {
      WebUtils.redirectToError(
          "Account for User " + userId + " needs to be activated", request, httpServletResponse);
      return;
    }

    LOG.info("Logged in user " + userId);

    sessionInfo.sessionId = null;
    if (sessionInfo.browserId == null) {
      sessionInfo.browserId = getRandomId();
    } else {
      for (LoginInfo loginInfo : loginInfoDb.getLoginsForBrowser(sessionInfo.browserId)) {
        if (userId.equals(loginInfo.userId)) {
          sessionInfo.sessionId = loginInfo.sessionId;
          break;
        }
      }
    }

    long expireOn = System.currentTimeMillis() + Config.getConfig().loginExpireInterval;
    if (sessionInfo.sessionId == null) {
      sessionInfo.sessionId = getRandomId();
      Config config = Config.getConfig();
      loginInfoDb.add(
          new LoginInfo(
              sessionInfo.browserId,
              sessionInfo.sessionId,
              userId,
              expireOn,
              rememberAccount,
              config.defaultStyle,
              config.defaultItemsPerPage,
              config.defaultFeedDateFormat));
      LOG.info(String.format("Logging in in a new session. User: %s", user));
    } else {
      loginInfoDb.updateExpireTime(sessionInfo.browserId, sessionInfo.sessionId, expireOn);
      LOG.info(String.format("Logging in in an existing session. User: %s", user));
    }

    WebUtils.saveCookies(
        httpServletResponse, secured, sessionInfo.browserId, sessionInfo.sessionId);

    httpServletResponse.sendRedirect("/");
  }
Пример #5
0
  /**
   * Normally sets the path and a few attributes that the JSPs are likely to need. Also verifies the
   * login information. If necessary, just redirects to the login page.
   *
   * @param target
   * @param request
   * @param httpServletResponse
   * @param secured
   * @return true if the request is already handled so the .jsp shouldn't get called
   * @throws Exception
   */
  private boolean prepareForJspGet(
      String target, Request request, HttpServletResponse httpServletResponse, boolean secured)
      throws Exception {

    LoginInfo.SessionInfo sessionInfo = UserHelpers.getSessionInfo(request);

    LOG.info(
        String.format(
            "hndl - %s ; %s; %s ; %s",
            target,
            request.getPathInfo(),
            request.getMethod(),
            secured ? "secured" : "not secured"));

    String path = request.getUri().getDecodedPath();

    boolean redirectToLogin = path.equals(PATH_LOGOUT);
    LoginInfo loginInfo = null;
    if (sessionInfo.isNull()) {
      redirectToLogin = true;
      LOG.info("Null session info. Logging in again.");
    } else {
      loginInfo =
          loginInfoDb.get(
              sessionInfo.browserId,
              sessionInfo.sessionId); // ttt2 use a cache, to avoid going to DB
      if (loginInfo == null || loginInfo.expiresOn < System.currentTimeMillis()) {
        LOG.info("Session has expired. Logging in again. Info: " + loginInfo);
        redirectToLogin = true;
      }
    }

    if (!path.equals(PATH_LOGIN) && !path.equals(PATH_SIGNUP) && !path.equals(PATH_ERROR)) {

      if (redirectToLogin) {
        // ttt2 perhaps store URI, to return to it after login
        logOut(sessionInfo.browserId);
        addLoginParams(request, loginInfo);
        httpServletResponse.sendRedirect(PATH_LOGIN);
        return true;
      }

      User user = userDb.get(loginInfo.userId);
      if (user == null) {
        WebUtils.redirectToError("Unknown user", request, httpServletResponse);
        return true;
      }
      if (!user.active) {
        WebUtils.redirectToError("Account is not active", request, httpServletResponse);
        return true;
      }
      request.setAttribute(VAR_FEED_DB, feedDb);
      request.setAttribute(VAR_USER_DB, userDb);
      request.setAttribute(VAR_ARTICLE_DB, articleDb);
      request.setAttribute(VAR_READ_ARTICLES_COLL_DB, readArticlesCollDb);

      request.setAttribute(VAR_USER, user);
      request.setAttribute(VAR_LOGIN_INFO, loginInfo);

      MultiMap<String> params = new MultiMap<>();
      params.put(PARAM_PATH, path);
      request.setParameters(params);
    }

    if (path.equals(PATH_LOGIN)) {
      addLoginParams(request, loginInfo);
    }
    return false;
  }