ldapextsampler.java

测试工具

		LdapExtClient temp_client = (LdapExtClient) ldapConnections.get(getThreadName());
		DirContext dirContext = (DirContext) ldapContexts.get(getThreadName());
		if (temp_client == null) {
			temp_client = new LdapExtClient();
			try {
				dirContext = new InitialDirContext();
			} catch (NamingException err) {
				log.error("Ldap client context creation - ", err);
			}
			ldapConnections.put(getThreadName(), temp_client);
		}

		try {
			xmlBuffer.openTag("operation"); // $NON-NLS-1$
			final String testType = getTest();
			xmlBuffer.tag("opertype", testType); // $NON-NLS-1$
			log.debug("performing test: " + testType);
			if (testType.equals(UNBIND)) {
				res.setSamplerData("Unbind");
				xmlBuffer.tag("baseobj",getRootdn()); // $NON-NLS-1$
				xmlBuffer.tag("binddn",getUserDN()); // $NON-NLS-1$
				unbindOp(temp_client, dirContext, res);
			} else if (testType.equals(BIND)) {
				res.setSamplerData("Bind as "+getUserDN());
				xmlBuffer.tag("baseobj",getRootdn()); // $NON-NLS-1$
				xmlBuffer.tag("binddn",getUserDN()); // $NON-NLS-1$
				xmlBuffer.tag("connectionTO",getConnTimeOut()); // $NON-NLS-1$
				bindOp(temp_client, dirContext, res);
			} else if (testType.equals(SBIND)) {
				res.setSamplerData("SingleBind as "+getUserDN());
				xmlBuffer.tag("baseobj",getRootdn()); // $NON-NLS-1$
				xmlBuffer.tag("binddn",getUserDN()); // $NON-NLS-1$
				xmlBuffer.tag("connectionTO",getConnTimeOut()); // $NON-NLS-1$
				singleBindOp(res);
			} else if (testType.equals(COMPARE)) {
				res.setSamplerData("Compare "+getPropertyAsString(COMPAREFILT) + " "
								+ getPropertyAsString(COMPAREDN));
				xmlBuffer.tag("comparedn",getPropertyAsString(COMPAREDN)); // $NON-NLS-1$
				xmlBuffer.tag("comparefilter",getPropertyAsString(COMPAREFILT)); // $NON-NLS-1$
                NamingEnumeration cmp;
				try {
					res.sampleStart();
					cmp = temp_client.compare(dirContext, getPropertyAsString(COMPAREFILT),
							getPropertyAsString(COMPAREDN));
				} finally {
					res.sampleEnd();
				}				
				if (cmp.hasMore()) {
				} else {
					res.setResponseCode("5"); // $NON-NLS-1$
					res.setResponseMessage("compareFalse");
					isSuccessful = false;
				}
			} else if (testType.equals(ADD)) {
				res.setSamplerData("Add object " + getBaseEntryDN());
				xmlBuffer.tag("attributes",getArguments().toString()); // $NON-NLS-1$
				xmlBuffer.tag("dn",getBaseEntryDN()); // $NON-NLS-1$
				addTest(temp_client, dirContext, res);
			} else if (testType.equals(DELETE)) {
				res.setSamplerData("Delete object " + getBaseEntryDN());
				xmlBuffer.tag("dn",getBaseEntryDN()); // $NON-NLS-1$
				deleteTest(temp_client, dirContext, res);
			} else if (testType.equals(MODIFY)) {
				res.setSamplerData("Modify object " + getBaseEntryDN());
				xmlBuffer.tag("dn",getBaseEntryDN()); // $NON-NLS-1$
				xmlBuffer.tag("attributes",getLDAPArguments().toString()); // $NON-NLS-1$
				modifyTest(temp_client, dirContext, res);
			} else if (testType.equals(RENAME)) {
				res.setSamplerData("ModDN object " + getPropertyAsString(MODDDN) + " to " + getPropertyAsString(NEWDN));
				xmlBuffer.tag("dn",getPropertyAsString(MODDDN)); // $NON-NLS-1$
				xmlBuffer.tag("newdn",getPropertyAsString(NEWDN)); // $NON-NLS-1$
				renameTest(temp_client, dirContext, res);
			} else if (testType.equals(SEARCH)) {
                final String            scopeStr = getScope();
                final int               scope = getScopeAsInt();
                final String searchFilter = getPropertyAsString(SEARCHFILTER);
				final String searchBase = getPropertyAsString(SEARCHBASE);
				final String timeLimit = getTimelim();
				final String countLimit = getCountlim();

				res.setSamplerData("Search with filter " + searchFilter);
				xmlBuffer.tag("searchfilter",searchFilter); // $NON-NLS-1$
				xmlBuffer.tag("baseobj",getRootdn()); // $NON-NLS-1$
				xmlBuffer.tag("searchbase",searchBase);// $NON-NLS-1$
				xmlBuffer.tag("scope" , scopeStr); // $NON-NLS-1$
				xmlBuffer.tag("countlimit",countLimit); // $NON-NLS-1$
				xmlBuffer.tag("timelimit",timeLimit); // $NON-NLS-1$

                NamingEnumeration srch;
				try {
					res.sampleStart();
					srch = temp_client.searchTest(
							dirContext, searchBase, searchFilter,
							scope, getCountlimAsLong(),
							getTimelimAsInt(),
							getRequestAttributes(getAttrs()),
							isRetobj(),
							isDeref());
				} finally {
					res.sampleEnd();
				}				

                if (isParseFlag()) {
					try {
						xmlBuffer.openTag("searchresults"); // $NON-NLS-1$
						writeSearchResults(xmlBuffer, srch);
					} finally {
						xmlBuffer.closeTag("searchresults"); // $NON-NLS-1$
					}					
                }
			}

		} catch (NamingException ex) {
			//log.warn("DEBUG",ex);
// e.g. javax.naming.SizeLimitExceededException: [LDAP: error code 4 - Sizelimit Exceeded]; remaining name ''
//                                                123456789012345678901
			// TODO: tidy this up
			String returnData = ex.toString();
			final int indexOfLDAPErrCode = returnData.indexOf("LDAP: error code");
			if (indexOfLDAPErrCode >= 0) {
				res.setResponseMessage(returnData.substring(indexOfLDAPErrCode + 21, returnData
						.indexOf("]"))); // $NON-NLS-1$
				res.setResponseCode(returnData.substring(indexOfLDAPErrCode + 17, indexOfLDAPErrCode + 19));
			} else {
				res.setResponseMessage(returnData);
				res.setResponseCode("800"); // $NON-NLS-1$
			}
			isSuccessful = false;
		} finally {
			xmlBuffer.closeTag("operation"); // $NON-NLS-1$
			xmlBuffer.tag("responsecode",res.getResponseCode()); // $NON-NLS-1$
			xmlBuffer.tag("responsemessage",res.getResponseMessage()); // $NON-NLS-1$
			res.setResponseData(xmlBuffer.toString().getBytes());
			res.setDataType(SampleResult.TEXT);
			res.setSuccessful(isSuccessful);
		}
		return res;
	}

    /*
     *   Write out search results in a stable order (including order of all subelements which might
     * be reordered like attributes and their values) so that simple textual comparison can be done,
     * unless the number of results exceeds {@link #MAX_SORTED_RESULTS} in which case just stream
     * the results out without sorting.
     */
    private void writeSearchResults(final XMLBuffer xmlb, final NamingEnumeration srch)
            throws NamingException
    {
   	
        final ArrayList     sortedResults = new ArrayList(MAX_SORTED_RESULTS);
        final String        searchBase = getPropertyAsString(SEARCHBASE);
        final String        rootDn = getRootdn();

        // read all sortedResults into memory so we can guarantee ordering
        try {
			while (srch.hasMore() && (sortedResults.size() < MAX_SORTED_RESULTS)) {
			    final SearchResult    sr = (SearchResult) srch.next();

			        // must be done prior to sorting
			    normaliseSearchDN(sr, searchBase, rootDn);
			    sortedResults.add(sr);
			}
		} finally { // show what we did manage to retrieve
		
	        sortResults(sortedResults);
	        
	        for (Iterator it = sortedResults.iterator(); it.hasNext();)
	        {
	            final SearchResult  sr = (SearchResult) it.next();
	            writeSearchResult(sr, xmlb);
	        }
		}

		while (srch.hasMore()) { // If there's anything left ...
            final SearchResult    sr = (SearchResult) srch.next();

            normaliseSearchDN(sr, searchBase, rootDn);
            writeSearchResult(sr, xmlb);
        }
    }

    private void writeSearchResult(final SearchResult sr, final XMLBuffer xmlb)
            throws NamingException
    {
        final Attributes    attrs = sr.getAttributes();
        final int           size = attrs.size();
        final ArrayList     sortedAttrs = new ArrayList(size);

        xmlb.openTag("searchresult"); // $NON-NLS-1$
        xmlb.tag("dn", sr.getName()); // $NON-NLS-1$
 		xmlb.tag("returnedattr",Integer.toString(size)); // $NON-NLS-1$
 		xmlb.openTag("attributes"); // $NON-NLS-1$

 		try {
			for (NamingEnumeration en = attrs.getAll(); en.hasMore(); )
			{
			    final Attribute     attr = (Attribute) en.next();

			    sortedAttrs.add(attr);
			}
			sortAttributes(sortedAttrs);
			for (Iterator ait = sortedAttrs.iterator(); ait.hasNext();)
			{
			    final Attribute     attr = (Attribute) ait.next();

			    StringBuffer sb = new StringBuffer();
			    if (attr.size() == 1)
			        sb.append(getWriteValue(attr.get()));
			    else
			    {
			        final ArrayList     sortedVals = new ArrayList(attr.size());
			        boolean             first = true;

			        for (NamingEnumeration ven = attr.getAll(); ven.hasMore(); )
			        {
			            final Object    value = getWriteValue(ven.next());
			            sortedVals.add(value.toString());
			        }

			        Collections.sort(sortedVals);
			        
			        for (Iterator vit = sortedVals.iterator(); vit.hasNext();)
			        {
			            final String    value = (String) vit.next();
			            if (first) {
			                first = false;
			            } else {
			                sb.append(", "); // $NON-NLS-1$
			            }
			            sb.append(value);
			        }
			    }
			    xmlb.tag(attr.getID(),sb);
			}
		} finally {
	 		xmlb.closeTag("attributes"); // $NON-NLS-1$
	        xmlb.closeTag("searchresult"); // $NON-NLS-1$
		}
    }

	private void sortAttributes(final ArrayList sortedAttrs) {
		Collections.sort(sortedAttrs, new Comparator()
        {
            public int compare(Object o1, Object o2)
            {
                String      nm1 = ((Attribute) o1).getID();
                String      nm2 = ((Attribute) o2).getID();

                return nm1.compareTo(nm2);
            }
        });
	}

	private void sortResults(final ArrayList sortedResults) {
		Collections.sort(sortedResults, new Comparator()
		{
		    private int compareToReverse(final String s1, final String s2)
		    {
		        int     len1 = s1.length();
		        int     len2 = s2.length();
		        int     s1i = len1 - 1;
		        int     s2i = len2 - 1;

		        for ( ; (s1i >= 0) && (s2i >= 0); s1i--, s2i--)
		        {
		            char    c1 = s1.charAt(s1i);
		            char    c2 = s2.charAt(s2i);

		            if (c1 != c2)
		                return c1 - c2;
		        }
		        return len1 - len2;
		    }

		    public int compare(Object o1, Object o2)
		    {
		        String      nm1 = ((SearchResult) o1).getName();
		        String      nm2 = ((SearchResult) o2).getName();

		        if (nm1 == null)
		            nm1 = "";
		        if (nm2 == null)
		            nm2 = "";
		        return compareToReverse(nm1, nm2);
		    }
		});
	}

    private String normaliseSearchDN(final SearchResult sr, final String searchBase, final String rootDn)
    {
        String      srName = sr.getName();

        if (!srName.endsWith(searchBase))
        {
            if (srName.length() > 0)
                srName = srName + ',';
            srName = srName + searchBase;
        }
        if ((rootDn.length() > 0) && !srName.endsWith(rootDn))
        {
            if (srName.length() > 0)
                srName = srName + ',';
            srName = srName + rootDn;
        }
        sr.setName(srName);
        return srName;
    }

    private String getWriteValue(final Object value)
    {
        if (value instanceof String)
            // assume it's senstive data
            return StringEscapeUtils.escapeXml((String)value);
        else if (value instanceof byte[])
            try
            {
                return StringEscapeUtils.escapeXml(new String((byte[])value, "UTF-8"));
            }
            catch (UnsupportedEncodingException e)
            {
                log.error("this can't happen: UTF-8 character encoding not supported", e);
            }
        return StringEscapeUtils.escapeXml(value.toString());
    }

	public void testStarted() {
		testStarted(""); // $NON-NLS-1$
	}

	public void testEnded() {
		testEnded(""); // $NON-NLS-1$
	}

	public void testStarted(String host) {
		// ignored
	}

	// Ensure any remaining contexts are closed
	public void testEnded(String host) {
		Iterator it = ldapContexts.entrySet().iterator();
		while (it.hasNext()) {
			Map.Entry entry = (Map.Entry) it.next();
			String key = (String) entry.getKey();
			DirContext dc = (DirContext) entry.getValue();
			try {
				log.warn("Tidying old Context for thread: " + key);
				dc.close();
			} catch (NamingException ignored) {
				// ignored
			}
			it.remove();// Make sure the entry is not left around for the next run
		}

	}

	public void testIterationStart(LoopIterationEvent event) {
		// ignored
	}
}