001/* 002 * (C) Copyright 2014 Nuxeo SA (http://nuxeo.com/) and contributors. 003 * 004 * All rights reserved. This program and the accompanying materials 005 * are made available under the terms of the GNU Lesser General Public License 006 * (LGPL) version 2.1 which accompanies this distribution, and is available at 007 * http://www.gnu.org/licenses/lgpl-2.1.html 008 * 009 * This library is distributed in the hope that it will be useful, 010 * but WITHOUT ANY WARRANTY; without even the implied warranty of 011 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 012 * Lesser General Public License for more details. 013 * 014 * Contributors: 015 * Tiry 016 * bdelbosc 017 */ 018package org.nuxeo.elasticsearch; 019 020import static org.nuxeo.elasticsearch.ElasticSearchConstants.ES_ENABLED_PROPERTY; 021import static org.nuxeo.elasticsearch.ElasticSearchConstants.INDEXING_QUEUE_ID; 022import static org.nuxeo.elasticsearch.ElasticSearchConstants.REINDEX_ON_STARTUP_PROPERTY; 023 024import java.util.ArrayList; 025import java.util.Arrays; 026import java.util.Collections; 027import java.util.HashMap; 028import java.util.HashSet; 029import java.util.List; 030import java.util.Map; 031import java.util.Set; 032import java.util.concurrent.Callable; 033import java.util.concurrent.ExecutionException; 034import java.util.concurrent.Executors; 035import java.util.concurrent.ThreadFactory; 036import java.util.concurrent.TimeUnit; 037import java.util.concurrent.TimeoutException; 038import java.util.concurrent.atomic.AtomicInteger; 039 040import javax.transaction.Transaction; 041 042import org.apache.commons.logging.Log; 043import org.apache.commons.logging.LogFactory; 044import org.elasticsearch.client.Client; 045import org.elasticsearch.index.query.QueryBuilder; 046import org.nuxeo.ecm.automation.jaxrs.io.documents.JsonESDocumentWriter; 047import org.nuxeo.ecm.core.api.CoreSession; 048import org.nuxeo.ecm.core.api.DocumentModelList; 049import org.nuxeo.ecm.core.api.SortInfo; 050import org.nuxeo.ecm.core.repository.RepositoryService; 051import org.nuxeo.ecm.core.work.api.Work; 052import org.nuxeo.ecm.core.work.api.WorkManager; 053import org.nuxeo.elasticsearch.api.ElasticSearchAdmin; 054import org.nuxeo.elasticsearch.api.ElasticSearchIndexing; 055import org.nuxeo.elasticsearch.api.ElasticSearchService; 056import org.nuxeo.elasticsearch.api.EsResult; 057import org.nuxeo.elasticsearch.commands.IndexingCommand; 058import org.nuxeo.elasticsearch.config.ElasticSearchDocWriterDescriptor; 059import org.nuxeo.elasticsearch.config.ElasticSearchIndexConfig; 060import org.nuxeo.elasticsearch.config.ElasticSearchLocalConfig; 061import org.nuxeo.elasticsearch.config.ElasticSearchRemoteConfig; 062import org.nuxeo.elasticsearch.core.ElasticSearchAdminImpl; 063import org.nuxeo.elasticsearch.core.ElasticSearchIndexingImpl; 064import org.nuxeo.elasticsearch.core.ElasticSearchServiceImpl; 065import org.nuxeo.elasticsearch.query.NxQueryBuilder; 066import org.nuxeo.elasticsearch.work.IndexingWorker; 067import org.nuxeo.elasticsearch.work.ScrollingIndexingWorker; 068import org.nuxeo.runtime.api.Framework; 069import org.nuxeo.runtime.model.ComponentContext; 070import org.nuxeo.runtime.model.ComponentInstance; 071import org.nuxeo.runtime.model.DefaultComponent; 072import org.nuxeo.runtime.transaction.TransactionHelper; 073 074import com.google.common.util.concurrent.ListenableFuture; 075import com.google.common.util.concurrent.ListeningExecutorService; 076import com.google.common.util.concurrent.MoreExecutors; 077 078/** 079 * Component used to configure and manage ElasticSearch integration 080 */ 081public class ElasticSearchComponent extends DefaultComponent implements ElasticSearchAdmin, ElasticSearchIndexing, 082 ElasticSearchService { 083 084 private static final Log log = LogFactory.getLog(ElasticSearchComponent.class); 085 086 private static final String EP_REMOTE = "elasticSearchRemote"; 087 088 private static final String EP_LOCAL = "elasticSearchLocal"; 089 090 private static final String EP_INDEX = "elasticSearchIndex"; 091 092 private static final String EP_DOC_WRITER = "elasticSearchDocWriter"; 093 094 private static final long REINDEX_TIMEOUT = 20; 095 096 // Indexing commands that where received before the index initialization 097 private final List<IndexingCommand> stackedCommands = Collections.synchronizedList(new ArrayList<>()); 098 099 private final Map<String, ElasticSearchIndexConfig> indexConfig = new HashMap<>(); 100 101 private ElasticSearchLocalConfig localConfig; 102 103 private ElasticSearchRemoteConfig remoteConfig; 104 105 private ElasticSearchAdminImpl esa; 106 107 private ElasticSearchIndexingImpl esi; 108 109 private ElasticSearchServiceImpl ess; 110 111 protected JsonESDocumentWriter jsonESDocumentWriter; 112 113 private ListeningExecutorService waiterExecutorService; 114 115 private final AtomicInteger runIndexingWorkerCount = new AtomicInteger(0); 116 117 // Nuxeo Component impl ======================================é============= 118 @Override 119 public void registerContribution(Object contribution, String extensionPoint, ComponentInstance contributor) { 120 switch (extensionPoint) { 121 case EP_LOCAL: 122 ElasticSearchLocalConfig localContrib = (ElasticSearchLocalConfig) contribution; 123 if (localContrib.isEnabled()) { 124 localConfig = localContrib; 125 remoteConfig = null; 126 log.info("Registering local embedded configuration: " + localConfig + ", loaded from " 127 + contributor.getName()); 128 } else if (localConfig != null) { 129 log.info("Disabling previous local embedded configuration, deactivated by " + contributor.getName()); 130 localConfig = null; 131 } 132 break; 133 case EP_REMOTE: 134 ElasticSearchRemoteConfig remoteContribution = (ElasticSearchRemoteConfig) contribution; 135 if (remoteContribution.isEnabled()) { 136 remoteConfig = remoteContribution; 137 localConfig = null; 138 log.info("Registering remote configuration: " + remoteConfig + ", loaded from " + contributor.getName()); 139 } else if (remoteConfig != null) { 140 log.info("Disabling previous remote configuration, deactivated by " + contributor.getName()); 141 remoteConfig = null; 142 } 143 break; 144 case EP_INDEX: 145 ElasticSearchIndexConfig idx = (ElasticSearchIndexConfig) contribution; 146 ElasticSearchIndexConfig previous = indexConfig.get(idx.getName()); 147 if (idx.isEnabled()) { 148 idx.merge(previous); 149 indexConfig.put(idx.getName(), idx); 150 log.info("Registering index configuration: " + idx + ", loaded from " + contributor.getName()); 151 } else if (previous != null) { 152 log.info("Disabling index configuration: " + previous + ", deactivated by " + contributor.getName()); 153 indexConfig.remove(idx.getName()); 154 } 155 break; 156 case EP_DOC_WRITER: 157 ElasticSearchDocWriterDescriptor writerDescriptor = (ElasticSearchDocWriterDescriptor) contribution; 158 try { 159 jsonESDocumentWriter = writerDescriptor.getKlass().newInstance(); 160 } catch (IllegalAccessException | InstantiationException e) { 161 log.error("Can not instantiate jsonESDocumentWriter from " + writerDescriptor.getKlass()); 162 throw new RuntimeException(e); 163 } 164 break; 165 default: 166 throw new IllegalStateException("Invalid EP: " + extensionPoint); 167 } 168 } 169 170 @Override 171 public void applicationStarted(ComponentContext context) { 172 if (!isElasticsearchEnabled()) { 173 log.info("Elasticsearch service is disabled"); 174 return; 175 } 176 esa = new ElasticSearchAdminImpl(localConfig, remoteConfig, indexConfig); 177 esi = new ElasticSearchIndexingImpl(esa, jsonESDocumentWriter); 178 ess = new ElasticSearchServiceImpl(esa); 179 initListenerThreadPool(); 180 processStackedCommands(); 181 reindexOnStartup(); 182 } 183 184 private void reindexOnStartup() { 185 boolean reindexOnStartup = Boolean.parseBoolean(Framework.getProperty(REINDEX_ON_STARTUP_PROPERTY, "false")); 186 if (!reindexOnStartup) { 187 return; 188 } 189 for (String repositoryName : esa.getInitializedRepositories()) { 190 log.warn(String.format("Indexing repository: %s on startup", repositoryName)); 191 runReindexingWorker(repositoryName, "SELECT ecm:uuid FROM Document"); 192 try { 193 prepareWaitForIndexing().get(REINDEX_TIMEOUT, TimeUnit.SECONDS); 194 } catch (InterruptedException e) { 195 Thread.currentThread().interrupt(); 196 } catch (ExecutionException e) { 197 log.error(e.getMessage(), e); 198 } catch (TimeoutException e) { 199 log.warn(String.format("Indexation of repository %s not finised after %d s, continuing in background", 200 repositoryName, REINDEX_TIMEOUT)); 201 } 202 } 203 } 204 205 protected boolean isElasticsearchEnabled() { 206 return Boolean.parseBoolean(Framework.getProperty(ES_ENABLED_PROPERTY, "true")); 207 } 208 209 @Override 210 public void deactivate(ComponentContext context) { 211 if (esa != null) { 212 esa.disconnect(); 213 } 214 } 215 216 @Override 217 public int getApplicationStartedOrder() { 218 RepositoryService component = (RepositoryService) Framework.getRuntime().getComponent( 219 "org.nuxeo.ecm.core.repository.RepositoryServiceComponent"); 220 return component.getApplicationStartedOrder() / 2; 221 } 222 223 void processStackedCommands() { 224 if (!stackedCommands.isEmpty()) { 225 log.info(String.format("Processing %d indexing commands stacked during startup", stackedCommands.size())); 226 runIndexingWorker(stackedCommands); 227 stackedCommands.clear(); 228 log.debug("Done"); 229 } 230 } 231 232 // Es Admin ================================================================ 233 234 @Override 235 public Client getClient() { 236 return esa.getClient(); 237 } 238 239 @Override 240 public void initIndexes(boolean dropIfExists) { 241 esa.initIndexes(dropIfExists); 242 } 243 244 @Override 245 public void dropAndInitIndex(String indexName) { 246 esa.dropAndInitIndex(indexName); 247 } 248 249 @Override 250 public void dropAndInitRepositoryIndex(String repositoryName) { 251 esa.dropAndInitRepositoryIndex(repositoryName); 252 } 253 254 @Override 255 public List<String> getRepositoryNames() { 256 return esa.getRepositoryNames(); 257 } 258 259 @Override 260 public String getIndexNameForRepository(String repositoryName) { 261 return esa.getIndexNameForRepository(repositoryName); 262 } 263 264 @Override 265 public int getPendingWorkerCount() { 266 WorkManager wm = Framework.getLocalService(WorkManager.class); 267 return wm.getQueueSize(INDEXING_QUEUE_ID, Work.State.SCHEDULED); 268 } 269 270 @Override 271 public int getRunningWorkerCount() { 272 WorkManager wm = Framework.getLocalService(WorkManager.class); 273 return runIndexingWorkerCount.get() + wm.getQueueSize(INDEXING_QUEUE_ID, Work.State.RUNNING); 274 } 275 276 @Override 277 public int getTotalCommandProcessed() { 278 return esa.getTotalCommandProcessed(); 279 } 280 281 @Override 282 public boolean isEmbedded() { 283 return esa.isEmbedded(); 284 } 285 286 @Override 287 public boolean isIndexingInProgress() { 288 return (runIndexingWorkerCount.get() > 0) || (getPendingWorkerCount() > 0) || (getRunningWorkerCount() > 0); 289 } 290 291 @Override 292 public ListenableFuture<Boolean> prepareWaitForIndexing() { 293 return waiterExecutorService.submit(new Callable<Boolean>() { 294 @Override 295 public Boolean call() throws Exception { 296 WorkManager wm = Framework.getLocalService(WorkManager.class); 297 wm.awaitCompletion(INDEXING_QUEUE_ID, 300, TimeUnit.SECONDS); 298 return true; 299 } 300 }); 301 } 302 303 private static class NamedThreadFactory implements ThreadFactory { 304 @SuppressWarnings("NullableProblems") 305 @Override 306 public Thread newThread(Runnable r) { 307 return new Thread(r, "waitForEsIndexing"); 308 } 309 } 310 311 protected void initListenerThreadPool() { 312 waiterExecutorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool(new NamedThreadFactory())); 313 } 314 315 @Override 316 public void refresh() { 317 esa.refresh(); 318 } 319 320 @Override 321 public void refreshRepositoryIndex(String repositoryName) { 322 esa.refreshRepositoryIndex(repositoryName); 323 } 324 325 @Override 326 public void flush() { 327 esa.flush(); 328 } 329 330 @Override 331 public void flushRepositoryIndex(String repositoryName) { 332 esa.flushRepositoryIndex(repositoryName); 333 } 334 335 @Override 336 public void optimize() { 337 esa.optimize(); 338 } 339 340 @Override 341 public void optimizeRepositoryIndex(String repositoryName) { 342 esa.optimizeRepositoryIndex(repositoryName); 343 } 344 345 @Override 346 public void optimizeIndex(String indexName) { 347 esa.optimizeIndex(indexName); 348 } 349 350 // ES Indexing ============================================================= 351 352 @Override 353 public void indexNonRecursive(IndexingCommand cmd) { 354 List<IndexingCommand> cmds = new ArrayList<>(1); 355 cmds.add(cmd); 356 indexNonRecursive(cmds); 357 } 358 359 @Override 360 public void indexNonRecursive(List<IndexingCommand> cmds) { 361 if (!isReady()) { 362 stackCommands(cmds); 363 return; 364 } 365 if (log.isDebugEnabled()) { 366 log.debug("Process indexing commands: " + Arrays.toString(cmds.toArray())); 367 } 368 esi.indexNonRecursive(cmds); 369 } 370 371 protected void stackCommands(List<IndexingCommand> cmds) { 372 if (log.isDebugEnabled()) { 373 log.debug("Delaying indexing commands: Waiting for Index to be initialized." 374 + Arrays.toString(cmds.toArray())); 375 } 376 stackedCommands.addAll(cmds); 377 } 378 379 @Override 380 public void runIndexingWorker(List<IndexingCommand> cmds) { 381 if (!isReady()) { 382 stackCommands(cmds); 383 return; 384 } 385 runIndexingWorkerCount.incrementAndGet(); 386 try { 387 dispatchWork(cmds); 388 } finally { 389 runIndexingWorkerCount.decrementAndGet(); 390 } 391 } 392 393 /** 394 * Dispatch jobs between sync and async worker 395 */ 396 protected void dispatchWork(List<IndexingCommand> cmds) { 397 Map<String, List<IndexingCommand>> syncCommands = new HashMap<>(); 398 Map<String, List<IndexingCommand>> asyncCommands = new HashMap<>(); 399 for (IndexingCommand cmd : cmds) { 400 if (cmd.isSync()) { 401 List<IndexingCommand> syncCmds = syncCommands.get(cmd.getRepositoryName()); 402 if (syncCmds == null) { 403 syncCmds = new ArrayList<>(); 404 } 405 syncCmds.add(cmd); 406 syncCommands.put(cmd.getRepositoryName(), syncCmds); 407 } else { 408 List<IndexingCommand> asyncCmds = asyncCommands.get(cmd.getRepositoryName()); 409 if (asyncCmds == null) { 410 asyncCmds = new ArrayList<>(); 411 } 412 asyncCmds.add(cmd); 413 asyncCommands.put(cmd.getRepositoryName(), asyncCmds); 414 } 415 } 416 runIndexingSyncWorker(syncCommands); 417 scheduleIndexingAsyncWorker(asyncCommands); 418 } 419 420 protected void scheduleIndexingAsyncWorker(Map<String, List<IndexingCommand>> asyncCommands) { 421 if (asyncCommands.isEmpty()) { 422 return; 423 } 424 WorkManager wm = Framework.getLocalService(WorkManager.class); 425 for (String repositoryName : asyncCommands.keySet()) { 426 IndexingWorker idxWork = new IndexingWorker(repositoryName, 427 asyncCommands.get(repositoryName)); 428 // we are in afterCompletion don't wait for a commit 429 wm.schedule(idxWork, false); 430 } 431 } 432 433 protected void runIndexingSyncWorker(Map<String, List<IndexingCommand>> syncCommands) { 434 if (syncCommands.isEmpty()) { 435 return; 436 } 437 Transaction transaction = TransactionHelper.suspendTransaction(); 438 try { 439 for (String repositoryName : syncCommands.keySet()) { 440 IndexingWorker idxWork = new IndexingWorker(repositoryName, 441 syncCommands.get(repositoryName)); 442 idxWork.run(); 443 } 444 } finally { 445 if (transaction != null) { 446 TransactionHelper.resumeTransaction(transaction); 447 } 448 449 } 450 } 451 452 @Override 453 public void runReindexingWorker(String repositoryName, String nxql) { 454 if (nxql == null || nxql.isEmpty()) { 455 throw new IllegalArgumentException("Expecting an NXQL query"); 456 } 457 ScrollingIndexingWorker worker = new ScrollingIndexingWorker(repositoryName, nxql); 458 WorkManager wm = Framework.getLocalService(WorkManager.class); 459 wm.schedule(worker); 460 } 461 462 // ES Search =============================================================== 463 @Override 464 public DocumentModelList query(NxQueryBuilder queryBuilder) { 465 return ess.query(queryBuilder); 466 } 467 468 @Override 469 public EsResult queryAndAggregate(NxQueryBuilder queryBuilder) { 470 return ess.queryAndAggregate(queryBuilder); 471 } 472 473 @Deprecated 474 @Override 475 public DocumentModelList query(CoreSession session, String nxql, int limit, int offset, SortInfo... sortInfos) 476 { 477 NxQueryBuilder query = new NxQueryBuilder(session).nxql(nxql).limit(limit).offset(offset).addSort(sortInfos); 478 return query(query); 479 } 480 481 @Deprecated 482 @Override 483 public DocumentModelList query(CoreSession session, QueryBuilder queryBuilder, int limit, int offset, 484 SortInfo... sortInfos) { 485 NxQueryBuilder query = new NxQueryBuilder(session).esQuery(queryBuilder).limit(limit).offset(offset).addSort( 486 sortInfos); 487 return query(query); 488 } 489 490 // misc ==================================================================== 491 private boolean isReady() { 492 return (esa != null) && esa.isReady(); 493 } 494 495}