Workspace/Siman-Common/src/org/splat/service/technical/IndexServiceImpl.java

   1 package org.splat.service.technical;
   2
   3 /**
   4  *
   5  * @author    Daniel Brunier-Coulin
   6  * @copyright OPEN CASCADE 2012
   7  */
   8
   9 import java.io.File;
  10 import java.io.IOException;
  11 import java.io.Serializable;
  12 import java.util.Iterator;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.apache.log4j.Logger;
  17
  18 import org.apache.lucene.analysis.standard.StandardAnalyzer;
  19 import org.apache.lucene.document.Field;
  20 import org.apache.lucene.index.CorruptIndexException;
  21 import org.apache.lucene.index.IndexReader;
  22 import org.apache.lucene.index.IndexWriter;
  23 import org.apache.lucene.index.Term;
  24 import org.apache.lucene.store.Directory;
  25 import org.apache.lucene.store.FSDirectory;
  26 import org.apache.lucene.store.LockObtainFailedException;
  27 import org.apache.lucene.util.Version;
  28 import org.splat.dal.bo.kernel.User;
  29 import org.splat.dal.bo.som.KnowledgeElement;
  30 import org.splat.dal.bo.som.ProgressState;
  31 import org.splat.dal.bo.som.Scenario;
  32 import org.splat.dal.bo.som.SimulationContext;
  33 import org.splat.dal.bo.som.Study;
  34 import org.splat.service.ProjectElementService;
  35 import org.splat.service.dto.Proxy;
  36 import org.splat.som.Step;
  37
  38 public class IndexServiceImpl implements IndexService {
  39
  40         private Directory index;
  41         private org.apache.lucene.document.Document body;
  42         private ProjectElementService _projectElementService;
  43         private RepositoryService _repositoryService;
  44
  45         protected static StandardAnalyzer analyzer = new StandardAnalyzer(
  46                         Version.LUCENE_29);
  47         private static final Logger logger = Logger
  48                         .getLogger(IndexServiceImpl.class);
  49
  50         private class Entry extends IndexWriter {
  51                 private org.apache.lucene.document.Document entry;
  52
  53                 private Entry(Study study) throws CorruptIndexException,
  54                                 LockObtainFailedException, IOException {
  55                         super(index, analyzer, false, IndexWriter.MaxFieldLength.UNLIMITED);
  56
  57                         // Addition of mandatory fields
  58                         entry = new org.apache.lucene.document.Document();
  59                         Field field;
  60                         field = body.getField("index");
  61                         field.setValue(String.valueOf(study.getIndex()));
  62                         entry.add(field);
  63                         field = body.getField("class");
  64                         field.setValue("Study");
  65                         entry.add(field);
  66                         field = body.getField("type");
  67                         field.setValue(""); // Reserved for configurable Study type
  68                         entry.add(field);
  69                         field = body.getField("ref");
  70                         field.setValue(study.getReference());
  71                         entry.add(field);
  72                         field = body.getField("area");
  73                         field.setValue(study.getVisibility().toString());
  74                         entry.add(field);
  75                         field = body.getField("state");
  76                         field.setValue(study.getProgressState().toString());
  77                         entry.add(field);
  78                         field = body.getField("author");
  79                         field.setValue(study.getAuthor().toString());
  80                         entry.add(field);
  81                         field = body.getField("title");
  82                         field.setValue(study.getTitle());
  83                         entry.add(field);
  84                         field = body.getField("contents");
  85                         field.setValue(study.getTitle());
  86                         entry.add(field);
  87
  88                         // Addition of optional fields
  89                         setActorsOf(study);
  90                         setContextAt(getProjectElementService().getSteps(study));
  91                 }
  92
  93                 private Entry(KnowledgeElement kelm) throws CorruptIndexException,
  94                                 LockObtainFailedException, IOException {
  95                         super(index, analyzer, false, IndexWriter.MaxFieldLength.UNLIMITED);
  96
  97                         // Addition of mandatory fields
  98                         entry = new org.apache.lucene.document.Document();
  99                         Field field;
 100                         field = body.getField("index");
 101                         field.setValue(String.valueOf(kelm.getIndex()));
 102                         entry.add(field);
 103                         field = body.getField("class");
 104                         field.setValue("KnowledgeElement");
 105                         entry.add(field);
 106                         field = body.getField("type");
 107                         field.setValue(kelm.getType().getName());
 108                         entry.add(field);
 109                         field = body.getField("ref");
 110                         field.setValue(kelm.getReference());
 111                         entry.add(field);
 112                         field = body.getField("area");
 113                         field.setValue(kelm.getVisibility().toString());
 114                         entry.add(field);
 115                         field = body.getField("state");
 116                         field.setValue(kelm.getProgressState().toString());
 117                         entry.add(field);
 118                         field = body.getField("author");
 119                         field.setValue(kelm.getAuthor().toString());
 120                         entry.add(field);
 121                         field = body.getField("title");
 122                         field.setValue(kelm.getTitle());
 123                         entry.add(field);
 124                         field = body.getField("contents");
 125                         field.setValue(kelm.getTitle());
 126                         entry.add(field);
 127
 128                         // TODO: Addition of optional fields
 129                         Scenario scene = kelm.getOwnerScenario();
 130                         Study study = scene.getOwnerStudy();
 131                         setActorsOf(study); // For restricting the visibility of knowledges attached to private studies
 132                         setContextAt(getProjectElementService().getSteps(study));
 133                         setContextAt(getProjectElementService().getSteps(scene));
 134                 }
 135
 136                 private void add() throws CorruptIndexException, IOException {
 137                         addDocument(entry);
 138                         // Save the new entry
 139                         optimize(); // Should be called before committing the index
 140                         close(); // Commits the index
 141                 }
 142
 143                 private void update() throws CorruptIndexException, IOException {
 144                         String value = entry.getField("ref").stringValue(); // Only field with unique value
 145                         Term term = new Term("ref").createTerm(value);
 146                         updateDocument(term, entry);
 147                         // Save the updated entry
 148                         optimize(); // Should be called before committing the index
 149                         close(); // Commits the index
 150                 }
 151
 152                 private void setContextAt(Step[] step) {
 153                         for (int i = 0; i < step.length; i++) {
 154                                 List<SimulationContext> contexts = step[i]
 155                                                 .getAllSimulationContexts();
 156                                 for (Iterator<SimulationContext> j = contexts.iterator(); j
 157                                                 .hasNext();) {
 158                                         SimulationContext context = j.next();
 159                                         String type = String.valueOf(context.getType().getIndex());
 160                                         String value = context.getValue();
 161                                         entry.add(new Field(type, value, Field.Store.NO,
 162                                                         Field.Index.NOT_ANALYZED));
 163                                 }
 164                         }
 165                 }
 166
 167                 private void setActorsOf(Study study) {
 168                         // RKV: This set is always not null. Let's assume that it must be initialized before reindexing: Set<User> actors =
 169                         // study.getActors();
 170                         Set<User> actors = study.getActor(); // RKV
 171                         if (logger.isDebugEnabled()) {
 172                                 logger.debug("Study " + study.getReference()
 173                                                 + " actors number to be added to the lucen index: "
 174                                                 + actors.size());
 175                         }
 176                         for (Iterator<User> i = actors.iterator(); i.hasNext();) {
 177                                 String value = i.next().toString();
 178                                 entry.add(new Field("actor", value, Field.Store.NO,
 179                                                 Field.Index.NOT_ANALYZED));
 180                                 if (logger.isDebugEnabled()) {
 181                                         logger.debug("    actor added to the lucen index: " + value);
 182                                 }
 183                         }
 184                 }
 185         }
 186
 187         public static class ObjectProxy implements Proxy, Serializable {
 188                 // --------------------------------------------------------------
 189                 private Long rid;
 190                 private String sid;
 191                 private ProgressState state;
 192                 private String title;
 193                 private String type;
 194                 private String name;
 195                 private static final long serialVersionUID = -4386494192709562221L;
 196
 197                 public ObjectProxy(org.apache.lucene.document.Document ludoc) {
 198                         rid = Long.valueOf(ludoc.get("index"));
 199                         sid = ludoc.get("ref");
 200                         state = ProgressState.valueOf(ludoc.get("state"));
 201                         title = ludoc.get("title");
 202                         name = ludoc.get("author");
 203                 }
 204
 205                 public String getAuthorName() {
 206                         return name;
 207                 }
 208
 209                 public Long getIndex() {
 210                         return rid;
 211                 }
 212
 213                 public ProgressState getProgressState() {
 214                         return state;
 215                 }
 216
 217                 public String getReference() {
 218                         return sid;
 219                 }
 220
 221                 public String getTitle() {
 222                         return title;
 223                 }
 224
 225                 public String getType() {
 226                         return type;
 227                 }
 228         }
 229
 230         // ==============================================================================================================================
 231         // Construction
 232         // ==============================================================================================================================
 233
 234         public void configure() throws IOException {
 235                 File indir = getRepositoryService().getRepositoryIndexDirectory();
 236                 index = FSDirectory.open(indir);
 237                 body = new org.apache.lucene.document.Document();
 238                 body.add(new Field("index", "", Field.Store.YES,
 239                                 Field.Index.NOT_ANALYZED));
 240                 body.add(new Field("class", "", Field.Store.NO,
 241                                 Field.Index.NOT_ANALYZED));
 242                 body.add(new Field("type", "", Field.Store.YES,
 243                                 Field.Index.NOT_ANALYZED));
 244                 body
 245                                 .add(new Field("ref", "", Field.Store.YES,
 246                                                 Field.Index.NOT_ANALYZED));
 247                 body
 248                                 .add(new Field("area", "", Field.Store.NO,
 249                                                 Field.Index.NOT_ANALYZED));
 250                 body.add(new Field("state", "", Field.Store.YES,
 251                                 Field.Index.NOT_ANALYZED));
 252                 body.add(new Field("author", "", Field.Store.YES,
 253                                 Field.Index.NOT_ANALYZED));
 254                 body.add(new Field("title", "", Field.Store.YES,
 255                                 Field.Index.NOT_ANALYZED));
 256                 body
 257                                 .add(new Field("contents", "", Field.Store.NO,
 258                                                 Field.Index.ANALYZED));
 259                 if (!this.exists())
 260                         this.create(); // Happens when re-indexing all studies
 261         }
 262
 263         public void create() throws IOException {
 264                 // -------------------------------
 265                 Directory index = FSDirectory.open(getRepositoryService()
 266                                 .getRepositoryIndexDirectory());
 267                 IndexWriter writer = new IndexWriter(index, analyzer, true,
 268                                 IndexWriter.MaxFieldLength.UNLIMITED);
 269                 writer.close(); // ==== Creates an empty index
 270         }
 271
 272         // ==============================================================================================================================
 273         // Member functions
 274         // ==============================================================================================================================
 275
 276         public void add(Study study) throws IOException {
 277                 // --------------------------------
 278                 IndexServiceImpl.Entry entry = new Entry(study);
 279                 entry.add();
 280                 if (logger.isInfoEnabled()) {
 281                         logger.info("Study \"" + study.getIndex() + "\" indexed.");
 282                 }
 283         }
 284
 285         public void add(KnowledgeElement kelm) throws IOException {
 286                 // ------------------------------------------
 287                 IndexServiceImpl.Entry entry = new Entry(kelm);
 288                 entry.add();
 289                 if (logger.isInfoEnabled()) {
 290                         logger.info("Knowledge \"" + kelm.getIndex() + "\" indexed.");
 291                 }
 292         }
 293
 294         public boolean exists() {
 295                 // ---------------------------
 296                 try {
 297                         return IndexReader.indexExists(index);
 298                 } catch (IOException error) {
 299                         error.printStackTrace();
 300                         return false;
 301                 }
 302         }
 303
 304         public void update(Study study) throws IOException {
 305                 // -----------------------------------
 306                 IndexServiceImpl.Entry entry = new Entry(study);
 307                 entry.update();
 308                 if (logger.isInfoEnabled()) {
 309                         logger.info("Study \"" + study.getIndex() + "\" re-indexed.");
 310                 }
 311         }
 312
 313         public void update(KnowledgeElement kelm) throws IOException {
 314                 // ---------------------------------------------
 315                 IndexServiceImpl.Entry entry = new Entry(kelm);
 316                 entry.update();
 317                 if (logger.isInfoEnabled()) {
 318                         logger.info("Knowledge \"" + kelm.getIndex() + "\" re-indexed.");
 319                 }
 320         }
 321
 322         /**
 323          * Get the projectElementService.
 324          *
 325          * @return the projectElementService
 326          */
 327         public ProjectElementService getProjectElementService() {
 328                 return _projectElementService;
 329         }
 330
 331         /**
 332          * Set the projectElementService.
 333          *
 334          * @param projectElementService
 335          *            the projectElementService to set
 336          */
 337         public void setProjectElementService(
 338                         ProjectElementService projectElementService) {
 339                 _projectElementService = projectElementService;
 340         }
 341
 342         /**
 343          * Get the repositoryService.
 344          *
 345          * @return the repositoryService
 346          */
 347         public RepositoryService getRepositoryService() {
 348                 return _repositoryService;
 349         }
 350
 351         /**
 352          * Set the repositoryService.
 353          *
 354          * @param repositoryService
 355          *            the repositoryService to set
 356          */
 357         public void setRepositoryService(RepositoryService repositoryService) {
 358                 _repositoryService = repositoryService;
 359         }
 360 }