/*

 * Copyright (c) 2008, 2010, 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

 * @bug 4607272 6814948 6842687

 * @summary Unit test for AsynchronousFileChannel#lock method

 * @key randomness

 */

import java.net.*;

import java.nio.ByteBuffer;

import java.nio.charset.Charset;

import java.nio.file.*;

import static java.nio.file.StandardOpenOption.*;

import java.nio.channels.*;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.util.Random;

import java.util.concurrent.*;

public class Lock {

    static final Random rand = new Random();

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

        if (args.length > 0 && args[0].equals("-lockslave")) {

            int port = Integer.parseInt(args[1]);

            runLockSlave(port);

            System.exit(0);

        }

        LockSlaveMirror slave = startLockSlave();

        try {

            // create temporary file

            File blah = File.createTempFile("blah", null);

            blah.deleteOnExit();

            // run tests

            testLockProtocol(blah, slave);

            testAsyncClose(blah, slave);

            // eagerly clean-up

            blah.delete();

        } finally {

            slave.shutdown();

        }

    }

    // test locking protocol

    static void testLockProtocol(File file, LockSlaveMirror slave)

        throws Exception

    {

        FileLock fl;

        // slave VM opens file and acquires exclusive lock

        slave.open(file.getPath()).lock();

        AsynchronousFileChannel ch = AsynchronousFileChannel

            .open(file.toPath(), READ, WRITE);

        // this VM tries to acquire lock

        // (lock should not be acquire until released by slave VM)

        Future<FileLock> result = ch.lock();

        try {

            result.get(2, TimeUnit.SECONDS);

            throw new RuntimeException("Timeout expected");

        } catch (TimeoutException x) {

        }

        // slave VM releases lock

        slave.unlock();

        // this VM should now acquire lock

        fl = result.get();

        fl.release();

        // slave VM acquires lock on range

        slave.lock(0, 10, false);

        // this VM acquires lock on non-overlapping range

        fl = ch.lock(10, 10, false).get();

        fl.release();

        // done

        ch.close();

        slave.close();

    }

    // test close of channel with outstanding lock operation

    static void testAsyncClose(File file, LockSlaveMirror slave) throws Exception {

        // slave VM opens file and acquires exclusive lock

        slave.open(file.getPath()).lock();

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

            AsynchronousFileChannel ch = AsynchronousFileChannel

                .open(file.toPath(), READ, WRITE);

            // try to lock file (should not complete because file is locked by slave)

            Future<FileLock> result = ch.lock();

            try {

                result.get(rand.nextInt(100), TimeUnit.MILLISECONDS);

                throw new RuntimeException("Timeout expected");

            } catch (TimeoutException x) {

            }

            // close channel with lock operation outstanding

            ch.close();

            // operation should complete with AsynchronousCloseException

            try {

                result.get();

                throw new RuntimeException("ExecutionException expected");

            } catch (ExecutionException x) {

                if (!(x.getCause() instanceof AsynchronousCloseException)) {

                    x.getCause().printStackTrace();

                    throw new RuntimeException("AsynchronousCloseException expected");

                }

            }

        }

        slave.close();

    }

    // starts a "lock slave" in another process, returning a mirror object to

    // control the slave

    static LockSlaveMirror startLockSlave() throws Exception {

        ServerSocketChannel ssc = ServerSocketChannel.open()

            .bind(new InetSocketAddress(0));

        int port = ((InetSocketAddress)(ssc.getLocalAddress())).getPort();

        String sep = FileSystems.getDefault().getSeparator();

        String command = System.getProperty("java.home") +

            sep + "bin" + sep + "java";

        String testClasses = System.getProperty("test.classes");

        if (testClasses != null)

            command += " -cp " + testClasses;

        command += " Lock -lockslave " + port;

        Process p = Runtime.getRuntime().exec(command);

        IOHandler.handle(p.getInputStream());

        IOHandler.handle(p.getErrorStream());

        // wait for slave to connect

        SocketChannel sc = ssc.accept();

        return new LockSlaveMirror(sc);

    }

    // commands that the slave understands

    static final String OPEN_CMD    = "open";

    static final String CLOSE_CMD   = "close";

    static final String LOCK_CMD    = "lock";

    static final String UNLOCK_CMD  = "unlock";

    static final char TERMINATOR    = ';';

    // provides a proxy to a "lock slave"

    static class LockSlaveMirror {

        private final SocketChannel sc;

        LockSlaveMirror(SocketChannel sc) {

            this.sc = sc;

        }

        private void sendCommand(String cmd, String... params)

            throws IOException

        {

            for (String s: params) {

                cmd += " " + s;

            }

            cmd += TERMINATOR;

            ByteBuffer buf = Charset.defaultCharset().encode(cmd);

            while (buf.hasRemaining()) {

                sc.write(buf);

            }

            // wait for ack

            buf = ByteBuffer.allocate(1);

            int n = sc.read(buf);

            if (n != 1)

                throw new RuntimeException("Reply expected");

            if (buf.get(0) != TERMINATOR)

                throw new RuntimeException("Terminated expected");

        }

        LockSlaveMirror open(String file) throws IOException {

            sendCommand(OPEN_CMD, file);

            return this;

        }

        void close() throws IOException {

            sendCommand(CLOSE_CMD);

        }

        LockSlaveMirror lock() throws IOException {

            sendCommand(LOCK_CMD);

            return this;

        }

        LockSlaveMirror lock(long position, long size, boolean shared)

            throws IOException

        {

            sendCommand(LOCK_CMD, position + "," + size + "," + shared);

            return this;

        }

        LockSlaveMirror unlock() throws IOException {

            sendCommand(UNLOCK_CMD);

            return this;

        }

        void shutdown() throws IOException {

            sc.close();

        }

    }

    // Helper class to direct process output to the parent System.out

    static class IOHandler implements Runnable {

        private final InputStream in;

        IOHandler(InputStream in) {

            this.in = in;

        }

        static void handle(InputStream in) {

            IOHandler handler = new IOHandler(in);

            Thread thr = new Thread(handler);

            thr.setDaemon(true);

            thr.start();

        }

        public void run() {

            try {

                byte b[] = new byte[100];

                for (;;) {

                    int n = in.read(b);

                    if (n < 0) return;

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

                        System.out.print((char)b[i]);

                    }

                }

            } catch (IOException ioe) { }

        }

    }

    // slave process that responds to simple commands a socket connection

    static void runLockSlave(int port) throws Exception {

        // establish connection to parent

        SocketChannel sc = SocketChannel.open(new InetSocketAddress(port));

        ByteBuffer buf = ByteBuffer.allocateDirect(1024);

        FileChannel fc = null;

        FileLock fl = null;

        try {

            for (;;) {

                // read command (ends with ";")

                buf.clear();

                int n, last = 0;

                do {

                    n = sc.read(buf);

                    if (n < 0)

                        return;

                    if (n == 0)

                        throw new AssertionError();

                    last += n;

                } while (buf.get(last-1) != TERMINATOR);

                // decode into command and optional parameter

                buf.flip();

                String s = Charset.defaultCharset().decode(buf).toString();

                int sp = s.indexOf(" ");

                String cmd = (sp < 0) ? s.substring(0, s.length()-1) :

                    s.substring(0, sp);

                String param = (sp < 0) ? "" : s.substring(sp+1, s.length()-1);

                // execute

                if (cmd.equals(OPEN_CMD)) {

                    if (fc != null)

                        throw new RuntimeException("File already open");

                    fc = FileChannel.open(Paths.get(param),READ, WRITE);

                }

                if (cmd.equals(CLOSE_CMD)) {

                    if (fc == null)

                        throw new RuntimeException("No file open");

                    fc.close();

                    fc = null;

                    fl = null;

                }

                if (cmd.equals(LOCK_CMD)) {

                    if (fl != null)

                        throw new RuntimeException("Already holding lock");

                    if (param.length() == 0) {

                        fl = fc.lock();

                    } else {

                        String[] values = param.split(",");

                        if (values.length != 3)

                            throw new RuntimeException("Lock parameter invalid");

                        long position = Long.parseLong(values[0]);

                        long size = Long.parseLong(values[1]);

                        boolean shared = Boolean.parseBoolean(values[2]);

                        fl = fc.lock(position, size, shared);

                    }

                }

                if (cmd.equals(UNLOCK_CMD)) {

                    if (fl == null)

                        throw new RuntimeException("Not holding lock");

                    fl.release();

                    fl = null;

                }

                // send reply

                byte[] reply = { TERMINATOR };

                n = sc.write(ByteBuffer.wrap(reply));

            }

        } finally {

            sc.close();

            if (fc != null) fc.close();

        }

    }

}