コード例 #1
0
  /**
   * Determines the number of bytes that will be used to store the serialized representation of a
   * single SearchResponse (assuming UTF-8 encoding)
   *
   * @param response The SearchResponse to serialize and evaluate
   * @return The number of bytes used to store the serialized response
   */
  public static int getSerializedResponseBytes(SearchResponse response) throws IOException {
    StringWriter serializeBuffer = new StringWriter();
    Node serializeNode = serializeSearchResponse(response);
    TransformerHelper.encodedTransform((Element) serializeNode, "UTF-8", serializeBuffer, true);

    return serializeBuffer.toString().length() * 2; // 2 bytes per character in UTF-8
  }
コード例 #2
0
  /*
   * @see up2p.peer.generic.message.SerializableMessage#serialize()
   */
  public Node serialize() {
    // create the XML DOM
    Document document = TransformerHelper.newDocument();

    // create root node
    Element root = document.createElement(GenericPeerMessage.X_UP2P_MESSAGE);
    document.appendChild(root);

    Element current = document.createElement(X_SEARCH_RESPONSE);
    current.setAttribute(X_URL_PREFIX, urlPrefix);
    current.setAttribute(X_SEARCH_ID, id);
    current.setAttribute(X_RESULT_SIZE, String.valueOf(getResultSetSize()));
    current.setAttribute(X_COMMUNITY, communityId);
    root.appendChild(current);

    // Add the metric list to the root node (if applicable)
    if (hostedResIdList != null && !hostedResIdList.isEmpty()) {
      // Generate the metricList node
      Element metricNode = document.createElement(X_HOSTED_RES_ID_LIST);
      // Add all the resource Ids
      for (String rId : hostedResIdList) {
        Element rIdNode = document.createElement(X_RESOURCE_ID);
        rIdNode.setTextContent(rId);
        metricNode.appendChild(rIdNode);
      }
      // Append the metricList to the search result node
      current.appendChild(metricNode);
    }

    // Add any raw trust metrics to the generated XML (if the trust metric map has elements)
    if (!trustMetrics.isEmpty()) {
      Iterator<String> metricKeys = trustMetrics.keySet().iterator();
      while (metricKeys.hasNext()) {
        Element rawMetricNode = document.createElement(X_TRUST_METRIC);
        String metricName = metricKeys.next();
        rawMetricNode.setAttribute(X_ATTR_METRIC_NAME, metricName);
        rawMetricNode.setAttribute(X_ATTR_METRIC_VALUE, trustMetrics.get(metricName));
        current.appendChild(rawMetricNode);
      }
    }

    // create searchResults nodes for each search result
    SearchResponse[] responses = getResponses();
    for (int i = 0; i < responses.length; i++) {
      SearchResponse response = responses[i];
      current.appendChild(document.importNode(serializeSearchResponse(response), true));
    }
    return document.getDocumentElement();
  }
コード例 #3
0
  /**
   * Generates an XML Element representing a single SearchResponse in the format expected by a
   * SearchResponseMessage.
   *
   * @param response The SearchResponse to generate XML for
   * @return The generated XML element
   */
  public static Element serializeSearchResponse(SearchResponse response) {
    Document document = TransformerHelper.newDocument();

    Element searchResult = document.createElement(X_SEARCH_RESULT);
    searchResult.setAttribute(X_TITLE, response.getTitle());
    searchResult.setAttribute(X_RESOURCE_ID, response.getId());
    searchResult.setAttribute(X_FILENAME, response.getFileName());

    // Add article DOM as a child of the searchResult
    try {
      NodeList copyNodes = response.getResourceDOM().getChildNodes();
      for (int k = 0; k < copyNodes.getLength(); k++) {
        Node importedNode = document.importNode(copyNodes.item(k), true);
        searchResult.appendChild(importedNode);
      }

    } catch (DOMException e) {
      e.printStackTrace(); // just output the trace and continue
    }

    return searchResult;
  }
コード例 #4
0
  /** @return The number of bytes the serialized message will require to store in UTF-8 encoding. */
  public int getSerializedBytes() throws IOException {
    StringWriter serializeBuffer = new StringWriter();
    TransformerHelper.encodedTransform((Element) this.serialize(), "UTF-8", serializeBuffer, true);

    return serializeBuffer.toString().length() * 2; // 2 bytes per character in UTF-8
  }
