alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  

What this is

This file is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Other links

The source code

// $Header: /home/cvs/jakarta-jmeter/src/protocol/http/org/apache/jmeter/protocol/http/parser/HtmlParsingUtils.java,v 1.10 2004/02/16 13:47:18 sebb Exp $
/*
 * Copyright 2003-2004 The Apache Software Foundation.
 *
 * Licensed 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.jmeter.protocol.http.parser;

import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.LinkedList;
import java.util.List;

import org.apache.jmeter.config.Argument;
import org.apache.jmeter.junit.JMeterTestCase;
import org.apache.jmeter.protocol.http.sampler.HTTPSampler;
import org.apache.jmeter.testelement.property.PropertyIterator;
import org.apache.jorphan.logging.LoggingManager;
import org.apache.jorphan.util.JOrphanUtils;
import org.apache.log.Logger;
import org.apache.oro.text.PatternCacheLRU;
import org.apache.oro.text.regex.MalformedPatternException;
import org.apache.oro.text.regex.Perl5Compiler;
import org.apache.oro.text.regex.Perl5Matcher;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.tidy.Tidy;
import org.xml.sax.SAXException;

/**
 * @author    Michael Stover
 * Created   June 14, 2001
 * @version   $Revision: 1.10 $ Last updated: $Date: 2004/02/16 13:47:18 $
 */
public final class HtmlParsingUtils
{
    transient private static Logger log = LoggingManager.getLoggerForClass();

    protected static String utfEncodingName;
    /* NOTUSED 
    private int compilerOptions =
        Perl5Compiler.CASE_INSENSITIVE_MASK
            | Perl5Compiler.MULTILINE_MASK
            | Perl5Compiler.READ_ONLY_MASK;
	*/
	
    private static PatternCacheLRU patternCache =
        new PatternCacheLRU(1000, new Perl5Compiler());

    private static ThreadLocal localMatcher = new ThreadLocal()
    {
        protected Object initialValue()
        {
            return new Perl5Matcher();
        }
    };

    /**
     * Private constructor to prevent instantiation.
     */
    private HtmlParsingUtils()
    {
    }

    public static synchronized boolean isAnchorMatched(
        HTTPSampler newLink,
        HTTPSampler config)
        throws MalformedPatternException
    {
        boolean ok = true;
        Perl5Matcher matcher = (Perl5Matcher) localMatcher.get();
        PropertyIterator iter = config.getArguments().iterator();

        String query = null;
        try
        {
            query = JOrphanUtils.decode(newLink.getQueryString(),"UTF-8");
        }
        catch (UnsupportedEncodingException e)
        {
            // UTF-8 unsupported? You must be joking!
            log.error("UTF-8 encoding not supported!");
            throw new Error("Should not happen: "+e.toString());
        }

        if (query == null && config.getArguments().getArgumentCount() > 0)
        {
            return false;
        }
        
        while (iter.hasNext())
        {
            Argument item = (Argument) iter.next().getObjectValue();
            if (query.indexOf(item.getName() + "=") == -1)
            {
                if (!(ok =
                    ok
                        && matcher.contains(
                            query,
                            patternCache.getPattern(
                                item.getName(),
                                Perl5Compiler.READ_ONLY_MASK))))
                {
                    return false;
                }
            }
        }

        if (config.getDomain() != null
            && config.getDomain().length() > 0
            && !newLink.getDomain().equals(config.getDomain()))
        {
            if (!(ok =
                ok
                    && matcher.matches(
                        newLink.getDomain(),
                        patternCache.getPattern(
                            config.getDomain(),
                            Perl5Compiler.READ_ONLY_MASK))))
            {
                return false;
            }
        }

        if (!newLink.getPath().equals(config.getPath())
            && !matcher.matches(
                newLink.getPath(),
                patternCache.getPattern(
                    "[/]*" + config.getPath(),
                    Perl5Compiler.READ_ONLY_MASK)))
        {
            return false;
        }

        if (!(ok =
            ok
                && matcher.matches(
                    newLink.getProtocol(),
                    patternCache.getPattern(
                        config.getProtocol(),
                        Perl5Compiler.READ_ONLY_MASK))))
        {
            return false;
        }

        return ok;
    }

