/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.apache.vinci.transport.vns.service;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.StringTokenizer;

import org.apache.vinci.debug.Debug;
import org.apache.vinci.transport.BaseClient;
import org.apache.vinci.transport.BaseServer;
import org.apache.vinci.transport.BaseServerRunnable;
import org.apache.vinci.transport.ErrorFrame;
import org.apache.vinci.transport.Frame;
import org.apache.vinci.transport.KeyValuePair;
import org.apache.vinci.transport.ServiceException;
import org.apache.vinci.transport.Transportable;
import org.apache.vinci.transport.VinciFrame;
import org.apache.vinci.transport.VinciServableAdapter;
import org.apache.vinci.transport.vns.VNSConstants;

/**
 * VNS (Vinci Naming Service) provides the "directory" of all available Vinci services. VNS must be
 * running somewhere on the network for VinciClient and VinciServer classes to function. These
 * classes consult org.apache.vinci.transport.vns.client.VNSConfig to determine the location of the
 * VNS service.
 */
public class VNS extends VinciServableAdapter {

  private HashMap cachedResults = new HashMap();

  public final static String dirCmdAddService = "addservice";

  public final static String dirCmdAddAlias = "addalias";

  public final static String dirCmdDelService = "delservice";

  public final static String dirCmdDelAlias = "delalias";

  public final static String dirCmdUpdateService = "updateservice";

  public final static String dirCmdGetList = "getlist";

  public final static String dirCmdGetNames = "getnames";

  public final static String dirCmdGetHits = "gethits";

  public String ENV_PROXY = "vinci.environment.proxy";

  // Static variables set up during the start of the program
  private static String configFile, backupFile, workspacesFile, counterFile;

  private static String logFile = null;

  private static String configDir = null;

  private static int backupInterval = 120;

  private static int srvPort = 9000;

  private static boolean logFlag = false;

  private static String bindAddress = null;

  private static int backlog = 100;

  private static int maxThreads = 200;

  /* Instance variables */
  int port;

  String myLogFile = null;

  Thread backupThread;

  BackupThread backupThreadRunnable;

  Hashtable hits; // for keeping track of the counters

  int totalhits;

  ServiceRegistry SR;

  WorkspaceConfig WS;

  Writer log; // for writing to the logfile

  String starttime;

  static File quitFile;

  static private void setConfigDir(String path) {
    if (path.charAt(path.length() - 1) == File.separatorChar) {
      path = path.substring(0, path.length() - 1);
    }
    configDir = path;
    configFile = path + File.separatorChar + "vns.services";
    backupFile = path + File.separatorChar + "vns.services.bak";
    workspacesFile = path + File.separatorChar + "vns.workspaces";
    counterFile = path + File.separatorChar + "vns.counter";
    quitFile = new File(configDir + File.separatorChar + "quit");
    quitFile.delete();
  }

  public static void main(String[] args) throws IOException {
    Debug.setThreadNameOutput(true);
    System.setProperty("sun.net.inetaddr.ttl", "30");
    // ^^ JDK1.3
    java.security.Security.setProperty("networkaddress.cache.ttl", "30");
    // ^^ JDK1.4
    // ^^ REQUIRED to keep Java from caching "null" IP addresses for domain names
    setConfigDir(".");
    // Parse the commandline options
    String s;
    for (int i = 0; i < args.length; i++) {
      s = args[i].trim();
      if (s.equals("-h") || s.equals("--help")) {
        printUsage();
        return;
      }
      if (s.equals("-l") || s.equals("--logfile")) {
        logFile = args[++i];
        logFlag = true;
        Debug.p("Log file set to: " + logFile);
        continue;
      }
      if (s.equals("-p") || s.equals("--port")) {
        srvPort = Integer.parseInt(args[++i]);
        Debug.p("Service port set to: " + srvPort);
        continue;
      }
      if (s.equals("-b") || s.equals("--bind")) {
        bindAddress = args[++i];
        Debug.p("Bind address set to: " + bindAddress);
        continue;
      }
      if (s.equals("-g") || s.equals("--backlog")) {
        backlog = Integer.parseInt(args[++i]);
        Debug.p("Backlog set to: " + backlog);
        continue;
      }
      if (s.equals("-m") || s.equals("--maxthreads")) {
        maxThreads = Integer.parseInt(args[++i]);
        Debug.p("Max threads set to: " + maxThreads);
        continue;
      }
      if (s.equals("-i") || s.equals("--interval")) {
        backupInterval = Integer.parseInt(args[++i]);
        Debug.p("Backup interval set to: " + backupInterval);
        continue;
      }
      if (s.equals("-a") || s.equals("--logging")) {
        Debug.p("Access logging enabled.");
        logFlag = true;
        continue;
      }
      if (s.equals("-c") || s.equals("--config")) {
        String dir = args[++i];
        Debug.p("Config directory set to: " + dir);
        setConfigDir(dir);
        continue;
      }

      System.out.println("Unrecognized option : " + args[i]);
      printUsage();
      return;
    }

    // Start the server
    startServing();
  }

