Example usage for org.apache.commons.io FileUtils openOutputStream

List of usage examples for org.apache.commons.io FileUtils openOutputStream

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.io.*
  5. FileUtils
  6. openOutputStream

Introduction

In this page you can find the example usage for org.apache.commons.io FileUtils openOutputStream.

Prototype

public static FileOutputStream openOutputStream(File file) throws IOException

Source Link

Document

Opens a FileOutputStream for the specified file, checking and creating the parent directory if it does not exist.

Usage

From source file:dotaSoundEditor.Controls.EditorPanel.java

private File createSoundFileFromWaveString(String waveString, Path vpkToPlayFrom) {
    if (!(waveString.contains(".wav") || (waveString.contains(".mp3")))) {
        return null;
    }//from w  w  w .  j  a v a2  s  . com

    File file = new File(vpkToPlayFrom.toString());
    VPKArchive vpk = new VPKArchive();
    File entryFile = new File("");

    String waveSubstring = "";
    int startIndex = -1;
    int endIndex = -1;
    if (waveString.contains("\"wave\"")) {
        startIndex = Utility.nthOccurrence(waveString, '\"', 2);
        endIndex = Utility.nthOccurrence(waveString, '\"', 3);
    }
    //For weird special cases where the "wave" part of the string is missing, i.e. Treant's Overgrowth.Target spell
    else {
        startIndex = Utility.nthOccurrence(waveString, '\"', 0);
        endIndex = Utility.nthOccurrence(waveString, '\"', 1);
    }

    waveSubstring = waveString.substring(startIndex, endIndex + 1);
    waveSubstring = waveSubstring.replace(")", "");
    waveSubstring = waveSubstring.replace("\"", "");
    waveSubstring = waveSubstring.replace("\\", "/");
    waveSubstring = waveSubstring.replace("#", "");
    waveSubstring = waveSubstring.replace("*", "");

    if (!waveString.contains("custom") && !waveString.contains("//Replaced")) {
        File localFile = new File(Paths.get(installDir + "/sound/" + waveSubstring).toString());
        if (localFile.isFile()) {
            return localFile;
        }

        try {
            vpk.load(file);
        } catch (Exception ex) {
            System.err.println("Can't open archive: " + ex.getMessage());
        }
        waveSubstring = "sound/" + waveSubstring;
        VPKEntry entry = vpk.getEntry(waveSubstring.toLowerCase());

        entryFile = entry.getType().contains("wav")
                ? new File(Paths.get(System.getProperty("user.dir") + "/scratch/scratch.wav").toString())
                : new File(Paths.get(System.getProperty("user.dir") + "/scratch/scratch.mp3").toString());

        try (FileChannel fc = FileUtils.openOutputStream(entryFile).getChannel()) {
            fc.write(entry.getData());
        } catch (IOException ex) {
            ex.printStackTrace();
        }

        return entryFile;
    } else //If it's NOT stored in the VPK, it's on the local filesys
    {
        entryFile = new File(Paths.get(installDir, "/dota/sound/" + waveSubstring).toString());
        return entryFile;
    }
}

From source file:com.cws.esolutions.security.dao.certmgmt.impl.CertificateManagerImpl.java

/**
 * @see com.cws.esolutions.security.dao.certmgmt.interfaces.ICertificateManager#createCertificateRequest(List, String, int, int)
 *///w w w.ja v  a2 s.  c o  m
