Example usage for java.io BufferedWriter close

List of usage examples for java.io BufferedWriter close

Introduction

In this page you can find the example usage for java.io BufferedWriter close.

Prototype

@SuppressWarnings("try")
    public void close() throws IOException 

Source Link

Usage

From source file:com.idiro.utils.db.mysql.MySqlUtils.java

public static boolean importTable(JdbcConnection conn, String tableName, Map<String, String> features,
        File fileIn, File tablePath, char delimiter, boolean header) {
    boolean ok = true;
    try {//from   ww  w . j  a v  a  2s.  c  o  m
        DbChecker dbCh = new DbChecker(conn);
        if (!dbCh.isTableExist(tableName)) {
            logger.debug("The table which has to be imported has not been created");
            logger.debug("Creation of the table");
            Integer ASCIIVal = (int) delimiter;
            String[] options = { ASCIIVal.toString(), tablePath.getCanonicalPath() };
            conn.executeQuery(new MySqlBasicStatement().createExternalTable(tableName, features, options));
        } else {
            //Check if it is the same table 
            if (!dbCh.areFeaturesTheSame(tableName, features.keySet())) {
                logger.warn("Mismatch between the table to import and the table in the database");
                return false;
            }

            logger.warn("Have to check if the table is external or not, I do not know how to do that");

        }
    } catch (SQLException e) {
        logger.debug("Fail to watch the datastore");
        logger.debug(e.getMessage());
        return false;
    } catch (IOException e) {
        logger.warn("Fail to get the output path from a File object");
        logger.warn(e.getMessage());
        return false;
    }

    //Check if the input file has the right number of field
    FileChecker fChIn = new FileChecker(fileIn);
    FileChecker fChOut = new FileChecker(tablePath);
    String strLine = "";
    try {

        if (fChIn.isDirectory() || !fChIn.canRead()) {
            logger.warn("The file " + fChIn.getFilename() + "is a directory or can not be read");
            return false;
        }
        BufferedReader br = new BufferedReader(new FileReader(fileIn));
        //Read first line
        strLine = br.readLine();
        br.close();
    } catch (IOException e1) {
        logger.debug("Fail to open the file" + fChIn.getFilename());
        return false;
    }

    if (StringUtils.countMatches(strLine, String.valueOf(delimiter)) != features.size() - 1) {
        logger.warn("File given does not match with the delimiter '" + delimiter
                + "' given and the number of fields '" + features.size() + "'");
        return false;
    }

    BufferedWriter bw = null;
    BufferedReader br = null;

    try {
        bw = new BufferedWriter(new FileWriter(tablePath));
        logger.debug("read the file" + fileIn.getAbsolutePath());
        br = new BufferedReader(new FileReader(fileIn));
        String delimiterStr = "" + delimiter;
        //Read File Line By Line
        while ((strLine = br.readLine()) != null) {
            bw.write("\"" + strLine.replace(delimiterStr, "\",\"") + "\"\n");
        }
        br.close();

        bw.close();
    } catch (FileNotFoundException e1) {
        logger.error(e1.getCause() + " " + e1.getMessage());
        logger.error("Fail to read " + fileIn.getAbsolutePath());
        ok = false;
    } catch (IOException e1) {
        logger.error("Error writting, reading on the filesystem from the directory" + fChIn.getFilename()
                + " to the file " + fChOut.getFilename());
        ok = false;
    }

    return ok;
}

From source file:playground.johannes.socialnets.GraphStatistics.java