  private static void printUsage() {
    System.out.println("Usage: java org.apache.vinci.transport.vns.service.VNS [options]");
    System.out.println("  -p N  --port N");
    System.out.println("    Serve on port number N [default=" + srvPort + "]");

    System.out.println("  -b ip_address  --bind ip_address");
    System.out
            .println("    Force socket server to bind only to ip_address [default is bind to all]");

    System.out.println("  -c dirname --config dirname");
    System.out.println("    Look for & write config files in this directory [default=.]");

    System.out.println("  -i N  --interval N");
    System.out.println("    Backup every N seconds [default=" + backupInterval + "]");

    System.out.println("  -l fname  --logfile fname");
    System.out.println("    Access log pathname [default=<configdir>/vns.log]");

    System.out.println("  -a  --logging");
    System.out.println("    Enable access logging (implied by -l/--logfile option)");

    System.out.println("  -g N  --backlog N");
    System.out.println("    Set the ServerSocket backlog [default=" + backlog + "]");

    System.out.println("  -m N  --maxthreads N");
    System.out.println("    Set the maximum size of the VNS thread pool [default=" + maxThreads
            + "].");

    System.out.println("  -h  --help");
    System.out.println("    This help message");

    System.exit(0);
  }

  /* Main run method to initialize the server and start running it */
  public static void startServing() throws IOException {
    VNS vns;
    if (logFlag) {
      if (logFile == null) {
        logFile = configDir + File.separatorChar + "vns.log";
      }
      vns = new VNS(srvPort, logFile);
    } else {
      vns = new VNS(srvPort);
    }

    // Load the settings files
    if (!vns.loadConfig(configFile)) {
      System.err.println("failed to load config file: " + configFile);
      System.err.println("Check its path and validity. If necessary, restore from backup.");
      System.exit(1);
    }

    vns.loadWorkspaces(workspacesFile);
    Debug.p("VNS Workspace : " + vns.WS.workspace);

    vns.loadCounters(counterFile);

    // Configure and start the backup thread
    Debug.p("Starting backup thread, using files " + backupFile + " and " + configFile);
    vns.backupThreadRunnable = new BackupThread(vns, backupFile, configFile, backupInterval,
            counterFile);

    vns.backupThread = new Thread(vns.backupThreadRunnable);
    vns.backupThread.start();

    // Start accepting connections and processing stuff
    Debug.p("Serving on port : " + vns.port);
    BaseServer server = null;
    if (bindAddress != null) {
      server = new BaseServer(vns) {
        protected ServerSocket createServerSocket(int port) throws IOException {
          return new ServerSocket(port, backlog, InetAddress.getByName(bindAddress));
        }
      };
    } else {
      server = new BaseServer(vns) {
        protected ServerSocket createServerSocket(int port) throws IOException {
          return new ServerSocket(port, backlog);
        }
      };
    }
    server.setSocketTimeout(5000);
    exitThread exitT = new exitThread(server);
    exitT.start();
    try {
      server.setThreadPoolSize(5, maxThreads);
      server.serve(vns.port);
    } catch (Throwable e) {
      Debug.reportException(e);
    } finally {
      Debug.p("Exiting.");
      System.exit(0);
    }
  }

  /* Constructors */
  public VNS() {
    SR = new ServiceRegistry();
    WS = new WorkspaceConfig(this);
    hits = new Hashtable();
    totalhits = 0;
    starttime = (new Date()).toString();
  }

  public VNS(int port) {
    this();
    this.port = port;
  }

  public VNS(int port, String logFile) throws IOException {
    this();
    this.port = port;
    this.myLogFile = new String(logFile);
    this.log = new BufferedWriter(new FileWriter(myLogFile, true));
  }

  /* Methods to load data from various files */
  public boolean loadConfig(String cFile) {
    File f = new File(cFile);
    if (!f.exists()) {
      Debug.p("WARNING: Config file doesn't exist, creating a new empty config file!");
      try {
        FileWriter writer = new FileWriter(f);
        writer.write("<CONFIGURATION></CONFIGURATION>");
        writer.close();
      } catch (IOException e) {
        Debug.reportException(e);
        return false;
      }
    }

    Debug.p("Loading config file : " + cFile);

    synchronized (SR) {
      try {
        SR.load(cFile);
        return true;
      } catch (Exception e) {
        Debug.reportException(e);
      }
    }
    return false;
  }

  public void loadWorkspaces(String wFile) {
    Debug.p("Loading workspaces file : " + wFile);

    FileReader F = null;
    try {
      F = new FileReader(wFile);
      WS.load(F);
      F.close();
    } catch (Exception e) {
      Debug.reportException(e);
      Debug.p("WARNING: failed to load workspace.");
    } finally {
      try {
        F.close();
      } catch (Exception e) {
      }
    }

  }