public synchronized File createCertificateRequest(final List<String> subjectData, final String storePassword,
        final int validityPeriod, final int keySize) throws CertificateManagementException {
    final String methodName = ICertificateManager.CNAME
            + "#createCertificateRequest(final List<String> subjectData, final String storePassword, final int validityPeriod, final int keySize) throws CertificateManagementException";

    if (DEBUG) {
        DEBUGGER.debug(methodName);
        DEBUGGER.debug("Value: {}", subjectData);
        DEBUGGER.debug("Value: {}", validityPeriod);
        DEBUGGER.debug("Value: {}", keySize);
    }

    final File rootDirectory = certConfig.getRootDirectory();
    final String signatureAlgorithm = certConfig.getSignatureAlgorithm();
    final String certificateAlgorithm = certConfig.getCertificateAlgorithm();
    final File privateKeyDirectory = FileUtils
            .getFile(certConfig.getPrivateKeyDirectory() + "/" + subjectData.get(0));
    final File publicKeyDirectory = FileUtils
            .getFile(certConfig.getPublicKeyDirectory() + "/" + subjectData.get(0));
    final File csrDirectory = FileUtils.getFile(certConfig.getCsrDirectory() + "/" + subjectData.get(0));
    final File storeDirectory = FileUtils.getFile(certConfig.getStoreDirectory() + "/" + subjectData.get(0));
    final X500Name x500Name = new X500Name("CN=" + subjectData.get(0) + ",OU=" + subjectData.get(1) + ",O="
            + subjectData.get(2) + ",L=" + subjectData.get(3) + ",ST=" + subjectData.get(4) + ",C="
            + subjectData.get(5) + ",E=" + subjectData.get(6));

    if (DEBUG) {
        DEBUGGER.debug("rootDirectory: {}", rootDirectory);
        DEBUGGER.debug("signatureAlgorithm: {}", signatureAlgorithm);
        DEBUGGER.debug("certificateAlgorithm: {}", certificateAlgorithm);
        DEBUGGER.debug("privateKeyDirectory: {}", privateKeyDirectory);
        DEBUGGER.debug("publicKeyDirectory: {}", publicKeyDirectory);
        DEBUGGER.debug("csrDirectory: {}", csrDirectory);
        DEBUGGER.debug("storeDirectory: {}", storeDirectory);
        DEBUGGER.debug("x500Name: {}", x500Name);
    }

    File csrFile = null;
    JcaPEMWriter csrPemWriter = null;
    JcaPEMWriter publicKeyWriter = null;
    JcaPEMWriter privateKeyWriter = null;
    FileOutputStream csrFileStream = null;
    FileOutputStream keyStoreStream = null;
    FileOutputStream publicKeyFileStream = null;
    FileOutputStream privateKeyFileStream = null;
    OutputStreamWriter csrFileStreamWriter = null;
    OutputStreamWriter privateKeyStreamWriter = null;
    OutputStreamWriter publicKeyStreamWriter = null;

    try {
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(null, storePassword.toCharArray());

        if (DEBUG) {
            DEBUGGER.debug("KeyStore: {}", keyStore);
        }

        SecureRandom random = new SecureRandom();
        KeyPairGenerator keyGenerator = KeyPairGenerator.getInstance(certificateAlgorithm);
        keyGenerator.initialize(keySize, random);

        if (DEBUG) {
            DEBUGGER.debug("KeyGenerator: {}", keyGenerator);
        }

        KeyPair keyPair = keyGenerator.generateKeyPair();

        if (DEBUG) {
            DEBUGGER.debug("KeyPair: {}", keyPair);
        }

        if (keyPair != null) {
            final Signature sig = Signature.getInstance(signatureAlgorithm);
            final PrivateKey privateKey = keyPair.getPrivate();
            final PublicKey publicKey = keyPair.getPublic();

            if (DEBUG) {
                DEBUGGER.debug("Signature: {}", sig);
                DEBUGGER.debug("PrivateKey: {}", privateKey);
                DEBUGGER.debug("PublicKey: {}", publicKey);
            }

            sig.initSign(privateKey, random);
            ContentSigner signGen = new JcaContentSignerBuilder(signatureAlgorithm).build(privateKey);

            if (DEBUG) {
                DEBUGGER.debug("ContentSigner: {}", signGen);
            }

            Calendar expiry = Calendar.getInstance();
            expiry.add(Calendar.DAY_OF_YEAR, validityPeriod);

            if (DEBUG) {
                DEBUGGER.debug("Calendar: {}", expiry);
            }

            CertificateFactory certFactory = CertificateFactory.getInstance(certConfig.getCertificateType());

            if (DEBUG) {
                DEBUGGER.debug("CertificateFactory: {}", certFactory);
            }

            X509Certificate[] issuerCert = new X509Certificate[] { (X509Certificate) certFactory
                    .generateCertificate(new FileInputStream(certConfig.getIntermediateCertificateFile())) };

            if (DEBUG) {
                DEBUGGER.debug("X509Certificate[]: {}", (Object) issuerCert);
            }

            keyStore.setCertificateEntry(certConfig.getRootCertificateName(), certFactory.generateCertificate(
                    new FileInputStream(FileUtils.getFile(certConfig.getRootCertificateFile()))));
            keyStore.setCertificateEntry(certConfig.getIntermediateCertificateName(),
                    certFactory.generateCertificate(new FileInputStream(
                            FileUtils.getFile(certConfig.getIntermediateCertificateFile()))));

            PKCS10CertificationRequestBuilder builder = new JcaPKCS10CertificationRequestBuilder(x500Name,
                    publicKey);

            if (DEBUG) {
                DEBUGGER.debug("PKCS10CertificationRequestBuilder: {}", builder);
            }

            PKCS10CertificationRequest csr = builder.build(signGen);

            if (DEBUG) {
                DEBUGGER.debug("PKCS10CertificationRequest: {}", csr);
            }

            // write private key
            File privateKeyFile = FileUtils.getFile(privateKeyDirectory + "/" + subjectData.get(0)
                    + SecurityServiceConstants.PRIVATEKEY_FILE_EXT);

            if (DEBUG) {
                DEBUGGER.debug("privateKeyFile: {}", privateKeyFile);
            }

            if (!(privateKeyFile.createNewFile())) {
                throw new IOException("Failed to store private file");
            }

            privateKeyFileStream = new FileOutputStream(privateKeyFile);
            privateKeyStreamWriter = new OutputStreamWriter(privateKeyFileStream);

            if (DEBUG) {
                DEBUGGER.debug("privateKeyFileStream: {}", privateKeyFileStream);
                DEBUGGER.debug("privateKeyStreamWriter: {}", privateKeyStreamWriter);
            }

            privateKeyWriter = new JcaPEMWriter(privateKeyStreamWriter);
            privateKeyWriter.writeObject(privateKey);
            privateKeyWriter.flush();
            privateKeyStreamWriter.flush();
            privateKeyFileStream.flush();

            // write public key
            File publicKeyFile = FileUtils.getFile(publicKeyDirectory + "/" + subjectData.get(0)
                    + SecurityServiceConstants.PUBLICKEY_FILE_EXT);

            if (DEBUG) {
                DEBUGGER.debug("publicKeyFile: {}", publicKeyFile);
            }

            if (!(publicKeyFile.createNewFile())) {
                throw new IOException("Failed to store public key file");
            }

            publicKeyFileStream = new FileOutputStream(publicKeyFile);
            publicKeyStreamWriter = new OutputStreamWriter(publicKeyFileStream);

            if (DEBUG) {
                DEBUGGER.debug("publicKeyFileStream: {}", publicKeyFileStream);
                DEBUGGER.debug("publicKeyStreamWriter: {}", publicKeyStreamWriter);
            }

            publicKeyWriter = new JcaPEMWriter(publicKeyStreamWriter);
            publicKeyWriter.writeObject(publicKey);
            publicKeyWriter.flush();
            publicKeyStreamWriter.flush();
            publicKeyFileStream.flush();

            // write csr
            csrFile = FileUtils
                    .getFile(csrDirectory + "/" + subjectData.get(0) + SecurityServiceConstants.CSR_FILE_EXT);

            if (DEBUG) {
                DEBUGGER.debug("csrFile: {}", csrFile);
            }

            if (!(csrFile.createNewFile())) {
                throw new IOException("Failed to store CSR file");
            }

            csrFileStream = new FileOutputStream(csrFile);
            csrFileStreamWriter = new OutputStreamWriter(csrFileStream);

            if (DEBUG) {
                DEBUGGER.debug("publicKeyFileStream: {}", publicKeyFileStream);
                DEBUGGER.debug("publicKeyStreamWriter: {}", publicKeyStreamWriter);
            }

            csrPemWriter = new JcaPEMWriter(csrFileStreamWriter);
            csrPemWriter.writeObject(csr);
            csrPemWriter.flush();
            csrFileStreamWriter.flush();
            csrFileStream.flush();

            File keyStoreFile = FileUtils
                    .getFile(storeDirectory + "/" + subjectData.get(0) + "." + KeyStore.getDefaultType());

            if (DEBUG) {
                DEBUGGER.debug("keyStoreFile: {}", keyStoreFile);
            }

            keyStoreStream = FileUtils.openOutputStream(keyStoreFile);

            if (DEBUG) {
                DEBUGGER.debug("keyStoreStream: {}", keyStoreStream);
            }

            keyStore.setKeyEntry(subjectData.get(0), (Key) keyPair.getPrivate(), storePassword.toCharArray(),
                    issuerCert);
            keyStore.store(keyStoreStream, storePassword.toCharArray());
            keyStoreStream.flush();

            if (DEBUG) {
                DEBUGGER.debug("KeyStore: {}", keyStore);
            }
        } else {
            throw new CertificateManagementException("Failed to generate keypair. Cannot continue.");
        }
    } catch (FileNotFoundException fnfx) {
        throw new CertificateManagementException(fnfx.getMessage(), fnfx);
    } catch (IOException iox) {
        throw new CertificateManagementException(iox.getMessage(), iox);
    } catch (NoSuchAlgorithmException nsax) {
        throw new CertificateManagementException(nsax.getMessage(), nsax);
    } catch (IllegalStateException isx) {
        throw new CertificateManagementException(isx.getMessage(), isx);
    } catch (InvalidKeyException ikx) {
        throw new CertificateManagementException(ikx.getMessage(), ikx);
    } catch (OperatorCreationException ocx) {
        throw new CertificateManagementException(ocx.getMessage(), ocx);
    } catch (KeyStoreException ksx) {
        throw new CertificateManagementException(ksx.getMessage(), ksx);
    } catch (CertificateException cx) {
        throw new CertificateManagementException(cx.getMessage(), cx);
    } finally {
        if (csrFileStreamWriter != null) {
            IOUtils.closeQuietly(csrFileStreamWriter);
        }

        if (csrFileStream != null) {
            IOUtils.closeQuietly(csrFileStream);
        }

        if (csrPemWriter != null) {
            IOUtils.closeQuietly(csrPemWriter);
        }

        if (publicKeyFileStream != null) {
            IOUtils.closeQuietly(publicKeyFileStream);
        }

        if (publicKeyStreamWriter != null) {
            IOUtils.closeQuietly(publicKeyStreamWriter);
        }

        if (publicKeyWriter != null) {
            IOUtils.closeQuietly(publicKeyWriter);
        }

        if (privateKeyFileStream != null) {
            IOUtils.closeQuietly(privateKeyFileStream);
        }

        if (privateKeyStreamWriter != null) {
            IOUtils.closeQuietly(privateKeyStreamWriter);
        }

        if (privateKeyWriter != null) {
            IOUtils.closeQuietly(privateKeyWriter);
        }

        if (keyStoreStream != null) {
            IOUtils.closeQuietly(keyStoreStream);
        }
    }

    return csrFile;
}