public static void writeHistogramNormalized(Histogram1D hist, String filename) {
    try {//from  w  w w .j a va 2  s .com
        int maxBin = hist.minMaxBins()[1];
        double maxY = hist.binHeight(maxBin);

        BufferedWriter writer = IOUtils.getBufferedWriter(filename);
        writer.write("x\ty");
        writer.newLine();
        for (int i = 0; i < 100; i++) {
            writer.write(String.valueOf(hist.xAxis().binCentre(i)));
            writer.write("\t");
            writer.write(String.valueOf(hist.binHeight(i) / maxY));
            writer.newLine();
        }
        writer.close();
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

}

From source file:ems.util.DataHandler.java

public static boolean csvDownload(File file, ObservableList<MyModelSimpleStringProperty> data) {
    StringBuilder sb = new StringBuilder();
    try {/*  w  w w .j  a v a2  s  .c om*/
        for (String data1 : Constants.REPORT_COLUMN_HEADERS) {
            sb.append(data1).append(",");
        }
        sb.setLength(sb.length() - 1);
        sb.append("\r\n");
        for (MyModelSimpleStringProperty data1 : data) {
            sb.append(data1.getObj1()).append(",").append(data1.getObj2()).append(",").append(data1.getObj4())
                    .append(",").append(data1.getObj5()).append(",").append(data1.getObj6()).append(",")
                    .append(data1.getObj7()).append(",").append(data1.getObj8()).append(",")
                    .append(data1.getObj9()).append(",").append(data1.getObj10()).append(",")
                    .append(data1.getObj11());
            sb.append("\r\n");
        }
        FileWriter fw = new FileWriter(file);
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write(sb.toString());
        bw.close();
        fw.close();
        return true;
    } catch (Exception e) {
        log.error(e.getMessage());
    }
    return false;
}

From source file:coolmap.application.io.internal.coolmapobject.InternalCoolMapObjectIO.java

private static void saveCoolMapObjectState(CoolMapObject object, TFile objectFolder) throws Exception {
    TFile stateFolder = new TFile(objectFolder + File.separator + IOTerm.DIR_STATE);

    //Save a state with row, column and selection
    CoolMapState state = CoolMapState.createState("State to save", object, null);

    //Save to JSON
    //save row base nodes
    TFile rowBaseNodeFile = new TFile(
            stateFolder.getAbsolutePath() + File.separator + IOTerm.FILE_STATE_NODE_ROWBASE);
    BufferedWriter rowBaseNodesWriter = new BufferedWriter(
            new OutputStreamWriter(new TFileOutputStream(rowBaseNodeFile)));
    JSONArray rowBaseNodesJSON = nodesToJSON(state.getRowBaseNodes());
    rowBaseNodesJSON.write(rowBaseNodesWriter);
    rowBaseNodesWriter.flush();//from   w  w  w.ja  v a 2 s.  c  om
    rowBaseNodesWriter.close();

    //save row tree nodes
    TFile rowTreeNodeFile = new TFile(
            stateFolder.getAbsolutePath() + File.separator + IOTerm.FILE_STATE_NODE_ROWTREE);
    BufferedWriter rowTreeNodesWriter = new BufferedWriter(
            new OutputStreamWriter(new TFileOutputStream(rowTreeNodeFile)));
    JSONArray rowTreeNodesJSON = nodesToJSON(state.getRowTreeNodes());
    rowTreeNodesJSON.write(rowTreeNodesWriter);
    rowTreeNodesWriter.flush();
    rowTreeNodesWriter.close();

    //save row tree structure
    TFile rowTreeFile = new TFile(stateFolder.getAbsolutePath() + File.separator + IOTerm.FILE_STATE_ROWTREE);
    BufferedWriter rowTreeWriter = new BufferedWriter(
            new OutputStreamWriter(new TFileOutputStream(rowTreeFile)));
    JSONObject rowTreeJSONObject = nodeIDTreeToJSON(state.getRowTreeNodes());
    rowTreeJSONObject.write(rowTreeWriter);
    rowTreeWriter.flush();
    rowTreeWriter.close();

    ////////////////////////////////////////////////////////////////////////
    //seems to be working just fine
    //save column base nodes
    TFile columnBaseNodeFile = new TFile(
            stateFolder.getAbsolutePath() + File.separator + IOTerm.FILE_STATE_NODE_COLUMNBASE);
    BufferedWriter columnBaseNodesWriter = new BufferedWriter(
            new OutputStreamWriter(new TFileOutputStream(columnBaseNodeFile)));
    nodesToJSON(state.getColumnBaseNodes()).write(columnBaseNodesWriter);
    columnBaseNodesWriter.flush();
    columnBaseNodesWriter.close();

    //save column tree nodes
    TFile columnTreeNodeFile = new TFile(
            stateFolder.getAbsolutePath() + File.separator + IOTerm.FILE_STATE_NODE_COLUMNTREE);
    BufferedWriter columnTreeNodesWriter = new BufferedWriter(
            new OutputStreamWriter(new TFileOutputStream(columnTreeNodeFile)));
    nodesToJSON(state.getColumnTreeNodes()).write(columnTreeNodesWriter);
    columnTreeNodesWriter.flush();
    columnTreeNodesWriter.close();

    //save column tree structure
    TFile columnTreeFile = new TFile(
            stateFolder.getAbsolutePath() + File.separator + IOTerm.FILE_STATE_COLUMNTREE);
    BufferedWriter columnTreeWriter = new BufferedWriter(
            new OutputStreamWriter(new TFileOutputStream(columnTreeFile)));
    nodeIDTreeToJSON(state.getColumnTreeNodes()).write(columnTreeWriter);
    columnTreeWriter.flush();
    columnTreeWriter.close();
}

From source file:com.ieasy.basic.util.file.FileUtils.java

/**
 * //w w w  . ja v  a 2s .  c o m
 * 
 * @param content
 * @param filePath
 */
public static void writeFile(String content, String filePath) {
    try {
        if (FileUtils.createFile(filePath)) {
            FileWriter fileWriter = new FileWriter(filePath, true);
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
            bufferedWriter.write(content);
            bufferedWriter.close();
            fileWriter.close();
        } else {
            logger.debug("??");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}

From source file:com.microsoft.azure.management.containerinstance.samples.ManageContainerInstanceZeroToOneAndOneToManyUsingKubernetesOrchestration.java

/**
 * Main function which runs the actual sample.
 *
 * @param azure instance of the azure client
 * @param clientId secondary service principal client ID
 * @param secret secondary service principal secret
 * @return true if sample runs successfully
 *//* w  w w  .j a va 2s .  c om*/
public static boolean runSample(Azure azure, String clientId, String secret) {
    final String rgName = SdkContext.randomResourceName("rgaci", 15);
    final Region region = Region.US_WEST;

    final String acrName = SdkContext.randomResourceName("acr", 20);

    final String aciName = SdkContext.randomResourceName("acisample", 20);
    final String containerImageName = "microsoft/aci-helloworld";
    final String containerImageTag = "latest";
    final String dockerContainerName = "sample-hello";

    final String acsName = SdkContext.randomResourceName("acssample", 30);
    String servicePrincipalClientId = clientId; // replace with a real service principal client id
    String servicePrincipalSecret = secret; // and corresponding secret
    final String rootUserName = "acsuser";
    String acsSecretName = "mysecret112233";
    String acsNamespace = "acrsample";
    String acsLbIngressName = "lb-acrsample";
    SSHShell shell = null;

    try {
        //=============================================================
        // Create an Azure Container Registry to store and manage private Docker container images

        System.out.println("Creating an Azure Container Registry");

        Date t1 = new Date();

        Registry azureRegistry = azure.containerRegistries().define(acrName).withRegion(region)
                .withNewResourceGroup(rgName).withBasicSku().withRegistryNameAsAdminUser().create();

        Date t2 = new Date();
        System.out.println("Created Azure Container Registry: (took " + ((t2.getTime() - t1.getTime()) / 1000)
                + " seconds) " + azureRegistry.id());
        Utils.print(azureRegistry);

        //=============================================================
        // Create a Docker client that will be used to push/pull images to/from the Azure Container Registry

        RegistryCredentials acrCredentials = azureRegistry.getCredentials();
        DockerClient dockerClient = DockerUtils.createDockerClient(azure, rgName, region,
                azureRegistry.loginServerUrl(), acrCredentials.username(),
                acrCredentials.accessKeys().get(AccessKeyType.PRIMARY));

        //=============================================================
        // Pull a temp image from public Docker repo and create a temporary container from that image
        // These steps can be replaced and instead build a custom image using a Dockerfile and the app's JAR

        dockerClient.pullImageCmd(containerImageName).withTag(containerImageTag)
                .exec(new PullImageResultCallback()).awaitSuccess();
        System.out.println("List local Docker images:");
        List<Image> images = dockerClient.listImagesCmd().withShowAll(true).exec();
        for (Image image : images) {
            System.out.format("\tFound Docker image %s (%s)\n", image.getRepoTags()[0], image.getId());
        }

        CreateContainerResponse dockerContainerInstance = dockerClient
                .createContainerCmd(containerImageName + ":" + containerImageTag).withName(dockerContainerName)
                .exec();
        System.out.println("List Docker containers:");
        List<Container> dockerContainers = dockerClient.listContainersCmd().withShowAll(true).exec();
        for (Container container : dockerContainers) {
            System.out.format("\tFound Docker container %s (%s)\n", container.getImage(), container.getId());
        }

        //=============================================================
        // Commit the new container

        String privateRepoUrl = azureRegistry.loginServerUrl() + "/samples/" + dockerContainerName;
        String dockerImageId = dockerClient.commitCmd(dockerContainerInstance.getId())
                .withRepository(privateRepoUrl).withTag("latest").exec();

        // We can now remove the temporary container instance
        dockerClient.removeContainerCmd(dockerContainerInstance.getId()).withForce(true).exec();

        //=============================================================
        // Push the new Docker image to the Azure Container Registry

        dockerClient.pushImageCmd(privateRepoUrl).withAuthConfig(dockerClient.authConfig())
                .exec(new PushImageResultCallback()).awaitSuccess();

        // Remove the temp image from the local Docker host
        try {
            dockerClient.removeImageCmd(containerImageName + ":" + containerImageTag).withForce(true).exec();
        } catch (NotFoundException e) {
            // just ignore if not exist
        }

        //=============================================================
        // Create a container group with one container instance of default CPU core count and memory size
        //   using public Docker image "microsoft/aci-helloworld" and mounts a new file share as read/write
        //   shared container volume.

        ContainerGroup containerGroup = azure.containerGroups().define(aciName).withRegion(region)
                .withNewResourceGroup(rgName).withLinux()
                .withPrivateImageRegistry(azureRegistry.loginServerUrl(), acrCredentials.username(),
                        acrCredentials.accessKeys().get(AccessKeyType.PRIMARY))
                .withoutVolume().defineContainerInstance(aciName).withImage(privateRepoUrl)
                .withExternalTcpPort(80).attach().create();

        Utils.print(containerGroup);

        //=============================================================
        // Check that the container instance is up and running

        // warm up
        System.out.println("Warming up " + containerGroup.ipAddress());
        Utils.curl("http://" + containerGroup.ipAddress());
        SdkContext.sleep(15000);
        System.out.println("CURLing " + containerGroup.ipAddress());
        System.out.println(Utils.curl("http://" + containerGroup.ipAddress()));

        //=============================================================
        // Check the container instance logs

        String logContent = containerGroup.getLogContent(aciName);
        System.out.format("Logs for container instance: %s\n%s", aciName, logContent);

        //=============================================================
        // If service principal client id and secret are not set via the local variables, attempt to read the service
        //   principal client id and secret from a secondary ".azureauth" file set through an environment variable.
        //
        //   If the environment variable was not set then reuse the main service principal set for running this sample.

        if (servicePrincipalClientId.isEmpty() || servicePrincipalSecret.isEmpty()) {
            String envSecondaryServicePrincipal = System.getenv("AZURE_AUTH_LOCATION_2");

            if (envSecondaryServicePrincipal == null || !envSecondaryServicePrincipal.isEmpty()
                    || !Files.exists(Paths.get(envSecondaryServicePrincipal))) {
                envSecondaryServicePrincipal = System.getenv("AZURE_AUTH_LOCATION");
            }

            servicePrincipalClientId = Utils.getSecondaryServicePrincipalClientID(envSecondaryServicePrincipal);
            servicePrincipalSecret = Utils.getSecondaryServicePrincipalSecret(envSecondaryServicePrincipal);
        }

        //=============================================================
        // Create an SSH private/public key pair to be used when creating the container service

        System.out.println("Creating an SSH private and public key pair");

        SSHShell.SshPublicPrivateKey sshKeys = SSHShell.generateSSHKeys("", "ACS");
        System.out.println("SSH private key value: \n" + sshKeys.getSshPrivateKey());
        System.out.println("SSH public key value: \n" + sshKeys.getSshPublicKey());

        //=============================================================
        // Create an Azure Container Service with Kubernetes orchestration

        System.out.println(
                "Creating an Azure Container Service with Kubernetes ochestration and one agent (virtual machine)");

        t1 = new Date();

        ContainerService azureContainerService = azure.containerServices().define(acsName).withRegion(region)
                .withNewResourceGroup(rgName).withKubernetesOrchestration()
                .withServicePrincipal(servicePrincipalClientId, servicePrincipalSecret).withLinux()
                .withRootUsername(rootUserName).withSshKey(sshKeys.getSshPublicKey())
                .withMasterNodeCount(ContainerServiceMasterProfileCount.MIN)
                .withMasterLeafDomainLabel("dns-" + acsName).defineAgentPool("agentpool").withVMCount(1)
                .withVMSize(ContainerServiceVMSizeTypes.STANDARD_D1_V2).withLeafDomainLabel("dns-ap-" + acsName)
                .attach().create();

        t2 = new Date();
        System.out.println("Created Azure Container Service: (took " + ((t2.getTime() - t1.getTime()) / 1000)
                + " seconds) " + azureContainerService.id());
        Utils.print(azureContainerService);

        Thread.sleep(30000);

        //=============================================================
        // Download the Kubernetes config file from one of the master virtual machines

        azureContainerService = azure.containerServices().getByResourceGroup(rgName, acsName);
        System.out.println("Found Kubernetes master at: " + azureContainerService.masterFqdn());

        shell = SSHShell.open(azureContainerService.masterFqdn(), 22, rootUserName,
                sshKeys.getSshPrivateKey().getBytes());

        String kubeConfigContent = shell.download("config", ".kube", true);
        System.out.println("Found Kubernetes config:\n" + kubeConfigContent);

        //=============================================================
        // Instantiate the Kubernetes client using the downloaded ".kube/config" file content
        //     The Kubernetes client API requires setting an environment variable pointing at a real file;
        //        we will create a temporary file that will be deleted automatically when the sample exits

        File tempKubeConfigFile = File.createTempFile("kube", ".config",
                new File(System.getProperty("java.io.tmpdir")));
        tempKubeConfigFile.deleteOnExit();
        BufferedWriter buffOut = new BufferedWriter(new FileWriter(tempKubeConfigFile));
        buffOut.write(kubeConfigContent);
        buffOut.close();

        System.setProperty(Config.KUBERNETES_KUBECONFIG_FILE, tempKubeConfigFile.getPath());
        Config config = new Config();
        KubernetesClient kubernetesClient = new DefaultKubernetesClient(config);

        Thread.sleep(5000);

        //=============================================================
        // List all the nodes available in the Kubernetes cluster

        System.out.println(kubernetesClient.nodes().list());

        //=============================================================
        // Create a namespace where all the sample Kubernetes resources will be created

        Namespace ns = new NamespaceBuilder().withNewMetadata().withName(acsNamespace)
                .addToLabels("acr", "sample").endMetadata().build();
        try {
            System.out.println("Created namespace" + kubernetesClient.namespaces().create(ns));
        } catch (Exception ignored) {
        }

        Thread.sleep(5000);
        for (Namespace namespace : kubernetesClient.namespaces().list().getItems()) {
            System.out.println("\tFound Kubernetes namespace: " + namespace.toString());
        }

        //=============================================================
        // Create a secret of type "docker-repository" that will be used for downloading the container image from
        //     our Azure private container repo

        String basicAuth = new String(Base64.encodeBase64(
                (acrCredentials.username() + ":" + acrCredentials.accessKeys().get(AccessKeyType.PRIMARY))
                        .getBytes()));
        HashMap<String, String> secretData = new HashMap<>(1);
        String dockerCfg = String.format("{ \"%s\": { \"auth\": \"%s\", \"email\": \"%s\" } }",
                azureRegistry.loginServerUrl(), basicAuth, "acrsample@azure.com");

        dockerCfg = new String(Base64.encodeBase64(dockerCfg.getBytes("UTF-8")), "UTF-8");
        secretData.put(".dockercfg", dockerCfg);
        SecretBuilder secretBuilder = new SecretBuilder().withNewMetadata().withName(acsSecretName)
                .withNamespace(acsNamespace).endMetadata().withData(secretData)
                .withType("kubernetes.io/dockercfg");

        System.out.println("Creating new secret: "
                + kubernetesClient.secrets().inNamespace(acsNamespace).create(secretBuilder.build()));

        Thread.sleep(5000);

        for (Secret kubeS : kubernetesClient.secrets().inNamespace(acsNamespace).list().getItems()) {
            System.out.println("\tFound secret: " + kubeS);
        }

        //=============================================================
        // Create a replication controller for our image stored in the Azure Container Registry

        ReplicationController rc = new ReplicationControllerBuilder().withNewMetadata().withName("acrsample-rc")
                .withNamespace(acsNamespace).addToLabels("acrsample-myimg", "myimg").endMetadata().withNewSpec()
                .withReplicas(2).withNewTemplate().withNewMetadata().addToLabels("acrsample-myimg", "myimg")
                .endMetadata().withNewSpec().addNewImagePullSecret(acsSecretName).addNewContainer()
                .withName("acrsample-pod-myimg").withImage(privateRepoUrl).addNewPort().withContainerPort(80)
                .endPort().endContainer().endSpec().endTemplate().endSpec().build();

        System.out.println("Creating a replication controller: "
                + kubernetesClient.replicationControllers().inNamespace(acsNamespace).create(rc));
        Thread.sleep(5000);

        rc = kubernetesClient.replicationControllers().inNamespace(acsNamespace).withName("acrsample-rc").get();
        System.out.println("Found replication controller: " + rc.toString());

        for (Pod pod : kubernetesClient.pods().inNamespace(acsNamespace).list().getItems()) {
            System.out.println("\tFound Kubernetes pods: " + pod.toString());
        }

        //=============================================================
        // Create a Load Balancer service that will expose the service to the world

        Service lbService = new ServiceBuilder().withNewMetadata().withName(acsLbIngressName)
                .withNamespace(acsNamespace).endMetadata().withNewSpec().withType("LoadBalancer").addNewPort()
                .withPort(80).withProtocol("TCP").endPort().addToSelector("acrsample-myimg", "myimg").endSpec()
                .build();

        System.out.println("Creating a service: "
                + kubernetesClient.services().inNamespace(acsNamespace).create(lbService));

        Thread.sleep(5000);

        System.out.println("\tFound service: "
                + kubernetesClient.services().inNamespace(acsNamespace).withName(acsLbIngressName).get());

        //=============================================================
        // Wait until the external IP becomes available

        String serviceIP = null;

        int timeout = 30 * 60 * 1000; // 30 minutes
        String matchIPV4 = "^(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)(\\.(25[0-5]|2[0-4]\\d|[0-1]?\\d?\\d)){3}$";

        while (timeout > 0) {
            try {
                List<LoadBalancerIngress> lbIngressList = kubernetesClient.services().inNamespace(acsNamespace)
                        .withName(acsLbIngressName).get().getStatus().getLoadBalancer().getIngress();
                if (lbIngressList != null && !lbIngressList.isEmpty() && lbIngressList.get(0) != null
                        && lbIngressList.get(0).getIp().matches(matchIPV4)) {
                    serviceIP = lbIngressList.get(0).getIp();
                    System.out.println("\tFound ingress IP: " + serviceIP);
                    timeout = 0;
                }
            } catch (Exception ignored) {
            }

            if (timeout > 0) {
                timeout -= 30000; // 30 seconds
                Thread.sleep(30000);
            }
        }

        //=============================================================
        // Check that the service is up and running

        if (serviceIP != null) {
            // warm up
            System.out.println("Warming up " + serviceIP);
            Utils.curl("http://" + serviceIP);
            SdkContext.sleep(15000);
            System.out.println("CURLing " + serviceIP);
            System.out.println(Utils.curl("http://" + serviceIP));
        } else {
            System.out.println("ERROR: service unavailable");
        }

        // Clean-up
        kubernetesClient.namespaces().delete(ns);

        shell.close();

        return true;
    } catch (Exception f) {
        System.out.println(f.getMessage());
        f.printStackTrace();
    } finally {
        try {
            System.out.println("Deleting Resource Group: " + rgName);
            azure.resourceGroups().beginDeleteByName(rgName);
            System.out.println("Deleted Resource Group: " + rgName);
        } catch (NullPointerException npe) {
            System.out.println("Did not create any resources in Azure. No clean up is necessary");
        } catch (Exception g) {
            g.printStackTrace();
        }
    }
    return false;
}

From source file:gov.nih.nci.restgen.util.GeneratorUtil.java

public static void writeFile(String _outputDir, String _fileName, String _content) {
    BufferedWriter bufferedWriter = null;

    try {//from   w w w  . j a va  2s .  co  m
        createOutputDir(_outputDir);
        File file = new File(_outputDir, _fileName);
        FileWriter fileWriter = new FileWriter(file);
        bufferedWriter = new BufferedWriter(fileWriter);
        bufferedWriter.write(_content);
        bufferedWriter.flush();
    } catch (Throwable t) {
        throw new RuntimeException(t);
    } finally {
        if (bufferedWriter != null) {
            try {
                bufferedWriter.close();
            } catch (Throwable t) {
            }
        }
    }
}

From source file:moskitt4me.repositoryClient.core.util.RepositoryClientUtil.java

private static void addBuildProperties(IProject feature) throws Exception {

    String featureLocation = feature.getLocation().toString();
    File f = new File(featureLocation + "/build.properties");
    if (!f.exists()) {
        f.createNewFile();//from   w w  w  .j  a  va 2 s  .  c  o m
        BufferedWriter output = new BufferedWriter(new FileWriter(f));
        output.write("bin.includes = feature.xml\n");
        output.close();
    }
}

From source file:edu.caltech.ipac.firefly.server.util.DsvToDataGroup.java

public static void write(Writer writer, DataGroup data, CSVFormat format) throws IOException {

    BufferedWriter outf = new BufferedWriter(writer, IpacTableUtil.FILE_IO_BUFFER_SIZE);
    try {/*from  ww w.j  a  v a2 s . c  om*/
        CSVPrinter printer = new CSVPrinter(outf, format);

        if (data != null && data.size() > 0) {
            for (DataType t : data.getDataDefinitions()) {
                printer.print(t.getKeyName());
            }
            printer.println();

            for (DataObject row : data.values()) {
                for (String s : row.getFormatedData()) {
                    printer.print(s.trim());
                }
                printer.println();
            }
        }
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        if (outf != null) {
            outf.close();
        }
    }
}

From source file:com.termmed.utils.FileHelper.java

/**
 * Copy to./*from  w ww  . j a  v  a  2s  .c om*/
 *
 * @param inputFile the input file
 * @param outputFile the output file
 * @throws IOException Signals that an I/O exception has occurred.
 */
public static void copyTo(File inputFile, File outputFile) throws IOException {

    FileInputStream fis = new FileInputStream(inputFile);
    InputStreamReader isr = new InputStreamReader(fis, "UTF-8");
    LineNumberReader reader = new LineNumberReader(isr);

    FileOutputStream fos = new FileOutputStream(outputFile);
    OutputStreamWriter osw = new OutputStreamWriter(fos, "UTF-8");
    BufferedWriter bw = new BufferedWriter(osw);

    String lineRead = "";
    while ((lineRead = reader.readLine()) != null) {
        bw.append(lineRead);
        bw.append("\r\n");
    }
    reader.close();
    bw.close();

}