  public void loadCounters(String cFile) {
    Debug.p("Loading counter file : " + cFile);

    FileReader F;
    BufferedReader br;
    int line = 1;

    try {
      F = new FileReader(cFile);
    } catch (FileNotFoundException e) {
      Debug.p("Could not load the counter file : " + cFile);
      return;
    }
    br = new BufferedReader(F);

    try {
      String s = br.readLine();
      if (s == null || s.trim().equals("")) {
        Debug.p("Invalid counter file format at line 1: " + cFile);
        br.close();
        F.close();
        return;
      }

      StringTokenizer str = new StringTokenizer(s);
      if (!(str.countTokens() > 1)) {
        Debug.p("Invalid counter file format at line 1: " + cFile);
        br.close();
        F.close();
        return;
      }

      if (!str.nextToken().equals("TOTAL")) {
        throw new Exception("First line invalid - does not start with TOTAL");
      }

      totalhits = Integer.parseInt(str.nextToken());
      hits = new Hashtable();
      line++;

      while ((s = br.readLine()) != null) {
        str = new StringTokenizer(s);
        hits.put(str.nextToken(), new Integer(str.nextToken()));
        line++;
      }

      br.close();
      F.close();
    } catch (IOException e2) {
      Debug.p("IO Problem while reading from counter file : " + cFile);
      Debug.p("Exception was : " + e2);
    } catch (NumberFormatException e3) {
      Debug.p("Invalid number specified in counter file " + cFile + " at line " + line);
    } catch (Exception e4) {
      Debug.p("Problem while parsing counter file : " + cFile);
      Debug.p("Exception generated : " + e4);
    } finally {
      try {
        br.close();
      } catch (IOException e5) {
      }
      try {
        F.close();
      } catch (IOException e6) {
      }
    }
  }

  /* Method to save data to various files */
  public void saveConfig(String cFile) {
    Debug.p("Saving to config file : " + cFile);
    long startTime = System.currentTimeMillis();
    synchronized (SR) {
      Writer F = null;
      try {
        F = new BufferedWriter(new FileWriter(cFile + ".rename"));
        try {
          SR.save(F);
        } finally {
          F.close();
        }
        File real_file = new File(cFile);
        real_file.delete();
        if (!new File(cFile + ".rename").renameTo(real_file)) {
          throw new IOException("FAILED to rename services config file!!!");
        }
      } catch (IOException e) {
        Debug.reportException(e);
        Debug.p("Could not save config file : " + cFile);
      }
    }
    startTime = System.currentTimeMillis() - startTime;
    Debug.p("Config save required " + startTime + " millis.");
    // flush the log too if it needs it...
    if (log != null) {
      synchronized (log) {
        try {
          log.flush();
        } catch (IOException e) {
          Debug.reportException(e);
        }
      }
    }
  }

  public void saveCounters(String cFile) {
    Debug.p("Saving counter file : " + cFile);

    FileWriter F;

    try {
      F = new FileWriter(cFile);
    } catch (IOException e) {
      Debug.p("Could not save the counter file : " + cFile);
      Debug.p("Exception generated : " + e);
      return;
    }

    try {
      F.write("TOTAL " + totalhits + "\n");
      if (hits == null) {
        F.close();
        return;
      }
      Enumeration keys = hits.keys();
      Integer value;
      String key;
      while (keys.hasMoreElements()) {
        key = (String) keys.nextElement();
        value = (Integer) hits.get(key);
        F.write(key.trim() + " " + value + "\n");
      }
    } catch (IOException e2) {
      Debug.reportException(e2);
      Debug.p("IO Problem while writing to counter file : " + cFile);
    } finally {
      try {
        if (F != null) {
          F.close();
        }
      } catch (IOException e3) {
        Debug.reportException(e3);
      }
    }
  }

  public void saveWorkspaces(String wFile) {
    Debug.p("Loading workspaces file : " + wFile);

    Writer F = null;
    try {
      F = new BufferedWriter(new FileWriter(wFile));
      WS.save(F);
      F.close();
    } catch (IOException e) {
      Debug.p("Could not save workspaces file : " + wFile);
      Debug.p("Exception generated : " + e);
    } catch (RuntimeException e2) {
      Debug.p("Problem while saving workspace file : " + wFile);
      Debug.p("Exception generated: " + e2);
    } finally {
      try {
        if (F != null) {
          F.close();
        }
      } catch (IOException e) {
        Debug.reportException(e);
      }
    }

  }

