content: /**
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.solr.core;
  
  import java.io.*;
  import java.util.*;
  import java.util.concurrent.atomic.AtomicBoolean;
  
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  import javax.xml.parsers.ParserConfigurationException;
  import javax.xml.xpath.XPathConstants;
  import javax.xml.xpath.XPath;
  import javax.xml.xpath.XPathExpressionException;
  
  import org.apache.solr.common.SolrException;
  import org.apache.solr.common.util.DOMUtil;
  import org.apache.solr.schema.IndexSchema;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  import org.xml.sax.SAXException;
  import org.xml.sax.InputSource;
  
  
  public class CoreContainer 
  {
    private static final String DEFAULT_DEFAULT_CORE_NAME = "collection1";
    protected static Logger log = LoggerFactory.getLogger(CoreContainer.class);
    protected final Map<String, SolrCore> cores = new LinkedHashMap<String, SolrCore>();
    protected SolrResourceLoader loader = null;
    protected Properties containerProperties;
    protected String solrHome;
    private String defaultCoreName = "";
    private boolean defaultAbortOnConfigError = false;
    private int numCoresAbortOnConfigError = 0;
    
    private static AtomicBoolean isException=new AtomicBoolean(false);
    
    public static boolean getIsException() {
  	return isException.get();
  }
    
    public static  void setException()
    {
  	  isException.set(true);
    }
  
  public CoreContainer() {
      solrHome = SolrResourceLoader.locateSolrHome();
      log.info("New CoreContainer: solrHome=" + solrHome + " instance="+System.identityHashCode(this));
    }
  
    public Properties getContainerProperties() {
      return containerProperties;
    }
  
    public static class Initializer {
      protected boolean abortOnConfigurationError = true;
      public boolean isAbortOnConfigurationError() {
        return abortOnConfigurationError;
      }
      
      public void setAbortOnConfigurationError(boolean abortOnConfigurationError) {
        this.abortOnConfigurationError = abortOnConfigurationError;
      }
  
      public CoreContainer initialize() throws IOException,
          ParserConfigurationException, SAXException {
        CoreContainer cores = null;
        String solrHome = SolrResourceLoader.locateSolrHome();
        File fconf = new File(solrHome, "solr.xml");
        log.info("looking for solr.xml: " + fconf.getAbsolutePath());
        cores = new CoreContainer();
        if (fconf.exists()) {
          cores.defaultAbortOnConfigError = false;
          cores.load(solrHome, new InputSource(fconf.toURI().toASCIIString()));
        } else {
          cores.defaultAbortOnConfigError = abortOnConfigurationError;
          cores.load(solrHome, new InputSource(new ByteArrayInputStream(DEF_SOLR_XML.getBytes("UTF-8"))));
        }
        setAbortOnConfigurationError(0 < cores.numCoresAbortOnConfigError);      
        return cores;
      }
    }
    
    public void load(String dir, InputSource cfgis)
        throws ParserConfigurationException, IOException, SAXException {
      this.loader = new SolrResourceLoader(dir);
      this.solrHome = loader.getInstanceDir();
      Config cfg = new Config(loader, null, cfgis, null);
  
      try {
        containerProperties = readProperties(cfg, ((NodeList) cfg.evaluate("solr", XPathConstants.NODESET)).item(0));
      } catch (Throwable e) {
        SolrConfig.severeErrors.add(e);
        SolrException.logOnce(log,null,e);
      }
    }
    
    private Properties readProperties(Config cfg, Node node) throws XPathExpressionException {
  	    XPath xpath = cfg.getXPath();
  	    NodeList props = (NodeList) xpath.evaluate("property", node, XPathConstants.NODESET);
  	    Properties properties = new Properties();
  	    for (int i=0; i<props.getLength(); i++) {
  	      Node prop = props.item(i);
  	      properties.setProperty(DOMUtil.getAttr(prop, "name"), DOMUtil.getAttr(prop, "value"));
  	    }
  	    return properties;
  	  }
  
  
  
    public SolrCore getCore(String name) {
  		name = checkDefault(name);
  		 if( name == null ||
  	        name.indexOf( '/'  ) >= 0 ||
  	        name.indexOf( '\\' ) >= 0 ){
  	      throw new RuntimeException( "Invalid core name: "+name );
  	    }
  		synchronized (cores) {
  			SolrCore core = cores.get(name);
  			if (core == null) {
  				String instanceDir=SolrResourceLoader.locateSolrHome();
  				String schema = instanceDir+ "/conf/schema.xml";
  				String datadir = instanceDir + "/data/";
  				if(!name.isEmpty())
  				{
  					instanceDir=SolrResourceLoader.GetSchemaHome() + "/" + name	+ "/solr";
  					schema = SolrResourceLoader.GetSchemaHome() + "/" + name	+ "/solr/conf/schema.xml";
  					datadir = SolrResourceLoader.GetSchemaHome() + "/" + name + "/solr/data/";
  				}
  				
  				log.info("higolog getCore"+schema+","+datadir);
  				try {
  					this.createCore(name, instanceDir, schema,datadir);
  				} catch (Exception e) {
  					isException.set(true);
  					log.error("getCore",e);
  				}
  				core = cores.get(name);
  			}
  			if (core != null) {
  				core.open(); // increment the ref count while still synchronized
  			}
  			return core;
  		}
  	}
    
    public void createCore(String name,String instanceDir,String schema,String datadir) throws ParserConfigurationException, IOException, SAXException
    {
  	  CoreDescriptor p = new CoreDescriptor(this, name, instanceDir);
  	  p.setSchemaName(schema);
  	  p.setDataDir(datadir);
        p.setCoreProperties( new Properties());
        
        SolrResourceLoader solrLoader = new SolrResourceLoader(p.getInstanceDir(), null, p.getCoreProperties());
        SolrConfig sconfig = new SolrConfig(solrLoader, p.getConfigName(), null);
  
        if (sconfig.getBool("abortOnConfigurationError",defaultAbortOnConfigError)) {
          numCoresAbortOnConfigError++;
        }
        
        IndexSchema ischema = new IndexSchema(sconfig, p.getSchemaName(), null);
        SolrCore core = new SolrCore(p.getName(), p.getDataDir(), sconfig, ischema, p);
        core.setName(name);
        core.getCoreDescriptor().name = name;
        
        SolrCore old = cores.put(name, core);
        if( old == null || old == core) {
          log.info( "registering core: "+name );
        }else {
          log.info( "replacing core: "+name );
          old.close();
        }
    }
  
  
    private boolean isShutDown = false;
    /**
     * Stops all cores.
     */
    public void shutdown() {
      synchronized(cores) {
        try {
          for(SolrCore core : cores.values()) {
            core.close();
          }
          cores.clear();
        } finally {
          isShutDown = true;
        }
      }
    }
    
    @Override
    protected void finalize() throws Throwable {
      try {
        if(!isShutDown){
          log.error("CoreContainer was not shutdown prior to finalize(), indicates a bug -- POSSIBLE RESOURCE LEAK!!!  instance=" + System.identityHashCode(this));
          shutdown();
        }
      } finally {
        super.finalize();
      }
    }
  
  
  
    
  
  	private String checkDefault(String name) {
  	    return name.length() == 0  || defaultCoreName.equals(name) || name.trim().length() == 0 ? "" : name;
  	} 
    
  	public String getSolrHome() {
  		return solrHome;
  	}
  	
  	  private static final String DEF_SOLR_XML ="<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n" +
  	  "<solr persistent=\"false\">\n" +
  	  "  <cores adminPath=\"/admin/cores\" defaultCoreName=\"" + DEFAULT_DEFAULT_CORE_NAME + "\">\n" +
  	  "    <core name=\""+ DEFAULT_DEFAULT_CORE_NAME + "\" instanceDir=\".\" />\n" +
  	  "  </cores>\n" +
  	  "</solr>";
  
  
  }
  