Example usage for java.io File deleteOnExit

List of usage examples for java.io File deleteOnExit

Introduction

In this page you can find the example usage for java.io File deleteOnExit.

Prototype

public void deleteOnExit() 

Source Link

Document

Requests that the file or directory denoted by this abstract pathname be deleted when the virtual machine terminates.

Usage

From source file:eu.planets_project.tb.impl.data.util.DataHandlerImpl.java

/**
 * Creates a temporary that's deleted on exit.
 * @return/*from w  w w. j  a  va  2 s .  com*/
 * @throws IOException
 */
public static File createTemporaryFile() throws IOException {
    int lowerBound = 1;
    int upperBound = 9999;
    int random = (int) (lowerBound + Math.random() * (upperBound - lowerBound));
    File f = File.createTempFile("dataHandlerTemp" + random, null);
    f.deleteOnExit();
    return f;
}

From source file:eu.riscoss.RemoteRiskAnalyserMain.java

static void loadJSmile() throws Exception {
    File dir = new File(FileUtils.getTempDirectory(), "jnativelibs-" + RandomStringUtils.randomAlphabetic(30));
    if (!dir.mkdir()) {
        throw new Exception("failed to make dir");
    }/*from   w ww  . ja  v  a 2 s .co  m*/
    File jsmile = new File(dir, "libjsmile.so");
    URL jsmURL = Thread.currentThread().getContextClassLoader().getResource("libjsmile.so");
    FileUtils.copyURLToFile(jsmURL, jsmile);
    System.setProperty("java.library.path",
            System.getProperty("java.library.path") + ":" + dir.getAbsolutePath());

    // flush the library paths
    Field sysPathsField = ClassLoader.class.getDeclaredField("sys_paths");
    sysPathsField.setAccessible(true);
    sysPathsField.set(null, null);

    // Check that it works...
    System.loadLibrary("jsmile");

    dir.deleteOnExit();
    jsmile.deleteOnExit();
}

From source file:com.cloud.utils.S3Utils.java

@SuppressWarnings("unchecked")
public static File getFile(final ClientOptions clientOptions, final String bucketName, final String key,
        final File targetDirectory, final FileNamingStrategy namingStrategy) {

    assert clientOptions != null;
    assert isNotBlank(bucketName);
    assert isNotBlank(key);
    assert targetDirectory != null && targetDirectory.isDirectory();
    assert namingStrategy != null;

    final AmazonS3 connection = acquireClient(clientOptions);

    File tempFile = null;
    try {//from w  ww. j av  a2s. co  m

        tempFile = createTempFile(join("-", targetDirectory.getName(), currentTimeMillis(), "part"), "tmp",
                targetDirectory);
        tempFile.deleteOnExit();

        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug(format("Downloading object %1$s from bucket %2$s to temp file %3$s", key, bucketName,
                    tempFile.getName()));
        }

        try {
            connection.getObject(new GetObjectRequest(bucketName, key), tempFile);
        } catch (AmazonClientException ex) {
            // hack to handle different ETAG format generated from RiakCS for multi-part uploaded object
            String msg = ex.getMessage();
            if (!msg.contains("verify integrity")) {
                throw ex;
            }
        }

        final File targetFile = new File(targetDirectory, namingStrategy.determineFileName(key));
        tempFile.renameTo(targetFile);

        return targetFile;

    } catch (FileNotFoundException e) {

        throw new CloudRuntimeException(
                format("Failed open file %1$s in order to get object %2$s from bucket %3$s.",
                        targetDirectory.getAbsoluteFile(), bucketName, key),
                e);

    } catch (IOException e) {

        throw new CloudRuntimeException(
                format("Unable to allocate temporary file in directory %1$s to download %2$s:%3$s from S3",
                        targetDirectory.getAbsolutePath(), bucketName, key),
                e);

    } finally {

        if (tempFile != null) {
            tempFile.delete();
        }

    }

}

From source file:be.fedict.eid.tsl.Tsl2PdfExporter.java

private static File createTempDirectory() throws IOException {
    final File tmpDir = File.createTempFile("eid-tsl-", ".fonts");
    tmpDir.delete();/*from   www  . j a  va 2s .c o  m*/
    tmpDir.mkdir();
    tmpDir.deleteOnExit();
    return tmpDir;
}

From source file:it.cnr.icar.eric.common.Utility.java

