domtofile.java

SIP（Session Initiation Protocol）是由IETF定义

/*
 * ====================================================================
 * The Vovida Software License, Version 1.0
 * 
 * Copyright (c) 2000 Vovida Networks, Inc.  All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 * 1. Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 * 
 * 2. Redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in
 * the documentation and/or other materials provided with the
 * distribution.
 * 
 * 3. The names "VOCAL", "Vovida Open Communication Application Library",
 * and "Vovida Open Communication Application Library (VOCAL)" must
 * not be used to endorse or promote products derived from this
 * software without prior written permission. For written
 * permission, please contact [e-mail].
 * 
 * 4. Products derived from this software may not be called "VOCAL", nor
 * may "VOCAL" appear in their name, without prior written
 * permission of Vovida Networks, Inc.
 * 
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
 * NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL VOVIDA
 * NETWORKS, INC. OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT DAMAGES
 * IN EXCESS OF $1,000, NOR FOR ANY INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 * 
 * ====================================================================
 * 
 * This software consists of voluntary contributions made by Vovida
 * Networks, Inc. and many individuals on behalf of Vovida Networks,
 * Inc.  For more information on Vovida Networks, Inc., please see
 * <http://www.vovida.org/>.
 * 
 */

package vocal.data;

import vocal.comm.VPPTransactionWrapper;
import vocal.comm.VPPException;
import vocal.ui.AdministrativeLogin;

import javax.xml.transform.TransformerFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.dom.DOMSource;

import org.w3c.dom.Node;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.w3c.dom.Attr;
import org.w3c.dom.NamedNodeMap;

import java.util.Vector;
import java.util.Hashtable;
import java.util.Enumeration;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;

/**
 * $RCSfile: DOMToFile.java,v $
 * 
 * @author $Author: bko $, $Date: 2002/09/26 01:14:00 $
 * @version $Revision: 1.31 $
 */
public class DOMToFile implements TreeNodeTypes
{
  private static Document baseDocument;
  private static Element rootElement;
  private static Element systemElement;
  private static Element serversElement;


  public static void deleteFile(Element currentNode)
  {

    String fileNameString = null;
    String fileDirString = null;

    fileNameString = currentNode.getAttribute("fileName");
    fileDirString = currentNode.getAttribute("fileDir");

    VPPTransactionWrapper connection = AdministrativeLogin.getConnection();

    try
    {
      connection.doDel(fileDirString, fileNameString);
    }
    catch (VPPException e)
    {
      VPPTransactionWrapper.showVPPException(e, "Error deleting file");
    }

  }


  /**
   * Write currentNode to file if it has an attribute "fileName"
   * @param currentNode the node we will try to write.
   * @return true if the file was successfully written, or false if
   * currentNode was not writable (did not have a filename);
   * @throws FailedToWriteFileException if currentNode should be writable but
   * the write failed
   */
  public static boolean tryToWriteFile(Element currentNode) 
    throws FailedToWriteFileException
  {
    String fileTypeString = null;
    String fileNameString = null;
    String fileDirString = null;

    try
    {
      fileNameString = currentNode.getAttribute("fileName");
      fileDirString = currentNode.getAttribute("fileDir");

      // uncomment for debugging
      // System.out.println("writing to file name: " + fileNameString);

      if (!fileNameString.equals(""))
      {
        fileTypeString = currentNode.getAttribute("fileType");

        int nodeType = Integer.parseInt(fileTypeString);

        writeFileFromNode(currentNode, nodeType, fileDirString, 
                          fileNameString);

        return true;
      }
    }
    catch (NumberFormatException e)
    {
      System.out.println("Error: corrupted data in xml for " + fileNameString 
                         + "\n" + fileTypeString 
                         + " cannot be parsed as a node type");
      e.printStackTrace();

    }

    return false;
  }     // tryToWriteFile

  /**
   * Starting from the root of a tree,
   * write to file any node that has
   * the attribute "fileName"
   */
  public static void writeAllFilesInTree(Document doc)
  {
    Node docElem = doc.getDocumentElement();
    writeAllFilesInTreeIter(docElem);
  }

