Example usage for org.springframework.core.io Resource getURL

List of usage examples for org.springframework.core.io Resource getURL

Introduction

In this page you can find the example usage for org.springframework.core.io Resource getURL.

Prototype

URL getURL() throws IOException;

Source Link

Document

Return a URL handle for this resource.

Usage

From source file:org.infosec.ismp.collectd.snmp.castor.CastorUtils.java

/**
 * Unmarshal a Castor XML configuration file.  Uses Java 5 generics for
 * return type. /*from w w  w .j a v a2  s.  c o  m*/
 * 
 * @param <T> the class representing the marshalled XML configuration
 *      file.  This will be the return time form the method.
 * @param clazz the class representing the marshalled XML configuration
 *      file
 * @param resource the marshalled XML configuration file to unmarshal
 * @return Unmarshalled object representing XML file
 * @throws MarshalException if the underlying Castor
 *      Unmarshaller.unmarshal() call throws a MarshalException
 * @throws ValidationException if the underlying Castor
 *      Unmarshaller.unmarshal() call throws a ValidationException
 * @throws IOException if the resource could not be opened
 */
public static <T> T unmarshal(Class<T> clazz, Resource resource)
        throws MarshalException, ValidationException, IOException {
    InputStream in;
    try {
        in = resource.getInputStream();
    } catch (IOException e) {
        IOException newE = new IOException(
                "Failed to open XML configuration file for resource '" + resource + "': " + e);
        newE.initCause(e);
        throw newE;
    }

    try {
        InputSource source = new InputSource(in);
        try {
            source.setSystemId(resource.getURL().toString());
        } catch (Throwable t) {
            // ignore
        }
        return unmarshal(clazz, source);
    } finally {
        IOUtils.closeQuietly(in);
    }
}

From source file:org.infosec.ismp.collectd.snmp.castor.CastorUtils.java

