Example usage for java.io BufferedWriter write

List of usage examples for java.io BufferedWriter write

Introduction

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

Prototype

public void write(int c) throws IOException 

Source Link

Document

Writes a single character.

Usage

From source file:data_gen.Data_gen.java

public static void generate_field_map() {
    try {//from ww w  . jav  a2 s.c o m
        File file = new File(output_dir + "/" + "fieldMap.xml");

        if (!file.exists()) {
            file.createNewFile();
        }
        FileWriter fw = new FileWriter(file.getAbsoluteFile());
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>" + "\n");
        bw.write("<fieldMap name=\"Default Field Map\" version=\"1.0\">" + "\n");
        bw.write("     <!--" + "\n");
        bw.write("     There are no field maps for the Law Exporter" + "\n");
        bw.write("     -->" + "\n");
        bw.write("</fieldMap>" + "\n");
        bw.close();

    } catch (IOException e) {
        System.out.println("There was an error writing to the xml file." + "\n");
    }

}

From source file:com.tactfactory.harmony.utils.TactFileUtils.java

/** Write StringBuffer contents to the given file.
 * @param buff The buffer to write to the file
 * @param file The file in which the buffer must be copied
 *//*from   w ww .ja va2s. c  o  m*/
public static void stringBufferToFile(final StringBuffer buff, final File file) {
    FileOutputStream fos = null;
    OutputStreamWriter out = null;
    BufferedWriter bw = null;
    try {
        fos = new FileOutputStream(file);
        out = new OutputStreamWriter(fos, TactFileUtils.DEFAULT_ENCODING);
        bw = new BufferedWriter(out);
        bw.write(buff.toString());

    } catch (final IOException e) {
        ConsoleUtils.displayError(e);
    } finally {
        try {
            if (bw != null) {
                bw.close();
            }
            if (out != null) {
                out.close();
            }
            if (fos != null) {
                fos.close();
            }
        } catch (final IOException e) {
            ConsoleUtils.displayError(e);
        }
    }
}

From source file:com.ibm.bi.dml.runtime.util.MapReduceTool.java

public static void writeDoubleToHDFS(double d, String filename) throws IOException {
    BufferedWriter br = setupOutputFile(filename);
    String line = "" + d;
    br.write(line);
    br.close();// w  w  w .j av a  2 s  .  co  m
}

From source file:com.ibm.bi.dml.runtime.util.MapReduceTool.java

public static void writeIntToHDFS(long i, String filename) throws IOException {
    BufferedWriter br = setupOutputFile(filename);
    String line = "" + i;
    br.write(line);
    br.close();// w w w  .j a v  a2s  .c  om
}

From source file:com.ibm.bi.dml.runtime.util.MapReduceTool.java

public static void writeBooleanToHDFS(boolean b, String filename) throws IOException {
    BufferedWriter br = setupOutputFile(filename);
    String line = "" + b;
    br.write(line);
    br.close();//from   ww  w  .j  a  v a 2s .co  m
}

From source file:com.ibm.bi.dml.runtime.util.MapReduceTool.java

public static void writeStringToHDFS(String s, String filename) throws IOException {
    BufferedWriter br = setupOutputFile(filename);
    String line = "" + s;
    br.write(line);
    br.close();/*from  www .j  a  va  2  s . c o m*/
}

From source file:edu.umn.cs.spatialHadoop.util.FileUtil.java

/**
 * Writes paths to a file where each path is a line.
 * //from   www.  j a v a 2 s.  c  om
 * @author ibrahimsabek
 * @param paths
 */
public static Path writePathsToFile(OperationsParams params, Path[] paths) {
    String tmpFileName = "pathsDictionary.txt";
    File tempFile;
    BufferedWriter buffWriter = null;
    try {
        // store the dictionary of paths in a local file
        tempFile = new File(tmpFileName);
        Path localFilePath = new Path(tempFile.getAbsolutePath());
        FileOutputStream outStream = new FileOutputStream(tempFile);
        buffWriter = new BufferedWriter(new OutputStreamWriter(outStream));

        for (int i = 0; i < paths.length; i++) {
            buffWriter.write(paths[i].toString());
            buffWriter.newLine();
        }
        // copy the local dictionary into an hdfs file
        Configuration conf = new Configuration();
        FileSystem fs = params.getPaths()[0].getFileSystem(conf);
        Path hdfsFilePath = new Path(params.getPaths()[0].toString() + "/" + tmpFileName);

        copyFromLocal(localFilePath, fs, hdfsFilePath);

        return hdfsFilePath;
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    } finally {
        IOUtils.closeQuietly(buffWriter);
    }

}

From source file:magixcel.FileMan.java

