Metacat

        IndexGenerator generator = new IndexGenerator(solrIndex);

    //private List<SystemMetadataEventListener> sysmetaListeners = new ArrayList<SystemMetadataEventListener>();

        	//sysmetaListeners.add(smel);

        //SystemMetadataEventListener listener = sysmetaListeners.get(FIRST);

        IndexGenerator generator = new IndexGenerator(index);

    private SystemMetadata getSystemMetadata(String id) {

    private List<String> getObsoletes(String id) {

		if(objectPath != null) {

		    InputStream data = null;

	        try {

	            data = new FileInputStream(objectPath);

	            solrIndex.update(pid.getValue(), obsoletesChain, systemMetadata, data);

	        } catch (Exception e) {

	            // TODO: need to track errors, retry later

	            log.error(e.getMessage(), e);

	        }

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import com.hazelcast.core.IMap;

    //private SystemMetadataEventListener systemMetadataListener = null;

    private IMap<Identifier, SystemMetadata> systemMetadataMap;

    private IMap<Identifier, String> objectPathMap;

    public IndexGenerator(SolrIndex solrIndex) {

        //this.systemMetadataListener = systemMetadataListener;

                            NotImplemented, ServiceFailure, SolrServerException, FileNotFoundException {

                NotAuthorized, NotImplemented, ServiceFailure, SolrServerException, FileNotFoundException {

                    NotAuthorized, NotImplemented, ServiceFailure, SolrServerException, FileNotFoundException {

     * @throws FileNotFoundException 

                                                InvalidToken, NotAuthorized, NotImplemented, ServiceFailure, FileNotFoundException {

        initSystemMetadataMap();

        initObjectPathMap();

        } catch (FileNotFoundException e) {

            log.error("IndexGenerator.run - Metadata-Index couldn't generate indexes for those documents which haven't been indexed : "+e.getMessage());

                    throw new ServiceFailure("0000", "IndexGenerator.getMetadataIds - the mnode "+ mNode.getNodeBaseServiceUrl()+

        String httpPort = Settings.getConfiguration().getString("server.httpPort");

        String serverURL = "http://";

        if(httpPort.equals("443") || httpPort.equals("8443"))

        {

            serverURL = "https://";

        }

        serverURL = serverURL+Settings.getConfiguration().getString("server.name");

        if (!httpPort.equals("80")) {

            serverURL += ":" + httpPort;

        }

        serverURL = serverURL +"/"+ Settings.getConfiguration().getString("application.context")+MNAPPENDIX;

        log.info("IndexGenerator.buildMNBaseURL - the base url of MNode is "+serverURL);

        return serverURL;

                SystemMetadata sysmeta = getSystemMetadata(id);

                //only update none-archived id.

                if(sysmeta != null && !sysmeta.getArchived()) {

                        InputStream data = getDataObject(id);

                            obsoleteChain = getObsoletes(id);

    /*

     * Initialize the system metadata map

     */

    private void initSystemMetadataMap() throws FileNotFoundException, ServiceFailure{

        int times = 0;

        if(systemMetadataMap == null) {

            while(true) {

                try {

                    systemMetadataMap = DistributedMapsFactory.getSystemMetadataMap();

                    break;

                } catch (FileNotFoundException e) {

                    throw e;

                } catch (ServiceFailure e) {

                    if(times <= MAXWAITNUMBER) {

                        log.warn("IndexGenerator.initSystemMetadataMap - the hazelcast service is not ready : "

                                         +e.getMessage()+"\nWe will try to access it 10 seconds later ");

                        try {

                            Thread.sleep(WAITTIME);

                        } catch (Exception ee) {

                            log.warn("IndexGenerator.initSystemMetadataMap - the thread can't sleep for 10 seconds to wait the hazelcast service");

                        }

                    } else {

                        throw new ServiceFailure("0000", "IndexGenerator.initSystemMetadataMap - the hazelcast service is not ready even though Metacat-index wailted for 30 minutes. We can't get the system metadata from it and the building index can't happen this time");

                    }

                }

                times++;

            }

        }

    }

    /*

     * We should call this method after calling initSystemMetadataMap since this method doesn't have the mechanism to wait the readiness of the hazelcast service

     */

    private void initObjectPathMap() throws FileNotFoundException, ServiceFailure {

        if(objectPathMap == null) {

            objectPathMap = DistributedMapsFactory.getObjectPathMap();

        }

    }

    /**

     * Get an InputStream as the data object for the specific pid.

     * @param pid

     * @return

     * @throws FileNotFoundException

     */

    private InputStream getDataObject(String pid) throws FileNotFoundException {

        Identifier identifier = new Identifier();

        identifier.setValue(pid);

        String objectPath = objectPathMap.get(identifier);

        InputStream data = null;

        data = new FileInputStream(objectPath);

        return data;

    }

    /**

     * Get the SystemMetadata for the specified id from the distributed Map.

     * The null maybe is returned if there is no system metadata found.

     * @param id  the specified id.

     * @return the SystemMetadata associated with the id.

     */

    private SystemMetadata getSystemMetadata(String id) {

        SystemMetadata metadata = null;

        if(systemMetadataMap != null && id != null) {

            Identifier identifier = new Identifier();

            identifier.setValue(id);

            metadata = systemMetadataMap.get(identifier);

        }

        return metadata;

    }

    /**

     * Get the obsoletes chain of the specified id. The returned list doesn't include

     * the specified id itself. The newer version has the lower index number in the list.

     * Empty list will be returned if there is no document to be obsoleted by this id.

     * @param id

     * @return

     */

    private List<String> getObsoletes(String id) {

        List<String> obsoletes = new ArrayList<String>();

        while (id != null) {

            SystemMetadata metadata = getSystemMetadata(id);

            id = null;//set it to be null in order to stop the while loop if the id can't be assinged to a new value in the following code.

            if(metadata != null) {

                Identifier identifier = metadata.getObsoletes();

                if(identifier != null && identifier.getValue() != null && !identifier.getValue().trim().equals("")) {

                    obsoletes.add(identifier.getValue());

                    id = identifier.getValue();

                } 

            } 

        }

        return obsoletes;

    }