From source file:com.willwinder.universalgcodesender.gcode.GcodeParserTest.java

@Test
public void autoLevelerProcessorSet() throws Exception {
    System.out.println("autoLevelerProcessorSet");
    GcodeParser gcp = new GcodeParser();
    gcp.addCommandProcessor(new CommentProcessor());
    gcp.addCommandProcessor(new ArcExpander(true, 0.1));
    gcp.addCommandProcessor(new LineSplitter(1));
    Position grid[][] = { { new Position(-5, -5, 0, MM), new Position(-5, 35, 0, MM) },
            { new Position(35, -5, 0, MM), new Position(35, 35, 0, MM) } };
    gcp.addCommandProcessor(new MeshLeveler(0, grid, Units.MM));

    Path output = Files.createTempFile("autoleveler_processor_set_test.nc", "");

    // Copy resource to temp file since my parser methods need it that way.
    URL file = this.getClass().getClassLoader().getResource("./gcode/circle_test.nc");
    File tempFile = File.createTempFile("temp", "file");
    IOUtils.copy(file.openStream(), FileUtils.openOutputStream(tempFile));

    GcodeParserUtils.processAndExport(gcp, tempFile, output.toFile());

    GcodeStreamReader reader = new GcodeStreamReader(output.toFile());

    file = this.getClass().getClassLoader().getResource("./gcode/circle_test.nc.processed");
    Files.lines(Paths.get(file.toURI())).forEach((t) -> {
        try {//w  w  w .ja  v  a 2  s . com
            GcodeCommand c = reader.getNextCommand();
            if (c == null) {
                Assert.fail("Reached end of gcode reader before end of expected commands.");
            }
            Assert.assertEquals(c.getCommandString(), t);
        } catch (IOException ex) {
            Assert.fail("Unexpected exception.");
        }
    });
    assertEquals(1027, reader.getNumRows());
    output.toFile().delete();
}

