filetodom.java

SIP（Session Initiation Protocol）是由IETF定义

                               + " into featureDoc");
            featureDoc.getDocumentElement().appendChild(featureNode);
          }
        }
        else
        {
          System.out.println("no extra server types to add to ListOfFeatureServers");
        }
      }
      catch (VPPNoSuchFileException e)
      {
        System.out.println("Creating new " + LIST_OF_FEATURE_SERVERS_FILE);

        featureDoc = defaultDoc;

        DOMToFile.writeFileFromNode(featureDoc.getDocumentElement(), 
                FEATURE_SERVERS, SYSTEM_DIR, LIST_OF_FEATURE_SERVERS_FILE);
      }

      System.out.println("after adding new server types, featureDoc is\n" 
                         + new XMLUtils().buildXMLString(featureDoc));

      Element featureNode = 
        (Element) (baseDocument.importNode(featureDoc.getDocumentElement(), 
              true));

      featureNode.setAttribute("fileDir", SYSTEM_DIR);
      featureNode.setAttribute("fileName", LIST_OF_FEATURE_SERVERS_FILE);
      featureNode.setAttribute("fileType", Integer.toString(FEATURE_SERVERS));
      serversElement.appendChild(featureNode);

      // fill in the feature hosts
      fillInServers((Element) featureNode, FEATURE_DIR);

      // get the list of marshal servers
      Document marshalDoc = null;

      try
      {
        System.out.println("looking for " + SYSTEM_DIR 
                           + LIST_OF_MARSHAL_SERVERS_FILE);

        StringReader reader = 
          new StringReader(AdministrativeLogin.getConnection().doGet(SYSTEM_DIR, 
                LIST_OF_MARSHAL_SERVERS_FILE));

        try
        {
          marshalDoc = parser.parse(new InputSource(reader));
        }
        catch (SAXException e)
        {
          System.out.println("bad XML: " + reader.toString());
          e.printStackTrace();
        }

      }
      catch (VPPNoSuchFileException e)
      {
        System.out.println("Creating new " + LIST_OF_MARSHAL_SERVERS_FILE);

        StringReader reader = new StringReader(LIST_OF_MARSHAL_SERVERS_XML);

        marshalDoc = parser.parse(new InputSource(reader));

        DOMToFile.writeFileFromNode(marshalDoc.getDocumentElement(), 
                MARSHAL_SERVERS, SYSTEM_DIR, LIST_OF_MARSHAL_SERVERS_FILE);
      }

      Element marshalNode = 
        (Element) (baseDocument.importNode(marshalDoc.getDocumentElement(), 
              true));

      marshalNode.setAttribute("fileDir", SYSTEM_DIR);
      marshalNode.setAttribute("fileName", LIST_OF_MARSHAL_SERVERS_FILE);
      marshalNode.setAttribute("fileType", Integer.toString(MARSHAL_SERVERS));
      serversElement.appendChild(marshalNode);

      // fill in the marshal hosts
      fillInServers(marshalNode, MARSHAL_DIR);

      // get the list of redirect servers
      Document redirectDoc = null;

      try
      {
        System.out.println("looking for " + SYSTEM_DIR 
                           + LIST_OF_REDIRECT_SERVERS_FILE);

        StringReader reader = 
          new StringReader(AdministrativeLogin.getConnection().doGet(SYSTEM_DIR, 
                LIST_OF_REDIRECT_SERVERS_FILE));

        try
        {
          redirectDoc = parser.parse(new InputSource(reader));
        }
        catch (SAXException e)
        {
          System.out.println("bad XML: " + reader.toString());
          e.printStackTrace();
        }

      }
      catch (VPPNoSuchFileException e)
      {
        System.out.println("Creating new " + LIST_OF_REDIRECT_SERVERS_FILE);

        StringReader reader = new StringReader(LIST_OF_REDIRECT_SERVERS_XML);

        redirectDoc = parser.parse(new InputSource(reader));

        DOMToFile.writeFileFromNode(redirectDoc.getDocumentElement(), 
                REDIRECT_SERVERS, SYSTEM_DIR, LIST_OF_REDIRECT_SERVERS_FILE);
      }

      Element redirectNode = 
        (Element) (baseDocument.importNode(redirectDoc.getDocumentElement(), 
              true));

      redirectNode.setAttribute("fileDir", SYSTEM_DIR);
      redirectNode.setAttribute("fileName", LIST_OF_REDIRECT_SERVERS_FILE);
      redirectNode.setAttribute("fileType", 
              Integer.toString(REDIRECT_SERVERS));
      serversElement.appendChild(redirectNode);

      // fill in the redirect hosts
      fillInServers(redirectNode, REDIRECT_DIR);

      // get the list of cdr servers
      Document cdrDoc = null;

      try
      {
        System.out.println("looking for " + SYSTEM_DIR 
                           + LIST_OF_CDR_SERVERS_FILE);

        StringReader reader = 
          new StringReader(AdministrativeLogin.getConnection().doGet(SYSTEM_DIR, 
                LIST_OF_CDR_SERVERS_FILE));

        try
        {
          cdrDoc = parser.parse(new InputSource(reader));
        }
        catch (SAXException e)
        {
          System.out.println("bad XML: " + reader.toString());
          e.printStackTrace();
        }
      }
      catch (VPPNoSuchFileException e)
      {
        System.out.println("Creating new " + LIST_OF_CDR_SERVERS_FILE);

        StringReader reader = new StringReader(LIST_OF_CDR_SERVERS_XML);

        cdrDoc = parser.parse(new InputSource(reader));

        DOMToFile.writeFileFromNode(cdrDoc.getDocumentElement(), CDR_SERVERS, 
                SYSTEM_DIR, LIST_OF_CDR_SERVERS_FILE);
      }

      Element cdrNode = 
        (Element) (baseDocument.importNode(cdrDoc.getDocumentElement(), 
              true));

      cdrNode.setAttribute("fileDir", SYSTEM_DIR);
      cdrNode.setAttribute("fileName", LIST_OF_CDR_SERVERS_FILE);
      cdrNode.setAttribute("fileType", Integer.toString(CDR_SERVERS));
      serversElement.appendChild(cdrNode);

      // fill in the cdr hosts
      fillInServers(cdrNode, CDR_DIR);

      // get the list of pdp servers
      Document pdpDoc = null;

      try
      {
        System.out.println("looking for " + SYSTEM_DIR 
                           + LIST_OF_PDP_SERVERS_FILE);

        StringReader reader = 
          new StringReader(AdministrativeLogin.getConnection().doGet(SYSTEM_DIR, 
                LIST_OF_PDP_SERVERS_FILE));

        try
        {
          pdpDoc = parser.parse(new InputSource(reader));
        }
        catch (SAXException e)
        {
          System.out.println("bad XML: " + reader.toString());
          e.printStackTrace();
        }

      }
      catch (VPPNoSuchFileException e)
      {
        System.out.println("Creating new " + LIST_OF_PDP_SERVERS_FILE);

        StringReader reader = new StringReader(LIST_OF_PDP_SERVERS_XML);

        pdpDoc = parser.parse(new InputSource(reader));

        DOMToFile.writeFileFromNode(pdpDoc.getDocumentElement(), PDP_SERVERS, 
                SYSTEM_DIR, LIST_OF_PDP_SERVERS_FILE);
      }

      Element pdpNode = 
        (Element) (baseDocument.importNode(pdpDoc.getDocumentElement(), 
              true));

      pdpNode.setAttribute("fileDir", SYSTEM_DIR);
      pdpNode.setAttribute("fileName", LIST_OF_PDP_SERVERS_FILE);
      pdpNode.setAttribute("fileType", Integer.toString(PDP_SERVERS));
      serversElement.appendChild(pdpNode);

      // fill in the pdp hosts
      fillInServers(pdpNode, PDP_DIR);


      // get the list of heartbeat servers
      Document heartbeatDoc = null;

      try
      {
        System.out.println("looking for " + SYSTEM_DIR 
                           + LIST_OF_HEARTBEAT_SERVERS_FILE);

        StringReader reader = 
          new StringReader(AdministrativeLogin.getConnection().doGet(SYSTEM_DIR, 
                LIST_OF_HEARTBEAT_SERVERS_FILE));

        try
        {
          heartbeatDoc = parser.parse(new InputSource(reader));
        }
        catch (SAXException e)
        {
          System.out.println("bad XML: " + reader.toString());
          e.printStackTrace();
        }
      }
      catch (VPPNoSuchFileException e)
      {
        System.out.println("Creating new " + LIST_OF_HEARTBEAT_SERVERS_FILE);

        StringReader reader = new StringReader(LIST_OF_HEARTBEAT_SERVERS_XML);

        heartbeatDoc = parser.parse(new InputSource(reader));

        DOMToFile.writeFileFromNode(heartbeatDoc.getDocumentElement(), 
                HEARTBEAT_SERVERS, SYSTEM_DIR, 
                LIST_OF_HEARTBEAT_SERVERS_FILE);
      }

      Element heartbeatNode = 
        (Element) (baseDocument.importNode(heartbeatDoc.getDocumentElement(), 
              true));

      heartbeatNode.setAttribute("fileDir", SYSTEM_DIR);
      heartbeatNode.setAttribute("fileName", LIST_OF_HEARTBEAT_SERVERS_FILE);
      heartbeatNode.setAttribute("fileType", 
              Integer.toString(HEARTBEAT_SERVERS));
      serversElement.appendChild(heartbeatNode);

      // fill in the heartbeat hosts
      fillInServers(heartbeatNode, HEARTBEAT_DIR);

    }
    catch (FailedToWriteFileException ftwfex)
    {

      // not much we can do about it.
    }

    return baseDocument;

  }

  /**
   * 
   * @param serversElement
   * @param dirName
   * 
   * @throws IOException
   */
  private static void fillInServers(Element serversElement, 
          String dirName) throws IOException, VPPException
  {
    DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
    DocumentBuilder parser = null;
    try
    {
      parser = dbf.newDocumentBuilder();
    }
    catch(ParserConfigurationException e1)
    {
      e1.printStackTrace();
      return;
    }
    NodeList nodes = serversElement.getElementsByTagName("server");
    Vector vector = new Vector(nodes.getLength());

    for (int i = 0; i < nodes.getLength(); i++)
    {
      vector.addElement(nodes.item(i));
    }

    for (int i = 0; i < vector.size(); i++)
    {
      Element serverElement = (Element) vector.elementAt(i);
      Node serverParent = serverElement.getParentNode();
      String serverFileName = (serverElement.getAttribute("host") + ":" 
              + serverElement.getAttribute("port"));

      System.out.println("looking for " + serverFileName);

      StringReader reader = 
        new StringReader(AdministrativeLogin.getConnection().doGet(dirName, 
              serverFileName));

      try
      {
        Document serverDocument = parser.parse(new InputSource(reader));
        Element serverNode = (Element) (baseDocument.importNode
          (serverDocument.getDocumentElement(), true));

        serverNode.setAttribute("fileDir", dirName);
        serverNode.setAttribute("fileName", serverFileName);
        serverNode.setAttribute("fileType", Integer.toString(FEATURE_SERVER));
        serverParent.replaceChild(serverNode, serverElement);
      }
      catch (SAXException e)
      {
        System.out.println("bad XML: " + reader.toString());
        e.printStackTrace();
      }
    }
  }

}