Server.java

Go to the documentation of this file.

/*
 * (c) copyright 2008, Technische Universitaet Graz and Technische Universitaet Wien
 *
 * This file is part of jdiagengine.
 *
 * jdiagengine is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * jdiagengine is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with jdiagengine. If not, see <http://www.gnu.org/licenses/>.
 *
 * Authors: Joerg Weber, Franz Wotawa
 * Contact: jweber@ist.tugraz.at (preferred), or fwotawa@ist.tugraz.at
 *
 */


package ATPInterface;

import java.net.*;
import java.io.IOException;
import java.util.*;

public class Server {

    protected InetAddress ip;

    protected int port;

    protected Map openSessions;

    boolean verboseOutput = false;


    protected static void printSyntaxHelp() {
        System.err.println("arguments: IP PORT [options]");
        System.err.println("possible options:");
        System.err.println("    -v   verbose output to stdout");
        System.err.println();
    }

    public static void main(String[] args) {
        
        System.err.println();

        System.out.println();
        System.out.println("ATP (Assumption-based Theorem prover Protocol) Server");

        if (args.length < 2) {
            printSyntaxHelp();
            return;
        }

        InetAddress ip;
        try {
            ip = InetAddress.getByName(args[0]);
        } catch (UnknownHostException e) {
            System.err.println("Unknown host IP address: " + args[0]);
            printSyntaxHelp();
            return;
        }

        Integer port;
        try {
            port = new Integer(args[1]);
        } catch (NumberFormatException e) {
            System.err.println("The PORT argument is not a valid integer number!");
            printSyntaxHelp();
            return;
        }

        Server server = new Server(ip, port.intValue(), args, 2, args.length - 1);
        server.run();        
    }

    public Server(InetAddress ip, int port, String[] options, int firstOptionIndex, int lastOptionIndex) {
        this.ip = ip;
        this.port = port;
        
        parseOptions(options, firstOptionIndex, lastOptionIndex);

        openSessions = Collections.synchronizedMap(new TreeMap());
    }

    protected void parseOptions(String[] args, int startIndex, int endIndex) {
        for (int iArgs = startIndex; iArgs <= endIndex; ++iArgs) {
            String opt = args[iArgs];
            if (opt.equals("-v")) {
                verboseOutput = true;
                System.out.println("Set option \"verbose output\" to TRUE");
            }
        }
    }

    public void run() {
        
        ServerSocket srvSocket;

        try {
            srvSocket = new ServerSocket(port, 5, ip);
        } catch (IOException e) {
            System.err.println("FATAL ERROR: server socket could not be created!");
            System.err.println("IOException message: " + e.getMessage());
            return;
        }

        System.out.println("Server socket created!");

        try {
            while(true) {
                
                Socket newSocket;
                newSocket = null;
                System.out.println("Server socket created!");
                try {
                    newSocket = srvSocket.accept();
                } catch (IOException e) {
                    System.err.println("FATAL ERROR: server not able to accept "
                                       + "incoming connections!");
                    System.err.println("IOException message: " + e.getMessage());
                    return;
                }
                
                System.out.println("Incoming connection accepted!");
                
                try {
                    Connection newConn = new Connection(newSocket, openSessions, verboseOutput);
                    newConn.start();
                } catch(Exception e) {
                    System.err.println(e.getMessage());
                    e.printStackTrace();
                    if ((newSocket != null) && (!newSocket.isClosed())) {
                        
                        try {
                            newSocket.close();
                        } catch (Exception e1) {
                        }
                    }
                }
                
            }  // while(true)

        } finally {
            try {
                srvSocket.close();
            } catch (IOException eIO) {}
        }
    }  // run()

}