From source file:com.htmlhifive.tools.wizard.download.DownloadModule.java

/**
 * 1???./*from w  w w .  ja  va  2  s . c o m*/
 * 
 * @param monitor 
 * @param totalWork 
 * @param file 
 * @param uri URI
 * @throws CoreException 
 */
private ZipFile download(final IProgressMonitor monitor, final int totalWork, ResultStatus logger, IFile file,
        final String urlStr) throws CoreException {

    // PI0111=INFO,[{0}]...
    monitor.subTask(Messages.PI0111.format(urlStr));

    lastDownloadStatus = false;

    int ret = 0;
    while (ret == 0) {
        try {
            if (file != null) {
                // ??.

                IConnectMethod method = ConnectMethodFactory.getMethod(urlStr, true);
                method.setConnectionTimeout(PluginConstant.URL_LIBRARY_CONNECTION_TIMEOUT);
                method.setProxy(getProxyService());
                method.getInputStream();

                boolean updateResult = updateFile(monitor, 0, logger, file, method);
                if (updateResult) {
                    lastDownloadStatus = true;
                }
                monitor.worked(totalWork);
            } else {
                // file?null?????ZipFile???.

                BufferedInputStream bufferIs = null;
                OutputStream os = null;

                try {
                    IConnectMethod method = ConnectMethodFactory.getMethod(urlStr, true);
                    method.setConnectionTimeout(PluginConstant.URL_LIBRARY_CONNECTION_TIMEOUT);
                    method.setProxy(getProxyService());
                    if (!method.connect()) {
                        // SE0101=ERROR,({0})??????URL={1}, File={2}
                        logger.log(Messages.SE0101, urlStr, file != null ? file.toString() : "");
                        return null;
                    }
                    final int contentLength = method.getContentLength();
                    //                  final int perWork;
                    //                  if (contentLength > 0) {
                    //                     perWork = Math.max(1, totalWork * DEFAULT_BUFFER_SIZE / 8 / contentLength);
                    //                  }else{
                    //                     perWork  = totalWork;
                    //                  }
                    InputStream is = method.getInputStream();

                    //                  if (H5IOUtils.isClassResources(urlStr)) {
                    //                     // url?null??????.
                    //                     is = DownloadModule.class.getResourceAsStream(urlStr);
                    //                  } else {
                    //                     // ?URL
                    //                     HttpMethod method = DownloadModule.this.connect(urlStr,
                    //                           PluginResource.URL_LIBRARY_CONNECTION_TIMEOUT);
                    //                     if (method == null) {
                    //                        return null;
                    //                     }
                    //
                    //                     // ??????.
                    //                     Header header = method.getResponseHeader("Content-Length");
                    //                     if (header != null) {
                    //                        contentLength = Integer.valueOf(header.getValue());
                    //                     }
                    //                     if (contentLength > 0) {
                    //                        perWork = Math.max(1, perWork * DEFAULT_BUFFER_SIZE / contentLength);
                    //                     }
                    //                     is = method.getResponseBodyAsStream();
                    //                  }
                    if (is == null) {
                        // SE0101=ERROR,({0})??????URL={1}, File={2}
                        logger.log(Messages.SE0101, urlStr, file != null ? file.toString() : "");
                        return null;
                    }

                    bufferIs = new BufferedInputStream(is) {
                        private int current = 0;
                        private final int perWork = Math.max(1, totalWork * buf.length / 8 / contentLength);

                        @Override
                        public synchronized int read() throws IOException {

                            int result = super.read();
                            current += result * 16;
                            monitor.subTask(Messages.PI0143.format(current, contentLength, urlStr));
                            //monitor.worked(result * 16);
                            monitor.worked(perWork);

                            return result;
                        }
                    };

                    // SE0093=INFO,{0}???
                    logger.log(Messages.SE0093, urlStr);

                    // ZIP.
                    File tempFile = File.createTempFile(H5WizardPlugin.getId(), "tmp");
                    // VM????.
                    tempFile.deleteOnExit();
                    // ??.
                    os = FileUtils.openOutputStream(tempFile);
                    IOUtils.copy(bufferIs, os);

                    //                  byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
                    //                  int n = 0;
                    //                  while (-1 != (n = is.read(buffer))) {
                    //                     os.write(buffer, 0, n);
                    //                     if (contentLength > 0) {
                    //                        monitor.worked(perWork);
                    //                     }
                    //                  }
                    if (contentLength == 0) {
                        monitor.worked(totalWork);
                    }

                    // SE0094=INFO,{0}????
                    logger.log(Messages.SE0094, urlStr);

                    lastDownloadStatus = true;
                    return new ZipFile(tempFile);
                } finally {
                    IOUtils.closeQuietly(bufferIs);
                    IOUtils.closeQuietly(os);
                }
            }
            ret = 1;
        } catch (IOException e) {
            // SE0101=ERROR,({0})??????URL={1}, File={2}
            logger.log(e, Messages.SE0101, urlStr, file != null ? file.toString() : "");

            // ?????.
            MessageDialog dialog = new MessageDialog(null, Messages.SE0115.format(),
                    Dialog.getImage(Dialog.DLG_IMG_MESSAGE_WARNING), Messages.SE0116.format(urlStr),
                    MessageDialog.QUESTION,
                    new String[] { UIMessages.Dialog_RETRY, UIMessages.Dialog_IGNORE, UIMessages.Dialog_STOP },
                    0);
            ret = dialog.open();
            if (ret == 2) {
                // 
                throw new OperationCanceledException(
                        Messages.SE0101.format(urlStr, file != null ? file.toString() : ""));
            }
        }
    }
    return null;
}

