public SolandraCoreContainer(String solrConfigFile) throws ParserConfigurationException, IOException, SAXException { this.solrConfigFile = solrConfigFile; SolrConfig solrConfig = new SolrConfig(solrConfigFile); CoreDescriptor dcore = new CoreDescriptor(null, "", "."); singleCore = new SolrCore("", "/tmp", solrConfig, null, dcore); }
SolrParams params = req.getParams(); String name = params.get(CoreAdminParams.NAME); CoreDescriptor dcore = new CoreDescriptor(coreContainer, name, params.get(CoreAdminParams.INSTANCE_DIR)); String opts = params.get(CoreAdminParams.CONFIG); if (opts != null) dcore.setConfigName(opts); opts = params.get(CoreAdminParams.SCHEMA); if (opts != null) dcore.setSchemaName(opts); opts = params.get(CoreAdminParams.DATA_DIR); if (opts != null) dcore.setDataDir(opts); dcore.setCoreProperties(null); SolrCore core = coreContainer.create(dcore); coreContainer.register(name, core, false); rsp.add("core", core.getName()); return coreContainer.isPersistent(); } catch (Exception ex) { throw new SolrException(SolrException.ErrorCode.BAD_REQUEST, "Error executing default implementation of CREATE", ex);
@Override public CoreContainer initialize() { CoreContainer container = new CoreContainer(new SolrResourceLoader(SolrResourceLoader.locateSolrHome())); CoreDescriptor dcore = new CoreDescriptor(container, coreName, solrConfig.getResourceLoader().getInstanceDir()); dcore.setConfigName(solrConfig.getResourceName()); dcore.setSchemaName(indexSchema.getResourceName()); SolrCore core = new SolrCore( null, dataDirectory, solrConfig, indexSchema, dcore); container.register(coreName, core, false); return container; } }
CoreContainer coreContainer = new CoreContainer(loader); coreContainer.load(); CoreDescriptor coreDescriptor = new CoreDescriptor(coreContainer, coreId, solrCoreFolder.getAbsolutePath()); SolrCore core = coreContainer.create(coreDescriptor); coreContainer.register(coreId, core, true);
/** * Get a reference to the searcher for the required collection. If the collection is * not the same as the search collection, we assume it is under the same Solr instance. * @param rb the response builder holding the facets. * @return a counted reference to the searcher. * @throws SolrException if the collection cannot be found. */ private RefCounted<SolrIndexSearcher> getSearcherReference(ResponseBuilder rb) throws SolrException { RefCounted<SolrIndexSearcher> searcherRef; SolrCore currentCore = rb.req.getCore(); if (StringUtils.isBlank(collection)) { searcherRef = currentCore.getSearcher(); } else { // Using an alternative core - find it SolrCore reqCore = currentCore.getCoreDescriptor().getCoreContainer().getCore(collection); if (reqCore == null) { throw new SolrException(ErrorCode.BAD_REQUEST, "Collection \"" + collection + "\" cannot be found"); } searcherRef = reqCore.getSearcher(); } return searcherRef; }
long eventTime = req.getStartTime(); String paramString = req.getParamString(); String impersonator = getImpersonatorName(req); HttpServletRequest sreq = (HttpServletRequest) req.getContext().get("httpRequest"); if (sreq != null) { try { auditLogger.log(userName.getName(), impersonator, ipAddress, operation, paramString, eventTime, AuditLogger.UNAUTHORIZED, ""); throw new SolrException(SolrException.ErrorCode.UNAUTHORIZED, msg); } else { // just warn log.warn(msg); collectionName = solrCore.getCoreDescriptor().getCloudDescriptor().getCollectionName(); auditLogger.log(userName.getName(), impersonator, ipAddress, operation, paramString, eventTime, AuditLogger.UNAUTHORIZED, collectionName); throw new SolrException(SolrException.ErrorCode.UNAUTHORIZED, ex);
throw new SolrException( SolrException.ErrorCode.SERVER_ERROR, "can not find logging file: "+loggingConfig ); CoreContainer cores = new CoreContainer(new SolrResourceLoader(instanceDir)); SolrConfig solrConfig = new SolrConfig(instanceDir, SolrConfig.DEFAULT_CONF_FILE, null); CoreDescriptor dcore = new CoreDescriptor(cores, "", solrConfig.getResourceLoader().getInstanceDir()); IndexSchema indexSchema = new IndexSchema(solrConfig, instanceDir+"/conf/schema.xml", null); core = new SolrCore( null, dataDir, solrConfig, indexSchema, dcore); cores.register("", core, false); parser = new SolrRequestParsers( solrConfig );
cores = new CoreContainer(); cores.load(solrHome, fconf); abortOnConfigurationError = false; for (SolrCore c : cores.getCores()) { if (c.getSolrConfig().getBool("abortOnConfigurationError", false)) { abortOnConfigurationError = true; break; cores = new CoreContainer(solrHome); CoreDescriptor dcore = new CoreDescriptor(cores, "", "."); dcore.setCoreProperties(null); SolrResourceLoader resourceLoader = new SolrResourceLoader(solrHome, null, getCoreProps(solrHome, null,dcore.getCoreProperties())); cores.loader = resourceLoader; SolrConfig cfg = solrConfigFilename == null ? new SolrConfig(resourceLoader, solrConfigFilename,null); IndexSchema schema = indexSchemaFilename != null ? new IndexSchema(cfg, indexSchemaFilename, null) : null; SolrCore singlecore = new SolrCore(null, null, cfg, schema, dcore); abortOnConfigurationError = cfg.getBool( "abortOnConfigurationError", abortOnConfigurationError);
"Constructed instance information solr.home %s (%s), instance dir %s, conf dir %s, writing index to temporary directory %s, with permdir %s", solrHome, solrHome.toUri(), loader.getInstanceDir(), loader.getConfigDir(), dataDir, perm)); CoreContainer container = new CoreContainer(loader); CoreDescriptor descr = new CoreDescriptor(container, "core1", solrHome.toString()); descr.setDataDir(dataDir); descr.setCoreProperties(props); core = container.create(descr); container.register(core, false); solr = new EmbeddedSolrServer(container, "core1"); batchWriter = new BatchWriter(solr, batchSize, context.getTaskAttemptID().getTaskID(), threadCount, queueSize);
SolrConfig config; try { config = new SolrConfig(loader, dcore.getConfigName(), null); } catch (Exception e) { log.error("Failed to load file {}", new File(instanceDir, dcore.getConfigName()).getAbsolutePath()); throw new SolrException(ErrorCode.SERVER_ERROR, "Could not load config for " + dcore.getConfigName(), e); final String resourceNameToBeUsed = IndexSchemaFactory.getResourceNameToBeUsed(dcore.getSchemaName(), config); File schemaFile = new File(resourceNameToBeUsed); if (!schemaFile.isAbsolute()) { schema = indexSchemaCache.get(key); if (schema == null) { log.info("creating new schema object for core: " + dcore.getProperty(CoreDescriptor.CORE_NAME)); schema = IndexSchemaFactory.buildIndexSchema(dcore.getSchemaName(), config); indexSchemaCache.put(key, schema); } else { log.info("re-using schema object for core: " + dcore.getProperty(CoreDescriptor.CORE_NAME)); schema = IndexSchemaFactory.buildIndexSchema(dcore.getSchemaName(), config); SolrCore core = new SolrCore(dcore.getName(), null, config, schema, dcore); if (core.getUpdateHandler().getUpdateLog() != null) { core.getUpdateHandler().getUpdateLog().recoverFromLog();
System.setProperty("solr.autoSoftCommit.maxTime", "-1"); CoreContainer container = new CoreContainer(loader); container.load(); CoreDescriptor descr = new CoreDescriptor(container, "core1", solrHomeDir.toString()); descr.setDataDir(dataDirStr); descr.setCoreProperties(props); SolrCore core = container.create(descr); if (!(core.getDirectoryFactory() instanceof HdfsDirectoryFactory)) { throw new UnsupportedOperationException( "Invalid configuration. Currently, the only DirectoryFactory supported is "
/** * registers a {@link SolrCore} to the {@link #server} managed by this * instance. Will replace an already existing {@link SolrCore} with the * same name * @param coreName the name of the {@link SolrCore} to register * @param coreDir the directory for the Core. If <code>null</code> is parsed * {@link #managedSolrDir}/coreName is used as default. */ private void registerCore(String coreName, File coreDir) { if(coreName == null){ coreName = server.getDefaultCoreName(); } if(coreDir == null){ //use the coreName as default coreDir = new File(managedSolrDir,coreName); } if(!coreDir.isDirectory()){ throw new IllegalArgumentException("The Core Directory '"+ coreDir+" for the Core '"+coreName+"' does not exist or is not an directory"); } SolrCore core; CoreDescriptor coreDescriptor = new CoreDescriptor(server, coreName, coreDir.getAbsolutePath()); core = server.create(coreDescriptor); //this will also replace an existing core with the same name server.register(coreName, core, false); server.persist(); //store the new/updated SolrCore in the solr.xml } private IndexMetadata updateCore(IndexMetadata metadata, ArchiveInputStream ais){
Exception exc = null; try { CoreDescriptor coreDescriptor = solrCore.getCoreDescriptor(); CoreContainer coreContainer = coreDescriptor.getCoreContainer(); CloudDescriptor cloud = coreDescriptor.getCloudDescriptor(); role = (cloud.isLeader() ? "Leader" : "Replica"); ZkController zkController = coreContainer.getZkController(); if (zkController != null) { nodeName = zkController.getNodeName(); if (zkController.isConnected()) { ClusterState clusterState = zkController.getClusterState(); Slice slice = clusterState.getSlice(collectionName, shardName); replicaState = (slice != null) ? slice.getState() : "gone"; } else { role, nodeName, shardName, collectionName, replicaState); if (exc != null) { throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, errMsg, exc); } else { throw new SolrException(SolrException.ErrorCode.SERVER_ERROR, errMsg);
@Override public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception { SolrParams params = req.getParams(); CoreAdminAction action = CoreAdminAction.STATUS; String a = params.get(CoreAdminParams.ACTION); if (a != null) { action = CoreAdminAction.get(a); case REQUESTRECOVERY: case REQUESTSYNCSHARD: { String cname = params.get(CoreAdminParams.CORE,""); collection = getCollectionFromCoreName(cname); break; CoreDescriptor coreDescriptor = buildCoreDescriptor(params, coreContainer); if (coreDescriptor != null) { collection = coreDescriptor.getCloudDescriptor().getCollectionName(); String cname = params.get(CoreAdminParams.NAME, ""); collection = getCollectionFromCoreName(cname); break;
server = StandaloneEmbeddedSolrServerProvider.getInstance().getSolrServer( solrServerRef,solrServerRef.getIndex()); this.core = server.getCoreContainer().getCore(solrServerRef.getIndex()); } else { if(server != null){ log.info(" ... initialised SolrCore with default configuration"); this.core = server.getCoreContainer().getCore(solrServerRef.getIndex()); } else if(solrServerRef.isPath() && new File(solrServerRef.getIndex()).isAbsolute()){ CoreDescriptor cd = new CoreDescriptor(cc, "dummy", solrServerRef.getIndex()); this.core = cc.create(cd); cc.register(core, false); server = new EmbeddedSolrServer(cc, "dummy");
@Override public SolrCore create(CoreDescriptor dcore) { if (isShutDown()) { throw new SolrException(ErrorCode.SERVICE_UNAVAILABLE, "Solr has shutdown."); } log.info(" .... createCore {}:{}",serverProperties.getServerName(),dcore.getName()); File idir = new File(dcore.getInstanceDir()); String instanceDir = idir.getPath(); SolrCore created; if (getZkController() != null) { created = createFromZk(instanceDir, dcore); } else { created = createFromLocal(dcore, instanceDir); } //TODO: solrCores is private ... //solrCores.addCreated(created); // For persisting newly-created cores. return created; }
@Override public File getSolrIndexDirectory(String name) { if(name == null || name.isEmpty()){ throw new IllegalArgumentException("The parsed index name MUST NOT be NULL nor empty!"); } SolrCore core = server.getCore(name); if(core != null){ File instanceDir = new File(core.getCoreDescriptor().getInstanceDir()); core.close(); return instanceDir; } else { return null; } }
this.core = server.getCore(name); //increases the reference count } else { this.core = parsedCore; parsedCore.open(); //increase the reference count!! props.put(PROPERTY_CORE_DIR, core.getCoreDescriptor().getInstanceDir()); props.put(PROPERTY_CORE_DATA_DIR, core.getDataDir()); props.put(PROPERTY_CORE_INDEX_DIR, core.getIndexDir()); props.put(PROPERTY_CORE_SCHEMA, core.getSchemaResource());
@Override public void removeIndex(String name, boolean deleteFiles) { if(name == null || name.isEmpty()){ throw new IllegalArgumentException("The parsed index name MUST NOT be NULL nor empty!"); } SolrCore core = server.remove(name); core.close(); //decrease reference count if(deleteFiles){ String instanceDir = core.getCoreDescriptor().getInstanceDir(); while(!core.isClosed()){ //ensure the core is closed! core.close(); } try { FileUtils.deleteDirectory(new File(instanceDir)); } catch (IOException e) { log.error("Unable to delete instance directory '"+ instanceDir+"' of SolrCore '"+name+"'! Please delete this" + "directory manually."); } } }
coreAdminHandler = new CoreAdminHandler(this); } else { coreAdminHandler = this.createMultiCoreHandler(adminHandler); List<String> aliases = StrUtils.splitSmart(names,','); String name = aliases.get(0); CoreDescriptor p = new CoreDescriptor(this, name, DOMUtil.getAttr(node, "instanceDir", null)); p.setConfigName(opt); p.setSchemaName(opt); p.setPropertiesName(opt); p.setDataDir(opt); p.setCoreProperties(readProperties(cfg, node)); SolrCore core = create(p); core.open(); register(aliases.get(a), core, false); SolrException.logOnce(log,null,ex);