Save This Page
Home » jakarta-jmeter-2.3.4_src » org.apache.jmeter.engine.util » [javadoc | source]
    1   /*
    2    * Licensed to the Apache Software Foundation (ASF) under one or more
    3    * contributor license agreements.  See the NOTICE file distributed with
    4    * this work for additional information regarding copyright ownership.
    5    * The ASF licenses this file to You under the Apache License, Version 2.0
    6    * (the "License"); you may not use this file except in compliance with
    7    * the License.  You may obtain a copy of the License at
    8    *
    9    *   http://www.apache.org/licenses/LICENSE-2.0
   10    *
   11    * Unless required by applicable law or agreed to in writing, software
   12    * distributed under the License is distributed on an "AS IS" BASIS,
   13    * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   14    * See the License for the specific language governing permissions and
   15    * limitations under the License.
   16    *
   17    */
   18   
   19   package org.apache.jmeter.engine.util;
   20   
   21   import java.util.Collection;
   22   import java.util.HashMap;
   23   import java.util.Iterator;
   24   import java.util.LinkedList;
   25   import java.util.List;
   26   import java.util.Map;
   27   
   28   import org.apache.jmeter.functions.Function;
   29   import org.apache.jmeter.functions.InvalidVariableException;
   30   import org.apache.jmeter.samplers.SampleResult;
   31   import org.apache.jmeter.samplers.Sampler;
   32   import org.apache.jmeter.threads.JMeterContext;
   33   import org.apache.jmeter.threads.JMeterContextService;
   34   import org.apache.jmeter.util.JMeterUtils;
   35   import org.apache.jorphan.logging.LoggingManager;
   36   import org.apache.jorphan.reflect.ClassFinder;
   37   import org.apache.log.Logger;
   38   
   39   /**
   40    * CompoundFunction.
   41    *
   42    */
   43   public class CompoundVariable implements Function {
   44       private static final Logger log = LoggingManager.getLoggerForClass();
   45   
   46       private String rawParameters;
   47   
   48       private static final FunctionParser functionParser = new FunctionParser();
   49   
   50       private static final Map functions = new HashMap();
   51   
   52       private boolean hasFunction, isDynamic;
   53   
   54       private String permanentResults = ""; // $NON-NLS-1$
   55   
   56       private LinkedList compiledComponents = new LinkedList();
   57   
   58       static {
   59           try {
   60               final String contain = // Classnames must contain this string [.functions.]
   61                   JMeterUtils.getProperty("classfinder.functions.contain"); // $NON-NLS-1$
   62               final String notContain = // Classnames must not contain this string [.gui.]
   63                   JMeterUtils.getProperty("classfinder.functions.notContain"); // $NON-NLS-1$
   64               if (contain!=null){
   65                   log.info("Note: Function class names must contain the string: '"+contain+"'");
   66               }
   67               if (notContain!=null){
   68                   log.info("Note: Function class names must not contain the string: '"+notContain+"'");
   69               }
   70               List classes = ClassFinder.findClassesThatExtend(JMeterUtils.getSearchPaths(),
   71                       new Class[] { Function.class }, true, contain, notContain);
   72               Iterator iter = classes.iterator();
   73               while (iter.hasNext()) {
   74                   Function tempFunc = (Function) Class.forName((String) iter.next()).newInstance();
   75                   String referenceKey = tempFunc.getReferenceKey();
   76                   functions.put(referenceKey, tempFunc.getClass());
   77                   // Add alias for original StringFromFile name (had only one underscore)
   78                   if (referenceKey.equals("__StringFromFile")){//$NON-NLS-1$
   79                       functions.put("_StringFromFile", tempFunc.getClass());//$NON-NLS-1$
   80                   }
   81               }
   82               final int functionCount = functions.size();
   83               if (functionCount == 0){
   84                   log.warn("Did not find any functions");
   85               } else {
   86                   log.debug("Function count: "+functionCount);
   87               }
   88           } catch (Exception err) {
   89               log.error("", err);
   90           }
   91       }
   92   
   93       public CompoundVariable() {
   94           super();
   95           isDynamic = true;
   96           hasFunction = false;
   97       }
   98   
   99       public CompoundVariable(String parameters) {
  100           this();
  101           try {
  102               setParameters(parameters);
  103           } catch (InvalidVariableException e) {
  104           }
  105       }
  106   
  107       public String execute() {
  108           if (isDynamic) {
  109               JMeterContext context = JMeterContextService.getContext();
  110               SampleResult previousResult = context.getPreviousResult();
  111               Sampler currentSampler = context.getCurrentSampler();
  112               return execute(previousResult, currentSampler);
  113           }
  114           return permanentResults; // $NON-NLS-1$
  115       }
  116   
  117       /**
  118        * Allows the retrieval of the original String prior to it being compiled.
  119        *
  120        * @return String
  121        */
  122       public String getRawParameters() {
  123           return rawParameters;
  124       }
  125   
  126       /*
  127        * (non-Javadoc)
  128        *
  129        * @see Function#execute(SampleResult, Sampler)
  130        */
  131       public String execute(SampleResult previousResult, Sampler currentSampler) {
  132           if (compiledComponents == null || compiledComponents.size() == 0) {
  133               return ""; // $NON-NLS-1$
  134           }
  135           boolean testDynamic = false;
  136           StringBuffer results = new StringBuffer();
  137           Iterator iter = compiledComponents.iterator();
  138           while (iter.hasNext()) {
  139               Object item = iter.next();
  140               if (item instanceof Function) {
  141                   testDynamic = true;
  142                   try {
  143                       results.append(((Function) item).execute(previousResult, currentSampler));
  144                   } catch (InvalidVariableException e) {
  145                   }
  146               } else if (item instanceof SimpleVariable) {
  147                   testDynamic = true;
  148                   results.append(((SimpleVariable) item).toString());
  149               } else {
  150                   results.append(item);
  151               }
  152           }
  153           if (!testDynamic) {
  154               isDynamic = false;
  155               permanentResults = results.toString();
  156           }
  157           return results.toString();
  158       }
  159   
  160       public CompoundVariable getFunction() {
  161           CompoundVariable func = new CompoundVariable();
  162           func.compiledComponents = (LinkedList) compiledComponents.clone();
  163           func.rawParameters = rawParameters;
  164           return func;
  165       }
  166   
  167       public List getArgumentDesc() {
  168           return new LinkedList();
  169       }
  170   
  171       public void clear() {
  172           // TODO should this also clear isDynamic, rawParameters, permanentResults?
  173           hasFunction = false;
  174           compiledComponents.clear();
  175       }
  176   
  177       public void setParameters(String parameters) throws InvalidVariableException {
  178           this.rawParameters = parameters;
  179           if (parameters == null || parameters.length() == 0) {
  180               return;
  181           }
  182   
  183           compiledComponents = functionParser.compileString(parameters);
  184           if (compiledComponents.size() > 1 || !(compiledComponents.get(0) instanceof String)) {
  185               hasFunction = true;
  186           }
  187       }
  188   
  189       static Object getNamedFunction(String functionName) throws InvalidVariableException {
  190           if (functions.containsKey(functionName)) {
  191               try {
  192                   return ((Class) functions.get(functionName)).newInstance();
  193               } catch (Exception e) {
  194                   log.error("", e); // $NON-NLS-1$
  195                   throw new InvalidVariableException();
  196               }
  197           }
  198           return new SimpleVariable(functionName);
  199       }
  200   
  201       public boolean hasFunction() {
  202           return hasFunction;
  203       }
  204   
  205       // Dummy methods needed by Function interface
  206   
  207       /**
  208        * @see Function#getReferenceKey()
  209        */
  210       public String getReferenceKey() {
  211           return ""; // $NON-NLS-1$
  212       }
  213   
  214       public void setParameters(Collection parameters) throws InvalidVariableException {
  215       }
  216   }

Save This Page
Home » jakarta-jmeter-2.3.4_src » org.apache.jmeter.engine.util » [javadoc | source]