From source file:eu.dnetlib.maven.plugin.properties.WritePredefinedProjectProperties.java

/**
 * Writes properties./*  w ww. j av a  2 s . c  om*/
 * @param properties
 * @param file
 * @throws MojoExecutionException
 */
protected void writeProperties(Properties properties, File file) throws MojoExecutionException {
    OutputStream out = null;
    try {
        out = FileUtils.openOutputStream(outputFile);
        properties.store(out, "Properties");
    } catch (IOException e) {
        throw new MojoExecutionException("Error creating properties file", e);
    } finally {
        IOUtils.closeQuietly(out);
    }
}

From source file:com.glaf.core.security.RSAUtils.java

/**
 * RSA??//from  w w w .j  a v  a 2s .  co  m
 * 
 * @param keyPair
 *            ??
 */
private static void saveKeyPair(KeyPair keyPair) {
    FileOutputStream fos = null;
    ObjectOutputStream oos = null;
    try {
        fos = FileUtils.openOutputStream(rsaPairFile);
        oos = new ObjectOutputStream(fos);
        oos.writeObject(keyPair);
    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        IOUtils.closeQuietly(oos);
        IOUtils.closeQuietly(fos);
    }
    FileInputStream fin = null;
    try {
        fin = FileUtils.openInputStream(rsaPairFile);
        SysKey sysKey = new SysKey();
        sysKey.setId("RSAKey");
        sysKey.setCreateBy("system");
        sysKey.setName("RSAKey");
        sysKey.setType("RSA");
        sysKey.setTitle("RSA?");
        sysKey.setPath(rsaPairFile.getName());
        sysKey.setData(IOUtils.toByteArray(fin));
        SysKeyService sysKeyService = ContextFactory.getBean("sysKeyService");
        sysKeyService.save(sysKey);
    } catch (Exception ex) {
        ex.printStackTrace();
    } finally {
        IOUtils.closeQuietly(fin);
    }
}