  private static void writeAllFilesInTreeIter(Node node)
  {
    try
    {
      NamedNodeMap atts = node.getAttributes();
      if(atts != null)
      {
        Node attNode = atts.getNamedItem("fileName");
        if (attNode != null)
        {
          tryToWriteFile((Element)node);
          return;
        }
        else
        {
          NodeList children = node.getChildNodes();
          for (int i = 0; i < children.getLength(); i++)
          {
            writeAllFilesInTreeIter(children.item(i));
          }
        }
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  /**
   * Starting from currentNode, write to file any node that has
   * an attribute "filename".
   */
  public static void writeAllFilesInPath(Element endOfPath) 
    throws FailedToWriteFileException
  {
    Element currentNode = endOfPath;

    try
    {
      Node parentNode = null;

      // uncomment for debugging
      // System.out.println("current node: " + currentNode.getNodeName());
      tryToWriteFile(currentNode);

      while (true)
      {
        parentNode = currentNode.getParentNode();

        if (parentNode != null 
            && parentNode.getNodeType() == Node.ELEMENT_NODE)
        {
          currentNode = (Element) parentNode;

          // uncomment for debugging
          // System.out.println("current node: " + currentNode.getNodeName());
          tryToWriteFile(currentNode);
        }
        else
        {
          if (parentNode == null)
          {

            // uncomment for debugging
            // System.out.println("returning because parent is null");
          }
          else if (parentNode.getNodeType() != Node.ELEMENT_NODE)
          {

            // uncomment for debugging
            // System.out.println("returning because parent type is "
            // + parentNode.getNodeType());
          }

          return;
        }
      }
    }
    catch (FailedToWriteFileException e)
    {
      System.out.println("Failed to write file at node " 
                         + currentNode.getNodeName());

      throw e;
    }

  }     // writeAllFilesInPath


  /**
   * Starting from currentNode, write to file first node that has
   * an attribute "filename".
   */
  public static void writeFirstFileInPath(Element endOfPath) 
    throws FailedToWriteFileException
  {
    Element currentNode = endOfPath;
    Node parentNode = null;

    if (tryToWriteFile(currentNode))
    {
      return;
    }

    while (true)
    {
      parentNode = currentNode.getParentNode();

      if (parentNode != null && parentNode.getNodeType() == Node.ELEMENT_NODE)
      {
        currentNode = (Element) parentNode;

        if (tryToWriteFile(currentNode))
        {
          return;
        }
      }
      else
      {
        return;
      }
    }
  }     // writeFirstFileInPath

  /**
   * 
   * @param nodeToWrite
   * @param nodeType
   * @param fileDir
   * @param filename
   * 
   * @throws NumberFormatException
   */
  public static void writeFileFromNode(Element nodeToWrite, int nodeType, 
          String fileDir, 
          String fileName) throws NumberFormatException, 
          FailedToWriteFileException
  {
    switch (nodeType)
    {

      case GLOBAL:

      case DIGITAL_DIAL_PLAN:

      case IP_DIAL_PLAN:

      case FEATURE_SERVER:

      case MARSHAL_SERVER:

      case CDR_SERVER:

      case HEARTBEAT_SERVER:

      case PDP_SERVER:

      case OSP_SERVER:

      case REDIRECT_SERVER:
      {
        String fileType = null;

        if (nodeToWrite.hasAttribute("fileDir"))
        {
          nodeToWrite.removeAttribute("fileDir");
        }

        if (nodeToWrite.hasAttribute("fileName"))
        {
          nodeToWrite.removeAttribute("fileName");
        }

        if (nodeToWrite.hasAttribute("fileType"))
        {
          fileType = nodeToWrite.getAttribute("fileType");
          nodeToWrite.removeAttribute("fileType");
        }

        String xmlString = new XMLUtils().buildXMLString(nodeToWrite);

        writeAsIs(xmlString, fileDir, fileName);

        nodeToWrite.setAttribute("fileDir", fileDir);
        nodeToWrite.setAttribute("fileName", fileName);
        if (fileType != null)
        {
          nodeToWrite.setAttribute("fileType", fileType);
        }

        break;
      }

      case FEATURE_SERVERS:

      case MARSHAL_SERVERS:

      case CDR_SERVERS:

      case HEARTBEAT_SERVERS:

      case REDIRECT_SERVERS:

      case PDP_SERVERS:
      {
        writeListOfServers(nodeToWrite, fileDir, fileName);

        break;
      }

      default:
      {
        String nodeTypeString = null;

        try
        {
          nodeTypeString = TreeNodeTypes.strings[nodeType];
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
          nodeTypeString = Integer.toString(nodeType);
        }

        System.out.println("cannot write file for node of type " 
                           + nodeTypeString);

        throw new NumberFormatException();
      }
    }
  }     // writeFileFromNode

  /**
   * Write the given string to the given file.
   * My apologies for the connection kluge. It is for Deployment.
   * I realized at the last moment that I need to
   * establish a connection through something other
   * than the AdministrativeLogin screen.
   * @param xmlString content of file to be written
   * @param fileDir directory path of file to be written
   * @param filename name of file to be written
   * @throws FailedToWriteFileException if the write was not successful
   */
  protected static void writeAsIs(String xmlString, String fileDir, 
          String filename) throws FailedToWriteFileException
  {

    // if the AdministrativeLogin screen returns a null connection,
    // get one from the Deployment class.
    VPPTransactionWrapper connection = AdministrativeLogin.getConnection();

    if (connection == null)
    {
      connection = DeployServers.getConnection();

      if (connection == null)
      {
        System.out.println("Error: null connection");

        return;
      }
    }

    try
    {
      connection.doPut(fileDir, filename, xmlString);
    }
    catch (VPPException e)
    {
      VPPTransactionWrapper.showVPPException(e, 
              "Error writing " + filename + " to " + fileDir);

      throw new FailedToWriteFileException(e.getMessage());
    }
  }

  private static void writeListOfServers(final Element nodeToWrite, 
          String fileDir, String filename) throws FailedToWriteFileException
  {

    try
    {
      TransformerFactory tf = TransformerFactory.newInstance();

      Class thisClass = Class.forName("vocal.data.DOMToFile");
      java.io.InputStream resourceInput
        = thisClass.getResourceAsStream("resources/ListOfServers.xsl");
      if(resourceInput == null)
      {
        System.out.println("resourceInput is null");
      }

      StreamSource xslSource = new StreamSource(resourceInput);
      
      Transformer transformer = tf.newTransformer(xslSource);

      DOMSource source = new DOMSource(nodeToWrite);
      StringWriter writer = new StringWriter();
      StreamResult result = new StreamResult(writer);
                                                               
      transformer.transform(source, result);

      StringBuffer outputBuf = writer.getBuffer();

      // delete the <? xml version line
      outputBuf.delete(0, outputBuf.indexOf("?>") + 3);

      writeAsIs(writer.getBuffer().toString(), fileDir, filename);
    }
    catch (TransformerConfigurationException e1)
    {
      e1.printStackTrace();
    }
    catch (TransformerException e2)
    {
      e2.printStackTrace();
    }
    catch (ClassNotFoundException e3)
    {
      e3.printStackTrace();
    }
  }
}