コード例 #5
0
  /**
   * Parses a search response from the given XML fragment.
   *
   * @param xmlNode the XML containing the search response
   * @return the search response
   * @throws MalformedPeerMessageException on a badly formed or invalid message
   */
  public static SearchResponseMessage parse(Node xmlNode) throws MalformedPeerMessageException {

    // check first node name
    try {
      if (xmlNode.getNodeName().equals(GenericPeerMessage.X_UP2P_MESSAGE)) {
        Node currentNode = xmlNode.getFirstChild();
        while (currentNode != null && currentNode.getNodeType() != Node.ELEMENT_NODE)
          currentNode = currentNode.getNextSibling();
        Element current = (Element) currentNode;

        String communityId = current.getAttribute(X_COMMUNITY);
        String searchId = current.getAttribute(X_SEARCH_ID);
        String urlPrefix = current.getAttribute(X_URL_PREFIX);

        SearchResponseMessage response =
            new SearchResponseMessage(searchId, communityId, urlPrefix);

        // add result for each searchResult child, and process the metric list
        // if it exists
        LocationEntry[] entries = null;
        NodeList resultList = current.getChildNodes();
        for (int i = 0; i < resultList.getLength(); i++) {

          // check node type to avoid mixed content
          if (resultList.item(i).getNodeType() == Node.ELEMENT_NODE
              && resultList.item(i).getNodeName().equals(X_SEARCH_RESULT)) {

            // A Search Result element has been found
            String resourceTitle = null;
            String resourceId = null;
            String fileName = null;

            Element result = (Element) resultList.item(i);
            resourceTitle = result.getAttribute(X_TITLE);
            resourceId = result.getAttribute(X_RESOURCE_ID);
            fileName = result.getAttribute(X_FILENAME);

            // Construct the SearchResponse with what we have so far (missing DOM, locations are not
            // serialized)
            SearchResponse newresponse =
                new SearchResponse(
                    resourceId, resourceTitle, communityId, fileName, null, false, searchId);

            if (result.hasChildNodes()) { // in this case, yes! we have a winner!
              // some gymnastics to create the exact same class of Document, in order to be able to
              // adopt nodes...
              // DOMImplementation impl = locationNode.getOwnerDocument().getImplementation();
              Document metadata =
                  TransformerHelper
                      .newDocument(); // impl.createDocument(null,
                                      // "qname",locationNode.getOwnerDocument().getDoctype() );

              /*
              System.out.println("adopter class:"+ metadata.getClass());
              System.out.println("adoptee class:" + locationNode.getOwnerDocument().getClass());
              */

              // Import the metadata into the new document context
              NodeList copyNodes = result.getChildNodes();
              for (int k = 0; k < copyNodes.getLength(); k++) {
                Node importedNode = metadata.importNode(copyNodes.item(k), true);
                metadata.appendChild(importedNode);
              }

              // add the DOM to the searchResponse under construction
              newresponse.addResourceDOM(metadata);
            }

            response.addResult(newresponse);
          } else if (resultList.item(i).getNodeType() == Node.ELEMENT_NODE
              && resultList.item(i).getNodeName().equals(X_HOSTED_RES_ID_LIST)) {

            // A hosted resource id list element has been found

            // The node is a metric list, build the metric list for this search response
            List<String> respMetrics = new ArrayList<String>();
            NodeList metricIds = resultList.item(i).getChildNodes();
            for (int j = 0; j < metricIds.getLength(); j++) {
              respMetrics.add(metricIds.item(j).getTextContent());
            }
            response.setHostedResIdList(respMetrics);
          } else if (resultList.item(i).getNodeType() == Node.ELEMENT_NODE
              && resultList.item(i).getNodeName().equals(X_TRUST_METRIC)) {

            // A trust metric element has been found
            String metricName = ((Element) resultList.item(i)).getAttribute(X_ATTR_METRIC_NAME);
            String metricValue = ((Element) resultList.item(i)).getAttribute(X_ATTR_METRIC_VALUE);
            response.addTrustMetric(metricName, metricValue);
          }
        }
        return response;
      }

      throw new MalformedPeerMessageException(
          ERROR_MSG + " Root node name: " + xmlNode.getNodeName());

    } catch (Exception e) {
      e.printStackTrace();
      throw new MalformedPeerMessageException(ERROR_MSG);
    }
  }