source/ch/cyberduck/cli/Console.java

   1 package ch.cyberduck.cli;
   2
   3 /*
   4  * Copyright (c) 2002-2014 David Kocher. All rights reserved.
   5  * http://cyberduck.io/
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * Bug fixes, suggestions and comments should be sent to:
  18  * feedback@cyberduck.io
  19  */
  20
  21 import ch.cyberduck.core.Factory;
  22 import ch.cyberduck.core.exception.ConnectionCanceledException;
  23 import ch.cyberduck.core.exception.LoginCanceledException;
  24
  25 import org.apache.commons.lang3.StringUtils;
  26 import org.fusesource.jansi.AnsiConsole;
  27
  28 import java.io.BufferedReader;
  29 import java.io.IOException;
  30 import java.io.InputStreamReader;
  31 import java.io.PrintStream;
  32 import java.io.PrintWriter;
  33 import java.util.Arrays;
  34 import java.util.concurrent.Semaphore;
  35
  36 /**
  37  * @version $Id$
  38  */
  39 public class Console {
  40
  41     private final java.io.Console console
  42             = System.console();
  43
  44     private final PrintStream out
  45             = AnsiConsole.out();
  46
  47     private static final Semaphore lock
  48             = new Semaphore(1);
  49
  50     public String readLine(String format, Object... args) throws ConnectionCanceledException {
  51         if(console != null) {
  52             return this.wrap(console.readLine(format, args));
  53         }
  54         this.printf(format, args);
  55         final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
  56         try {
  57             return this.wrap(reader.readLine());
  58         }
  59         catch(IOException e) {
  60             throw new ConnectionCanceledException(e);
  61         }
  62     }
  63
  64     public char[] readPassword(String format, Object... args) throws ConnectionCanceledException {
  65         if(console != null) {
  66             return this.wrap(console.readPassword(format, args));
  67         }
  68         final String line = this.readLine(format, args);
  69         if(StringUtils.isBlank(line)) {
  70             throw new LoginCanceledException();
  71         }
  72         return line.toCharArray();
  73     }
  74
  75     public void printf(final String format, Object... args) {
  76         if(StringUtils.isEmpty(format)) {
  77             return;
  78         }
  79         try {
  80             lock.acquire();
  81             if(console != null) {
  82                 switch(Factory.Platform.getDefault()) {
  83                     case windows:
  84                         break;
  85                     default:
  86                         final PrintWriter writer = console.writer();
  87                         if(Arrays.asList(args).isEmpty()) {
  88                             writer.print(format);
  89                         }
  90                         else {
  91                             writer.printf(format, args);
  92                         }
  93                         writer.flush();
  94                         return;
  95                 }
  96             }
  97             if(Arrays.asList(args).isEmpty()) {
  98                 out.printf(format);
  99             }
 100             else {
 101                 out.printf(format, args);
 102             }
 103             out.flush();
 104         }
 105         catch(InterruptedException e) {
 106             //
 107         }
 108         finally {
 109             lock.release();
 110         }
 111     }
 112
 113     private String wrap(final String input) throws ConnectionCanceledException {
 114         if(null == input) {
 115             throw new ConnectionCanceledException();
 116         }
 117         return input;
 118     }
 119
 120     private char[] wrap(final char[] input) throws ConnectionCanceledException {
 121         if(null == input) {
 122             throw new ConnectionCanceledException();
 123         }
 124         return input;
 125     }
 126 }