    public static synchronized boolean isArgumentMatched(
        Argument arg,
        Argument patternArg)
        throws MalformedPatternException
    {
        Perl5Matcher matcher = (Perl5Matcher) localMatcher.get();
        return (
            arg.getName().equals(patternArg.getName())
                || matcher.matches(
                    arg.getName(),
                    patternCache.getPattern(
                        patternArg.getName(),
                        Perl5Compiler.READ_ONLY_MASK)))
            && (arg.getValue().equals(patternArg.getValue())
                || matcher.matches(
                    (String) arg.getValue(),
                    patternCache.getPattern(
                        (String) patternArg.getValue(),
                        Perl5Compiler.READ_ONLY_MASK)));
    }

    /**
     * Returns tidy as HTML parser.
     *
     * @return   a tidy HTML parser
     */
    public static Tidy getParser()
    {
        log.debug("Start : getParser1");
        Tidy tidy = new Tidy();
        tidy.setCharEncoding(org.w3c.tidy.Configuration.UTF8);
        tidy.setQuiet(true);
        tidy.setShowWarnings(false);

        if (log.isDebugEnabled())
        {
            log.debug("getParser1 : tidy parser created - " + tidy);
        }

        log.debug("End : getParser1");

        return tidy;
    }

    /**
     * Returns a node representing a whole xml given an xml document.
     *
     * @param text              an xml document
     * @return                  a node representing a whole xml
     */
    public static Node getDOM(String text) throws SAXException
    {
        log.debug("Start : getDOM1");

        try
        {
            Node node =
                getParser().parseDOM(
                    new ByteArrayInputStream(
                        text.getBytes("UTF-8")),
                    null);

            if (log.isDebugEnabled())
            {
                log.debug("node : " + node);
            }

            log.debug("End : getDOM1");

            return node;
        }
        catch (UnsupportedEncodingException e)
        {
            log.error("getDOM1 : Unsupported encoding exception - " + e);
            log.debug("End : getDOM1");
            throw new RuntimeException("UTF-8 encoding failed");
        }
    }

    public static Document createEmptyDoc()
    {
        return Tidy.createEmptyDocument();
    }

    /**
     * Create a new URL based on an HREF string plus a contextual URL object.
     * Given that an HREF string might be of three possible forms, some
     * processing is required.
     */
    public static HTTPSampler createUrlFromAnchor(
        String parsedUrlString,
        URL context)
        throws MalformedURLException
    {
        if (log.isDebugEnabled())
        {
            log.debug("Creating URL from Anchor: "+parsedUrlString
                +", base: "+context);
        }
        URL url= new URL(context, parsedUrlString);
        HTTPSampler sampler = new HTTPSampler();
        sampler.setDomain(url.getHost());
        sampler.setProtocol(url.getProtocol());
        sampler.setPort(url.getPort());
        sampler.setPath(url.getPath());
        sampler.parseArguments(url.getQuery());

        return sampler;
    }

    public static List createURLFromForm(
            Node doc, 
            URL context)
    {
        String selectName = null;
        LinkedList urlConfigs = new LinkedList();
        recurseForm(doc, urlConfigs, context, selectName, false);
        /*
         * NamedNodeMap atts = formNode.getAttributes();
         * if(atts.getNamedItem("action") == null)
         * {
         * throw new MalformedURLException();
         * }
         * String action = atts.getNamedItem("action").getNodeValue();
         * UrlConfig url = createUrlFromAnchor(action, context);
         * recurseForm(doc, url, selectName,true,formStart);
         */
        return urlConfigs;
    }