  /* Main processing routine */
  public Transportable eval(Transportable inp) throws ServiceException {
    VinciFrame in = (VinciFrame) inp;
    VinciFrame out = null;

    Debug.p("Request from " + in.fgetString("vinci:REMOTEIP"));

    String command;
    command = in.fgetString("vinci:COMMAND");
    if (command == null) {
      out = new VinciFrame();
      out.fadd("vinci:ERROR", "Malformed request");
      return out;
    }

    try {
      if (VNSConstants.RESOLVE_COMMAND.equals(command)) {
        out = resolve(in);
      } else if (VNSConstants.SERVEON_COMMAND.equals(command)) {
        out = serveon(in);
      } else if (command.equals(dirCmdAddService))
        out = addService(in);
      else if (command.equals(dirCmdAddAlias))
        out = addAlias(in);
      else if (command.equals(dirCmdUpdateService))
        out = updateService(in);
      else if (command.equals(dirCmdDelService))
        out = delService(in);
      else if (command.equals(dirCmdDelAlias))
        out = delAlias(in);
      else if (command.equals(dirCmdGetList))
        out = getList(in);
      else if (command.equals(dirCmdGetNames))
        out = getNames(in);
      else if (command.equals(dirCmdGetHits))
        out = getHits(in);
      else {
        out = new VinciFrame();
        out.fadd("vinci:ERROR", "Unrecognized command");
      }
    } catch (Exception e) {
      // Exact translation of the Python code [may not be necessary]
      out = new VinciFrame();
      out
              .fadd(
                      "vinci:ERROR",
                      "Critical error :\n"
                              + e
                              + "\nThe server MAY not respond to further requests.\nPlease notify the administrator\n");
      e.printStackTrace();
    }

    return out;
  }

  /* Various processing routines */
  VinciFrame resolveLocal(VinciFrame in) {

    Debug.p("Local resolve");

    VinciFrame out = new VinciFrame();

    String name = in.fgetString("SERVICE");
    if (strip(name) == null)
      return new ErrorFrame("No service name specified");

    String host = strip(in.fgetString("HOST"));
    String realhost = strip(in.fgetString("IP"));
    if (strip(realhost) == null && strip(host) != null) {
      try {
        // Try to resolve the IP if possible
        realhost = (InetAddress.getByName(host)).getHostAddress();
      } catch (Exception e) {
        // realhost = null;

        // return error message
        return new ErrorFrame("Could not resolve IP address for service " + name);
      }
    }

    String instance = in.fgetString("INSTANCE");
    int inst = -1;
    try {
      inst = Integer.parseInt(instance);
    } catch (Exception e) {
      inst = -1;
    }

    String level = in.fgetString("LEVEL");

    // Default as specified in SPEC.txt
    if (strip(level) == null || level.trim().toLowerCase().equals("none"))
      level = "-1";
    else if (level.toLowerCase().equals("all")) {
      Debug.p("Specific level must be given (not all)");
      out.fadd("vinci:ERROR", "Specific level must be given (not all)");
      return out;
    }

    synchronized (SR) {
      // Construct a valid number from the level string specified
      level = "" + SR.getLevel(name, level);
    }
    Service[] servicesList;

    // Check the cache for matches
    CachedItem citem = (CachedItem) checkCache(name + "[" + level + "]");
    if (citem == null) {
      synchronized (SR) {
        // Find all services that match the specified name and are <= level specified
        // Also, resolve all aliases to actual services
        servicesList = SR.getServices(name, level, true);
      }
      // Cache the result (if any matches found)
      if (servicesList != null && servicesList.length > 0) {
        // Cache the resolve result under the actual name and level returned
        cache(name + "[" + servicesList[0].level + "]", new CachedItem(servicesList));
        // Have a proxy pointer to the entry created if it is not the same
        if (!servicesList[0].level.equals(level)) {
          cache(name + "[" + level + "]", new ProxyCachedItem(name + "[" + servicesList[0].level
                  + "]"));
        }
      }
    } else
      servicesList = citem.servicesList;

    if (servicesList == null) {
      Debug.p("Service " + name + " not found");
      out.fadd("vinci:ERROR", "Service " + name + " not found");
      return out;
    }

    Debug.p("Number of services found with name = " + name + ", and level = " + level + " : "
            + servicesList.length);

    if (servicesList.length == 0)
      System.err.println("NO SERVICES FOUND WITH REALHOST = " + realhost + " name = " + name);

    ArrayList v = new ArrayList();

    // Filter the services with matching realhost and instance
    for (int i = 0; i < servicesList.length; i++) {
      if (realhost != null && !servicesList[i].realhost.equals(realhost))
        continue;
      if (inst > -1 && inst != servicesList[i].instance)
        continue;
      v.add(servicesList[i]);
    }

    servicesList = new Service[v.size()];

    for (int i = 0; i < v.size(); i++)
      servicesList[i] = (Service) v.get(i);

    if (servicesList == null || servicesList.length == 0) {
      Debug.p("Service " + name + " not found");
      out.fadd("vinci:ERROR", "Service " + name + " not found");
      return out;
    }

    VinciFrame temp;
    for (int j = 0; j < servicesList.length; j++) {
      temp = new VinciFrame();

      temp.fadd("HOST", (String) servicesList[j].getAttr("host"));
      temp.fadd("PORT", "" + servicesList[j].port);
      temp.fadd("INSTANCE", "" + servicesList[j].instance);

      if (servicesList[j].meta) {
        Object o = servicesList[j].dict.get("META");
        if (o instanceof String)
          temp.fadd("META", (String) o);
        if (o instanceof Frame)
          temp.fadd("META", (Frame) o);
      }

      out.fadd("SERVER", temp);
    }

    out.fadd("LEVEL", servicesList[0].level); // should all be the same
    return out;
  }

