SessionEdit.java :  » J2EE » Enhydra-Application-Framework » org » enhydra » server » Java Open Source

package org.enhydra.server;


import org.enhydra.util.ConfigFileInterface;

import com.lutris.util.Config;
import com.lutris.util.ConfigException;
import com.lutris.util.KeywordValueException;

/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2002</p>
 * <p>Company: www.together.at</p>
 * @author tufeX tufex@uns.ns.ac.yu
 * @version 1.1
 */

public class SessionEdit {

  private String sessionLifetimeMax;
  private String sessionIdleTimeMax;
  private String sessionNoUserIdleTimeMax;
  private String idleScanInterval;
  private String randomizerIntervals[];
  private String memoryPersistence;
  private String mode;
  private String maxSessions;
  private String pageThreshold;
  private String pageTimeThreshold;
  private String pageWait;
  private String saveOnRestart;
  private String pageDir;
  private String databaseName;
  private String dBTableName;
  private String sessionHomeClass;
  private String sessionUserTableClass;

  private String sessionEncodeUrlState;
  private String sessionEncodeFirstUrl;
  //Default values

  private String sessionLifetimeMaxDefault = "0";
  private String sessionIdleTimeMaxDefault = "30";
  private String sessionNoUserIdleTimeMaxDefault = "30";
  private String idleScanIntervalDefault = "30";
  private String randomizerIntervalsDefault[] = {"301","1001","5003"};
  private String memoryPersistenceDefault = "false";
  private String modeDefault = "BASIC";
  private String maxSessionsDefault = "-1";
  private String pageThresholdDefault = "-1";
//  private String pageTimeThresholdDefault = "-1";
  private String pageWaitDefault = "60000";
  private String saveOnRestartDefault = "false";
  private String pageDirDefault = "";
  private String databaseNameDefault = "";
  private String dBTableNameDefault = "PersistentSession";
  private String sessionHomeClassDefault = "";
  private String sessionUserTableClassDefault = "";

  private String sessionEncodeUrlStateDefault = "Auto";
  private String sessionEncodeFirstUrlDefault = "false";
  

  Config config;

