MtasUpdateRequestProcessorFactory.java

  1. package mtas.solr.update.processor;

  3. import java.io.IOException;
  4. import java.io.Reader;
  5. import java.io.StringReader;
  6. import java.lang.reflect.Constructor;
  7. import java.lang.reflect.InvocationTargetException;
  8. import java.util.ArrayList;
  9. import java.util.HashMap;
  10. import java.util.HashSet;
  11. import java.util.Iterator;
  12. import java.util.Map;
  13. import java.util.Map.Entry;
  14. import java.util.Set;

  16. import org.apache.commons.logging.Log;
  17. import org.apache.commons.logging.LogFactory;
  18. import org.apache.lucene.analysis.tokenattributes.CharTermAttribute;
  19. import org.apache.lucene.analysis.tokenattributes.FlagsAttribute;
  20. import org.apache.lucene.analysis.tokenattributes.OffsetAttribute;
  21. import org.apache.lucene.analysis.tokenattributes.PayloadAttribute;
  22. import org.apache.lucene.analysis.tokenattributes.PositionIncrementAttribute;
  23. import org.apache.lucene.analysis.util.CharFilterFactory;
  24. import org.apache.lucene.analysis.util.ResourceLoader;
  25. import org.apache.lucene.util.BytesRef;
  26. import org.apache.solr.common.SolrInputDocument;
  27. import org.apache.solr.common.SolrInputField;
  28. import org.apache.solr.common.util.NamedList;
  29. import org.apache.solr.common.util.SimpleOrderedMap;
  30. import org.apache.solr.core.SolrResourceLoader;
  31. import org.apache.solr.request.SolrQueryRequest;
  32. import org.apache.solr.response.SolrQueryResponse;
  33. import org.apache.solr.schema.FieldType;
  34. import org.apache.solr.schema.SchemaField;
  35. import org.apache.solr.update.AddUpdateCommand;
  36. import org.apache.solr.update.processor.UpdateRequestProcessor;
  37. import org.apache.solr.update.processor.UpdateRequestProcessorFactory;

  39. import mtas.analysis.MtasTokenizer;
  40. import mtas.analysis.util.MtasCharFilterFactory;
  41. import mtas.analysis.util.MtasTokenizerFactory;
  42. import mtas.codec.util.CodecUtil;
  43. import mtas.solr.schema.MtasPreAnalyzedField;

  45. /**
  46.  * A factory for creating MtasUpdateRequestProcessor objects.
  47.  */
  48. public class MtasUpdateRequestProcessorFactory
  49.     extends UpdateRequestProcessorFactory {

  51.   /** The Constant log. */
  52.   private static final Log log = LogFactory
  53.       .getLog(MtasUpdateRequestProcessorFactory.class);

  55.   /** The config. */
  56.   private MtasUpdateRequestProcessorConfig config = null;

  58.   /*
  59.    * (non-Javadoc)
  60.    * 
  61.    * @see
  62.    * org.apache.solr.update.processor.UpdateRequestProcessorFactory#init(org.
  63.    * apache.solr.common.util.NamedList)
  64.    */
  65.   @Override
  66.   @SuppressWarnings("rawtypes")
  67.   public void init(NamedList args) {
  68.     super.init(args);
  69.   }

  71.   /**
  72.    * Inits the.
  73.    *
  74.    * @param req the req
  75.    * @throws IOException Signals that an I/O exception has occurred.
  76.    */
  77.   @SuppressWarnings("unchecked")
  78.   private void init(SolrQueryRequest req) throws IOException {
  79.     if (config == null) {
  80.       // initialise
  81.       config = new MtasUpdateRequestProcessorConfig();
  82.       // required info
  83.       Map<String, FieldType> fieldTypes = req.getSchema().getFieldTypes();
  84.       Map<String, SchemaField> fields = req.getSchema().getFields();
  85.       SolrResourceLoader resourceLoader = req.getCore().getSolrConfig()
  86.           .getResourceLoader();
  87.       // check fieldTypes
  88.       // for (String name : fieldTypes.keySet()) {
  89.       for (Entry<String, FieldType> entry : fieldTypes.entrySet()) {
  90.         // only for MtasPreAnalyzedField
  91.         if (entry.getValue() instanceof MtasPreAnalyzedField) {
  92.           MtasPreAnalyzedField mpaf = (MtasPreAnalyzedField) entry.getValue();
  93.           config.fieldTypeDefaultConfiguration.put(entry.getKey(),
  94.               mpaf.defaultConfiguration);
  95.           config.fieldTypeConfigurationFromField.put(entry.getKey(),
  96.               mpaf.configurationFromField);
  97.           config.fieldTypeNumberOfTokensField.put(entry.getKey(),
  98.               mpaf.setNumberOfTokens);
  99.           config.fieldTypeNumberOfPositionsField.put(entry.getKey(),
  100.               mpaf.setNumberOfPositions);
  101.           config.fieldTypeSizeField.put(entry.getKey(), mpaf.setSize);
  102.           config.fieldTypeErrorField.put(entry.getKey(), mpaf.setError);
  103.           config.fieldTypePrefixField.put(entry.getKey(), mpaf.setPrefix);
  104.           if (mpaf.followIndexAnalyzer == null
  105.               || !fieldTypes.containsKey(mpaf.followIndexAnalyzer)) {
  106.             throw new IOException(
  107.                 entry.getKey() + " can't follow " + mpaf.followIndexAnalyzer);
  108.           } else {
  109.             FieldType fieldType = fieldTypes.get(mpaf.followIndexAnalyzer);
  110.             SimpleOrderedMap<?> analyzer = null;
  111.             Object tmpObj1 = fieldType.getNamedPropertyValues(false)
  112.                 .get(FieldType.INDEX_ANALYZER);
  113.             if (tmpObj1 != null && tmpObj1 instanceof SimpleOrderedMap) {
  114.               analyzer = (SimpleOrderedMap<?>) tmpObj1;
  115.             }
  116.             if (analyzer == null) {
  117.               Object tmpObj2 = fieldType.getNamedPropertyValues(false)
  118.                   .get(FieldType.ANALYZER);
  119.               if (tmpObj2 != null && tmpObj2 instanceof SimpleOrderedMap) {
  120.                 analyzer = (SimpleOrderedMap<?>) tmpObj2;
  121.               }
  122.             }
  123.             if (analyzer == null) {
  124.               throw new IOException("no analyzer");
  125.             } else {
  126.               // charfilters
  127.               ArrayList<SimpleOrderedMap<Object>> listCharFilters = null;
  128.               SimpleOrderedMap<Object> configTokenizer = null;
  129.               try {
  130.                 listCharFilters = (ArrayList<SimpleOrderedMap<Object>>) analyzer
  131.                     .findRecursive(FieldType.CHAR_FILTERS);
  132.                 ;
  133.                 configTokenizer = (SimpleOrderedMap<Object>) analyzer
  134.                     .findRecursive(FieldType.TOKENIZER);
  135.               } catch (ClassCastException e) {
  136.                 throw new IOException(
  137.                     "could not cast charFilters and/or tokenizer from analyzer",
  138.                     e);
  139.               }
  140.               if (listCharFilters != null && !listCharFilters.isEmpty()) {
  141.                 CharFilterFactory[] charFilterFactories = new CharFilterFactory[listCharFilters
  142.                     .size()];
  143.                 int number = 0;
  144.                 for (SimpleOrderedMap<Object> configCharFilter : listCharFilters) {
  145.                   String className = null;
  146.                   Map<String, String> args = new HashMap<>();
  147.                   Iterator<Map.Entry<String, Object>> it = configCharFilter
  148.                       .iterator();
  149.                   // get className and args
  150.                   while (it.hasNext()) {
  151.                     Map.Entry<String, Object> obj = it.next();
  152.                     if (obj.getValue() instanceof String) {
  153.                       if (obj.getKey().equals(FieldType.CLASS_NAME)) {
  154.                         className = (String) obj.getValue();
  155.                       } else {
  156.                         args.put(obj.getKey(), (String) obj.getValue());
  157.                       }
  158.                     }
  159.                   }
  160.                   if (className != null) {
  161.                     try {
  162.                       Class<?> cls = Class.forName((String) className);
  163.                       if (cls.isAssignableFrom(MtasCharFilterFactory.class)) {
  164.                         Class<?>[] types = { Map.class, ResourceLoader.class };
  165.                         Constructor<?> cnstr = cls.getConstructor(types);
  166.                         Object cff = cnstr.newInstance(args, resourceLoader);
  167.                         if (cff instanceof MtasCharFilterFactory) {
  168.                           charFilterFactories[number] = (MtasCharFilterFactory) cff;
  169.                           number++;
  170.                         } else {
  171.                           throw new IOException(
  172.                               className + " is no MtasCharFilterFactory");
  173.                         }
  174.                       } else {
  175.                         Class<?>[] types = { Map.class };
  176.                         Constructor<?> cnstr = cls.getConstructor(types);
  177.                         Object cff = cnstr.newInstance(args);
  178.                         if (cff instanceof CharFilterFactory) {
  179.                           charFilterFactories[number] = (CharFilterFactory) cff;
  180.                           number++;
  181.                         } else {
  182.                           throw new IOException(
  183.                               className + " is no CharFilterFactory");
  184.                         }
  185.                       }
  186.                     } catch (ClassNotFoundException | InstantiationException
  187.                         | IllegalAccessException | IllegalArgumentException
  188.                         | InvocationTargetException | NoSuchMethodException e) {
  189.                       throw new IOException(e);
  190.                     }
  191.                   } else {
  192.                     throw new IOException("no className");
  193.                   }
  194.                 }
  195.                 config.fieldTypeCharFilterFactories.put(entry.getKey(),
  196.                     charFilterFactories);
  197.               } else {
  198.                 config.fieldTypeCharFilterFactories.put(entry.getKey(), null);
  199.               }
  200.               if (configTokenizer != null) {
  201.                 String className = null;
  202.                 Map<String, String> args = new HashMap<>();
  203.                 Iterator<Map.Entry<String, Object>> it = configTokenizer
  204.                     .iterator();
  205.                 // get className and args
  206.                 while (it.hasNext()) {
  207.                   Map.Entry<String, Object> obj = it.next();
  208.                   if (obj.getValue() instanceof String) {
  209.                     if (obj.getKey().equals(FieldType.CLASS_NAME)) {
  210.                       className = (String) obj.getValue();
  211.                     } else {
  212.                       args.put(obj.getKey(), (String) obj.getValue());
  213.                     }
  214.                   }
  215.                 }
  216.                 if (className != null) {
  217.                   try {
  218.                     Class<?> cls = Class.forName((String) className);
  219.                     Class<?>[] types = { Map.class, ResourceLoader.class };
  220.                     Constructor<?> cnstr = cls.getConstructor(types);
  221.                     Object cff = cnstr.newInstance(args, resourceLoader);
  222.                     if (cff instanceof MtasTokenizerFactory) {
  223.                       config.fieldTypeTokenizerFactory.put(entry.getKey(),
  224.                           (MtasTokenizerFactory) cff);
  225.                     } else {
  226.                       throw new IOException(
  227.                           className + " is no MtasTokenizerFactory");
  228.                     }
  229.                   } catch (ClassNotFoundException | InstantiationException
  230.                       | IllegalAccessException | IllegalArgumentException
  231.                       | InvocationTargetException | NoSuchMethodException e) {
  232.                     throw new IOException(e);
  233.                   }
  234.                 } else {
  235.                   throw new IOException("no className");
  236.                 }
  237.               }

  239.             }
  240.           }
  241.         }
  242.       }
  243.       for (Entry<String, SchemaField> entry : fields.entrySet()) {
  244.         if (entry.getValue().getType() != null
  245.             && config.fieldTypeTokenizerFactory
  246.                 .containsKey(entry.getValue().getType().getTypeName())) {
  247.           config.fieldMapping.put(entry.getKey(),
  248.               entry.getValue().getType().getTypeName());
  249.         }
  250.       }
  251.     }
  252.   }

  254.   /*
  255.    * (non-Javadoc)
  256.    * 
  257.    * @see
  258.    * org.apache.solr.update.processor.UpdateRequestProcessorFactory#getInstance(
  259.    * org.apache.solr.request.SolrQueryRequest,
  260.    * org.apache.solr.response.SolrQueryResponse,
  261.    * org.apache.solr.update.processor.UpdateRequestProcessor)
  262.    */
  263.   @Override
  264.   public UpdateRequestProcessor getInstance(SolrQueryRequest req,
  265.       SolrQueryResponse rsp, UpdateRequestProcessor next) {
  266.     try {
  267.       init(req);
  268.     } catch (IOException e) {
  269.       log.error(e);
  270.     }
  271.     return new MtasUpdateRequestProcessor(next, config);
  272.   }

  274. }

  276. class MtasUpdateRequestProcessor extends UpdateRequestProcessor {

  278.   /** The log. */
  279.   private static Log log = LogFactory.getLog(MtasUpdateRequestProcessor.class);

  281.   private MtasUpdateRequestProcessorConfig config;

  283.   public MtasUpdateRequestProcessor(UpdateRequestProcessor next,
  284.       MtasUpdateRequestProcessorConfig config) {
  285.     super(next);
  286.     this.config = config;
  287.   }

  289.   @Override
  290.   public void processAdd(AddUpdateCommand cmd) throws IOException {
  291.     if (config != null && config.fieldMapping.size() > 0) {
  292.       // get document
  293.       SolrInputDocument doc = cmd.getSolrInputDocument();
  294.       // loop over configurations
  295.       for (String field : config.fieldMapping.keySet()) {
  296.         SolrInputField originalValue = doc.get(field);
  297.         String fieldType = config.fieldMapping.get(field);
  298.         CharFilterFactory[] charFilterFactories = config.fieldTypeCharFilterFactories
  299.             .get(fieldType);
  300.         MtasTokenizerFactory tokenizerFactory = config.fieldTypeTokenizerFactory
  301.             .get(config.fieldMapping.get(field));
  302.         MtasUpdateRequestProcessorSizeReader sizeReader;
  303.         if (originalValue != null
  304.             && originalValue.getValue() instanceof String) {
  305.           MtasUpdateRequestProcessorResultWriter result = null;
  306.           try {
  307.             String storedValue = (String) originalValue.getValue();
  308.             // create reader
  309.             Reader reader = new StringReader(storedValue);
  310.             // configuration
  311.             String configuration = null;
  312.             String defaultConfiguration = config.fieldTypeDefaultConfiguration
  313.                 .get(fieldType);
  314.             if (config.fieldTypeConfigurationFromField.get(fieldType) != null) {
  315.               Object obj = doc.getFieldValue(
  316.                   config.fieldTypeConfigurationFromField.get(fieldType));
  317.               if (obj != null) {
  318.                 configuration = obj.toString();
  319.               }
  320.             }
  321.             // charFilterFactories
  322.             if (charFilterFactories != null) {
  323.               for (CharFilterFactory charFilterFactory : charFilterFactories) {
  324.                 if (charFilterFactory instanceof MtasCharFilterFactory) {
  325.                   reader = ((MtasCharFilterFactory) charFilterFactory)
  326.                       .create(reader, configuration, defaultConfiguration);
  327.                 } else {
  328.                   reader = charFilterFactory.create(reader);
  329.                 }
  330.                 if (reader == null) {
  331.                   throw new IOException(
  332.                       "charFilter " + charFilterFactory.getClass().getName()
  333.                           + " returns null");
  334.                 }
  335.               }
  336.             }
  337.             
  338.             sizeReader = new MtasUpdateRequestProcessorSizeReader(reader);

  340.             // tokenizerFactory
  341.             result = new MtasUpdateRequestProcessorResultWriter(storedValue);
  342.             int numberOfPositions = 0;
  343.             int numberOfTokens = 0;
  344.             Set<String> prefixes = new HashSet<>();
  345.             try (MtasTokenizer tokenizer = tokenizerFactory.create(configuration, defaultConfiguration)) {              
  346.               tokenizer.setReader(sizeReader);
  347.               tokenizer.reset();
  348.               // attributes
  349.               CharTermAttribute termAttribute = tokenizer
  350.                   .getAttribute(CharTermAttribute.class);
  351.               OffsetAttribute offsetAttribute = tokenizer
  352.                   .getAttribute(OffsetAttribute.class);
  353.               PositionIncrementAttribute positionIncrementAttribute = tokenizer
  354.                   .getAttribute(PositionIncrementAttribute.class);
  355.               PayloadAttribute payloadAttribute = tokenizer
  356.                   .getAttribute(PayloadAttribute.class);
  357.               FlagsAttribute flagsAttribute = tokenizer
  358.                   .getAttribute(FlagsAttribute.class);

  360.               while (tokenizer.incrementToken()) {
  361.                 String term = null;
  362.                 Integer offsetStart = null;
  363.                 Integer offsetEnd = null;
  364.                 Integer posIncr = null;
  365.                 Integer flags = null;
  366.                 BytesRef payload = null;
  367.                 if (termAttribute != null) {
  368.                   term = termAttribute.toString();
  369.                   prefixes.add(CodecUtil.termPrefix(term));
  370.                 }
  371.                 if (offsetAttribute != null) {
  372.                   offsetStart = offsetAttribute.startOffset();
  373.                   offsetEnd = offsetAttribute.endOffset();
  374.                 }
  375.                 if (positionIncrementAttribute != null) {
  376.                   posIncr = positionIncrementAttribute.getPositionIncrement();
  377.                 } else {
  378.                   posIncr = 0;
  379.                 }
  380.                 if (payloadAttribute != null) {
  381.                   payload = payloadAttribute.getPayload();
  382.                 }
  383.                 if (flagsAttribute != null) {
  384.                   flags = flagsAttribute.getFlags();
  385.                 }
  386.                 numberOfTokens++;
  387.                 numberOfPositions += posIncr;
  388.                 result.addItem(term, offsetStart, offsetEnd, posIncr, payload,
  389.                     flags);
  390.                 // System.out.print(term+" ");
  391.               }

  393.               // update field
  394.               doc.remove(field);
  395.               if (result.getTokenNumber() > 0) {
  396.                 doc.addField(field, result.getFileName());
  397.               }
  398.             } finally {
  399.               result.close();
  400.             }
  401.             // update size
  402.             setFields(doc, config.fieldTypeSizeField.get(fieldType),
  403.                 sizeReader.getTotalReadSize());
  404.             // update numberOfPositions
  405.             setFields(doc,
  406.                 config.fieldTypeNumberOfPositionsField.get(fieldType),
  407.                 numberOfPositions);
  408.             // update numberOfTokens
  409.             setFields(doc, config.fieldTypeNumberOfTokensField.get(fieldType),
  410.                 numberOfTokens);
  411.             // update prefixes
  412.             setFields(doc, config.fieldTypePrefixField.get(fieldType),
  413.                 prefixes);
  414.           } catch (IOException e) {
  415.             log.info(e);
  416.             // update error
  417.             doc.addField(config.fieldTypeErrorField.get(fieldType),
  418.                 e.getMessage());
  419.             // update size
  420.             setFields(doc, config.fieldTypeSizeField.get(fieldType), 0);
  421.             // update numberOfPositions
  422.             setFields(doc,
  423.                 config.fieldTypeNumberOfPositionsField.get(fieldType), 0);
  424.             // update numberOfTokens
  425.             setFields(doc, config.fieldTypeNumberOfTokensField.get(fieldType),
  426.                 0);
  427.             // update prefixes
  428.             removeFields(doc, config.fieldTypePrefixField.get(fieldType));
  429.             if (result != null) {
  430.               result.forceCloseAndDelete();
  431.               doc.remove(field);
  432.             }
  433.           }
  434.         }
  435.       }

  437.     }
  438.     // pass it up the chain
  439.     super.processAdd(cmd);
  440.   }

  442.   private void removeFields(SolrInputDocument doc, String fieldNames) {
  443.     if (fieldNames != null) {
  444.       String[] tmpFields = fieldNames.split(",");
  445.       for (int i = 0; i < tmpFields.length; i++) {
  446.         doc.removeField(tmpFields[i]);
  447.       }
  448.     }
  449.   }

  451.   private void setFields(SolrInputDocument doc, String fieldNames,
  452.       Object value) {
  453.     if (fieldNames != null) {
  454.       String[] tmpFields = fieldNames.split(",");
  455.       for (int i = 0; i < tmpFields.length; i++) {
  456.         if (!tmpFields[i].trim().isEmpty()) {
  457.           doc.addField(tmpFields[i].trim(), value);
  458.         }
  459.       }
  460.     }
  461.   }

  463. }

  465. class MtasUpdateRequestProcessorConfig {

  467.   HashMap<String, CharFilterFactory[]> fieldTypeCharFilterFactories;
  468.   HashMap<String, MtasTokenizerFactory> fieldTypeTokenizerFactory;
  469.   HashMap<String, String> fieldMapping;
  470.   HashMap<String, String> fieldTypeDefaultConfiguration;
  471.   HashMap<String, String> fieldTypeConfigurationFromField;
  472.   HashMap<String, String> fieldTypeNumberOfTokensField;
  473.   HashMap<String, String> fieldTypeNumberOfPositionsField;
  474.   HashMap<String, String> fieldTypeSizeField;
  475.   HashMap<String, String> fieldTypeErrorField;
  476.   HashMap<String, String> fieldTypePrefixField;

  478.   MtasUpdateRequestProcessorConfig() {
  479.     fieldMapping = new HashMap<>();
  480.     fieldTypeCharFilterFactories = new HashMap<>();
  481.     fieldTypeTokenizerFactory = new HashMap<>();
  482.     fieldTypeDefaultConfiguration = new HashMap<>();
  483.     fieldTypeConfigurationFromField = new HashMap<>();
  484.     fieldTypeNumberOfTokensField = new HashMap<>();
  485.     fieldTypeNumberOfPositionsField = new HashMap<>();
  486.     fieldTypeSizeField = new HashMap<>();
  487.     fieldTypeErrorField = new HashMap<>();
  488.     fieldTypePrefixField = new HashMap<>();
  489.   }

  491. }

  493. class MtasUpdateRequestProcessorSizeReader extends Reader {

  495.   Reader reader;
  496.   long totalReadSize;

  498.   public MtasUpdateRequestProcessorSizeReader(Reader reader) {
  499.     this.reader = reader;
  500.     totalReadSize = 0;
  501.   }

  503.   public int read(char[] cbuf, int off, int len) throws IOException {
  504.     int read = reader.read(cbuf, off, len);
  505.     totalReadSize += read;
  506.     return read;
  507.   }

  509.   public void close() throws IOException {
  510.     reader.close();
  511.   }

  513.   public long getTotalReadSize() {
  514.     return totalReadSize;
  515.   }

  517. }
Created with JaCoCo 0.7.9.201702052155