  VinciFrame resolveProxy(VinciFrame in, String workspace) {
    Debug.p("Proxy resolve");
    if (workspace == null)
      workspace = in.fgetString("WORKSPACE");

    if (workspace == null || workspace.equals(WS.workspace)) {
      // New spec - assume it is local
      return resolveLocal(in);
    }

    Service[] services = SR.getServices(ENV_PROXY);
    VinciFrame out = new VinciFrame();
    if (services == null || services.length == 0) {
      out.fadd("vinci:ERROR", "Cannot locate proxy service");
      return out;
    }

    // Iterate through all the registered proxy services and try to resolve at each
    for (int i = 0; i < services.length; i++) {
      Service S = services[i];
      if (S.realhost == null) {
        continue; // Can't do anything if realhost isn't specified
      }

      try {
        // If the host specified is the local one, then use resolveLocal()
        // else it will have an infinite loop
        if (S.port == srvPort && InetAddress.getLocalHost().getHostAddress().equals(S.realhost))
          out = resolveLocal(in);
        else {
          Debug.p("Resolving with VNS: " + S.realhost + ":" + S.port);
          out = BaseClient.rpc(in, S.realhost, S.port);
        }
        System.out.println(out.toXML());
        if (out == null || out instanceof ErrorFrame || strip(out.fgetString("LEVEL")) == null
                || out.fgetString("vinci:ERROR") != null) {
          continue; // Check if resolve actually worked
        }
        return out;
      } catch (ServiceException se) {
        // Don't need to worry - caused due to an ErrorFrame as the server was unable to
        // resolve
        System.out.println(se);
        se.printStackTrace();
      } catch (Exception e) {
        e.printStackTrace();
        out.fadd("vinci:ERROR", "Proxy forwarding failed due to " + e);
        return out;
      }
    }
    return new ErrorFrame("Proxy forwarding failed");
  }

  VinciFrame resolveDefaults(VinciFrame in) {
    String name = in.fgetString("SERVICE");
    String workspace;

    VinciFrame out;

    if (WS.workspace == null || WS.search.size() == 0)
      return resolveLocal(in); // Use resolveLocal() if WS was not defined

    for (int i = 0; i < WS.search.size(); i++) {
      workspace = ((String) WS.search.get(i));

      if (workspace.equals(WS.workspace)) {
        Debug.p("Resolving on local workspace ...");

        out = resolveLocal(in);
      } else {
        Debug.p("Resolving on workspace " + workspace + " ...");
        out = resolveProxy(in, workspace);
      }

      if (out.fgetString("vinci:ERROR") == null)
        return out;
    }

    Debug.p("Resolution failed");
    return new ErrorFrame("Could not find service " + name + " in default workspaces");
  }

  VinciFrame resolve(VinciFrame in) {
    logRequest(VNSConstants.RESOLVE_COMMAND, in.fgetString("vinci:REMOTEIP"), in
            .fgetString("SERVICE"));

    if (in.fgetString("WORKSPACE") == null) {
      return resolveDefaults(in);
    } else {
      Debug.p("Resolving on workspace " + in.fgetString("WORKSPACE") + " ...");
      return resolveProxy(in, null);
    }
  }

