Example usage for java.util.zip ZipEntry getSize

List of usage examples for java.util.zip ZipEntry getSize

Introduction

In this page you can find the example usage for java.util.zip ZipEntry getSize.

Prototype

public long getSize() 

Source Link

Document

Returns the uncompressed size of the entry data.

Usage

From source file:org.jahia.services.importexport.ImportExportBaseService.java

public void getFileList(Resource file, Map<String, Long> sizes, List<String> fileList) throws IOException {
    ZipInputStream zis = getZipInputStream(file);
    try {/*from ww  w .  ja v a 2 s  .  c  o  m*/
        while (true) {
            ZipEntry zipentry = zis.getNextEntry();
            if (zipentry == null)
                break;
            String name = zipentry.getName().replace('\\', '/');
            if (expandImportedFilesOnDisk) {
                final File file1 = new File(expandImportedFilesOnDiskPath + File.separator + name);
                if (zipentry.isDirectory()) {
                    file1.mkdirs();
                } else {
                    long timer = System.currentTimeMillis();
                    if (logger.isDebugEnabled()) {
                        logger.debug("Expanding {} into {}", zipentry.getName(), file1);
                    }
                    file1.getParentFile().mkdirs();
                    final OutputStream output = new BufferedOutputStream(new FileOutputStream(file1),
                            1024 * 64);
                    try {
                        IOUtils.copyLarge(zis, output);
                        if (logger.isDebugEnabled()) {
                            logger.debug("Expanded {} in {}", zipentry.getName(),
                                    DateUtils.formatDurationWords(System.currentTimeMillis() - timer));
                        }
                    } finally {
                        output.close();
                    }
                }
            }
            if (name.endsWith(".xml")) {
                BufferedReader br = new BufferedReader(new InputStreamReader(zis));
                try {
                    long i = 0;
                    while (br.readLine() != null) {
                        i++;
                    }
                    sizes.put(name, i);
                } finally {
                    IOUtils.closeQuietly(br);
                }
            } else {
                sizes.put(name, zipentry.getSize());
            }
            if (name.contains("/")) {
                fileList.add("/" + name);
            }
            zis.closeEntry();
        }
    } finally {
        closeInputStream(zis);
    }
}

From source file:jhplot.P1D.java

/**
 * Read P1D from a Zipped file. The old content will be lost. The file
 * should contain 2, or 4, or 6, or 10 columns: 1) x,y: data without any
 * errors 2) x,y, y(upper), y(lower) - data with 1st level errors on Y 3)
 * x,y, x(left), x(right), y(upper), y(lower) - data with 1st level errors
 * on X and Y 4) x,y, x(left), x(right), y(upper), y(lower), x(leftSys),
 * x(rightSys), y(upperSys), y(lowerSys) - data with X and Y and 1st and 2nd
 * level errors. Comment lines starting with "#" and "*" are ignored.
 * //from  ww w . jav  a  2  s  .  com
 * @param sfile
 *            File name with input (extension zip)
 * @return zero if success
 */
public int readZip(String sfile) {

    // clear all data
    clear();

    try {
        ZipFile zf = new ZipFile(sfile);
        Enumeration entries = zf.entries();
        BufferedReader input = new BufferedReader(new InputStreamReader(System.in));

        while (entries.hasMoreElements()) {
            ZipEntry ze = (ZipEntry) entries.nextElement();
            // System.out.println("Read " + ze.getName() + "?");
            String inputLine = input.readLine();
            if (inputLine.equalsIgnoreCase("yes")) {
                long size = ze.getSize();
                if (size > 0) {
                    // System.out.println("Length is " + size);

                    BufferedReader br = new BufferedReader(new InputStreamReader(zf.getInputStream(ze)));

                    read(br); // read data
                    br.close();
                }
            }
        }

    } catch (FileNotFoundException e) {
        ErrorMessage("File not found:" + sfile);
        e.printStackTrace();
        return 1;
    } catch (IOException e) {
        e.printStackTrace();
        return 2;
    }

    return 0;

}

From source file:org.jahia.services.importexport.ImportExportBaseService.java