From source file:com.silverpeas.workflow.engine.model.ProcessModelManagerImpl.java

/**
 * Saves a process model definition from java objects to an XML file
 * @param processFileName the xml file name that contains process model definition
 * @param process A processModel object to be saved
 * @throws WorkflowException when something goes wrong
 *///from www  .  ja  v a  2 s  . c  o m
@Override
public void saveProcessModel(ProcessModel process, String processFileName) throws WorkflowException {
    Mapping mapping = new Mapping();
    String mappingFileName = settings.getString("CastorXMLMappingFileURL"); // get
    // configuration
    // files
    // url
    String schemaFileName = settings.getString("ProcessModesSchemaFileURL");
    String strProcessModelFileEncoding = settings.getString("ProcessModelFileEncoding");
    boolean runOnUnix = !FileUtil.isWindows();
    String processPath = getProcessPath(processFileName);
    try {
        if (runOnUnix) {
            mappingFileName = mappingFileName.replace('\\', '/');
        } else {
            mappingFileName = "file:///" + mappingFileName.replace('\\', '/');
        }
        mapping.loadMapping(mappingFileName);
        File file = new File(processPath);
        Marshaller mar = new Marshaller(
                new OutputStreamWriter(FileUtils.openOutputStream(file), strProcessModelFileEncoding));
        mar.setMapping(mapping);
        mar.setNoNamespaceSchemaLocation(schemaFileName);
        mar.setSuppressXSIType(true);
        mar.setValidation(false);
        mar.setEncoding(strProcessModelFileEncoding);
        mar.marshal(process);
        clearProcessModelCache();
    } catch (MappingException me) {
        throw new WorkflowException("ProcessModelManagerImpl.saveProcessModel",
                "workflowEngine.EX_ERR_CASTOR_LOAD_XML_MAPPING",
                "Mapping file name : " + (mappingFileName == null ? "<null>" : mappingFileName), me);
    } catch (MarshalException me) {
        throw new WorkflowException("ProcessModelManagerImpl.saveProcessModel",
                "workflowEngine.EX_ERR_CASTOR_MARSHALL_PROCESSMODEL",
                "Process file name : " + (processPath == null ? "<null>" : processPath), me);
    } catch (ValidationException ve) {
        throw new WorkflowException("ProcessModelManagerImpl.saveProcessModel",
                "workflowEngine.EX_ERR_CASTOR_INVALID_XML_PROCESSMODEL",
                "Process file name : " + (processPath == null ? "<null>" : processPath), ve);
    } catch (IOException ioe) {
        throw new WorkflowException("ProcessModelManagerImpl.saveProcessModel",
                "workflowEngine.EX_ERR_CASTOR_SAVE_PROCESSMODEL",
                "Process file name : " + (processPath == null ? "<null>" : processPath), ioe);
    }
}

