Package org.apache.solr.core

Class SolrCore

java.lang.Object
org.apache.solr.core.SolrCore
All Implemented Interfaces:
Closeable, AutoCloseable, SolrInfoBean, SolrMetricProducer
Direct Known Subclasses:
SyntheticSolrCore
public class SolrCore extends Object implements SolrInfoBean, Closeable
SolrCore got its name because it represents the "core" of Solr -- one index and everything needed to make it work. When multi-core support was added to Solr way back in version 1.3, this class was required so that the core functionality could be re-used multiple times.

  • Field Details

    • version

      public static final String version
      See Also:

    • uniqueId

      public final UUID uniqueId
      A unique id to differentiate multiple instances of the same core If we reload a core, the name remains same , but the id will be new

    • searchEnabled

      public volatile boolean searchEnabled

    • indexEnabled

      public volatile boolean indexEnabled

    • readOnly

      public volatile boolean readOnly

    • coreProvider

      public final SolrCore.Provider coreProvider

    • VERBOSE

      public static boolean VERBOSE
      NOTE: This API is for internal purposes only and might change in incompatible ways in the next release.
      Debugging aid only. No non-test code should be released with uncommented verbose() calls.

    • DEFAULT_RESPONSE_WRITERS

      public static final Map<String,QueryResponseWriter> DEFAULT_RESPONSE_WRITERS

  • Constructor Details

  • Method Details

    • getStartTimeStamp

      public Date getStartTimeStamp()

    • getStartNanoTime

      public long getStartNanoTime()

    • getUptimeMs

      public long getUptimeMs()

    • getRestManager

      public RestManager getRestManager()

    • getPackageListeners

      public PackageListeners getPackageListeners()

    • getResourceLoader

      public SolrResourceLoader getResourceLoader()
      The SolrResourceLoader used to load all resources for this core.
      Since:
      solr 1.3

    • getResourceLoader

      public SolrResourceLoader getResourceLoader(String pkg)
      Gets the SolrResourceLoader for a given package
      Parameters:
      pkg - The package name

    • getConfigResource

      public String getConfigResource()
      Gets the configuration resource name used by this core instance.
      Since:
      solr 1.3

    • getSolrConfig

      public SolrConfig getSolrConfig()
      Gets the configuration object used by this core instance.

    • getSchemaResource

      public String getSchemaResource()
      Gets the schema resource name used by this core instance.
      Since:
      solr 1.3

    • getLatestSchema

      public IndexSchema getLatestSchema()
      Returns:
      the latest snapshot of the schema used by this core instance.
      See Also:

    • getInstancePath

      public Path getInstancePath()
      The core's instance directory (absolute).

    • setLatestSchema

      public void setLatestSchema(IndexSchema replacementSchema)
      Sets the latest schema snapshot to be used by this core instance. If the specified replacementSchema uses a SimilarityFactory which is SolrCoreAware then this method will SolrCoreAware.inform(org.apache.solr.core.SolrCore) that factory about this SolrCore prior to using the replacementSchema
      See Also:

    • getConfigSetProperties

      public org.apache.solr.common.util.NamedList<?> getConfigSetProperties()

    • getDataDir

      public String getDataDir()

    • getIndexDir

      public String getIndexDir()

    • getNewIndexDir

      public String getNewIndexDir()
      Returns the indexdir as given in index.properties. If index.properties exists in dataDir and there is a property index available, and it points to a valid directory in dataDir that is returned. Else dataDir/index is returned. Only called for creating new indexSearchers and indexwriters. Use the getIndexDir() method to know the active index directory
      Returns:
      the indexdir as given in index.properties
      Throws:
      org.apache.solr.common.SolrException - if for any reason an index directory cannot be determined.

    • getDirectoryFactory

      public DirectoryFactory getDirectoryFactory()

    • getIndexReaderFactory

      public IndexReaderFactory getIndexReaderFactory()

    • getIndexSize

      public long getIndexSize()
      The index size in bytes, of the index that the current searcher is pointed to.

    • getSegmentCount

      public int getSegmentCount()

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • getName

      public String getName()
      Description copied from interface: SolrInfoBean
      Simple common usage name, e.g. BasicQueryHandler, or fully qualified class name.
      Specified by:
      getName in interface SolrInfoBean

    • setName

      public void setName(String v)
      Called to rename a core. Not called to initialize the name.

    • getCoreAttributes

      public io.opentelemetry.api.common.Attributes getCoreAttributes()

    • getCoreMetricManager

      public SolrCoreMetricManager getCoreMetricManager()
      Returns the SolrCoreMetricManager for this core.
      Returns:
      the SolrCoreMetricManager for this core

    • getInfoRegistry

      public Map<String,SolrInfoBean> getInfoRegistry()
      Returns a Map of name vs SolrInfoBean objects. The returned map is an instance of a ConcurrentHashMap and therefore no synchronization is needed for putting, removing or iterating over it.
      Returns:
      the Info Registry map which contains SolrInfoBean objects keyed by name
      Since:
      solr 1.3

    • deleteNamedSnapshot

      public void deleteNamedSnapshot(String commitName) throws IOException
      This method deletes the snapshot with the specified name. If the directory storing the snapshot is not the same as the *current* core index directory, then delete the files corresponding to this snapshot. Otherwise we leave the index files related to snapshot as is (assuming the underlying Solr IndexDeletionPolicy will clean them up appropriately).
      Parameters:
      commitName - The name of the snapshot to be deleted.
      Throws:
      IOException - in case of I/O error.

    • deleteNonSnapshotIndexFiles

      public void deleteNonSnapshotIndexFiles(String indexDirPath) throws IOException
      This method deletes the index files not associated with any named snapshot only if the specified indexDirPath is not the *current* index directory.
      Parameters:
      indexDirPath - The path of the directory
      Throws:
      IOException - In case of I/O error.

    • createEventListener

      public SolrEventListener createEventListener(PluginInfo info)

    • registerFirstSearcherListener

      public void registerFirstSearcherListener(SolrEventListener listener)
      NOTE: this function is not thread safe. However, it is safe to call within the inform( SolrCore core ) function for SolrCoreAware classes. Outside inform, this could potentially throw a ConcurrentModificationException
      See Also:

    • registerNewSearcherListener

      public void registerNewSearcherListener(SolrEventListener listener)
      NOTE: this function is not thread safe. However, it is safe to call within the inform( SolrCore core ) function for SolrCoreAware classes. Outside inform, this could potentially throw a ConcurrentModificationException
      See Also:

    • registerResponseWriter

      public QueryResponseWriter registerResponseWriter(String name, QueryResponseWriter responseWriter)
      NOTE: this function is not thread safe. However, it is safe to call within the inform( SolrCore core ) function for SolrCoreAware classes. Outside inform, this could potentially throw a ConcurrentModificationException
      See Also:

    • reload

      public SolrCore reload(ConfigSet coreConfig) throws IOException
      Throws:
      IOException

    • cloneForReloadCore

      protected SolrCore cloneForReloadCore(CoreDescriptor newCoreDescriptor, ConfigSet newCoreConfig, boolean cloneCoreState)
      Clones the current core for core reload, with the provided CoreDescriptor and ConfigSet.
      Returns:
      the cloned core to be used for reload(org.apache.solr.core.ConfigSet)

    • createInstance

      public static <T> T createInstance(String className, Class<T> cast, String msg, SolrCore core, org.apache.lucene.util.ResourceLoader resourceLoader)
      Creates an instance by trying a constructor that accepts a SolrCore before trying the default (no arg) constructor.
      Parameters:
      className - the instance class to create
      cast - the class or interface that the instance should extend or implement
      msg - a message helping compose the exception error if any occurs.
      core - The SolrCore instance for which this object needs to be loaded
      Returns:
      the desired instance
      Throws:
      org.apache.solr.common.SolrException - if the object could not be instantiated

    • createInitInstance

      public <T> T createInitInstance(PluginInfo info, Class<T> cast, String msg, String defClassName)

    • initPlugin

      public static <T> T initPlugin(PluginInfo info, T o)

    • getCoreContainer

      public CoreContainer getCoreContainer()

    • bufferUpdatesIfConstructing

      protected void bufferUpdatesIfConstructing(CoreDescriptor coreDescriptor)
      Set UpdateLog to buffer updates if the slice is in construction.

    • initializeMetrics

      public void initializeMetrics(SolrMetricsContext parentContext, io.opentelemetry.api.common.Attributes attributes)
      Description copied from interface: SolrMetricProducer
      Implementation should initialize all metrics to a SolrMetricsContext Registry/MeterProvider with Attributes as the common set of attributes that will be attached to every metric that is initialized for that class/component
      Specified by:
      initializeMetrics in interface SolrMetricProducer
      Parameters:
      parentContext - The registry that the component will initialize metrics to
      attributes - Base set of attributes that will be bound to all metrics for that component

    • getMetricTag

      public String getMetricTag()

    • getSolrMetricsContext

      public SolrMetricsContext getSolrMetricsContext()
      Description copied from interface: SolrMetricProducer
      Implementations should return the context used in SolrMetricProducer.initializeMetrics(SolrMetricsContext, Attributes) to ensure proper cleanup of metrics at the end of the life-cycle of this component. This should be the child context if one was created, or null if the parent context was used.
      Specified by:
      getSolrMetricsContext in interface SolrMetricProducer

    • modifyIndexProps

      public boolean modifyIndexProps(String tmpIdxDirName)

    • closeAndWait

      public void closeAndWait()
      Close the core, if it is still in use waits until is no longer in use.
      See Also:

    • createStatsCache

      public StatsCache createStatsCache()
      Create an instance of StatsCache using configured parameters.

    • getSolrCoreState

      public SolrCoreState getSolrCoreState()

    • getUpdateProcessingChain

      public UpdateRequestProcessorChain getUpdateProcessingChain(String name)
      Returns:
      an update processor registered to the given name. Throw an exception if this chain is undefined

    • getUpdateProcessorChain

      public UpdateRequestProcessorChain getUpdateProcessorChain(org.apache.solr.common.params.SolrParams params)

    • getUpdateProcessors

      public PluginBag<UpdateRequestProcessorFactory> getUpdateProcessors()

    • getCircuitBreakerRegistry

      public CircuitBreakerRegistry getCircuitBreakerRegistry()

    • open

      public void open()
      expert: increments the core reference count

    • close

      public void close()
      Close all resources allocated by the core if it is no longer in use...
      • searcher
      • updateHandler
      • all CloseHooks will be notified
      • All MBeans will be unregistered from MBeanServer if JMX was enabled

      The behavior of this method is determined by the result of decrementing the core's reference count (A core is created with a reference count of 1)...

      • If reference count is > 0, the usage count is decreased by 1 and no resources are released.
      • If reference count is == 0, the resources are released.
      • If reference count is < 0, and error is logged and no further action is taken.
      Specified by:
      close in interface AutoCloseable
      Specified by:
      close in interface Closeable
      Specified by:
      close in interface SolrMetricProducer
      See Also:

    • getOpenCount

      public int getOpenCount()
      Current core usage count.

    • isClosed

      public boolean isClosed()
      Whether this core is closed.

    • isReady

      public boolean isReady()
      Returns true if the core is ready for use. It is not initializing or closing/closed.

    • addCloseHook

      public void addCloseHook(CloseHook hook)
      Add a close callback hook

    • removeCloseHook

      public void removeCloseHook(CloseHook hook)
      Remove a close callback hook

    • getCloseHooks

      public Collection<CloseHook> getCloseHooks()

    • verbose

      public static void verbose(Object... args)

    • getRequestHandler

      public SolrRequestHandler getRequestHandler(String handlerName)
      Get the request handler registered to a given name.

      This function is thread safe.

    • getRequestHandlers

      public PluginBag<SolrRequestHandler> getRequestHandlers()
      Returns an unmodifiable Map containing the registered handlers

    • getJerseyApplicationHandler

      public org.glassfish.jersey.server.ApplicationHandler getJerseyApplicationHandler()

    • registerRequestHandler

      public SolrRequestHandler registerRequestHandler(String handlerName, SolrRequestHandler handler)
      Registers a handler at the specified location. If one exists there, it will be replaced. To remove a handler, register null at its path

      Once registered the handler can be accessed through: 

         http://${host}:${port}/${context}/${handlerName}
 or:
   http://${host}:${port}/${context}/select?qt=${handlerName}

      Handlers must be initialized before getting registered. Registered handlers can immediately accept requests.

      This call is thread safe.

      Returns:
      the previous SolrRequestHandler registered to this name null if none.

    • getSearchComponent

      public SearchComponent getSearchComponent(String name)
      Returns:
      a Search Component registered to a given name. Throw an exception if the component is undefined

    • getSearchComponents

      public PluginBag<SearchComponent> getSearchComponents()
      Accessor for all the Search Components
      Returns:
      An unmodifiable Map of Search Components

    • getUpdateHandler

      public UpdateHandler getUpdateHandler()
      RequestHandlers need access to the updateHandler so they can all talk to the same RAM indexer.

    • getSearcher

      public RefCounted<SolrIndexSearcher> getSearcher()
      Return a registered RefCounted<SolrIndexSearcher> with the reference count incremented. It must be decremented when no longer needed. This method should not be called from SolrCoreAware.inform() since it can result in a deadlock if useColdSearcher==false. If handling a normal request, the searcher should be obtained from SolrQueryRequest.getSearcher() instead. If you still think you need to call this, consider withSearcher(IOFunction) instead which is easier to use.
      See Also:

    • withSearcher

      public <R> R withSearcher(IOFunction<SolrIndexSearcher,R> lambda) throws IOException
      Executes the lambda with the SolrIndexSearcher. This is more convenient than using getSearcher() since there is no ref-counting business to worry about. Example: 
         IndexReader reader = h.getCore().withSearcher(SolrIndexSearcher::getIndexReader);
      Warning: although a lambda is concise, it may be inappropriate to simply return the IndexReader because it might be closed soon after this method returns; it really depends.
      Throws:
      IOException

    • getIndexFingerprint

      public IndexFingerprint getIndexFingerprint(SolrIndexSearcher searcher, org.apache.lucene.index.LeafReaderContext ctx, long maxVersion) throws IOException
      Computes fingerprint of a segment and caches it only if all the version in segment are included in the fingerprint. We can't use computeIfAbsent as caching is conditional (as described above) There is chance that two threads may compute fingerprint on the same segment. It might be OK to do so rather than locking entire map.
      Parameters:
      searcher - searcher that includes specified LeaderReaderContext
      ctx - LeafReaderContext of a segment to compute fingerprint of
      maxVersion - maximum version number to consider for fingerprint computation
      Returns:
      IndexFingerprint of the segment
      Throws:
      IOException - Can throw IOException

    • getRegisteredSearcher

      public RefCounted<SolrIndexSearcher> getRegisteredSearcher()
      Returns the current registered searcher with its reference count incremented, or null if none are registered.

    • getNewestSearcher

      public RefCounted<SolrIndexSearcher> getNewestSearcher(boolean openNew)
      Return the newest normal RefCounted<SolrIndexSearcher> with the reference count incremented. It must be decremented when no longer needed. If no searcher is currently open, then if openNew==true a new searcher will be opened, or null is returned if openNew==false.

    • getRealtimeSearcher

      public RefCounted<SolrIndexSearcher> getRealtimeSearcher()
      Gets the latest real-time searcher w/o forcing open a new searcher if one already exists. The reference count will be incremented.

    • getSearcher

      public RefCounted<SolrIndexSearcher> getSearcher(boolean forceNew, boolean returnSearcher, Future<?>[] waitSearcher)

    • openNewSearcher

      public RefCounted<SolrIndexSearcher> openNewSearcher(boolean updateHandlerReopens, boolean realtime)
      Opens a new searcher and returns a RefCounted<SolrIndexSearcher> with its reference incremented.

      "realtime" means that we need to open quickly for a realtime view of the index, hence don't do any autowarming and add to the _realtimeSearchers queue rather than the _searchers queue (so it won't be used for autowarming by a future normal searcher). A "realtime" searcher will currently never become "registered" (since it currently lacks caching).

      realtimeSearcher is updated to the latest opened searcher, regardless of the value of "realtime".

      This method acquires openSearcherLock - do not call with searchLock held!

    • getSearcher

      public RefCounted<SolrIndexSearcher> getSearcher(boolean forceNew, boolean returnSearcher, Future<?>[] waitSearcher, boolean updateHandlerReopens)
      Get a SolrIndexSearcher or start the process of creating a new one.

      The registered searcher is the default searcher used to service queries. A searcher will normally be registered after all of the warming and event handlers (newSearcher or firstSearcher events) have run. In the case where there is no registered searcher, the newly created searcher will be registered before running the event handlers (a slow searcher is better than no searcher).

      These searchers contain read-only IndexReaders. To access a non read-only IndexReader, see newSearcher(String name, boolean readOnly).

      If forceNew==true then A new searcher will be opened and registered regardless of whether there is already a registered searcher or other searchers in the process of being created.

      If forceNew==false then:

      • If a searcher is already registered, that searcher will be returned
      • If no searcher is currently registered, but at least one is in the process of being created, then this call will block until the first searcher is registered
      • If no searcher is currently registered, and no searchers in the process of being registered, a new searcher will be created.

      If returnSearcher==true then a RefCounted<SolrIndexSearcher> will be returned with the reference count incremented. It must be decremented when no longer needed.

      If waitSearcher!=null and a new SolrIndexSearcher was created, then it is filled in with a Future that will return after the searcher is registered. The Future may be set to null in which case the SolrIndexSearcher created has already been registered at the time this method returned.

      Parameters:
      forceNew - if true, force the open of a new index searcher regardless if there is already one open.
      returnSearcher - if true, returns a SolrIndexSearcher holder with the refcount already incremented.
      waitSearcher - if non-null, will be filled in with a Future that will return after the new searcher is registered.
      updateHandlerReopens - if true, the UpdateHandler will be used when reopening a SolrIndexSearcher.

    • isReloaded

      public boolean isReloaded()

    • closeSearcher

      public void closeSearcher()

    • execute

      public void execute(SolrRequestHandler handler, SolrQueryRequest req, SolrQueryResponse rsp)

    • preDecorateResponse

      public static void preDecorateResponse(SolrQueryRequest req, SolrQueryResponse rsp)

    • postDecorateResponse

      public static void postDecorateResponse(SolrRequestHandler handler, SolrQueryRequest req, SolrQueryResponse rsp)
      Put status, QTime, and possibly request handler and params, in the response header

    • getResponseWriters

      public PluginBag<QueryResponseWriter> getResponseWriters()

    • fetchLatestSchema

      public void fetchLatestSchema()

    • getQueryResponseWriter

      public final QueryResponseWriter getQueryResponseWriter(String writerName)
      Finds a writer by name, or returns the default writer if not found.

    • getQueryResponseWriter

      public final QueryResponseWriter getQueryResponseWriter(SolrQueryRequest request)
      Returns the appropriate writer for a request. If the request specifies a writer via the 'wt' parameter, attempts to find that one; otherwise return the default writer.

    • getQueryPlugin

      public QParserPlugin getQueryPlugin(String parserName)

    • getTransformerFactory

      public TransformerFactory getTransformerFactory(String name)

    • addTransformerFactory

      public void addTransformerFactory(String name, TransformerFactory factory)

    • initPlugins

      public <T> T initPlugins(List<PluginInfo> pluginInfos, Map<String,T> registry, Class<T> type, String defClassName)

    • initDefaultPlugin

      public void initDefaultPlugin(Object plugin, Class<?> type)

    • initPlugins

      public <T> List<T> initPlugins(List<PluginInfo> pluginInfos, Class<T> type, String defClassName)
      For a given List of PluginInfo return the instances as a List
      Parameters:
      defClassName - The default classname if PluginInfo#className == null
      Returns:
      The instances initialized

    • initPlugins

      public <T> T initPlugins(Map<String,T> registry, Class<T> type)
      Parameters:
      registry - The map to which the instance should be added to. The key is the name attribute
      type - The type of the Plugin. These should be standard ones registered by type.getName() in SolrConfig
      Returns:
      The default if any

    • getValueSourceParser

      public ValueSourceParser getValueSourceParser(String parserName)

    • initRestManager

      protected RestManager initRestManager() throws org.apache.solr.common.SolrException
      Creates and initializes a RestManager based on configuration args in solrconfig.xml. RestManager provides basic storage support for managed resource data, such as to persist stopwords to ZooKeeper if running in SolrCloud mode.
      Throws:
      org.apache.solr.common.SolrException

    • getCoreDescriptor

      public CoreDescriptor getCoreDescriptor()

    • getDeletionPolicy

      public IndexDeletionPolicyWrapper getDeletionPolicy()

    • getSnapshotMetaDataManager

      public SolrSnapshotMetaDataManager getSnapshotMetaDataManager()
      Returns:
      A reference of SolrSnapshotMetaDataManager managing the persistent snapshots for this Solr core.

    • getRuleExpiryLock

      public ReentrantLock getRuleExpiryLock()

    • getDescription

      public String getDescription()
      Description copied from interface: SolrInfoBean
      Simple one or two line description
      Specified by:
      getDescription in interface SolrInfoBean

    • getCategory

      public SolrInfoBean.Category getCategory()
      Description copied from interface: SolrInfoBean
      Category of this component
      Specified by:
      getCategory in interface SolrInfoBean

    • getCodec

      public org.apache.lucene.codecs.Codec getCodec()

    • unloadOnClose

      public void unloadOnClose(CoreDescriptor desc, boolean deleteIndexDir, boolean deleteDataDir, boolean deleteInstanceDir)

    • deleteUnloadedCore

      public static void deleteUnloadedCore(CoreDescriptor cd, boolean deleteDataDir, boolean deleteInstanceDir)

    • addConfListener

      public void addConfListener(Runnable runnable)
      Register to notify for any file change in the conf directory. If the file change results in a core reload , then the listener is not fired

    • removeConfListener

      public boolean removeConfListener(Runnable runnable)
      Remove a listener

    • getConfListener

      public static Runnable getConfListener(SolrCore core, ZkSolrResourceLoader zkSolrResourceLoader)

    • registerInfoBean

      public void registerInfoBean(String name, SolrInfoBean solrInfoBean)

    • cleanupOldIndexDirectories

      public void cleanupOldIndexDirectories(boolean reload)

    • getImplicitHandlers

      public List<PluginInfo> getImplicitHandlers()

    • getCancellableQueryTracker

      public CancellableQueryTracker getCancellableQueryTracker()

    • runAsync

      public void runAsync(Runnable r)
      Run an arbitrary task in its own thread. This is an expert option and is a method you should use with great care. It would be bad to run something that never stopped or run something that took a very long time. Typically, this is intended for actions that take a few seconds, and therefore would be bad to wait for within a request, but would not pose a significant hindrance to server shut down times. It is not intended for long-running tasks and if you are using a Runnable with a loop in it, you are almost certainly doing it wrong.

      WARNING: Solr wil not be able to shut down gracefully until this task completes!

      A significant upside of using this method vs creating your own ExecutorService is that your code does not have to properly shutdown executors which typically is risky from a unit testing perspective since the test framework will complain if you don't carefully ensure the executor shuts down before the end of the test. Also, the threads running this task are sure to have a proper MDC for logging.

      Parameters:
      r - the task to run