source: greenstone3/trunk/src/java/org/greenstone/server/BaseServer.java@ 18690

package org.greenstone.server;

import java.awt.Dimension;
import java.awt.Toolkit;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;
import java.util.Properties;

import org.apache.log4j.*;

import org.greenstone.gsdl3.util.Dictionary;

public abstract class BaseServer 
{
    static protected String START_CMD;
    static protected String RESTART_CMD;
    static protected String CONFIGURE_CMD;
    static protected String STOP_CMD;

    static protected final int SERVER_STARTED = 0;
    static protected final int SERVER_START_FAILED = 1;
    static protected final int BROWSER_LAUNCHED = 2;
    static protected final int BROWSER_LAUNCH_FAILED = 3; 
 
    static protected Properties build_properties;
    static protected Logger logger_;

    static public File build_properties_file;
    static public Dictionary dictionary;
    static public BaseProperty Property;

    protected int server_state_ = -1;    
    protected boolean configure_required_ = true;
    protected String gsdl_home;
    protected BaseServerControl server_control_;    
    
    protected BaseServer(String gsdl_home, String lang, String build_properties_path)
    {
    this.gsdl_home = gsdl_home;

    // make sure we write to the correct logs
    initLogger();
    logger_ = Logger.getLogger(BaseServer.class.getName());

    build_properties_file = new File(build_properties_path);

    if (!build_properties_file.exists()) {
        logger_.fatal("Can't find build.properties file "+build_properties_path);
        System.exit(1);
    }
    
    build_properties = new Properties();
    reloadBuildProperties();
    
    dictionary = new Dictionary("server", lang, this.getClass().getClassLoader());

    }

    // override to write to the correct logs
    protected void initLogger() {}

    public void autoStart()
    {
    String auto_start = build_properties.getProperty(BaseServer.Property.AUTOSTART);
    if (auto_start != null && auto_start.equals("true")) {
        restart();
    }
    else{
        start();
    }  
    
    }

    protected int getServerState()
    {
    return server_state_;
    }

    protected abstract int runTarget(String cmd);


    public void reconfigRequired()
    {
    configure_required_ = true;
    }

    public void start() 
    {
        int state = -1;
        server_state_ = -1;
    server_control_.updateControl();

    server_control_.displayMessage(dictionary.get("ServerControl.Starting"));
    stop(true); // silent, no messages displayed
    
    // reconfigure if necessary
        if (configure_required_){
        server_control_.displayMessage(dictionary.get("ServerControl.Configuring"));
        state = runTarget(CONFIGURE_CMD);
        
       if (state != RunTarget.SUCCESS){
           recordError(CONFIGURE_CMD);
       }
       reload();
       configure_required_ = false;
    }
    else{
        recordSuccess(CONFIGURE_CMD); 
    }
    
        state = runTarget(START_CMD);
    
    if (state != RunTarget.SUCCESS){
        recordError(START_CMD);
            server_state_ = SERVER_START_FAILED;  
            
    }               
    else{
        recordSuccess(START_CMD); 
            server_state_ = SERVER_STARTED; 
        } 

        server_control_.updateControl();
    }
    
    protected void recordError(String message){
        message = dictionary.get("ServerControl.Error",new String[]{message,gsdl_home});
    server_control_.displayMessage(message);
    logger_.error(dictionary.get("ServerControl.Failed",new String[]{message}));
    }


    protected void recordError(String message, Exception e){
        message = dictionary.get("ServerControl.Error",new String[]{message,gsdl_home});
    server_control_.displayMessage(message);
    logger_.error(dictionary.get("ServerControl.Failed",new String[]{message}),e);
    }

    protected void recordSuccess(String message){
        message = dictionary.get("ServerControl.Success",new String[]{message});
    server_control_.displayMessage(message);
    logger_.info(message);
    }

   
    public abstract String getBrowserURL();
    public abstract void reload(); // reload properties, since they may have changed

    public void launchBrowser() {
        server_state_ = -1;
        server_control_.updateControl();   
        String message = dictionary.get("ServerControl.LaunchingBrowser");
        server_control_.displayMessage(message); 
    String url = getBrowserURL();
    //recordError("**** browserURL: " + url);
    BrowserLauncher launcher = new BrowserLauncher(build_properties.getProperty(BaseServer.Property.BROWSER_PATH),url);
        logger_.info(message);

    launcher.start();
     
        //wait for a while
        while(launcher.getBrowserState() == -1){
            try{
        Thread.sleep(3000);
        }
        catch(Exception e){
        logger_.error(e);
        }
         } 

    if (launcher.getBrowserState() != BrowserLauncher.LAUNCHSUCCESS ){
        recordError(dictionary.get("ServerControl.LaunchBrowser")); 
        server_state_ = BROWSER_LAUNCH_FAILED; 
    }
    else{
        recordSuccess(dictionary.get("ServerControl.LaunchBrowser")); 
        server_state_ = BROWSER_LAUNCHED;
    }    
        
    server_control_.updateControl();        
    }
    
    public void restart(){
    start();       
        if (server_state_ == SERVER_STARTED){
        launchBrowser();
    }  
    }

    // Preserving the current behaviour of stop() which is to
    // display the message on stopping
    public void stop() {
    stop(false);
    }

    public void stop(boolean silent) {
    if(!silent) {
        server_control_.displayMessage(dictionary.get("ServerControl.Stopping"));
    }
    int state = runTarget(STOP_CMD);
    
        if (state != RunTarget.SUCCESS){
        recordError(STOP_CMD);
    }
    else{
        recordSuccess(STOP_CMD);
    }

    }
    
    public  void reloadBuildProperties() {
    try {
        //InputStream in = this.getClass().getClassLoader().getResourceAsStream("build.properties");
        FileInputStream in = new FileInputStream(build_properties_file);

        if (in != null) {
        logger_.info("loading build properties");
        build_properties.load(in);
        in.close();
        } else {
        logger_.error("Couldn't load build properties!");
        }
    } catch (Exception e) {
        logger_.error("Exception trying to reload build.properties: "+e);
    }
    
    }

}