  VinciFrame serveon(VinciFrame in) {
    logRequest(VNSConstants.SERVEON_COMMAND, in.fgetString("vinci:REMOTEIP"), null);

    Service S = null, srv = null;
    VinciFrame out = new VinciFrame();

    String name = in.fgetString("SERVICE");
    if (strip(name) == null)
      return new ErrorFrame("Invalid service name specified : " + name);
    String host = in.fgetString("HOST");

    if (strip(host) == null) {
      Debug.p("Getting host from socket peer info");
      host = in.fgetString("vinci:REMOTEHOST");
      if (host == null)
        host = in.fgetString("vinci:REMOTEIP");
      if (host == null)
        return new ErrorFrame("Host could not be parsed - specify HOST");
      Debug.p("Peer host is : " + host);
    }

    String level = in.fgetString("LEVEL");

    // Default as specified in SPEC.txt
    if (strip(level) == null || level.trim().toLowerCase().equals("none"))
      level = "0";

    if (level.equals("all")) {
      out.fadd("vinci:ERROR", "Specific level must be given or none at all");
      return out;
    }

    String instance = in.fgetString("INSTANCE");
    try {
      instance = "" + Integer.parseInt(instance);
    } catch (Exception e) {
      instance = null;
    }

    if (instance == null)
      instance = "0";

    Debug.p("Host = " + host);
    String realhost = in.fgetString("IP");
    try {
      if (realhost == null)
        realhost = InetAddress.getByName(host).getHostAddress();
    } catch (Exception e) {
      out.fadd("vinci:ERROR", "Could not resolve IP due to Exception " + e);
      return out;
    }

    Debug.p("search: realhost = " + realhost + " - instance = " + instance);

    synchronized (SR) {
      level = "" + SR.getLevel(name, level);
    }

    Debug.p("Level = " + level);

    // Update the cache
    updateCache(name + "[" + level + "]");

    Object[] services;
    synchronized (SR) {
      services = SR.getServices(name, level);
    }

    if (services != null) {
      for (int i = 0; i < services.length; i++) {
        S = (Service) services[i];
        Debug.p("current: realhost = " + S.realhost + " - instance = " + S.instance);
        if (S.realhost.equals(realhost) && instance.equals("" + S.instance)
                && S.level.equals(level)) {
          srv = S;
          break;
        }
      }
    }

    if (srv == null) {
      Debug.p("Creating now");
      Hashtable H = new Hashtable();
      H.put("NAME", name);
      H.put("HOST", host);
      H.put("LEVEL", level);
      H.put("INSTANCE", instance);
      H.put("IP", realhost);
      srv = new Service(H);
      boolean ok = false;
      synchronized (SR) {
        Debug.p("Adding service : " + H.get("NAME") + ", lvl=" + H.get("LEVEL") + ",instance="
                + H.get("INSTANCE") + ",ip=" + H.get("IP"));
        ok = SR.addService(srv);
      }
      if (!ok) {
        out.fadd("vinci:ERROR", "COuld not find or add service " + name);
        return out;
      }
    } else {
      if (srv.minport != srv.maxport) { // if it isn't running on a fixed port
        final String s_host = srv.host;
        final int s_port = srv.port;
        new Thread(new Runnable() {
          public void run() {
            Debug.p("Trying to shutdown old service ...");
            VinciFrame shutdown = new VinciFrame();
            shutdown
                    .fadd(
                            "vinci:SHUTDOWN",
                            "Identical service started on this host. Use the INSTANCE tag to run multiple instances of the same service on a single host.");
            try {
              VinciFrame f = BaseClient.rpc(shutdown, s_host, s_port, 10000);
              Debug.p("Shutdown response received: " + f.toXML());
            } catch (Exception e) {
              Debug.p("Old service already closed: " + e);
            }
          }
        }).start();
      }
    }

    srv.updatePort();
    out.fadd("HOST", srv.host);
    out.fadd("PORT", srv.port);
    out.fadd("LEVEL", srv.level);
    out.fadd("INSTANCE", srv.instance);
    out.fadd("IP", srv.realhost);
    return out;
  }

  VinciFrame addService(VinciFrame in) {
    logRequest(dirCmdAddService, in.fgetString("vinci:REMOTEIP"), null);

    VinciFrame service = in.fgetVinciFrame("SERVICE");

    Hashtable H = new Hashtable();

    int total = service.getKeyValuePairCount();
    KeyValuePair P;
    for (int i = 0; i < total; i++) {
      P = service.getKeyValuePair(i);
      if (P.isValueALeaf()) {
        H.put(P.getKey(), P.getValueAsString());
      } else {
        H.put(P.getKey(), P.getValue());
      }
    }

    String level = (String) H.get("LEVEL");
    if (strip(level) == null) {
      H.put("LEVEL", "0"); // default level of 0
    }

    boolean ok = false;

    synchronized (SR) {
      Service S;
      ok = SR.addService(S = new Service(H));
      updateCache(S);
    }

    return getFrame(ok, "Add Service request failed");
  }

  VinciFrame addAlias(VinciFrame in) {
    logRequest(dirCmdAddAlias, in.fgetString("vinci:REMOTEIP"), null);

    VinciFrame service = in.fgetVinciFrame("SERVICE");

    boolean ok = true;

    if (service.fgetString("NAME") == null || service.fgetString("TARGET") == null)
      getFrame(false, "Malformed request");
    else {
      synchronized (SR) {
        ok = SR
                .addAlias(new ServiceAlias(service.fgetString("NAME"), service.fgetString("TARGET")));
      }
    }

    return getFrame(ok, "Add alias request failed");
  }

  VinciFrame delService(VinciFrame in) {
    logRequest(dirCmdDelService, in.fgetString("vinci:REMOTEIP"), null);

    VinciFrame service = in.fgetVinciFrame("SERVICE");

    Hashtable H = new Hashtable();

    int total = service.getKeyValuePairCount();
    KeyValuePair P = null;
    for (int i = 0; i < total; i++) {
      P = service.getKeyValuePair(i);

      if (P.isValueALeaf()) {
        H.put(P.getKey(), P.getValueAsString());
      } else {
        H.put(P.getKey(), P.getValue());
      }
    }

    String level = (String) H.get("LEVEL");
    if (strip(level) == null)
      H.put("LEVEL", "0"); // default level of 0

    boolean ok = false;

    synchronized (SR) {
      Service S;
      ok = SR.delService(S = new Service(H));
      updateCache(S);
    }

    return getFrame(ok, "Delete Service request failed");
  }