From source file:com.cws.esolutions.security.dao.certmgmt.impl.CertificateManagerImpl.java

/**
 * @see com.cws.esolutions.security.dao.certmgmt.interfaces.ICertificateManager#applyCertificateRequest(String, File, File, String)
 *//*from  www .ja v  a 2 s . co  m*/
public synchronized boolean applyCertificateRequest(final String commonName, final File certificateFile,
        final File keystoreFile, final String storePassword) throws CertificateManagementException {
    final String methodName = ICertificateManager.CNAME
            + "#applyCertificateRequest(final String commonName, final File certificateFile, final File keystoreFile, final String storePassword) throws CertificateManagementException";

    if (DEBUG) {
        DEBUGGER.debug(methodName);
        DEBUGGER.debug("Value: {}", commonName);
        DEBUGGER.debug("Value: {}", certificateFile);
        DEBUGGER.debug("Value: {}", keystoreFile);
    }

    final File rootDirectory = certConfig.getRootDirectory();
    final File certificateDirectory = FileUtils
            .getFile(certConfig.getCertificateDirectory() + "/" + commonName);
    final File storeDirectory = FileUtils.getFile(certConfig.getStoreDirectory() + "/" + commonName);

    if (DEBUG) {
        DEBUGGER.debug("rootDirectory: {}", rootDirectory);
        DEBUGGER.debug("certificateDirectory: {}", certificateDirectory);
        DEBUGGER.debug("storeDirectory: {}", storeDirectory);
        DEBUGGER.debug("certificateFile: {}", certificateFile);
        DEBUGGER.debug("keystoreFile: {}", keystoreFile);
    }

    boolean isComplete = false;
    FileInputStream certStream = null;
    FileOutputStream storeStream = null;
    FileInputStream keystoreInput = null;
    FileInputStream rootCertStream = null;
    FileInputStream intermediateCertStream = null;

    try {
        if (!(rootDirectory.exists())) {
            throw new CertificateManagementException(
                    "Root certificate directory either does not exist or cannot be written to. Cannot continue.");
        }

        if (!(rootDirectory.canWrite())) {
            throw new CertificateManagementException(
                    "Root certificate directory either does not exist or cannot be written to. Cannot continue.");
        }

        if (!(certConfig.getRootCertificateFile().exists())) {
            throw new CertificateManagementException("Root certificate file does not exist. Cannot continue.");
        }

        if (!(certConfig.getIntermediateCertificateFile().exists())) {
            throw new CertificateManagementException(
                    "Intermediate certificate file does not exist. Cannot continue.");
        }

        if (!(storeDirectory.canWrite())) {
            throw new CertificateManagementException(
                    "Keystore directory either does not exist or cannot be written to. Cannot continue.");
        }

        if (!(keystoreFile.canWrite())) {
            throw new CertificateManagementException(
                    "Unable to write to applicable keystore. Cannot continue.");
        }

        keystoreInput = FileUtils.openInputStream(keystoreFile);
        certStream = FileUtils.openInputStream(certificateFile);

        if (DEBUG) {
            DEBUGGER.debug("keystoreInput: {}", keystoreInput);
            DEBUGGER.debug("certStream: {}", certStream);
        }

        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        keyStore.load(keystoreInput, storePassword.toCharArray());

        if (DEBUG) {
            DEBUGGER.debug("KeyStore: {}", keyStore);
        }

        Key privateKey = keyStore.getKey(commonName, storePassword.toCharArray());
        CertificateFactory certFactory = CertificateFactory.getInstance(certConfig.getCertificateType());

        if (DEBUG) {
            DEBUGGER.debug("CertificateFactory: {}", certFactory);
        }

        rootCertStream = FileUtils.openInputStream(FileUtils.getFile(certConfig.getRootCertificateFile()));
        intermediateCertStream = FileUtils
                .openInputStream(FileUtils.getFile(certConfig.getIntermediateCertificateFile()));

        if (DEBUG) {
            DEBUGGER.debug("rootCertStream: {}", rootCertStream);
            DEBUGGER.debug("intermediateCertStream: {}", intermediateCertStream);
        }

        X509Certificate[] responseCert = new X509Certificate[] {
                (X509Certificate) certFactory.generateCertificate(rootCertStream),
                (X509Certificate) certFactory.generateCertificate(intermediateCertStream),
                (X509Certificate) certFactory.generateCertificate(certStream) };

        if (DEBUG) {
            DEBUGGER.debug("X509Certificate[]", (Object) responseCert);
        }

        storeStream = FileUtils.openOutputStream(keystoreFile);
        keyStore.setKeyEntry(commonName, privateKey, storePassword.toCharArray(), responseCert);
        keyStore.store(storeStream, storePassword.toCharArray());

        isComplete = true;
    } catch (FileNotFoundException fnfx) {
        throw new CertificateManagementException(fnfx.getMessage(), fnfx);
    } catch (IOException iox) {
        throw new CertificateManagementException(iox.getMessage(), iox);
    } catch (NoSuchAlgorithmException nsax) {
        throw new CertificateManagementException(nsax.getMessage(), nsax);
    } catch (IllegalStateException isx) {
        throw new CertificateManagementException(isx.getMessage(), isx);
    } catch (KeyStoreException ksx) {
        throw new CertificateManagementException(ksx.getMessage(), ksx);
    } catch (CertificateException cx) {
        throw new CertificateManagementException(cx.getMessage(), cx);
    } catch (UnrecoverableKeyException ukx) {
        throw new CertificateManagementException(ukx.getMessage(), ukx);
    } finally {
        if (storeStream != null) {
            IOUtils.closeQuietly(storeStream);
        }

        if (intermediateCertStream != null) {
            IOUtils.closeQuietly(intermediateCertStream);
        }

        if (rootCertStream != null) {
            IOUtils.closeQuietly(rootCertStream);
        }

        if (certStream != null) {
            IOUtils.closeQuietly(certStream);
        }

        if (keystoreInput != null) {
            IOUtils.closeQuietly(keystoreInput);
        }
    }

    return isComplete;
}