/**
 * Import a full site zip into a newly created site.
 * <p/>/*w  w  w  .  j  a v  a  2  s  .  co  m*/
 * zip file can contain all kind of legacy jahia import files or jcr import format.
 *
 * @param file                      Zip file
 * @param site                      The new site where to import
 * @param infos                     site infos
 * @param legacyMappingFilePath     path to the legacy mappings
 * @param legacyDefinitionsFilePath path for the legacy definitions
 * @param session                   the current JCR session to use for the import
 * @throws RepositoryException
 * @throws IOException
 */
public void importSiteZip(Resource file, JahiaSite site, Map<Object, Object> infos,
        Resource legacyMappingFilePath, Resource legacyDefinitionsFilePath, JCRSessionWrapper session)
        throws RepositoryException, IOException {
    long timerSite = System.currentTimeMillis();
    logger.info("Start import for site {}", site != null ? site.getSiteKey() : "");

    final CategoriesImportHandler categoriesImportHandler = new CategoriesImportHandler();
    final UsersImportHandler usersImportHandler = new UsersImportHandler(site, session);

    boolean legacyImport = false;
    List<String[]> catProps = null;
    List<String[]> userProps = null;

    Map<String, Long> sizes = new HashMap<String, Long>();
    List<String> fileList = new ArrayList<String>();

    logger.info("Start analyzing import file {}", file);
    long timer = System.currentTimeMillis();
    getFileList(file, sizes, fileList);
    logger.info("Done analyzing import file {} in {}", file,
            DateUtils.formatDurationWords(System.currentTimeMillis() - timer));

    Map<String, String> pathMapping = session.getPathMapping();
    for (JahiaTemplatesPackage pkg : templatePackageRegistry.getRegisteredModules().values()) {
        String key = "/modules/" + pkg.getId() + "/";
        if (!pathMapping.containsKey(key)) {
            pathMapping.put(key, "/modules/" + pkg.getId() + "/" + pkg.getVersion() + "/");
        }
    }

    ZipInputStream zis;
    if (sizes.containsKey(USERS_XML)) {
        // Import users first
        zis = getZipInputStream(file);
        try {
            while (true) {
                ZipEntry zipentry = zis.getNextEntry();
                if (zipentry == null)
                    break;
                String name = zipentry.getName();
                if (name.equals(USERS_XML)) {
                    userProps = importUsers(zis, usersImportHandler);
                    break;
                }
                zis.closeEntry();
            }
        } finally {
            closeInputStream(zis);
        }
    }

    // Check if it is an 5.x or 6.1 import :
    for (Map.Entry<String, Long> entry : sizes.entrySet()) {
        if (entry.getKey().startsWith("export_")) {
            legacyImport = true;
            break;
        }
    }

    if (sizes.containsKey(SITE_PROPERTIES)) {
        zis = getZipInputStream(file);
        try {
            while (true) {
                ZipEntry zipentry = zis.getNextEntry();
                if (zipentry == null)
                    break;
                String name = zipentry.getName();
                if (name.equals(SITE_PROPERTIES)) {
                    importSiteProperties(zis, site, session);
                    break;
                }
                zis.closeEntry();
            }
        } finally {
            closeInputStream(zis);
        }
    }

    if (sizes.containsKey(REPOSITORY_XML)) {
        // Parse import file to detect sites
        zis = getZipInputStream(file);
        try {
            while (true) {
                ZipEntry zipentry = zis.getNextEntry();
                if (zipentry == null)
                    break;
                String name = zipentry.getName();
                if (name.equals(REPOSITORY_XML)) {
                    timer = System.currentTimeMillis();
                    logger.info("Start importing " + REPOSITORY_XML);

                    DocumentViewValidationHandler h = new DocumentViewValidationHandler();
                    h.setSession(session);
                    List<ImportValidator> validators = new ArrayList<ImportValidator>();
                    SitesValidator sitesValidator = new SitesValidator();
                    validators.add(sitesValidator);
                    h.setValidators(validators);
                    handleImport(zis, h, name);

                    Map<String, Properties> sites = ((SitesValidatorResult) sitesValidator.getResult())
                            .getSitesProperties();
                    for (String s : sites.keySet()) {
                        // Only the first site returned is mapped (if its not the systemsite, which is always the same key)
                        if (!s.equals("systemsite") && !site.getSiteKey().equals("systemsite")) {
                            // Map to the new sitekey
                            pathMapping.put("/sites/" + s + "/", "/sites/" + site.getSiteKey() + "/");
                            break;
                        }
                    }

                    if (!sizes.containsKey(SITE_PROPERTIES)) {
                        // todo : site properties can be removed and properties get from here
                    }
                    logger.info("Done importing " + REPOSITORY_XML + " in {}",
                            DateUtils.formatDurationWords(System.currentTimeMillis() - timer));
                    break;
                }
                zis.closeEntry();
            }
        } finally {
            closeInputStream(zis);
        }

        importZip(null, file, DocumentViewImportHandler.ROOT_BEHAVIOUR_IGNORE, session,
                Sets.newHashSet(USERS_XML, CATEGORIES_XML), true);
    } else {
        // No repository descriptor - prepare to import files directly
        pathMapping.put("/", "/sites/" + site.getSiteKey() + "/files/");
    }

    NodeTypeRegistry reg = NodeTypeRegistry.getInstance();
    DefinitionsMapping mapping = null;

    // Import additional files - site.properties, old cateogries.xml , sitepermissions.xml
    // and eventual plain file from 5.x imports
    if (!sizes.containsKey(REPOSITORY_XML) || sizes.containsKey(SITE_PROPERTIES)
            || sizes.containsKey(CATEGORIES_XML) || sizes.containsKey(SITE_PERMISSIONS_XML)
            || sizes.containsKey(DEFINITIONS_CND) || sizes.containsKey(DEFINITIONS_MAP)) {
        zis = getZipInputStream(file);
        try {
            while (true) {
                ZipEntry zipentry = zis.getNextEntry();
                if (zipentry == null)
                    break;
                String name = zipentry.getName();
                if (name.indexOf('\\') > -1) {
                    name = name.replace('\\', '/');
                }
                if (name.indexOf('/') > -1) {
                    if (!sizes.containsKey(REPOSITORY_XML) && !sizes.containsKey(FILESACL_XML)) {
                        // No repository descriptor - Old import format only
                        name = "/" + name;
                        if (name.startsWith("/content/sites")) {
                            name = pathMapping.get("/") + StringUtils
                                    .stripStart(name.replaceFirst("/content/sites/[^/]+/files/", ""), "/");
                        } else if (name.startsWith("/users")) {
                            Matcher m = Pattern.compile("/users/([^/]+)(/.*)?").matcher(name);
                            if (m.matches()) {
                                name = ServicesRegistry.getInstance().getJahiaUserManagerService()
                                        .getUserSplittingRule().getPathForUsername(m.group(1));
                                name = name + "/files" + ((m.group(2) != null) ? m.group(2) : "");
                            }
                        } else if (name.startsWith("/content/users")) {
                            Matcher m = Pattern.compile("/content/users/([^/]+)(/.*)?").matcher(name);
                            if (m.matches()) {
                                name = ServicesRegistry.getInstance().getJahiaUserManagerService()
                                        .getUserSplittingRule().getPathForUsername(m.group(1));
                                name = name + ((m.group(2) != null) ? m.group(2) : "");
                            }
                        } else {
                            name = pathMapping.get("/") + StringUtils.stripStart(name, "/");
                        }
                        if (!zipentry.isDirectory()) {
                            try {
                                String filename = name.substring(name.lastIndexOf('/') + 1);
                                ensureFile(session, name, zis, JCRContentUtils.getMimeType(filename), site);
                            } catch (Exception e) {
                                logger.error("Cannot upload file " + zipentry.getName(), e);
                            }
                        } else {
                            ensureDir(session, name, site);
                        }
                    }
                } else if (name.equals(CATEGORIES_XML)) {
                    catProps = importCategoriesAndGetUuidProps(zis, categoriesImportHandler);
                } else if (name.equals(DEFINITIONS_CND)) {
                    reg = new NodeTypeRegistry(); // this is fishy: a new instance is created here when NodeTypeRegistry is meant to be used as a singleton
                    try {
                        for (Map.Entry<String, File> entry : NodeTypeRegistry.getSystemDefinitionsFiles()
                                .entrySet()) {
                            reg.addDefinitionsFile(entry.getValue(), entry.getKey());
                        }
                        if (legacyImport) {
                            JahiaCndReaderLegacy r = new JahiaCndReaderLegacy(
                                    new InputStreamReader(zis, Charsets.UTF_8), zipentry.getName(),
                                    file.getURL().getPath(), reg);
                            r.parse();
                        } else {
                            reg.addDefinitionsFile(new InputStreamResource(zis, zipentry.getName()),
                                    file.getURL().getPath());
                        }
                    } catch (RepositoryException | ParseException e) {
                        logger.error(e.getMessage(), e);
                    }
                } else if (name.equals(DEFINITIONS_MAP)) {
                    mapping = new DefinitionsMapping();
                    mapping.load(zis);

                }
                zis.closeEntry();
            }
        } finally {
            closeInputStream(zis);
        }
    }

    // Import legacy content from 5.x and 6.x
    if (legacyImport) {
        long timerLegacy = System.currentTimeMillis();
        final String originatingJahiaRelease = (String) infos.get("originatingJahiaRelease");
        logger.info("Start legacy import, source version is " + originatingJahiaRelease);
        if (legacyMappingFilePath != null) {
            mapping = new DefinitionsMapping();
            final InputStream fileInputStream = legacyMappingFilePath.getInputStream();
            try {
                mapping.load(fileInputStream);
            } finally {
                IOUtils.closeQuietly(fileInputStream);
            }
        }
        if (legacyDefinitionsFilePath != null) {
            reg = new NodeTypeRegistry();
            if ("6.1".equals(originatingJahiaRelease)) {
                logger.info("Loading the built in 6.1 definitions before processing the provided custom ones");
                final List<String> builtInLegacyDefs = Arrays.asList("01-system-nodetypes.cnd",
                        "02-jahiacore-nodetypes.cnd", "03-files-nodetypes.cnd", "04-jahiacontent-nodetypes.cnd",
                        "05-standard-types.cnd", "10-extension-nodetypes.cnd", "11-preferences-nodetypes.cnd");

                for (String builtInLegacyDefsFile : builtInLegacyDefs) {
                    InputStreamReader inputStreamReader = null;
                    try {
                        final InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(
                                "org/jahia/migration/legacyDefinitions/jahia6/" + builtInLegacyDefsFile);
                        if (inputStream != null) {
                            inputStreamReader = new InputStreamReader(inputStream, "UTF-8");
                            final JahiaCndReaderLegacy r = new JahiaCndReaderLegacy(inputStreamReader,
                                    builtInLegacyDefsFile, file.getURL().getPath(), reg);
                            r.parse();
                        } else {
                            logger.error("Couldn't load " + builtInLegacyDefsFile);
                        }
                    } catch (ParseException e) {
                        logger.error(e.getMessage(), e);
                    } finally {
                        IOUtils.closeQuietly(inputStreamReader);
                    }
                }
            } else {
                try {
                    for (Map.Entry<String, File> entry : NodeTypeRegistry.getSystemDefinitionsFiles()
                            .entrySet()) {
                        reg.addDefinitionsFile(entry.getValue(), entry.getKey());
                    }
                } catch (ParseException e) {
                    logger.error("Cannot parse definitions : " + e.getMessage(), e);
                }
            }
            InputStreamReader streamReader = null;
            try {
                streamReader = new InputStreamReader(legacyDefinitionsFilePath.getInputStream(), "UTF-8");
                JahiaCndReaderLegacy r = new JahiaCndReaderLegacy(streamReader,
                        legacyDefinitionsFilePath.getFilename(), file.getURL().getPath(), reg);
                r.parse();
            } catch (ParseException e) {
                logger.error(e.getMessage(), e);
            } finally {
                IOUtils.closeQuietly(streamReader);
            }
        }
        // Old import
        JCRNodeWrapper siteFolder = session.getNode("/sites/" + site.getSiteKey());

        zis = new NoCloseZipInputStream(new BufferedInputStream(file.getInputStream()));
        try {
            int legacyImportHandlerCtnId = 1;
            while (true) {
                ZipEntry zipentry = zis.getNextEntry();
                if (zipentry == null)
                    break;
                String name = zipentry.getName();
                if (name.equals(FILESACL_XML)) {
                    logger.info("Importing file " + FILESACL_XML);
                    importFilesAcl(site, file, zis, mapping, fileList);
                } else if (name.startsWith("export")) {
                    logger.info("Importing file " + name);
                    String languageCode;
                    if (name.indexOf("_") != -1) {
                        languageCode = name.substring(7, name.lastIndexOf("."));
                    } else {
                        languageCode = site.getLanguagesAsLocales().iterator().next().toString();
                    }
                    zipentry.getSize();

                    LegacyImportHandler importHandler = new LegacyImportHandler(session, siteFolder, reg,
                            mapping, LanguageCodeConverters.languageCodeToLocale(languageCode),
                            infos != null ? originatingJahiaRelease : null, legacyPidMappingTool,
                            legacyImportHandlerCtnId);
                    Map<String, List<String>> references = new LinkedHashMap<String, List<String>>();
                    importHandler.setReferences(references);

                    InputStream documentInput = zis;
                    if (this.xmlContentTransformers != null && this.xmlContentTransformers.size() > 0) {
                        documentInput = new ZipInputStream(file.getInputStream());
                        while (!name.equals(((ZipInputStream) documentInput).getNextEntry().getName()))
                            ;
                        byte[] buffer = new byte[2048];
                        final File tmpDirectoryForSite = new File(
                                new File(System.getProperty("java.io.tmpdir"), "jahia-migration"),
                                FastDateFormat.getInstance("yyyy_MM_dd-HH_mm_ss_SSS").format(timerSite) + "_"
                                        + site.getSiteKey());
                        tmpDirectoryForSite.mkdirs();
                        File document = new File(tmpDirectoryForSite,
                                "export_" + languageCode + "_00_extracted.xml");
                        final OutputStream output = new BufferedOutputStream(new FileOutputStream(document),
                                2048);
                        int count = 0;
                        while ((count = documentInput.read(buffer, 0, 2048)) > 0) {
                            output.write(buffer, 0, count);
                        }
                        output.flush();
                        output.close();
                        documentInput.close();
                        for (XMLContentTransformer xct : xmlContentTransformers) {
                            document = xct.transform(document, tmpDirectoryForSite);
                        }
                        documentInput = new FileInputStream(document);
                    }

                    handleImport(documentInput, importHandler, name);
                    legacyImportHandlerCtnId = importHandler.getCtnId();
                    ReferencesHelper.resolveCrossReferences(session, references);
                    siteFolder.getSession().save(JCRObservationManager.IMPORT);
                }
                zis.closeEntry();
            }
            ReferencesHelper.resolveReferencesKeeper(session);
            siteFolder.getSession().save(JCRObservationManager.IMPORT);
        } finally {
            closeInputStream(zis);
        }
        logger.info("Done legacy import in {}",
                DateUtils.formatDurationWords(System.currentTimeMillis() - timerLegacy));
    }

    categoriesImportHandler.setUuidProps(catProps);
    usersImportHandler.setUuidProps(userProps);

    // session.save();
    session.save(JCRObservationManager.IMPORT);
    cleanFilesList(fileList);

    if (legacyImport && this.postImportPatcher != null) {
        final long timerPIP = System.currentTimeMillis();
        logger.info("Executing post import patches");
        this.postImportPatcher.executePatches(site);
        logger.info("Executed post import patches in {}",
                DateUtils.formatDurationWords(System.currentTimeMillis() - timerPIP));
    }

    logger.info("Done importing site {} in {}", site != null ? site.getSiteKey() : "",
            DateUtils.formatDurationWords(System.currentTimeMillis() - timerSite));
}