/**
 * Unmarshal a Castor XML configuration file.  Uses Java 5 generics for
 * return type and throws DataAccessExceptions.
 * /*from  ww w . j a v  a 2s .c o m*/
 * @param <T> the class representing the marshalled XML configuration
 *      file.  This will be the return time form the method.
 * @param clazz the class representing the marshalled XML configuration
 *      file
 * @param resource the marshalled XML configuration file to unmarshal
 * @return Unmarshalled object representing XML file
 * @throws DataAccessException if the resource could not be opened or the
 *      underlying Castor
 *      Unmarshaller.unmarshal() call throws a MarshalException or
 *      ValidationException.  The underlying exception will be translated
 *      using CastorExceptionTranslator and will include information about
 *      the resource from its {@link Resource#toString() toString()} method.
 */
public static <T> T unmarshalWithTranslatedExceptions(Class<T> clazz, Resource resource) {
    // TODO It might be useful to add code to test for readability on real files; the code below is from DefaultManualProvisioningDao - dj@opennms.org 
    //        if (!importFile.canRead()) {
    //            throw new PermissionDeniedDataAccessException("Unable to read file "+importFile, null);
    //        }

    InputStream in;
    try {
        in = resource.getInputStream();
    } catch (IOException e) {
        throw CASTOR_EXCEPTION_TRANSLATOR
                .translate("opening XML configuration file for resource '" + resource + "'", e);
    }

    try {
        InputSource source = new InputSource(in);
        try {
            source.setSystemId(resource.getURL().toString());
        } catch (Throwable t) {
            /*
             * resource.getURL() might throw an IOException
             * (or maybe a DataAccessException, since it's a
             * RuntimeException), indicating that the resource can't be
             * represented as a URL.  We don't really care so much--we'll
             * only lose the ability for Castor to include the resource URL
             * in error messages and for it to directly resolve relative
             * URLs (which we don't currently use), so we just ignore it.
             */
        }
        return unmarshal(clazz, source);
    } catch (MarshalException e) {
        throw CASTOR_EXCEPTION_TRANSLATOR.translate("unmarshalling XML file for resource '" + resource + "'",
                e);
    } catch (ValidationException e) {
        throw CASTOR_EXCEPTION_TRANSLATOR.translate("unmarshalling XML file for resource '" + resource + "'",
                e);
    } finally {
        IOUtils.closeQuietly(in);
    }
}

From source file:org.jahia.bundles.extender.jahiamodules.Activator.java

private void scanForImportFiles(Bundle bundle, JahiaTemplatesPackage jahiaTemplatesPackage) {
    List<Resource> importFiles = new ArrayList<Resource>();
    Enumeration<URL> importXMLEntryEnum = bundle.findEntries("META-INF", "import*.xml", false);
    if (importXMLEntryEnum != null) {
        while (importXMLEntryEnum.hasMoreElements()) {
            importFiles.add(new BundleResource(importXMLEntryEnum.nextElement(), bundle));
        }//ww w. ja v  a 2s .  c  o m
    }
    Enumeration<URL> importZIPEntryEnum = bundle.findEntries("META-INF", "import*.zip", false);
    if (importZIPEntryEnum != null) {
        while (importZIPEntryEnum.hasMoreElements()) {
            importFiles.add(new BundleResource(importZIPEntryEnum.nextElement(), bundle));
        }
    }
    Collections.sort(importFiles, IMPORT_FILE_COMPARATOR);
    for (Resource importFile : importFiles) {
        try {
            jahiaTemplatesPackage.addInitialImport(importFile.getURL().getPath());
        } catch (IOException e) {
            logger.error("Error retrieving URL for resource " + importFile, e);
        }
    }
}

From source file:org.jahia.services.content.nodetypes.NodeTypeRegistry.java

/**
 * Reads the specified CND file resource and parses it to obtain a list of node type definitions.
 * /*w w w  .j a  va  2  s .c o m*/
 * @param resource
 *            a resource, representing a CND file
 * @param systemId
 *            the ID to use to specify the "origin" on the node types from this file
 * @return a list of the node types parsed from the specified resource
 * @throws ParseException
 *             in case of a parsing error
 * @throws IOException
 *             in case of an I/O error when reading the specified resource
 */
public List<ExtendedNodeType> getDefinitionsFromFile(Resource resource, String systemId)
        throws ParseException, IOException {
    String ext = resource.getURL().getPath().substring(resource.getURL().getPath().lastIndexOf('.'));
    if (ext.equalsIgnoreCase(".cnd")) {
        Reader resourceReader = null;
        try {
            resourceReader = new InputStreamReader(resource.getInputStream(), Charsets.UTF_8);
            JahiaCndReader r = new JahiaCndReader(resourceReader, resource.getURL().getPath(), systemId, this);
            r.parse();
            return r.getNodeTypesList();
        } finally {
            IOUtils.closeQuietly(resourceReader);
        }
    }
    return Collections.emptyList();
}

From source file:org.jahia.services.content.rules.RulesListener.java

public void addRules(Resource dsrlFile, JahiaTemplatesPackage aPackage) {
    long start = System.currentTimeMillis();
    try {/*from ww w  . j a v a2s .  co m*/
        File compiledRulesDir = new File(SettingsBean.getInstance().getJahiaVarDiskPath() + "/compiledRules");
        if (aPackage != null) {
            compiledRulesDir = new File(compiledRulesDir, aPackage.getIdWithVersion());
        } else {
            compiledRulesDir = new File(compiledRulesDir, "system");
        }
        if (!compiledRulesDir.exists()) {
            compiledRulesDir.mkdirs();
        }

        ClassLoader packageClassLoader = aPackage != null ? aPackage.getClassLoader() : null;
        if (packageClassLoader != null) {
            ruleBaseClassLoader.addClassLoaderToEnd(packageClassLoader);
        }

        // first let's test if the file exists in the same location, if it was pre-packaged as a compiled rule
        File pkgFile = new File(compiledRulesDir,
                StringUtils.substringAfterLast(dsrlFile.getURL().getPath(), "/") + ".pkg");
        if (pkgFile.exists() && pkgFile.lastModified() > dsrlFile.lastModified()) {
            ObjectInputStream ois = null;
            try {
                ois = new DroolsObjectInputStream(new FileInputStream(pkgFile),
                        packageClassLoader != null ? packageClassLoader : null);
                Package pkg = new Package();
                pkg.readExternal(ois);
                if (ruleBase.getPackage(pkg.getName()) != null) {
                    ruleBase.removePackage(pkg.getName());
                }
                applyDisabledRulesConfiguration(pkg);
                ruleBase.addPackage(pkg);
                if (aPackage != null) {
                    modulePackageNameMap.put(aPackage.getName(), pkg.getName());
                }
            } finally {
                IOUtils.closeQuietly(ois);
            }
        } else {
            InputStream drlInputStream = dsrlFile.getInputStream();
            List<String> lines = Collections.emptyList();
            try {
                lines = IOUtils.readLines(drlInputStream);
            } finally {
                IOUtils.closeQuietly(drlInputStream);
            }
            StringBuilder drl = new StringBuilder(4 * 1024);
            for (String line : lines) {
                if (drl.length() > 0) {
                    drl.append("\n");
                }
                if (line.trim().length() > 0 && line.trim().charAt(0) == '#') {
                    drl.append(StringUtils.replaceOnce(line, "#", "//"));
                } else {
                    drl.append(line);
                }
            }

            PackageBuilderConfiguration cfg = packageClassLoader != null
                    ? new PackageBuilderConfiguration(packageClassLoader)
                    : new PackageBuilderConfiguration();

            PackageBuilder builder = new PackageBuilder(cfg);

            Reader drlReader = new StringReader(drl.toString());
            try {
                builder.addPackageFromDrl(drlReader, new StringReader(getDslFiles()));
            } finally {
                IOUtils.closeQuietly(drlReader);
            }

            PackageBuilderErrors errors = builder.getErrors();

            if (errors.getErrors().length == 0) {
                Package pkg = builder.getPackage();

                ObjectOutputStream oos = null;
                try {
                    pkgFile.getParentFile().mkdirs();
                    oos = new DroolsObjectOutputStream(new FileOutputStream(pkgFile));
                    pkg.writeExternal(oos);
                } catch (IOException e) {
                    logger.error("Error writing rule package to file " + pkgFile, e);
                } finally {
                    IOUtils.closeQuietly(oos);
                }

                if (ruleBase.getPackage(pkg.getName()) != null) {
                    ruleBase.removePackage(pkg.getName());
                }
                applyDisabledRulesConfiguration(pkg);
                ruleBase.addPackage(pkg);
                if (aPackage != null) {
                    modulePackageNameMap.put(aPackage.getName(), pkg.getName());
                }
                logger.info("Rules for " + pkg.getName() + " updated in " + (System.currentTimeMillis() - start)
                        + "ms.");
            } else {
                logger.error(
                        "---------------------------------------------------------------------------------");
                logger.error("Errors when compiling rules in " + dsrlFile + " : " + errors.toString());
                logger.error(
                        "---------------------------------------------------------------------------------");
            }
        }
    } catch (Exception e) {
        logger.error(e.getMessage(), e);
    }
}

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

/**
 * Import a full site zip into a newly created site.
 * <p/>//from www. ja  va 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));
}

From source file:org.jahia.utils.FileUtils.java

/**
 * Returns the last modified date of the specified resource.
 * //from  ww  w  . ja va2 s.  co m
 * @param resource
 *            resource to check the last modified date on
 * @return the last modified date of the specified resource
 * @throws IOException
 *             in case of an I/O error
 */
public static long getLastModified(Resource resource) throws IOException {
    URL resourceUrl = resource.getURL();
    return ResourceUtils.isJarURL(resourceUrl)
            ? ResourceUtils.getFile(ResourceUtils.extractJarFileURL(resourceUrl)).lastModified()
            : resource.lastModified();
}

From source file:org.jasig.cas.adaptors.x509.util.CertUtils.java

/**
 * Fetches an X.509 CRL from a resource such as a file or URL.
 *
 * @param resource Resource descriptor.//from w  w w.jav a2  s  . c  o  m
 *
 * @return X.509 CRL
 *
 * @throws IOException On IOErrors.
 * @throws CRLException On CRL parse errors.
 */
public static X509CRL fetchCRL(final Resource resource) throws CRLException, IOException {
    // Always attempt to open a new stream on the URL underlying the resource
    final InputStream in = resource.getURL().openStream();
    try {
        return (X509CRL) CertUtils.getCertificateFactory().generateCRL(in);
    } finally {
        IOUtils.closeQuietly(in);
    }
}

From source file:org.jumpmind.metl.core.util.DatabaseScriptContainer.java

protected void executeImports(Resource resource) throws IOException {
    BufferedReader reader = null;
    try {//from   w ww.  j  a  v  a 2s  .c  o  m
        reader = new BufferedReader(new InputStreamReader(resource.getInputStream()));
        String line = reader.readLine();
        while (line != null) {
            if (line.startsWith(IMPORT_PREFIX)) {
                String file = line.substring(IMPORT_PREFIX.length()).trim();
                Resource[] resources = ResourcePatternUtils
                        .getResourcePatternResolver(new DefaultResourceLoader())
                        .getResources(String.format("classpath*:%s/%s", scriptLocation, file));
                for (Resource resource2 : resources) {
                    execute(resource2.getURL());
                }
            }
            line = reader.readLine();
        }
    } finally {
        IOUtils.closeQuietly(reader);
    }
}

From source file:org.jzkit.search.util.RecordConversion.XSLFragmentTransformer.java

private void reloadStylesheet() throws javax.xml.transform.TransformerConfigurationException {
    log.debug("XSLFragmentTransformer::reloadStylesheet()");
    try {// ww w  .  j  av  a  2s  .c o  m
        TransformerFactory tFactory = TransformerFactory.newInstance();
        if (ctx == null)
            throw new RuntimeException("Application Context Is Null. Cannot resolve resources");

        org.springframework.core.io.Resource r = ctx.getResource(the_path);
        if ((r != null) && (r.exists())) {
            URL path_url = r.getURL();
            URLConnection conn = path_url.openConnection();
            datestamp = conn.getDate();
            log.debug("get template for " + the_path + " url:" + path_url + " datestamp=" + datestamp);
            t = tFactory.newTemplates(new javax.xml.transform.stream.StreamSource(conn.getInputStream()));
        } else {
            log.error("Unable to resolve URL for " + the_path);
        }
    } catch (java.io.IOException ioe) {
        log.warn("Problem with XSL mapping", ioe);
        throw new RuntimeException("Unable to locate mapping: " + the_path);
    } catch (javax.xml.transform.TransformerConfigurationException tce) {
        log.warn("Problem with XSL mapping", tce);
        throw (tce);
    }

}