  private SessionEdit() {
  }
  /**
   * One and only constructor, fill SessionManager parameters from application
   * config file (or set default value if parameter doesn't exist).
   * @param appConfig application Config
   * @throws ConfigException
   * @throws KeywordValueException
   */
  public SessionEdit(Config appConfig) throws ConfigException, KeywordValueException {
    config = appConfig;
    String temp;
      if (config == null) throw new ConfigException("Exception in SessionEdit(), config == null");
      //SessionManager.*
      if(config.containsKey("SessionManager.Lifetime")){ // backwards compatibility
        setSessionLifetimeMax(config.getString("SessionManager.Lifetime"));  //set new parameter
        config.remove("SessionManager.Lifetime");  //remove old parameter
      }else sessionLifetimeMax = config.getString("SessionManager.SessionLifetimeMax",sessionLifetimeMaxDefault);

      if(config.containsKey("SessionManager.MaxIdleTime")){ // backwards compatibility
        setSessionIdleTimeMax(config.getString("SessionManager.MaxIdleTime"));  //set new parameter
        config.remove("SessionManager.MaxIdleTime");  //remove old parameter
      }else sessionIdleTimeMax = config.getString("SessionManager.SessionIdleTimeMax",sessionIdleTimeMaxDefault);

      if(config.containsKey("SessionManager.MaxNoUserIdleTime")){ // backwards compatibility
        setSessionNoUserIdleTimeMax(config.getString("SessionManager.MaxNoUserIdleTime"));  //set new parameter
        config.remove("SessionManager.MaxNoUserIdleTime");  //remove old parameter
      }else sessionNoUserIdleTimeMax = config.getString("SessionManager.SessionNoUserIdleTimeMax",sessionNoUserIdleTimeMaxDefault);

      idleScanInterval = config.getString("SessionManager.IdleScanInterval",idleScanIntervalDefault);

      randomizerIntervals = config.getStrings("SessionManager.RandomizerIntervals",randomizerIntervalsDefault);
      memoryPersistence = config.getString("SessionManager.MemoryPersistence",memoryPersistenceDefault);

      if(config.containsKey("SessionManager.EncodeUrlState")){ // backwards compatibility
        setSessionEncodeUrlState(config.getString("SessionManager.EncodeUrlState"));  //set new parameter
        config.remove("SessionManager.EncodeUrlState");  //remove old parameter
      }else sessionEncodeUrlState = config.getString("SessionManager.SessionEncodeUrlState",sessionEncodeUrlStateDefault);
      
      sessionEncodeFirstUrl = config.getString("SessionManager.SessionEncodeFirstUrl",sessionEncodeFirstUrlDefault);
      
      //SessionManager.SessionHome.*
      mode = config.getString("SessionManager.SessionHome.Mode",modeDefault);
      maxSessions = config.getString("SessionManager.SessionHome.MaxSessions",maxSessionsDefault);
      pageThreshold = config.getString("SessionManager.SessionHome.PageThreshold",pageThresholdDefault);
      pageTimeThreshold = config.getString("SessionManager.SessionHome.PageTimeThreshold",pageTimeThreshold);
      pageWait = config.getString("SessionManager.SessionHome.PageWait",pageWaitDefault);
      saveOnRestart = config.getString("SessionManager.SessionHome.SaveOnRestart",saveOnRestartDefault);
      pageDir = config.getString("SessionManager.SessionHome.PageDir",pageDirDefault);
      databaseName = config.getString("SessionManager.SessionHome.DatabaseName",databaseNameDefault);
      dBTableName = config.getString("SessionManager.SessionHome.DBTableName",dBTableNameDefault);


      sessionHomeClass = config.getString("SessionManager.SessionHome.Class",sessionHomeClassDefault);
      sessionUserTableClass = config.getString("SessionManager.SessionUserTable.Class",sessionUserTableClassDefault);

  }


  public String getSessionLifetimeMax() {
    return sessionLifetimeMax;
  }
  public void setSessionLifetimeMax(String lifetimeMax) throws KeywordValueException{
    this.sessionLifetimeMax = lifetimeMax;
    config.set("SessionManager.SessionLifetimeMax",lifetimeMax);
  }

  public String getSessionIdleTimeMax() {
    return sessionIdleTimeMax;
  }

  public void setSessionIdleTimeMax(String idleTimeMax) throws KeywordValueException{
    this.sessionIdleTimeMax = idleTimeMax;
    config.set("SessionManager.SessionIdleTimeMax",idleTimeMax);
  }

  public String getSessionNoUserIdleTimeMax() {
    return sessionNoUserIdleTimeMax;
  }

  public void setSessionNoUserIdleTimeMax(String noUserIdleTimeMax) throws KeywordValueException{
    this.sessionNoUserIdleTimeMax = noUserIdleTimeMax;
    config.set("SessionManager.SessionNoUserIdleTimeMax",noUserIdleTimeMax);
  }

  public String getIdleScanInterval() {
    return idleScanInterval;
  }

  public void setIdleScanInterval(String idleScanInterval) throws KeywordValueException{
    this.idleScanInterval = idleScanInterval;
    config.set("SessionManager.IdleScanInterval",idleScanInterval);
  }

  public String[] getRandomizerIntervals() {
    return randomizerIntervals;
  }

  public void setRandomizerIntervals(String[] randomizerIntervals) throws KeywordValueException{
    this.randomizerIntervals = randomizerIntervals;
    config.set("SessionManager.RandomizerIntervals",randomizerIntervals);
  }

  public String getMemoryPersistence() {
    return memoryPersistence;
  }

  public void setMemoryPersistence(String memoryPersistence) throws KeywordValueException{
    this.memoryPersistence = memoryPersistence;
    config.set("SessionManager.MemoryPersistence",memoryPersistence);
  }

  public String getSessionEncodeUrlState(){
    return sessionEncodeUrlState;
  }