    private static boolean recurseForm(
        Node tempNode,
        LinkedList urlConfigs,
        URL context,
        String selectName,
        boolean inForm)
    {
        NamedNodeMap nodeAtts = tempNode.getAttributes();
        String tag = tempNode.getNodeName();
        try
        {
            if (inForm)
            {
                HTTPSampler url = (HTTPSampler) urlConfigs.getLast();
                if (tag.equalsIgnoreCase("form"))
                {
                    try
                    {
                        urlConfigs.add(createFormUrlConfig(tempNode, context));
                    }
                    catch (MalformedURLException e)
                    {
                        inForm = false;
                    }
                }
                else if (tag.equalsIgnoreCase("input"))
                {
                    url.addArgument(
                        getAttributeValue(nodeAtts, "name"),
                        getAttributeValue(nodeAtts, "value"));
                }
                else if (tag.equalsIgnoreCase("textarea"))
                {
                    try
                    {
                        url.addArgument(
                            getAttributeValue(nodeAtts, "name"),
                            tempNode.getFirstChild().getNodeValue());
                    }
                    catch (NullPointerException e)
                    {
                        url.addArgument(
                            getAttributeValue(nodeAtts, "name"),
                            "");
                    }
                }
                else if (tag.equalsIgnoreCase("select"))
                {
                    selectName = getAttributeValue(nodeAtts, "name");
                }
                else if (tag.equalsIgnoreCase("option"))
                {
                    String value = getAttributeValue(nodeAtts, "value");
                    if (value == null)
                    {
                        try
                        {
                            value = tempNode.getFirstChild().getNodeValue();
                        }
                        catch (NullPointerException e)
                        {
                            value = "";
                        }
                    }
                    url.addArgument(selectName, value);
                }
            }
            else if (tag.equalsIgnoreCase("form"))
            {
                try
                {
                    urlConfigs.add(createFormUrlConfig(tempNode, context));
                    inForm = true;
                }
                catch (MalformedURLException e)
                {
                    inForm = false;
                }
                // I can't see the point for this code being here. Looks like
                // a really obscure performance optimization feature :-)
                // Seriously: I'll comment it out... I just don't dare to
                // remove it completely, in case there *is* a reason.
                /*try
                {
                    Thread.sleep(5000);
                }
                catch (Exception e)
                {
                }*/
            }
        }
        catch (Exception ex)
        {
            log.warn("Some bad HTML " + printNode(tempNode), ex);
        }
        NodeList childNodes = tempNode.getChildNodes();
        for (int x = 0; x < childNodes.getLength(); x++)
        {
            inForm =
                recurseForm(
                    childNodes.item(x),
                    urlConfigs,
                    context,
                    selectName,
                    inForm);
        }
        return inForm;
    }

    private static String getAttributeValue(NamedNodeMap att, String attName)
    {
        try
        {
            return att.getNamedItem(attName).getNodeValue();
        }
        catch (Exception ex)
        {
            return "";
        }
    }

    private static String printNode(Node node)
    {
        StringBuffer buf = new StringBuffer();
        buf.append("<");
        buf.append(node.getNodeName());
        NamedNodeMap atts = node.getAttributes();
        for (int x = 0; x < atts.getLength(); x++)
        {
            buf.append(" ");
            buf.append(atts.item(x).getNodeName());
            buf.append("=\"");
            buf.append(atts.item(x).getNodeValue());
            buf.append("\"");
        }

        buf.append(">");

        return buf.toString();
    }
    private static HTTPSampler createFormUrlConfig(
        Node tempNode,
        URL context)
        throws MalformedURLException
    {
        NamedNodeMap atts = tempNode.getAttributes();
        if (atts.getNamedItem("action") == null)
        {
            throw new MalformedURLException();
        }
        String action = atts.getNamedItem("action").getNodeValue();
        HTTPSampler url = createUrlFromAnchor(action, context);
        return url;
    }
    
///////////////////// Start of Test Code /////////////////

// TODO: need more tests

	public static class Test extends JMeterTestCase
	{

		public Test(String name)
		{
			super(name);
		}

		protected void setUp()
		{
		}
		
		public void testGetParser() throws Exception
		{
			getParser();
		}
		public void testGetDom() throws Exception
		{
			getDOM("");
			getDOM("");
		}
		public void testIsArgumentMatched() throws Exception
		{
			Argument arg = new Argument();
			Argument argp = new Argument();
			assertTrue(isArgumentMatched(arg,argp));

			arg = new Argument("test","abcd");
			argp = new Argument("test","a.*d");
			assertTrue(isArgumentMatched(arg,argp));

			arg = new Argument("test","abcd");
			argp = new Argument("test","a.*e");
			assertFalse(isArgumentMatched(arg,argp));
		}
	}
}
... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.