public static File createTempFile(byte[] bytes, String prefix, String extension, boolean deleteOnExit)
        throws IOException {
    File temp = File.createTempFile(prefix, extension);

    // Delete temp file when program exits.
    if (deleteOnExit) {
        temp.deleteOnExit();
    }//  w ww  .  j a  v a  2 s  .  c om

    // Write to temp file
    BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(temp));
    out.write(bytes, 0, bytes.length);
    out.close();

    return temp;
}

From source file:gate.util.Files.java

/**
  * Writes aString into a temporary file located inside
  * the default temporary directory defined by JVM, using the specific
  * anEncoding./*ww  w  .ja  v a  2s. c  o m*/
  * An unique ID is generated and associated automaticaly with the file name.
  * @param aString the String to be written. If is null then the file will be
  * empty.
  * @param anEncoding the encoding to be used. If is null then the default
  * encoding will be used.
  * @return the tmp file containing the string.
  */
public static File writeTempFile(String aString, String anEncoding)
        throws UnsupportedEncodingException, IOException {
    File resourceFile = null;
    OutputStreamWriter writer = null;

    // Create a temporary file name
    resourceFile = File.createTempFile("gateResource", ".tmp");
    resourceFile.deleteOnExit();

    if (aString == null)
        return resourceFile;
    // Prepare the writer
    if (anEncoding == null) {
        // Use default encoding
        writer = new OutputStreamWriter(new FileOutputStream(resourceFile));

    } else {
        // Use the specified encoding
        writer = new OutputStreamWriter(new FileOutputStream(resourceFile), anEncoding);
    } // End if

    // This Action is added only when a gate.Document is created.
    // So, is for sure that the resource is a gate.Document
    writer.write(aString);
    writer.flush();
    writer.close();
    return resourceFile;
}

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
 *//*from  w ww  .j ava 2 s.  c  o m*/
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.nasa.ensemble.common.CommonUtils.java

/**
 * Creates a temporary directory - TODO: ensure all contents are erased
 * //from w w  w  . j  a va 2s.c om
 * @return
 */
public static File createTempDir() {
    final String baseTempPath = System.getProperty("java.io.tmpdir");
    Random rand = new Random();
    int randomInt = 1 + rand.nextInt();
    File tempDir = new File(baseTempPath + File.separator + "tempDir" + randomInt);
    if (tempDir.exists() == false) {
        tempDir.mkdir();
    }
    tempDir.deleteOnExit();
    return tempDir;
}

From source file:com.vmware.admiral.host.BaseManagementHostClusterIT.java

protected static File getResourceAsFile(String resourcePath) {
    try {//  w w  w.  j a va2  s .c  om
        InputStream in = BaseTestCase.class.getResourceAsStream(resourcePath);
        if (in == null) {
            return null;
        }

        File tempFile = File.createTempFile(String.valueOf(in.hashCode()), ".tmp");
        tempFile.deleteOnExit();

        try (FileOutputStream out = new FileOutputStream(tempFile)) {
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = in.read(buffer)) != -1) {
                out.write(buffer, 0, bytesRead);
            }
        }
        return tempFile;
    } catch (IOException e) {
        e.printStackTrace();
        return null;
    }
}

From source file:net.sf.keystore_explorer.crypto.signing.JarSigner.java

/**
 * Sign a JAR file overwriting it with the signed JAR.
 *
 * @param jsrFile//w  w  w .  j  av a 2  s.c  om
 *            JAR file to sign
 * @param privateKey
 *            Private key to sign with
 * @param certificateChain
 *            Certificate chain for private key
 * @param signatureType
 *            Signature type
 * @param signatureName
 *            Signature name
 * @param signer
 *            Signer
 * @param digestType
 *            Digest type
 * @param tsaUrl
 *             TSA URL
 * @throws IOException
 *             If an I/O problem occurs while signing the JAR file
 * @throws CryptoException
 *             If a crypto problem occurs while signing the JAR file
 */
public static void sign(File jsrFile, PrivateKey privateKey, X509Certificate[] certificateChain,
        SignatureType signatureType, String signatureName, String signer, DigestType digestType, String tsaUrl,
        Provider provider) throws IOException, CryptoException {
    File tmpFile = File.createTempFile("kse", "tmp");
    tmpFile.deleteOnExit();

    sign(jsrFile, tmpFile, privateKey, certificateChain, signatureType, signatureName, signer, digestType,
            tsaUrl, provider);

    CopyUtil.copyClose(new FileInputStream(tmpFile), new FileOutputStream(jsrFile));

    tmpFile.delete();
}