1/*
2 * Copyright (c) 2010, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/* @test
25 * @bug 6907760 6929532
26 * @summary Tests WatchService behavior when lots of events are pending (use -Dseed=X to set PRNG seed)
27 * @library ..
28 * @library /test/lib
29 * @build jdk.test.lib.RandomFactory
30 * @run main/timeout=180 LotsOfEvents
31 * @key randomness
32 */
33
34import java.io.IOException;
35import java.io.OutputStream;
36import java.nio.file.*;
37import static java.nio.file.StandardWatchEventKinds.*;
38import java.util.*;
39import java.util.concurrent.TimeUnit;
40import jdk.test.lib.RandomFactory;
41
42public class LotsOfEvents {
43
44    private static final Random RAND = RandomFactory.getRandom();
45
46    public static void main(String[] args) throws Exception {
47        Path dir = TestUtil.createTemporaryDirectory();
48        try {
49            testOverflowEvent(dir);
50            testModifyEventsQueuing(dir);
51        } finally {
52            TestUtil.removeAll(dir);
53        }
54    }
55
56    /**
57     * Tests that OVERFLOW events are not retreived with other events.
58     */
59    static void testOverflowEvent(Path dir)
60        throws IOException, InterruptedException
61    {
62        try (WatchService watcher = dir.getFileSystem().newWatchService()) {
63            dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE);
64
65            // create a lot of files
66            int n = 1024;
67            Path[] files = new Path[n];
68            for (int i=0; i<n; i++) {
69                files[i] = Files.createFile(dir.resolve("foo" + i));
70            }
71
72            // give time for events to accumulate (improve chance of overflow)
73            Thread.sleep(1000);
74
75            // check that we see the create events (or overflow)
76            drainAndCheckOverflowEvents(dir, watcher, ENTRY_CREATE, n);
77
78            // delete the files
79            for (int i=0; i<n; i++) {
80                Files.delete(files[i]);
81            }
82
83            // give time for events to accumulate (improve chance of overflow)
84            Thread.sleep(1000);
85
86            // check that we see the delete events (or overflow)
87            drainAndCheckOverflowEvents(dir, watcher, ENTRY_DELETE, n);
88        }
89    }
90
91    static void drainAndCheckOverflowEvents(Path dir,
92                                            WatchService watcher,
93                                            WatchEvent.Kind<?> expectedKind,
94                                            int count)
95        throws IOException, InterruptedException
96    {
97        // wait for key to be signalled - the timeout is long to allow for
98        // polling implementations
99        WatchKey key = watcher.poll(15, TimeUnit.SECONDS);
100        if (key != null && count == 0)
101            throw new RuntimeException("Key was signalled (unexpected)");
102        if (key == null && count > 0)
103            throw new RuntimeException("Key not signalled (unexpected)");
104
105        int nread = 0;
106        boolean gotOverflow = false;
107        while (key != null) {
108            List<WatchEvent<?>> events = key.pollEvents();
109            for (WatchEvent<?> event: events) {
110                WatchEvent.Kind<?> kind = event.kind();
111                if (kind == expectedKind) {
112                    // expected event kind
113                    if (++nread > count)
114                        throw new RuntimeException("More events than expected!!");
115                } else if (kind == OVERFLOW) {
116                    // overflow event should not be retrieved with other events
117                    if (events.size() > 1)
118                        throw new RuntimeException("Overflow retrieved with other events");
119                    gotOverflow = true;
120                } else {
121                    throw new RuntimeException("Unexpected event '" + kind + "'");
122                }
123            }
124            if (!key.reset())
125                throw new RuntimeException("Key is no longer valid");
126            key = watcher.poll(2, TimeUnit.SECONDS);
127        }
128
129        // check that all expected events were received or there was an overflow
130        if (nread < count && !gotOverflow) {
131            System.err.printf("Test directory %s contains %d files%n",
132                dir, Files.list(dir).count());
133
134            long timeBeforePoll = System.nanoTime();
135            key = watcher.poll(15, TimeUnit.SECONDS);
136            long timeAfterPoll = System.nanoTime();
137            if (key == null) {
138                System.err.println("key still null after extra polling");
139            } else {
140                List<WatchEvent<?>> events = key.pollEvents();
141                System.err.printf("Retrieved key with %d events after %d ns%n",
142                    events.size(), timeAfterPoll - timeBeforePoll);
143            }
144
145            throw new RuntimeException("Insufficient "
146                + expectedKind.name() + "  events: expected "
147                + count + ", received " + nread);
148        }
149    }
150
151    /**
152     * Tests that check that ENTRY_MODIFY events are queued efficiently
153     */
154    static void testModifyEventsQueuing(Path dir)
155        throws IOException, InterruptedException
156    {
157        // this test uses a random number of files
158        final int nfiles = 5 + RAND.nextInt(10);
159        DirectoryEntry[] entries = new DirectoryEntry[nfiles];
160        for (int i=0; i<nfiles; i++) {
161            entries[i] = new DirectoryEntry(dir.resolve("foo" + i));
162
163            // "some" of the files exist, some do not.
164            entries[i].deleteIfExists();
165            if (RAND.nextBoolean())
166                entries[i].create();
167        }
168
169        try (WatchService watcher = dir.getFileSystem().newWatchService()) {
170            dir.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY);
171
172            // do several rounds of noise and test
173            for (int round=0; round<10; round++) {
174
175                // make some noise!!!
176                for (int i=0; i<100; i++) {
177                    DirectoryEntry entry = entries[RAND.nextInt(nfiles)];
178                    int action = RAND.nextInt(10);
179                    switch (action) {
180                        case 0 : entry.create(); break;
181                        case 1 : entry.deleteIfExists(); break;
182                        default: entry.modifyIfExists();
183                    }
184                }
185
186                // process events and ensure that we don't get repeated modify
187                // events for the same file.
188                WatchKey key = watcher.poll(15, TimeUnit.SECONDS);
189                while (key != null) {
190                    Set<Path> modified = new HashSet<>();
191                    for (WatchEvent<?> event: key.pollEvents()) {
192                        WatchEvent.Kind<?> kind = event.kind();
193                        Path file = (kind == OVERFLOW) ? null : (Path)event.context();
194                        if (kind == ENTRY_MODIFY) {
195                            boolean added = modified.add(file);
196                            if (!added) {
197                                throw new RuntimeException(
198                                    "ENTRY_MODIFY events not queued efficiently");
199                            }
200                        } else {
201                            if (file != null) modified.remove(file);
202                        }
203                    }
204                    if (!key.reset())
205                        throw new RuntimeException("Key is no longer valid");
206                    key = watcher.poll(2, TimeUnit.SECONDS);
207                }
208            }
209        }
210    }
211
212    static class DirectoryEntry {
213        private final Path file;
214        DirectoryEntry(Path file) {
215            this.file = file;
216        }
217        void create() throws IOException {
218            if (Files.notExists(file))
219                Files.createFile(file);
220
221        }
222        void deleteIfExists() throws IOException {
223            Files.deleteIfExists(file);
224        }
225        void modifyIfExists() throws IOException {
226            if (Files.exists(file)) {
227                try (OutputStream out = Files.newOutputStream(file, StandardOpenOption.APPEND)) {
228                    out.write("message".getBytes());
229                }
230            }
231        }
232    }
233
234}
235