  VinciFrame delAlias(VinciFrame in) {
    logRequest(dirCmdDelAlias, in.fgetString("vinci:REMOTEIP"), null);
    VinciFrame service = in.fgetVinciFrame("SERVICE");
    boolean ok = true;
    if (service.fgetString("NAME") == null || service.fgetString("TARGET") == null) {
      getFrame(false, "Malformed request");
    } else {
      synchronized (SR) {
        ok = SR.delAlias(service.fgetString("NAME"));
      }
    }
    return getFrame(ok, "Delete alias request failed");
  }

  VinciFrame updateService(VinciFrame in) {
    logRequest(dirCmdUpdateService, in.fgetString("vinci:REMOTEIP"), null);

    VinciFrame service = in.fgetVinciFrame("SERVICE");

    Hashtable H = new Hashtable();

    int total = service.getKeyValuePairCount();
    KeyValuePair P;
    for (int i = 0; i < total; i++) {
      P = service.getKeyValuePair(i);
      if (P.isValueALeaf()) {
        H.put(P.getKey(), P.getValueAsString());
      } else {
        H.put(P.getKey(), P.getValue());
      }
    }

    boolean ok = false;

    synchronized (SR) {
      Service S;
      ok = SR.updateService(S = new Service(H));
      updateCache(S);
    }

    return getFrame(ok, "Update Service request failed");
  }

  VinciFrame getList(VinciFrame in) {
    String level = in.fgetString("LEVEL");

    // Default as specified in SPEC.txt
    if (level == null || level.trim().toLowerCase().equals("none")) {
      level = "-1";
    }

    String prefix = in.fgetString("PREFIX");
    if (prefix == null) {
      prefix = "";
    }

    logRequest(dirCmdGetList, in.fgetString("vinci:REMOTEIP"), prefix);

    Object[] servicelist;
    synchronized (SR) {
      Debug.p("Getting list for level : " + level);
      servicelist = SR.listServices(prefix, level);
      if (servicelist == null)
        servicelist = new Object[0]; // For safety
      Debug.p("Matches for getList : " + servicelist.length);
    }

    VinciFrame F = new VinciFrame();
    for (int i = 0; i < servicelist.length; i++) {
      if (ServiceAlias.isAlias(servicelist))
        F.fadd("SERVICE", ((ServiceAlias) servicelist[i]).toFrame());
      else
        F.fadd("SERVICE", ((Service) servicelist[i]).toFrame());
    }

    return F;
  }

  VinciFrame getNames(VinciFrame in) {
    String level = in.fgetString("LEVEL");

    // Default as specified in SPEC.txt
    if (level == null || level.trim().toLowerCase().equals("none"))
      level = "-1";

    String prefix = in.fgetString("PREFIX");
    if (prefix == null)
      prefix = "";

    logRequest(dirCmdGetNames, in.fgetString("vinci:REMOTEIP"), prefix);

    String[] servicelist;
    synchronized (SR) {
      Debug.p("Getting names list for level : " + level);
      servicelist = SR.listNames(prefix, level);
      if (servicelist == null)
        servicelist = new String[0]; // For safety
      Debug.p("Matches for getNames : " + servicelist.length);
    }

    VinciFrame F = new VinciFrame();
    for (int i = 0; i < servicelist.length; i++) {
      F.fadd("SERVICE", servicelist[i]);
    }

    return F;
  }

  VinciFrame getHits(VinciFrame in) {
    String type = in.fgetString("TYPE");

    VinciFrame F = new VinciFrame();
    VinciFrame temp;
    String key;

    if (type != null) {
      if (type.equals("all")) {
        Enumeration keys = hits.keys();
        while (keys.hasMoreElements()) {
          key = (String) keys.nextElement();
          temp = new VinciFrame();
          temp.fadd("TYPE", key);
          temp.fadd("COUNT", hits.get(key).toString());
          F.fadd("HITS", temp);
        }
        F.fadd("TOTAL", "" + totalhits);
      } else {
        if (hits.get(type) != null)
          F.fadd("HITS", hits.get(type).toString());
        else {
          F.fadd("vinci:ERROR", "No such type: " + type);
          return F;
        }
      }
    } else {
      F.fadd("HITS", "" + totalhits);
    }

    F.fadd("STARTED", "" + starttime);

    return F;
  }

  /* Caching routines */
  private void cache(String s, Object o) {
    synchronized (cachedResults) {
      cachedResults.put(s, o);
    }
  }

  private void updateCache(String s) {
    synchronized (cachedResults) {
      cachedResults.remove(s);
    }
  }

  private Service updateCache(Service S) {
    String name = (String) S.getAttr("name");
    String level = "";
    synchronized (SR) {
      level = "" + SR.getLevel(name, (String) S.getAttr("level"));
    }

    updateCache(name + "[" + level + "]");
    return S;
  }

