1 /*
2 * Copyright (c) 2010, 2014, 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 import java.io.*;
25 import java.nio.*;
26 import java.nio.channels.*;
27 import java.nio.file.*;
28 import java.nio.file.spi.*;
29 import java.nio.file.attribute.*;
30 import java.net.*;
31 import java.text.DateFormat;
32 import java.text.SimpleDateFormat;
33 import java.util.*;
34
35 import static java.nio.file.StandardOpenOption.*;
36 import static java.nio.file.StandardCopyOption.*;
37
38 /*
39 * ZipFileSystem usage demo
40 *
41 * java Demo action ZipfileName [...]
42 *
43 * @author Xueming Shen
44 */
45
46 public class Demo {
47
48 static enum Action {
49 rename, // <java Demo rename zipfile src dst>
50 // rename entry src to dst inside zipfile
51
52 movein, // <java Demo movein zipfile src dst>
53 // move an external src file into zipfile
54 // as entry dst
55
56 moveout, // <java Demo moveout zipfile src dst>
57 // move a zipfile entry src out to dst
58
59 copy, // <java Demo copy zipfile src dst>
60 // copy entry src to dst inside zipfile
61
62 copyin, // <java Demo copyin zipfile src dst>
63 // copy an external src file into zipfile
64 // as entry dst
65
66 copyin_attrs, // <java Demo copyin_attrs zipfile src dst>
67 // copy an external src file into zipfile
68 // as entry dst, with attributes (timestamp)
69
70 copyout, // <java Demo copyout zipfile src dst>
71 // copy zipfile entry src" out to file dst
72
73 copyout_attrs, // <java Demo copyout_attrs zipfile src dst>
74
75 zzmove, // <java Demo zzmove zfsrc zfdst path>
76 // move entry path/dir from zfsrc to zfdst
77
78 zzcopy, // <java Demo zzcopy zfsrc zfdst path>
79 // copy path from zipfile zfsrc to zipfile
80 // zfdst
81
82 attrs, // <java Demo attrs zipfile path>
83 // printout the attributes of entry path
84
85 attrsspace, // <java Demo attrsspace zipfile path>
86 // printout the storespace attrs of entry path
87
88 setmtime, // <java Demo setmtime zipfile "MM/dd/yy-HH:mm:ss" path...>
89 // set the lastModifiedTime of entry path
90
91 setatime, // <java Demo setatime zipfile "MM/dd/yy-HH:mm:ss" path...>
92 setctime, // <java Demo setctime zipfile "MM/dd/yy-HH:mm:ss" path...>
93
94 lsdir, // <java Demo lsdir zipfile dir>
95 // list dir's direct child files/dirs
96
97 mkdir, // <java Demo mkdir zipfile dir>
98
99 mkdirs, // <java Demo mkdirs zipfile dir>
100
101 rmdirs, // <java Demo rmdirs zipfile dir>
102
103 list, // <java Demo list zipfile [dir]>
104 // recursively list all entries of dir
105 // via DirectoryStream
106
107 tlist, // <java Demo tlist zipfile [dir]>
108 // list with buildDirTree=true
109
110 vlist, // <java Demo vlist zipfile [dir]>
111 // recursively verbose list all entries of
112 // dir via DirectoryStream
113
114 walk, // <java Demo walk zipfile [dir]>
115 // recursively walk all entries of dir
116 // via Files.walkFileTree
117
118 twalk, // <java Demo twalk zipfile [dir]>
119 // walk with buildDirTree=true
120
121 extract, // <java Demo extract zipfile file [...]>
122
123 update, // <java Demo extract zipfile file [...]>
124
125 delete, // <java Demo delete zipfile file [...]>
126
127 add, // <java Demo add zipfile file [...]>
128
129 create, // <java Demo create zipfile file [...]>
130 // create a new zipfile if it doesn't exit
131 // and then add the file(s) into it.
132
133 attrs2, // <java Demo attrs2 zipfile file [...]>
134 // test different ways to print attrs
135
136 prof,
137 }
138
139 public static void main(String[] args) throws Throwable {
140 FileSystemProvider provider = getZipFSProvider();
141 if (provider == null) {
142 System.err.println("ZIP filesystem provider is not installed");
143 System.exit(1);
144 }
145
146 Action action = Action.valueOf(args[0]);
147 Map<String, Object> env = env = new HashMap<>();
148 if (action == Action.create)
149 env.put("create", "true");
150 try (FileSystem fs = provider.newFileSystem(Paths.get(args[1]), env)) {
151 Path path, src, dst;
152 switch (action) {
153 case rename:
154 src = fs.getPath(args[2]);
155 dst = fs.getPath(args[3]);
156 Files.move(src, dst);
157 break;
158 case moveout:
159 src = fs.getPath(args[2]);
160 dst = Paths.get(args[3]);
161 Files.move(src, dst);
162 break;
163 case movein:
164 src = Paths.get(args[2]);
165 dst = fs.getPath(args[3]);
166 Files.move(src, dst);
167 break;
168 case copy:
169 src = fs.getPath(args[2]);
170 dst = fs.getPath(args[3]);
171 Files.copy(src, dst);
172 break;
173 case copyout:
174 src = fs.getPath(args[2]);
175 dst = Paths.get(args[3]);
176 Files.copy(src, dst);
177 break;
178 case copyin:
179 src = Paths.get(args[2]);
180 dst = fs.getPath(args[3]);
181 Files.copy(src, dst);
182 break;
183 case copyin_attrs:
184 src = Paths.get(args[2]);
185 dst = fs.getPath(args[3]);
186 Files.copy(src, dst, COPY_ATTRIBUTES);
187 break;
188 case copyout_attrs:
189 src = fs.getPath(args[2]);
190 dst = Paths.get(args[3]);
191 Files.copy(src, dst, COPY_ATTRIBUTES);
192 break;
193 case zzmove:
194 try (FileSystem fs2 = provider.newFileSystem(Paths.get(args[2]), env)) {
195 z2zmove(fs, fs2, args[3]);
196 }
197 break;
198 case zzcopy:
199 try (FileSystem fs2 = provider.newFileSystem(Paths.get(args[2]), env)) {
200 z2zcopy(fs, fs2, args[3]);
201 }
202 break;
203 case attrs:
204 for (int i = 2; i < args.length; i++) {
205 path = fs.getPath(args[i]);
206 System.out.println(path);
207 System.out.println(
208 Files.readAttributes(path, BasicFileAttributes.class).toString());
209 }
210 break;
211 case setmtime:
212 DateFormat df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
213 Date newDatetime = df.parse(args[2]);
214 for (int i = 3; i < args.length; i++) {
215 path = fs.getPath(args[i]);
216 Files.setAttribute(path, "lastModifiedTime",
217 FileTime.fromMillis(newDatetime.getTime()));
218 System.out.println(
219 Files.readAttributes(path, BasicFileAttributes.class).toString());
220 }
221 break;
222 case setctime:
223 df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
224 newDatetime = df.parse(args[2]);
225 for (int i = 3; i < args.length; i++) {
226 path = fs.getPath(args[i]);
227 Files.setAttribute(path, "creationTime",
228 FileTime.fromMillis(newDatetime.getTime()));
229 System.out.println(
230 Files.readAttributes(path, BasicFileAttributes.class).toString());
231 }
232 break;
233 case setatime:
234 df = new SimpleDateFormat("MM/dd/yyyy-HH:mm:ss");
235 newDatetime = df.parse(args[2]);
236 for (int i = 3; i < args.length; i++) {
237 path = fs.getPath(args[i]);
238 Files.setAttribute(path, "lastAccessTime",
239 FileTime.fromMillis(newDatetime.getTime()));
240 System.out.println(
241 Files.readAttributes(path, BasicFileAttributes.class).toString());
242 }
243 break;
244 case attrsspace:
245 path = fs.getPath("/");
246 FileStore fstore = Files.getFileStore(path);
247 System.out.printf("filestore[%s]%n", fstore.name());
248 System.out.printf(" totalSpace: %d%n",
249 (Long)fstore.getAttribute("totalSpace"));
250 System.out.printf(" usableSpace: %d%n",
251 (Long)fstore.getAttribute("usableSpace"));
252 System.out.printf(" unallocSpace: %d%n",
253 (Long)fstore.getAttribute("unallocatedSpace"));
254 break;
255 case list:
256 case tlist:
257 if (args.length < 3)
258 list(fs.getPath("/"), false);
259 else
260 list(fs.getPath(args[2]), false);
261 break;
262 case vlist:
263 if (args.length < 3)
264 list(fs.getPath("/"), true);
265 else
266 list(fs.getPath(args[2]), true);
267 break;
268 case twalk:
269 case walk:
270 walk(fs.getPath((args.length > 2)? args[2] : "/"));
271 break;
272 case extract:
273 if (args.length == 2) {
274 extract(fs, "/");
275 } else {
276 for (int i = 2; i < args.length; i++) {
277 extract(fs, args[i]);
278 }
279 }
280 break;
281 case delete:
282 for (int i = 2; i < args.length; i++)
283 Files.delete(fs.getPath(args[i]));
284 break;
285 case create:
286 case add:
287 case update:
288 for (int i = 2; i < args.length; i++) {
289 update(fs, args[i]);
290 }
291 break;
292 case lsdir:
293 path = fs.getPath(args[2]);
294 final String fStr = (args.length > 3)?args[3]:"";
295 try (DirectoryStream<Path> ds = Files.newDirectoryStream(path,
296 new DirectoryStream.Filter<Path>() {
297 @Override
298 public boolean accept(Path path) {
299 return path.toString().contains(fStr);
300 }
301 }))
302 {
303 for (Path p : ds)
304 System.out.println(p);
305 }
306 break;
307 case mkdir:
308 Files.createDirectory(fs.getPath(args[2]));
309 break;
310 case mkdirs:
311 mkdirs(fs.getPath(args[2]));
312 break;
313 case attrs2:
314 for (int i = 2; i < args.length; i++) {
315 path = fs.getPath(args[i]);
316 System.out.printf("%n%s%n", path);
317 System.out.println("-------(1)---------");
318 System.out.println(
319 Files.readAttributes(path, BasicFileAttributes.class).toString());
320 System.out.println("-------(2)---------");
321 Map<String, Object> map = Files.readAttributes(path, "zip:*");
322 for (Map.Entry<String, Object> e : map.entrySet()) {
323 System.out.printf(" %s : %s%n", e.getKey(), e.getValue());
324 }
325 System.out.println("-------(3)---------");
326 map = Files.readAttributes(path, "size,lastModifiedTime,isDirectory");
327 for (Map.Entry<String, ?> e : map.entrySet()) {
328 System.out.printf(" %s : %s%n", e.getKey(), e.getValue());
329 }
330 }
331 break;
332 case prof:
333 list(fs.getPath("/"), false);
334 while (true) {
335 Thread.sleep(10000);
336 //list(fs.getPath("/"), true);
337 System.out.println("sleeping...");
338 }
339 }
340 } catch (Exception x) {
341 x.printStackTrace();
342 }
343 }
344
345 private static FileSystemProvider getZipFSProvider() {
346 for (FileSystemProvider provider : FileSystemProvider.installedProviders()) {
347 if ("jar".equals(provider.getScheme()))
348 return provider;
349 }
350 return null;
351 }
352
353 @SuppressWarnings("unused")
354 /**
355 * Not used in demo, but included for demonstrational purposes.
356 */
357 private static byte[] getBytes(String name) {
358 return name.getBytes();
359 }
360
361 @SuppressWarnings("unused")
362 /**
363 * Not used in demo, but included for demonstrational purposes.
364 */
365 private static String getString(byte[] name) {
366 return new String(name);
367 }
368
369 private static void walk(Path path) throws IOException
370 {
371 Files.walkFileTree(
372 path,
373 new SimpleFileVisitor<Path>() {
374 private int indent = 0;
375 private void indent() {
376 int n = 0;
377 while (n++ < indent)
378 System.out.printf(" ");
379 }
380
381 @Override
382 public FileVisitResult visitFile(Path file,
383 BasicFileAttributes attrs)
384 {
385 indent();
386 System.out.printf("%s%n", file.getFileName().toString());
387 return FileVisitResult.CONTINUE;
388 }
389
390 @Override
391 public FileVisitResult preVisitDirectory(Path dir,
392 BasicFileAttributes attrs)
393 {
394 indent();
395 System.out.printf("[%s]%n", dir.toString());
396 indent += 2;
397 return FileVisitResult.CONTINUE;
398 }
399
400 @Override
401 public FileVisitResult postVisitDirectory(Path dir,
402 IOException ioe)
403 {
404 indent -= 2;
405 return FileVisitResult.CONTINUE;
406 }
407 });
408 }
409
410 private static void update(FileSystem fs, String path) throws Throwable{
411 Path src = FileSystems.getDefault().getPath(path);
412 if (Files.isDirectory(src)) {
413 try (DirectoryStream<Path> ds = Files.newDirectoryStream(src)) {
414 for (Path child : ds)
415 update(fs, child.toString());
416 }
417 } else {
418 Path dst = fs.getPath(path);
419 Path parent = dst.getParent();
420 if (parent != null && Files.notExists(parent))
421 mkdirs(parent);
422 Files.copy(src, dst, REPLACE_EXISTING);
423 }
424 }
425
426 private static void extract(FileSystem fs, String path) throws Throwable{
427 Path src = fs.getPath(path);
428 if (Files.isDirectory(src)) {
429 try (DirectoryStream<Path> ds = Files.newDirectoryStream(src)) {
430 for (Path child : ds)
431 extract(fs, child.toString());
432 }
433 } else {
434 if (path.startsWith("/"))
435 path = path.substring(1);
436 Path dst = FileSystems.getDefault().getPath(path);
437 Path parent = dst.getParent();
438 if (Files.notExists(parent))
439 mkdirs(parent);
440 Files.copy(src, dst, REPLACE_EXISTING);
441 }
442 }
443
444 // use DirectoryStream
445 private static void z2zcopy(FileSystem src, FileSystem dst, String path)
446 throws IOException
447 {
448 Path srcPath = src.getPath(path);
449 Path dstPath = dst.getPath(path);
450
451 if (Files.isDirectory(srcPath)) {
452 if (!Files.exists(dstPath)) {
453 try {
454 mkdirs(dstPath);
455 } catch (FileAlreadyExistsException x) {}
456 }
457 try (DirectoryStream<Path> ds = Files.newDirectoryStream(srcPath)) {
458 for (Path child : ds) {
459 z2zcopy(src, dst,
460 path + (path.endsWith("/")?"":"/") + child.getFileName());
461 }
462 }
463 } else {
464 //System.out.println("copying..." + path);
465 Files.copy(srcPath, dstPath);
466 }
467 }
468
469 // use TreeWalk to move
470 private static void z2zmove(FileSystem src, FileSystem dst, String path)
471 throws IOException
472 {
473 final Path srcPath = src.getPath(path).toAbsolutePath();
474 final Path dstPath = dst.getPath(path).toAbsolutePath();
475
476 Files.walkFileTree(srcPath, new SimpleFileVisitor<Path>() {
477
478 @Override
479 public FileVisitResult visitFile(Path file,
480 BasicFileAttributes attrs)
481 {
482 Path dst = srcPath.relativize(file);
483 dst = dstPath.resolve(dst);
484 try {
485 Path parent = dstPath.getParent();
486 if (parent != null && Files.notExists(parent))
487 mkdirs(parent);
488 Files.move(file, dst);
489 } catch (IOException x) {
490 x.printStackTrace();
491 }
492 return FileVisitResult.CONTINUE;
493 }
494
495 @Override
496 public FileVisitResult preVisitDirectory(Path dir,
497 BasicFileAttributes attrs)
498 {
499 Path dst = srcPath.relativize(dir);
500 dst = dstPath.resolve(dst);
501 try {
502
503 if (Files.notExists(dst))
504 mkdirs(dst);
505 } catch (IOException x) {
506 x.printStackTrace();
507 }
508 return FileVisitResult.CONTINUE;
509 }
510
511 @Override
512 public FileVisitResult postVisitDirectory(Path dir,
513 IOException ioe)
514 throws IOException
515 {
516 try {
517 Files.delete(dir);
518 } catch (IOException x) {
519 //x.printStackTrace();
520 }
521 return FileVisitResult.CONTINUE;
522 }
523 });
524
525 }
526
527 private static void mkdirs(Path path) throws IOException {
528 path = path.toAbsolutePath();
529 Path parent = path.getParent();
530 if (parent != null) {
531 if (Files.notExists(parent))
532 mkdirs(parent);
533 }
534 Files.createDirectory(path);
535 }
536
537 @SuppressWarnings("unused")
538 /**
539 * Not used in demo, but included for demonstrational purposes.
540 */
541 private static void rmdirs(Path path) throws IOException {
542 while (path != null && path.getNameCount() != 0) {
543 Files.delete(path);
544 path = path.getParent();
545 }
546 }
547
548 private static void list(Path path, boolean verbose ) throws IOException {
549 if (!"/".equals(path.toString())) {
550 System.out.printf(" %s%n", path.toString());
551 if (verbose)
552 System.out.println(Files.readAttributes(path, BasicFileAttributes.class).toString());
553 }
554 if (Files.notExists(path))
555 return;
556 if (Files.isDirectory(path)) {
557 try (DirectoryStream<Path> ds = Files.newDirectoryStream(path)) {
558 for (Path child : ds)
559 list(child, verbose);
560 }
561 }
562 }
563
564 @SuppressWarnings("unused")
565 /**
566 * Checks that the content of two paths are equal.
567 * Not used in demo, but included for demonstrational purposes.
568 */
569 private static void checkEqual(Path src, Path dst) throws IOException
570 {
571 //System.out.printf("checking <%s> vs <%s>...%n",
572 // src.toString(), dst.toString());
573
574 //streams
575 byte[] bufSrc = new byte[8192];
576 byte[] bufDst = new byte[8192];
577 try (InputStream isSrc = Files.newInputStream(src);
578 InputStream isDst = Files.newInputStream(dst))
579 {
580 int nSrc = 0;
581 while ((nSrc = isSrc.read(bufSrc)) != -1) {
582 int nDst = 0;
583 while (nDst < nSrc) {
584 int n = isDst.read(bufDst, nDst, nSrc - nDst);
585 if (n == -1) {
586 System.out.printf("checking <%s> vs <%s>...%n",
587 src.toString(), dst.toString());
588 throw new RuntimeException("CHECK FAILED!");
589 }
590 nDst += n;
591 }
592 while (--nSrc >= 0) {
593 if (bufSrc[nSrc] != bufDst[nSrc]) {
594 System.out.printf("checking <%s> vs <%s>...%n",
595 src.toString(), dst.toString());
596 throw new RuntimeException("CHECK FAILED!");
597 }
598 nSrc--;
599 }
600 }
601 }
602
603 // channels
604
605 try (SeekableByteChannel chSrc = Files.newByteChannel(src);
606 SeekableByteChannel chDst = Files.newByteChannel(dst))
607 {
608 if (chSrc.size() != chDst.size()) {
609 System.out.printf("src[%s].size=%d, dst[%s].size=%d%n",
610 chSrc.toString(), chSrc.size(),
611 chDst.toString(), chDst.size());
612 throw new RuntimeException("CHECK FAILED!");
613 }
614 ByteBuffer bbSrc = ByteBuffer.allocate(8192);
615 ByteBuffer bbDst = ByteBuffer.allocate(8192);
616
617 int nSrc = 0;
618 while ((nSrc = chSrc.read(bbSrc)) != -1) {
619 int nDst = chDst.read(bbDst);
620 if (nSrc != nDst) {
621 System.out.printf("checking <%s> vs <%s>...%n",
622 src.toString(), dst.toString());
623 throw new RuntimeException("CHECK FAILED!");
624 }
625 while (--nSrc >= 0) {
626 if (bbSrc.get(nSrc) != bbDst.get(nSrc)) {
627 System.out.printf("checking <%s> vs <%s>...%n",
628 src.toString(), dst.toString());
629 throw new RuntimeException("CHECK FAILED!");
630 }
631 nSrc--;
632 }
633 bbSrc.flip();
634 bbDst.flip();
635 }
636 } catch (IOException x) {
637 x.printStackTrace();
638 }
639 }
640
641 private static void fchCopy(Path src, Path dst) throws IOException
642 {
643 Set<OpenOption> read = new HashSet<>();
644 read.add(READ);
645 Set<OpenOption> openwrite = new HashSet<>();
646 openwrite.add(CREATE_NEW);
647 openwrite.add(WRITE);
648
649 try (FileChannel srcFc = src.getFileSystem().provider().newFileChannel(src, read);
650 FileChannel dstFc = dst.getFileSystem().provider().newFileChannel(dst, openwrite))
651 {
652 ByteBuffer bb = ByteBuffer.allocate(8192);
653 while (srcFc.read(bb) >= 0) {
654 bb.flip();
655 dstFc.write(bb);
656 bb.clear();
657 }
658 }
659 }
660
661 private static void chCopy(Path src, Path dst) throws IOException
662 {
663 Set<OpenOption> read = new HashSet<>();
664 read.add(READ);
665 Set<OpenOption> openwrite = new HashSet<>();
666 openwrite.add(CREATE_NEW);
667 openwrite.add(WRITE);
668
669 try (SeekableByteChannel srcCh = Files.newByteChannel(src, read);
670 SeekableByteChannel dstCh = Files.newByteChannel(dst, openwrite))
671 {
672 ByteBuffer bb = ByteBuffer.allocate(8192);
673 while (srcCh.read(bb) >= 0) {
674 bb.flip();
675 dstCh.write(bb);
676 bb.clear();
677 }
678 }
679 }
680
681 private static void streamCopy(Path src, Path dst) throws IOException
682 {
683 byte[] buf = new byte[8192];
684 try (InputStream isSrc = Files.newInputStream(src);
685 OutputStream osDst = Files.newOutputStream(dst))
686 {
687 int n = 0;
688 while ((n = isSrc.read(buf)) != -1) {
689 osDst.write(buf, 0, n);
690 }
691 }
692 }
693 }