Examples with UpdateSite org.openntf.nsfodp.compiler.update.UpdateSite used on opensource projects

Example 1 with UpdateSite

use of org.openntf.nsfodp.compiler.update.UpdateSite in project org.openntf.nsfodp by OpenNTF.

the class ODPCompilerServlet method doPost.

@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    Principal user = req.getUserPrincipal();
    resp.setBufferSize(0);
    resp.setStatus(HttpServletResponse.SC_OK);
    ServletOutputStream os = resp.getOutputStream();
    Set<Path> cleanup = new HashSet<>();
    try {
        if (!ALLOW_ANONYMOUS && "Anonymous".equalsIgnoreCase(user.getName())) {
            // $NON-NLS-1$
            resp.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            // $NON-NLS-1$
            resp.setContentType("text/plain");
            os.println(Messages.ODPCompilerServlet_anonymousDisallowed);
            return;
        }
        // Developer's note: multipart/form-data with files broken out would be nice,
        // but Domino as of 9.0.1FP10 behaves poorly with them; for now, it's safer
        // to use a combined ZIP and pass options in headers
        String contentType = req.getContentType();
        if (!"application/zip".equals(contentType)) {
            // $NON-NLS-1$
            throw new IllegalArgumentException(Messages.ODPCompilerServlet_contentMustBeZip);
        }
        // $NON-NLS-1$ //$NON-NLS-2$
        Path packageFile = Files.createTempFile(NSFODPUtil.getTempDirectory(), "package", ".zip");
        cleanup.add(packageFile);
        try (InputStream reqInputStream = req.getInputStream()) {
            Files.copy(reqInputStream, packageFile, StandardCopyOption.REPLACE_EXISTING);
        }
        // Look for an ODP item
        Path odpZip = null;
        List<Path> siteZips = new ArrayList<>();
        List<Path> classPathJars = new ArrayList<>();
        try (ZipFile packageZip = new ZipFile(packageFile.toFile(), StandardCharsets.UTF_8)) {
            // $NON-NLS-1$
            ZipEntry odpEntry = packageZip.getEntry("odp.zip");
            if (odpEntry == null) {
                // Then the package is itself the ODP
                odpZip = packageFile;
            } else {
                // Then extract the ODP
                // $NON-NLS-1$ //$NON-NLS-2$
                odpZip = Files.createTempFile(NSFODPUtil.getTempDirectory(), "odp", ".zip");
                cleanup.add(odpZip);
                try (InputStream odpIs = packageZip.getInputStream(odpEntry)) {
                    Files.copy(odpIs, odpZip, StandardCopyOption.REPLACE_EXISTING);
                }
                // Look for any embedded update sites and classpath entries
                packageZip.stream().forEach(entry -> {
                    try {
                        if (SITE_ZIP_PATTERN.matcher(entry.getName()).matches()) {
                            // Then add it as an update site
                            // $NON-NLS-1$ //$NON-NLS-2$
                            Path siteZip = Files.createTempFile(NSFODPUtil.getTempDirectory(), "site", ".zip");
                            cleanup.add(siteZip);
                            try (InputStream siteIs = packageZip.getInputStream(entry)) {
                                Files.copy(siteIs, siteZip, StandardCopyOption.REPLACE_EXISTING);
                            }
                            siteZips.add(siteZip);
                        } else if (entry.getName().startsWith("classpath/")) {
                            // $NON-NLS-1$
                            // Then add it as an individual JAR
                            // $NON-NLS-1$ //$NON-NLS-2$
                            Path cpJar = Files.createTempFile(NSFODPUtil.getTempDirectory(), "classpathJar", ".jar");
                            cleanup.add(cpJar);
                            try (InputStream jarIs = packageZip.getInputStream(entry)) {
                                Files.copy(jarIs, cpJar, StandardCopyOption.REPLACE_EXISTING);
                            }
                            classPathJars.add(cpJar);
                        }
                    } catch (IOException e) {
                        throw new RuntimeException(e);
                    }
                });
            }
        }
        IProgressMonitor mon = new LineDelimitedJsonProgressMonitor(os);
        Path nsf;
        try (FileSystem fs = NSFODPUtil.openZipPath(odpZip)) {
            // $NON-NLS-1$
            Path odpFile = fs.getPath("/");
            OnDiskProject odp = new OnDiskProject(odpFile);
            ODPCompiler compiler = new ODPCompiler(ODPCompilerActivator.instance.getBundle().getBundleContext(), odp, mon);
            // See if the client requested a specific compiler level
            String compilerLevel = req.getHeader(NSFODPConstants.HEADER_COMPILER_LEVEL);
            if (StringUtil.isNotEmpty(compilerLevel)) {
                compiler.setCompilerLevel(compilerLevel);
            }
            String appendTimestamp = req.getHeader(NSFODPConstants.HEADER_APPEND_TIMESTAMP);
            if ("true".equals(appendTimestamp)) {
                // $NON-NLS-1$
                compiler.setAppendTimestampToTitle(true);
            }
            String templateName = req.getHeader(NSFODPConstants.HEADER_TEMPLATE_NAME);
            if (StringUtil.isNotEmpty(templateName)) {
                compiler.setTemplateName(templateName);
                String templateVersion = req.getHeader(NSFODPConstants.HEADER_TEMPLATE_VERSION);
                if (StringUtil.isNotEmpty(templateVersion)) {
                    compiler.setTemplateVersion(templateVersion);
                }
            }
            String setXspOptions = req.getHeader(NSFODPConstants.HEADER_SET_PRODUCTION_XSP);
            if ("true".equals(setXspOptions)) {
                // $NON-NLS-1$
                compiler.setSetProductionXspOptions(true);
            }
            String odsRelease = req.getHeader(NSFODPConstants.HEADER_ODS_RELEASE);
            if (StringUtil.isNotEmpty(odsRelease)) {
                compiler.setOdsRelease(odsRelease);
            }
            String compileBasicLs = req.getHeader(NSFODPConstants.HEADER_COMPILE_BASICLS);
            if ("true".equals(compileBasicLs)) {
                // $NON-NLS-1$
                compiler.setCompileBasicElementLotusScript(true);
            }
            if (siteZips != null && !siteZips.isEmpty()) {
                for (Path siteZip : siteZips) {
                    Path siteFile = NSFODPUtil.expandZip(siteZip);
                    cleanup.add(siteFile);
                    UpdateSite updateSite = new FilesystemUpdateSite(siteFile);
                    compiler.addUpdateSite(updateSite);
                }
            }
            classPathJars.forEach(compiler::addClassPathEntry);
            nsf = this.exec.submit(() -> {
                Path result = compiler.compile();
                mon.done();
                return result;
            }).get();
        }
        // Now stream the NSF
        cleanup.add(nsf);
        try (OutputStream gzos = new GZIPOutputStream(os)) {
            Files.copy(nsf, gzos);
        }
        resp.flushBuffer();
        // Delete the NSF via the Notes API
        try (NotesAPI api = NotesAPI.get()) {
            api.deleteDatabase(nsf.toString());
        }
    } catch (Throwable e) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        PrintWriter out = new PrintWriter(baos);
        e.printStackTrace(out);
        out.flush();
        os.println(LineDelimitedJsonProgressMonitor.message(// $NON-NLS-1$ //$NON-NLS-2$
        "type", // $NON-NLS-1$ //$NON-NLS-2$
        "error", // $NON-NLS-1$
        "stackTrace", // $NON-NLS-1$
        baos.toString()));
    } finally {
        NSFODPUtil.deltree(cleanup);
    }
}