  public void setSessionEncodeUrlState(String sessionEncodeUrlState) throws KeywordValueException{
    this.sessionEncodeUrlState = sessionEncodeUrlState;
    config.set("SessionManager.SessionEncodeUrlState",sessionEncodeUrlState);
  }
  
  public String getSessionEncodeFirstUrl(){
    return sessionEncodeFirstUrl;
  }

  public void setSessionEncodeFirstUrl(String sessionEncodeFirstUrl) throws KeywordValueException{
    this.sessionEncodeFirstUrl = sessionEncodeFirstUrl;
    config.set("SessionManager.SessionEncodeFirstUrl",sessionEncodeFirstUrl);
  }

  public String getMode() {
    return mode;
  }
  
  public void setMode(String mode) throws KeywordValueException{
    this.mode = mode;
    config.set("SessionManager.SessionHome.Mode",mode);
  }

  public String getMaxSessions() {
    return maxSessions;
  }

  public void setMaxSessions(String maxSessions) throws KeywordValueException{
    this.maxSessions = maxSessions;
    config.set("SessionManager.SessionHome.MaxSessions",maxSessions);
  }

  public String getPageThreshold() {
    return pageThreshold;
  }

  public void setPageThreshold(String pageThreshold) throws KeywordValueException{
    this.pageThreshold = pageThreshold;
    config.set("SessionManager.SessionHome.PageThreshold",pageThreshold);
  }

  public String getPageTimeThreshold() {
    return pageTimeThreshold;
  }

  public void setPageTimeThreshold(String pageTimeThreshold) throws KeywordValueException{
    this.pageTimeThreshold = pageTimeThreshold;
    config.set("SessionManager.SessionHome.PageTimeThreshold",pageTimeThreshold);
  }

  public String getPageWait() {
    return pageWait;
  }

  public void setPageWait(String pageWait) throws KeywordValueException{
    this.pageWait = pageWait;
    config.set("SessionManager.SessionHome.PageWait",pageWait);
  }

  public String getSaveOnRestart() {
    return saveOnRestart;
  }

  public void setSaveOnRestart(String saveOnRestart) throws KeywordValueException{
    this.saveOnRestart = saveOnRestart;
    config.set("SessionManager.SessionHome.SaveOnRestart",saveOnRestart);
  }

  public String getPageDir() {
    return pageDir;
  }

  public void setPageDir(String pageDir) throws KeywordValueException{
    this.pageDir = pageDir;
    config.set("SessionManager.SessionHome.PageDir",pageDir);
  }

  public String getDatabaseName() {
    return databaseName;
  }

  public void setDatabaseName(String databaseName) throws KeywordValueException{
    this.databaseName = databaseName;
    config.set("SessionManager.SessionHome.DatabaseName",databaseName);
  }

  public String getDBTableName() {
    return dBTableName;
  }

  public void setDBTableName(String dBTableName) throws KeywordValueException{
    this.dBTableName = dBTableName;
    config.set("SessionManager.SessionHome.DBTableName",dBTableName);
  }

  public String getSessionHomeClass() {
    return sessionHomeClass;
  }

  public void setSessionHomeClass(String sessionHomeClass) throws KeywordValueException{
    this.sessionHomeClass = sessionHomeClass;
    config.set("SessionManager.SessionHome.Class",sessionHomeClass);
  }

  public String getSessionUserTableClass() {
    return sessionUserTableClass;
  }

  public void setSessionUserTableClass(String sessionUserTableClass) throws KeywordValueException{
    this.sessionUserTableClass = sessionUserTableClass;
    config.set("SessionManager.SessionUserTable.Class",sessionUserTableClass);
  }

  /**
   * Save state of SessionManager configuration parameters into config file.
   * @return TRUE if OK, else FALSE.
   */

  public boolean saveState(){
    try{
    ConfigFileInterface confFile = config.getConfigFile();
    confFile.write();
   }catch(Exception e){ //FIXME log Exception
      return false;
    }
    return true;
  }
}