Java tutorial
/* DigiDoc4J library * * This software is released under either the GNU Library General Public * License (see LICENSE.LGPL). * * Note that the only valid version of the LGPL license as far as this * project is concerned is the original GNU Library General Public License * Version 2.1, February 1999 */ package org.digidoc4j.impl.bdoc.asic; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.zip.ZipEntry; import org.apache.commons.io.IOUtils; import org.apache.commons.io.input.BOMInputStream; import org.apache.commons.lang.StringUtils; import org.digidoc4j.Configuration; import org.digidoc4j.DataFile; import org.digidoc4j.exceptions.DuplicateDataFileException; import org.digidoc4j.exceptions.TechnicalException; import org.digidoc4j.exceptions.UnsupportedFormatException; import org.digidoc4j.impl.StreamDocument; import org.digidoc4j.impl.bdoc.manifest.ManifestEntry; import org.digidoc4j.impl.bdoc.manifest.ManifestParser; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import eu.europa.esig.dss.DSSDocument; import eu.europa.esig.dss.InMemoryDocument; import eu.europa.esig.dss.MimeType; public abstract class AsicContainerParser { private final static Logger logger = LoggerFactory.getLogger(AsicContainerParser.class); //Matches META-INF/*signatures*.xml where the last * is a number private static final String SIGNATURES_FILE_REGEX = "META-INF/(.*)signatures(.*).xml"; private static final Pattern SIGNATURE_FILE_ENDING_PATTERN = Pattern.compile("(\\d+).xml"); public static final String MANIFEST = "META-INF/manifest.xml"; private AsicParseResult parseResult = new AsicParseResult(); private List<DSSDocument> signatures = new ArrayList<>(); private LinkedHashMap<String, DataFile> dataFiles = new LinkedHashMap<>(); private List<DSSDocument> detachedContents = new ArrayList<>(); private Integer currentSignatureFileIndex; private String mimeType; private String zipFileComment; private List<AsicEntry> asicEntries = new ArrayList<>(); private Map<String, ManifestEntry> manifestFileItems = Collections.emptyMap(); private ManifestParser manifestParser; private boolean storeDataFilesOnlyInMemory; private long maxDataFileCachedInBytes; protected AsicContainerParser(Configuration configuration) { storeDataFilesOnlyInMemory = configuration.storeDataFilesOnlyInMemory(); maxDataFileCachedInBytes = configuration.getMaxDataFileCachedInBytes(); } public AsicParseResult read() { parseContainer(); validateParseResult(); populateParseResult(); return parseResult; } protected abstract void parseContainer(); protected abstract void extractManifest(ZipEntry entry); protected abstract InputStream getZipEntryInputStream(ZipEntry entry); protected void parseManifestEntry(DSSDocument manifestFile) { logger.debug("Parsing manifest"); manifestParser = new ManifestParser(manifestFile); manifestFileItems = manifestParser.getManifestFileItems(); } protected void parseEntry(ZipEntry entry) { String entryName = entry.getName(); logger.debug("Paring zip entry " + entryName + " with comment: " + entry.getComment()); if (isMimeType(entryName)) { extractMimeType(entry); } else if (isManifest(entryName)) { extractManifest(entry); } else if (isSignaturesFile(entryName)) { determineCurrentSignatureFileIndex(entryName); extractSignature(entry); } else if (isDataFile(entryName)) { extractDataFile(entry); } else { extractAsicEntry(entry); } } private void extractMimeType(ZipEntry entry) { try { InputStream zipFileInputStream = getZipEntryInputStream(entry); BOMInputStream bomInputStream = new BOMInputStream(zipFileInputStream); DSSDocument document = new InMemoryDocument(bomInputStream); mimeType = StringUtils.trim(IOUtils.toString(getDocumentBytes(document), "UTF-8")); extractAsicEntry(entry, document); } catch (IOException e) { logger.error("Error parsing container mime type: " + e.getMessage()); throw new TechnicalException("Error parsing container mime type: " + e.getMessage(), e); } } private void extractSignature(ZipEntry entry) { logger.debug("Extracting signature"); InputStream zipFileInputStream = getZipEntryInputStream(entry); String fileName = entry.getName(); InMemoryDocument document = new InMemoryDocument(zipFileInputStream, fileName); signatures.add(document); extractSignatureAsicEntry(entry, document); } private void extractDataFile(ZipEntry entry) { logger.debug("Extracting data file"); String fileName = entry.getName(); validateDataFile(fileName); DSSDocument document = extractStreamDocument(entry); DataFile dataFile = new AsicDataFile(document); dataFiles.put(fileName, dataFile); detachedContents.add(document); extractAsicEntry(entry, document); } private DSSDocument extractStreamDocument(ZipEntry entry) { logger.debug("Zip entry size is " + entry.getSize() + " bytes"); InputStream zipFileInputStream = getZipEntryInputStream(entry); String fileName = entry.getName(); String mimeType = getDataFileMimeType(fileName); MimeType mimeTypeCode = MimeType.fromMimeTypeString(mimeType); DSSDocument document; if (storeDataFilesOnlyInMemory || entry.getSize() <= maxDataFileCachedInBytes) { document = new InMemoryDocument(zipFileInputStream, fileName, mimeTypeCode); } else { document = new StreamDocument(zipFileInputStream, fileName, mimeTypeCode); } return document; } protected AsicEntry extractAsicEntry(ZipEntry entry) { logger.debug("Extracting asic entry"); DSSDocument document = extractStreamDocument(entry); return extractAsicEntry(entry, document); } private AsicEntry extractAsicEntry(ZipEntry zipEntry, DSSDocument document) { AsicEntry asicEntry = new AsicEntry(zipEntry); asicEntry.setContent(document); asicEntries.add(asicEntry); return asicEntry; } private void extractSignatureAsicEntry(ZipEntry entry, DSSDocument document) { AsicEntry asicEntry = extractAsicEntry(entry, document); asicEntry.setSignature(true); } protected String getDataFileMimeType(String fileName) { if (manifestFileItems.containsKey(fileName)) { ManifestEntry manifestEntry = manifestFileItems.get(fileName); return manifestEntry.getMimeType(); } else { MimeType mimeType = MimeType.fromFileName(fileName); return mimeType.getMimeTypeString(); } } private void validateParseResult() { if (!StringUtils.equalsIgnoreCase(MimeType.ASICE.getMimeTypeString(), mimeType)) { logger.error( "Container mime type is not " + MimeType.ASICE.getMimeTypeString() + " but is " + mimeType); throw new UnsupportedFormatException( "Container mime type is not " + MimeType.ASICE.getMimeTypeString() + " but is " + mimeType); } } private void validateDataFile(String fileName) { if (dataFiles.containsKey(fileName)) { logger.error("Container contains duplicate data file: " + fileName); throw new DuplicateDataFileException("Container contains duplicate data file: " + fileName); } } private void populateParseResult() { Collection<DataFile> files = dataFiles.values(); parseResult.setDataFiles(new ArrayList<>(files)); parseResult.setSignatures(signatures); parseResult.setCurrentUsedSignatureFileIndex(currentSignatureFileIndex); parseResult.setDetachedContents(detachedContents); parseResult.setManifestParser(manifestParser); parseResult.setZipFileComment(zipFileComment); parseResult.setAsicEntries(asicEntries); } private boolean isMimeType(String entryName) { return StringUtils.equalsIgnoreCase("mimetype", entryName); } private boolean isDataFile(String entryName) { return !entryName.startsWith("META-INF/") && !isMimeType(entryName); } private boolean isManifest(String entryName) { return StringUtils.equalsIgnoreCase(MANIFEST, entryName); } private boolean isSignaturesFile(String entryName) { return entryName.matches(SIGNATURES_FILE_REGEX); } private void determineCurrentSignatureFileIndex(String entryName) { Matcher fileEndingMatcher = SIGNATURE_FILE_ENDING_PATTERN.matcher(entryName); boolean fileEndingFound = fileEndingMatcher.find(); if (fileEndingFound) { String fileEnding = fileEndingMatcher.group(); String indexNumber = fileEnding.replace(".xml", ""); int fileIndex = Integer.parseInt(indexNumber); if (currentSignatureFileIndex == null || currentSignatureFileIndex <= fileIndex) { currentSignatureFileIndex = fileIndex; } } } private byte[] getDocumentBytes(DSSDocument document) { try { return IOUtils.toByteArray(document.openStream()); } catch (IOException e) { logger.error("Error getting document content: " + e.getMessage()); throw new TechnicalException("Error getting document content: " + e.getMessage(), e); } } void setZipFileComment(String zipFileComment) { this.zipFileComment = zipFileComment; } LinkedHashMap<String, DataFile> getDataFiles() { return dataFiles; } }