source: OAIHarvester/trunk/OAIHarvester/src/main/java/eu/clarin/cmdi/oai/harvester/impl/AbstractHarvester.java @ 3011

package eu.clarin.cmdi.oai.harvester.impl;

import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.List;

import javax.xml.namespace.QName;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;

import org.codehaus.stax2.XMLInputFactory2;
import org.codehaus.stax2.XMLStreamReader2;

import com.ctc.wstx.api.WstxInputProperties;

import eu.clarin.cmdi.oai.harvester.HarvestHandler;
import eu.clarin.cmdi.oai.harvester.HarvestJob;
import eu.clarin.cmdi.oai.harvester.Harvester;
import eu.clarin.cmdi.oai.harvester.HarvesterException;
import eu.clarin.cmdi.oai.harvester.ext.DescriptionParser;


abstract class AbstractHarvester implements Harvester {
    private static final int DEFAULT_MAX_NETWORK_RETRY_COUNT = 5;
    protected int maxNetworkRetryCount = DEFAULT_MAX_NETWORK_RETRY_COUNT;
    private final XMLInputFactory2 factory;
    // private final XMLValidationSchema schema;
    private List<DescriptionParser> descriptionParsers =
            new ArrayList<DescriptionParser>();


    protected AbstractHarvester() {
        factory = (XMLInputFactory2) XMLInputFactory.newInstance();

        // Stax settings
        factory.setProperty(XMLInputFactory.IS_COALESCING, Boolean.TRUE);
        factory.setProperty(XMLInputFactory.IS_NAMESPACE_AWARE, Boolean.TRUE);

        // Stax2 settings
        factory.setProperty(XMLInputFactory2.P_AUTO_CLOSE_INPUT, Boolean.FALSE);

        // Woodstox settings
        factory.setProperty(WstxInputProperties.P_NORMALIZE_LFS, Boolean.TRUE);

        // XMLValidationSchemaFactory schemaFactory =
        // XMLValidationSchemaFactory
        // .newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
        // URL url = Harvester.class.getClassLoader().getResource(
        // "META-INF/OAI-PMH.xsd");
        // if (url == null) {
        // throw new NullPointerException("schema not found!");
        // }
        // schema = schemaFactory.createSchema(url);
    }


    @Override
    public final void registerDescriptionParser(DescriptionParser parser)
            throws HarvesterException {
        if (parser == null) {
            throw new NullPointerException("parser == null");
        }
        if (findDescriptionParser(parser.getNamespaceURI(),
                parser.getLocalName()) != null) {
            throw new HarvesterException("description parser for '" +
                    new QName(parser.getNamespaceURI(), parser.getLocalName()) +
                            "' was already registered");
        }
        if (descriptionParsers == null) {
            descriptionParsers = new ArrayList<DescriptionParser>();
        }
        descriptionParsers.add(parser);
    }


    @Override
    public abstract HarvestJob createJob(URI repositoryURI,
            HarvestHandler handler) throws HarvesterException;


    @Override
    public final HarvestJob createJob(URI repositoryURI)
            throws HarvesterException {
        return createJob(repositoryURI, null);
    }


    @Override
    public final HarvestJob createJob(String repositoryURI,
            HarvestHandler handler) throws HarvesterException {
        try {
            return createJob(new URI(repositoryURI), handler);
        } catch (URISyntaxException e) {
            throw new HarvesterException("invalid repositoryURI", e);
        }
    }


    @Override
    public final HarvestJob createJob(String repositoryURI)
            throws HarvesterException {
        return createJob(repositoryURI, null);
    }


    @Override
    public final HarvestJob findJob(long id) throws HarvesterException {
        return doFindJob(id);
    }


    @Override
    public final HarvestJob cancelJob(long id) throws HarvesterException {
        HarvestJob job = doFindJob(id);
        if (job != null) {
            job.cancel();
        }
        return job;
    }


    @Override
    public final int getMaxNetworkRetryCount() {
        return maxNetworkRetryCount;
    }


    @Override
    public final void setMaxNetworkRetryCount(int maxNetworkRetryCount) {
        if (maxNetworkRetryCount < 1) {
            throw new IllegalArgumentException(
                    "invalid value for maxNetworkRetryCount: " +
                            maxNetworkRetryCount);
        }
        this.maxNetworkRetryCount = maxNetworkRetryCount;
    }


    DescriptionParser findDescriptionParser(String namespaceURI,
            String localName) {
        if (descriptionParsers != null) {
            for (DescriptionParser parser : descriptionParsers) {
                if (namespaceURI.equals(parser.getNamespaceURI()) &&
                        localName.equals(parser.getLocalName())) {
                    return parser;
                }
            }
        }
        return null;
    }


    abstract void doRunJob(HarvestJobImpl job) throws HarvesterException;


    abstract void doCancelJob(HarvestJobImpl job) throws HarvesterException;


    protected abstract HarvestJob doFindJob(long id) throws HarvesterException;


    protected final XMLStreamReader2 createReader(InputStream in)
            throws XMLStreamException {
        XMLStreamReader2 reader =
                (XMLStreamReader2) factory.createXMLStreamReader(in);
        // reader.validateAgainst(schema);
        return reader;
    }

} // abstract class AbstractHarvester