static void writeToFile() {
    FileOutputStream fos = null;/*from  w w  w  .ja v a2 s . co  m*/
    OutputStreamWriter osw = null;
    BufferedWriter bw = null;
    String fileNameFull = OUTPUT_FILE_DIRECTORY + "output.txt";

    System.out.println("writing to: " + fileNameFull);

    try {
        fos = new FileOutputStream(fileNameFull);
        osw = new OutputStreamWriter(fos, Charsets.ISO_8859_1);
        bw = new BufferedWriter(osw);
        for (String lineOut : OutputFormat.getOutputLines()) {
            if (Globals.DEVELOPER_MODE == 1) {
                System.out.println("Writing line: " + lineOut);
            }
            bw.write(lineOut + System.lineSeparator());

        }
        System.out.println("DONE");

    } catch (FileNotFoundException ex) {
        Logger.getLogger(FileMan.class.getName()).log(Level.SEVERE, null, ex);
    } catch (IOException ex) {
        Logger.getLogger(FileMan.class.getName()).log(Level.SEVERE, null, ex);
    } finally {
        try {
            bw.close();
            osw.close();
            fos.close();
        } catch (IOException ex) {
            Logger.getLogger(FileMan.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}

From source file:com.thoughtmetric.tl.TLLib.java

private static void writeEntitytoFile(HttpEntity entity, Context context)
        throws IllegalStateException, IOException {
    InputStream is = entity.getContent();
    BufferedReader br = new BufferedReader(new InputStreamReader(is));

    BufferedWriter bw = new BufferedWriter(
            new OutputStreamWriter(context.openFileOutput("TEMP.html", Context.MODE_PRIVATE)));
    String line;/*  w ww  .ja v  a2s  .c  o  m*/
    while ((line = br.readLine()) != null) {
        bw.write(line);
    }
}

From source file:com.microsoft.azure.management.compute.samples.DeployImageFromContainerRegistryToKubernetes.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
 *///from   w  w  w .j ava 2  s  .  c om
public static boolean runSample(Azure azure, String clientId, String secret) {
    final String rgName = SdkContext.randomResourceName("rgACR", 15);
    final String acrName = SdkContext.randomResourceName("acrsample", 20);
    final String saName = SdkContext.randomResourceName("sa", 20);
    final String acsName = SdkContext.randomResourceName("acssample", 30);
    final String rootUserName = "acsuser";
    final Region region = Region.US_EAST;
    final String dockerImageName = "nginx";
    final String dockerImageTag = "latest";
    final String dockerContainerName = "acrsample-nginx";
    String acsSecretName = "mysecret112233";
    String acsNamespace = "acrsample";
    String acsLbIngressName = "lb-acrsample";
    String servicePrincipalClientId = clientId; // replace with a real service principal client id
    String servicePrincipalSecret = secret; // and corresponding secret
    SSHShell shell = null;

    try {

        //=============================================================
        // 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)");

        Date 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();

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

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

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

        t1 = new Date();

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

        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

        RegistryListCredentials acrCredentials = azureRegistry.listCredentials();
        DockerClient dockerClient = DockerUtils.createDockerClient(azure, rgName, region,
                azureRegistry.loginServerUrl(), acrCredentials.username(),
                acrCredentials.passwords().get(0).value());

        //=============================================================
        // 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(dockerImageName).withTag(dockerImageTag).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(dockerImageName + ":" + dockerImageTag).withName(dockerContainerName)
                .withCmd("/hello").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(dockerImageName + ":" + dockerImageTag).withForce(true).exec();
        } catch (NotFoundException e) {
            // just ignore if not exist
        }

        //=============================================================
        // Verify that the image we saved in the Azure Container registry can be pulled and instantiated locally

        dockerClient.pullImageCmd(privateRepoUrl).withAuthConfig(dockerClient.authConfig())
                .exec(new PullImageResultCallback()).awaitSuccess();
        System.out.println(
                "List local Docker images after pulling sample image from the Azure Container Registry:");
        images = dockerClient.listImagesCmd().withShowAll(true).exec();
        for (Image image : images) {
            System.out.format("\tFound Docker image %s (%s)\n", image.getRepoTags()[0], image.getId());
        }
        dockerContainerInstance = dockerClient.createContainerCmd(privateRepoUrl)
                .withName(dockerContainerName + "-private").withCmd("/hello").exec();
        System.out.println(
                "List Docker containers after instantiating container from the Azure Container Registry sample image:");
        dockerContainers = dockerClient.listContainersCmd().withShowAll(true).exec();
        for (Container container : dockerContainers) {
            System.out.format("\tFound Docker container %s (%s)\n", container.getImage(), container.getId());
        }

        //=============================================================
        // 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);

        //=============================================================
        // 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.passwords().get(0).value()).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-nginx", "nginx").endMetadata().withNewSpec()
                .withReplicas(2).withNewTemplate().withNewMetadata().addToLabels("acrsample-nginx", "nginx")
                .endMetadata().withNewSpec().addNewImagePullSecret(acsSecretName).addNewContainer()
                .withName("acrsample-pod-nginx").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-nginx", "nginx").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

        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)) {
                    System.out.println("\tFound ingress IP: " + lbIngressList.get(0).getIp());
                    timeout = 0;
                }
            } catch (Exception ignored) {
            }

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

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

        shell.close();
        shell = null;

        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);
            if (shell != null) {
                shell.close();
            }
        } 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;
}