From source file:edu.cornell.med.icb.goby.modes.TestDiscoverSVMethylationRatesMode.java

@Before
public void setUp() throws IOException {

    final File dir = new File(BASE_TEST_DIR);
    dir.mkdirs();//from  ww  w  . ja  v a2 s. co  m

    genome = new RandomAccessSequenceTestSupport(sequences);
    final ReadsWriter referenceWriter = new ReadsWriterImpl(FileUtils.openOutputStream(
            new File("test-results/alignments/last-to-compact/last-reference.compact-reads")));
    referenceWriter.setIdentifier("0");
    referenceWriter.appendEntry();
    referenceWriter.close();

}

From source file:dotaSoundEditor.Controls.EditorPanel.java

protected void writeScriptFileToDisk(VPKEntry entryToWrite, boolean overwriteExisting) {
    File existsChecker = new File(Paths.get(installDir, entryToWrite.getPath()).toString());
    boolean fileExistsLocally = existsChecker.exists();
    if (fileExistsLocally && !overwriteExisting) {
        return;/*from w w  w . jav  a  2 s  .com*/
    }
    File entryFile = new File(Paths.get(installDir, "/dota/").toFile(), entryToWrite.getPath());
    File entryDir = entryFile.getParentFile();
    if (entryDir != null && !entryDir.exists()) {
        entryDir.mkdirs();
    }
    try (final FileChannel fc = FileUtils.openOutputStream(entryFile).getChannel()) {
        fc.write(entryToWrite.getData());
    } catch (IOException ex) {
        JOptionPane.showMessageDialog(this,
                "Error: Unable to write script file to disk.\nDetails: " + ex.getMessage(),
                "Error writing script file", JOptionPane.ERROR_MESSAGE);
    }
}