/*

 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* @test

 * @ignore This test has huge disk space requirements

 * @bug 8168628

 * @summary Test extending files to very large sizes without hitting a SIGBUS

 * @requires (os.family == "linux")

 * @run main/othervm/timeout=600 -Xms4g -Xmx4g FileExtensionAndMap

 * @run main/othervm/timeout=600 -Xms4g -Xmx4g FileExtensionAndMap true

 */

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.MappedByteBuffer;

import java.nio.channels.ClosedChannelException;

import java.nio.channels.FileChannel;

import java.nio.channels.FileChannel.MapMode;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.nio.file.StandardCopyOption;

import java.nio.file.StandardOpenOption;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

import java.util.concurrent.ForkJoinPool;

import java.util.concurrent.Semaphore;

import java.util.stream.IntStream;

public class FileExtensionAndMap {

    private static final ExecutorService CACHED_EXECUTORSERVICE =

        Executors.newCachedThreadPool();

    private static final String TMPDIR = System.getProperty("test.dir", ".");

    private static boolean useRaf = false;

    public static void main(String args[]) throws Exception {

        if (args.length > 2) {

            throw new IllegalArgumentException

                ("Arguments: [true|false [targetFolder]]");

        }

        String defaultFolder = TMPDIR + File.separator + "target";

        if (args.length > 0) {

            useRaf = Boolean.valueOf(args[0]);

            if (args.length > 1) {

                defaultFolder = args[1];

            }

        }

        final String targetFolder = defaultFolder;

        Path p = Paths.get(targetFolder);

        boolean targetExists = Files.exists(p);

        if (!targetExists) {

            Files.createDirectory(p);

        }

        System.out.printf("Using RandomAccessFile: %s; target folder: %s%n",

            useRaf, targetFolder);

        ForkJoinPool fjPool = new ForkJoinPool(3);

        fjPool.submit(() -> {

            IntStream.range(0, 20).parallel().forEach((index) -> {

                String fileName = "testBigFile_" + index + ".dat";

                Path source = null;

                Path target = null;

                try {

                    source = Paths.get(TMPDIR, fileName);

                    testCreateBigFile(source);

                    target = Paths.get(targetFolder, fileName);

                    testFileCopy(source, target);

                } catch (Throwable th) {

                    System.err.println("Error copying file with fileName: "

                        + fileName + " : " + th.getMessage());

                    th.printStackTrace(System.err);

                } finally {

                    try {

                        if (source != null) {

                            Files.deleteIfExists(source);

                        }

                    } catch (Throwable ignored) {

                    }

                    try {

                        if (target != null) {

                            Files.deleteIfExists(target);

                        }

                    } catch (Throwable ignored) {

                    }

                }

            });

        }).join();

        if (!targetExists) {

            Files.delete(p);

        }

    }

    private static void testFileCopy(Path source, Path target)

        throws IOException {

        Files.copy(source, target, StandardCopyOption.REPLACE_EXISTING);

        System.out.println("Finished copying file with fileName: "

                + source.getFileName());

    }

    private static void testCreateBigFile(Path segmentFile)

        throws IOException {

        final Semaphore concurrencySemaphore = new Semaphore(5);

        long fileSize = 3L * 1024L * 1024L * 1024L;

        int blockSize = 10 * 1024 * 1024;

        int loopCount = (int) Math.floorDiv(fileSize, blockSize);

        String fileName = segmentFile.getFileName().toString();

        if (useRaf) {

            try (RandomAccessFile raf

                = new RandomAccessFile(segmentFile.toFile(), "rw")) {

                raf.setLength(fileSize);

                try (FileChannel fc = raf.getChannel()) {

                    for (int i = 0; i < loopCount; i++) {

                        final long startPosition = 1L * blockSize * i;

                        concurrencySemaphore.acquireUninterruptibly();

                        CACHED_EXECUTORSERVICE.submit(() -> {

                            writeTemplateData(fileName, fc, startPosition,

                                    blockSize, concurrencySemaphore);

                        });

                    }

                } finally {

                    concurrencySemaphore.acquireUninterruptibly(5);

                }

            }

        } else {

            Path file = Files.createFile(segmentFile);

            try (FileChannel fc = FileChannel.open(file,

                StandardOpenOption.READ, StandardOpenOption.WRITE)) {

                for (int i = 0; i < loopCount; i++) {

                    final long startPosition = 1L * blockSize * i;

                    concurrencySemaphore.acquireUninterruptibly();

                    CACHED_EXECUTORSERVICE.submit(() -> {

                        writeTemplateData(fileName, fc, startPosition,

                                blockSize, concurrencySemaphore);

                    });

                }

            }

        }

    }

    private static void writeTemplateData(String fileName,

        FileChannel fc, long startPosition, int blockSize,

        Semaphore concurrencySemaphore) {

        try {

            byte[] EMPTY_RECORD = new byte[blockSize / 256];

            MappedByteBuffer mappedByteBuffer = fc.map(MapMode.READ_WRITE,

                startPosition, blockSize);

            IntStream.range(0, 256).forEach((recordIndex) -> {

                try {

                    mappedByteBuffer.position((int) (recordIndex *

                        EMPTY_RECORD.length));

                    mappedByteBuffer.put(EMPTY_RECORD, 0, EMPTY_RECORD.length);

                } catch (Throwable th) {

                    System.err.println

                        ("Error in FileExtensionAndMap.writeTemplateData empty record for fileName: "

                        + fileName + ", startPosition: " + startPosition + ", recordIndex: "

                        + recordIndex + " : " + th.getMessage());

                    th.printStackTrace(System.err);

                }

            });

            mappedByteBuffer.force();

        } catch (Throwable th) {

            if (!(th instanceof ClosedChannelException)) {

                System.err.println

                    ("Error in FileExtensionAndMap.writeTemplateData empty record for fileName: "

                    + fileName + ", startPosition: " + startPosition + " : "

                    + th.getMessage());

                th.printStackTrace(System.err);

            }

        } finally {

            concurrencySemaphore.release();

        }

    }

}