  private Object checkCache(String s) {
    synchronized (cachedResults) {
      Object o = null;
      do {
        o = cachedResults.get(s);
        if (o == null)
          return null;
        if (o instanceof ProxyCachedItem)
          s = ((ProxyCachedItem) o).altKey;
      } while (!(o instanceof CachedItem));
      return o;
    }
  }

  /* Helper method to return the correct VinciFrame */
  VinciFrame getFrame(boolean ok, String err) {
    VinciFrame F = null;
    if (ok) {
      F = new VinciFrame();
      F.fadd("STATUS", "OK");
    } else
      return new ErrorFrame(err);

    return F;
  }

  /* Helper methods */
  public static String strip(String s) {
    if (s == null || s.trim().equals(""))
      return null;
    return s;
  }

  public static String emptyString(String s) {
    if (strip(s) == null)
      return "";
    return s;
  }

  /* Logging routines */
  void logRequest(String type, String ip, String text) {
    if (ip == null) {
      ip = BaseServerRunnable.getSocket().getInetAddress().getHostAddress();
      if (ip == null) {
        ip = "UNKNOWN";
      }
    }
    if (text == null)
      text = "";

    // Update hit counter
    synchronized (hits) {
      Integer I = (Integer) hits.get(type);
      if (I == null)
        I = new Integer(0);
      I = new Integer(I.intValue() + 1);

      hits.put(type, I);
      totalhits++;
    }
    String ts = (new Date()).toString();
    String write_me = ip + " - [" + ts + "] " + type + " " + text + "\n";
    Debug.p(write_me);

    if (log == null)
      return;

    synchronized (log) {
      // Make an entry in the log file
      try {
        log.write(write_me);
      } catch (IOException e) {
        Debug.reportException(e);
      }
    }
  }

  public void cleanExit() {
    Debug.p("Exiting now ...");
    quitFile.delete();
    try {
      backupThreadRunnable.stop = true;
      backupThread.interrupt();
    } catch (Exception e) {
      Debug.reportException(e);
    }

    backupThreadRunnable.forceWrite();

    if (log != null) {
      try {
        synchronized (log) {
          log.close();
        }
      } catch (IOException e) {
        Debug.reportException(e);
      }
    }
  }

}

/* Class for the backup thread */
class BackupThread implements Runnable {
  VNS parent;

  String backupFile;

  String configFile = null;

  String counterFile = null;

  int interval;

  volatile protected boolean stop = false;

  public BackupThread(VNS parent, String backupFile, String configFile, int interval,
          String counterFile) {
    // We create new strings so that we can start another VNS instance without disturbing this one
    this.parent = parent;
    this.backupFile = new String(backupFile);
    if (configFile != null)
      this.configFile = new String(configFile);
    if (counterFile != null)
      this.counterFile = new String(counterFile);
    this.interval = interval * 1000; // Convert secs to millisecs
  }

  public void forceWrite() {
    parent.saveConfig(backupFile);
    if (configFile != null)
      parent.saveConfig(configFile);
    if (counterFile != null)
      parent.saveCounters(counterFile);
    Debug.p("All files written to disk");
  }

  public void run() {
    Debug.p("Backup thread started");
    while (true) {
      parent.saveConfig(backupFile);
      if (configFile != null) {
        parent.saveConfig(configFile);
      }
      if (counterFile != null) {
        parent.saveCounters(counterFile);
      }
      try {
        Thread.sleep(interval);
      } catch (InterruptedException e) {
        break;
      }
      if (stop) {
        break;
      }
    }
    Debug.p("Backup thread exitted");
  }

}

/* Thread to check for quit command */
class exitThread extends Thread {
  BaseServer parent = null;

  boolean run = false;

  public exitThread(BaseServer parent) {
    this.parent = parent;
    run = true;
  }

  public void run() {
    if (parent == null)
      return;

    int i = 0;

    char[] cmd = { 'q', 'u', 'i', 't' };
    System.out.println(">>>>>>>>>>>>> VNS is up and running! <<<<<<<<<<<<<<<<<");
    System.out.println(">>>>>>>>>>>>> Type \'quit\' and hit ENTER to terminate VNS <<<<<<<<<<<<<");
    while (run) {
      i = 0;

      try {
        if (System.in.available() > 0) {
          while (System.in.available() > 0) {
            if ((System.in.read()) != cmd[i])
              i = 0;
            else
              i++;
            if (i >= cmd.length) {
              run = false;
              break;
            }
          }
        }
      } catch (Exception e) {
      }

      try {
        Thread.sleep(1000);
        if (VNS.quitFile.exists()) {
          run = false;
        }
      } catch (InterruptedException e2) {
        run = false;
      }
    }

    System.out.println("Got quit command from user");
    parent.shutdownServing();
    System.out.println("Request handling thread successfully shutdown");
  }
}

/* Encapsulating class for cached item */
class CachedItem {

  CachedItem(Service[] s) {
    servicesList = s;
  }

  protected Service[] servicesList = null;
}

/* Points to some other cached entry */
class ProxyCachedItem {

  protected String altKey;

  ProxyCachedItem(String s) {
    altKey = s;
  }
}
