Class SolrCore

  • All Implemented Interfaces:
    Closeable, AutoCloseable, SolrInfoBean, SolrMetricProducer

    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 Detail

      • 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
      • 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.
    • Method Detail

      • getStartTimeStamp

        public Date getStartTimeStamp()
      • getStartNanoTime

        public long getStartNanoTime()
      • getUptimeMs

        public long getUptimeMs()
      • getResourceLoader

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

        public SolrResourceLoader getResourceLoader​(String pkg)
        Gets the SolrResourceLoader for a given package
        pkg - The package name
      • getConfigResource

        public String getConfigResource()
        Gets the configuration resource name used by this core instance.
        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.
        solr 1.3
      • getInstancePath

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

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

        public String getDataDir()
      • getUlogDir

        public String getUlogDir()
      • getIndexDir

        public String getIndexDir()
      • getNewIndexDir

        public String getNewIndexDir()
        Returns the indexdir as given in If 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
        the indexdir as given in
        org.apache.solr.common.SolrException - if for any reason an index directory cannot be determined.
      • getIndexSize

        public long getIndexSize()
      • getSegmentCount

        public int getSegmentCount()
      • 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.
      • 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.
        the Info Registry map which contains SolrInfoBean objects keyed by name
        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).
        commitName - The name of the snapshot to be deleted.
        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.
        indexDirPath - The path of the directory
        IOException - In case of I/O error.
      • 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:
      • 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.
        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
        the desired instance
        org.apache.solr.common.SolrException - if the object could not be instantiated
      • initPlugin

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

        public void seedVersionBuckets()
      • getMetricTag

        public String getMetricTag()
      • 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:
        close(), isClosed()
      • createStatsCache

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

        public UpdateRequestProcessorChain getUpdateProcessingChain​(String name)
        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)
      • 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
      • 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:


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

        This call is thread safe.

        the previous SolrRequestHandler registered to this name null if none.
      • getSearchComponent

        public SearchComponent getSearchComponent​(String name)
        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
        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.
      • 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.
      • 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.
        searcher - searcher that includes specified LeaderReaderContext
        ctx - LeafReaderContext of a segment to compute fingerprint of
        maxVersion - maximum version number to consider for fingerprint computation
        IndexFingerprint of the segment
        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.
      • 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<Void>[] 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.

        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()
      • 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.
      • 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
        defClassName - The default classname if PluginInfo#className == null
        The instances initialized
      • initPlugins

        public <T> T initPlugins​(Map<String,​T> registry,
                                 Class<T> type)
        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
        The default if any
      • 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.
      • 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
      • registerInfoBean

        public void registerInfoBean​(String name,
                                     SolrInfoBean solrInfoBean)
      • cleanupOldIndexDirectories

        public void cleanupOldIndexDirectories​(boolean reload)
      • loadDecodeAndCacheBlob

        public <T> BlobRepository.BlobContentRef<T> loadDecodeAndCacheBlob​(String key,
                                                                           BlobRepository.Decoder<T> decoder)
        Convenience method to load a blob. This method minimizes the degree to which component and other code needs to depend on the structure of solr's object graph and ensures that a proper close hook is registered. This method should normally be called in SolrCoreAware.inform(SolrCore), and should never be called during request processing. The Decoder will only run on the first invocations, subsequent invocations will return the cached object.
        key - A key in the format of name/version for a blob stored in the CollectionAdminParams.SYSTEM_COLL blob store via the Blob Store API
        decoder - a decoder with which to convert the blob into a Java Object representation (first time only)
        a reference to the blob that has already cached the decoded version.
      • 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.

        r - the task to run