dcaedt_validator/kwalify/src/main/java/kwalify/Main.java

   1 /*
   2  * @(#)Main.java        $Rev: 4 $ $Release: 0.5.1 $
   3  *
   4  * copyright(c) 2005 kuwata-lab all rights reserved.
   5  */
   6
   7 package kwalify;
   8
   9 import org.onap.sdc.common.onaplog.OnapLoggerDebug;
  10 import org.onap.sdc.common.onaplog.OnapLoggerError;
  11 import org.onap.sdc.common.onaplog.Enums.LogLevel;
  12
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.HashMap;
  16 import java.util.Iterator;
  17 import java.util.Collections;
  18 import java.util.regex.Matcher;
  19 import java.io.IOException;
  20
  21 /**
  22  * class for main program
  23  *
  24  * @revision    $Rev: 4 $
  25  * @release     $Release: 0.5.1 $
  26  */
  27 public class Main {
  28
  29     private static OnapLoggerError errLogger = OnapLoggerError.getInstance();
  30     private static OnapLoggerDebug debugLogger = OnapLoggerDebug.getInstance();
  31
  32     private String _command;
  33     private boolean _flag_help     = false;  // print help
  34     private boolean _flag_version  = false;  // print version
  35     private boolean _flag_silent   = false;  // suppress messages
  36     private boolean _flag_meta     = false;  // meta validation
  37     private boolean _flag_untabify = false;  // expand tab character to spaces
  38     private boolean _flag_emacs    = false;  // show errors in emacs style
  39     private boolean _flag_linenum  = false;  // show line number on where errors happened
  40     private boolean _flag_debug    = false;  // internal use only
  41     private String  _schema_filename = null; // schema filename
  42     private Map _properties = new HashMap();
  43
  44
  45     boolean isDebug() { return _flag_debug; }
  46
  47
  48     public String inspect() {
  49         StringBuffer sb = new StringBuffer();
  50         sb.append("command       : ").append(_command       ).append('\n');
  51         sb.append("flag_help     : ").append(_flag_help     ).append('\n');
  52         sb.append("flag_version  : ").append(_flag_version  ).append('\n');
  53         sb.append("flag_silent   : ").append(_flag_silent   ).append('\n');
  54         sb.append("flag_meta     : ").append(_flag_meta     ).append('\n');
  55         sb.append("flag_untabify : ").append(_flag_untabify ).append('\n');
  56         sb.append("flag_emacs    : ").append(_flag_emacs    ).append('\n');
  57         sb.append("flag_linenum  : ").append(_flag_linenum  ).append('\n');
  58         sb.append("flag_debug    : ").append(_flag_debug    ).append('\n');
  59         sb.append("schema_filename : ").append(_schema_filename).append('\n');
  60         sb.append("properties:\n");
  61         for (Iterator it = _properties.keySet().iterator(); it.hasNext(); ) {
  62             Object key = it.next();
  63             Object val = _properties.get(key);
  64             sb.append("  ").append(key).append(": ").append(val).append('\n');
  65         }
  66         return sb.toString();
  67     }
  68
  69
  70     private static final String REVISION = "$Release: 0.5.1 $";
  71     private static final String HELP = ""
  72         + "Usage1: %s [-hvstlE] -f schema.yaml doc.yaml [doc2.yaml ...]\n"
  73         + "Usage2: %s [-hvstlE] -m schema.yaml [schema2.yaml ...]\n"
  74         + "  -h, --help      :  help\n"
  75         + "  -v              :  version\n"
  76         + "  -s              :  silent\n"
  77         + "  -f schema.yaml  :  schema definition file\n"
  78         + "  -m              :  meta-validation mode\n"
  79         + "  -t              :  expand tab character automatically\n"
  80         + "  -l              :  show linenumber when errored (experimental)\n"
  81         + "  -E              :  show errors in emacs-style (implies '-l')\n"
  82         ;
  83
  84
  85     public Main(String command) {
  86         _command = command;
  87     }
  88
  89
  90     public String execute(String[] args) throws IOException, CommandOptionException, SyntaxException {
  91         // parse command-line options
  92         String[] filenames = parseOptions(args);
  93
  94         // help or version
  95         StringBuffer sb = new StringBuffer();
  96         if (_flag_version) {
  97             sb.append(version()).append('\n');
  98         }
  99         if (_flag_help) {
 100             sb.append(help());
 101         }
 102         if (sb.length() > 0) {
 103             return sb.toString();
 104         }
 105
 106         // main
 107         String s = null;
 108         if (_flag_meta) {
 109             s = metaValidate(filenames);
 110         } else if (_schema_filename == null) {
 111             throw optionError("command.option.noaction", '\0');
 112         } else if (_flag_debug) {
 113             s = inspectSchemaFile(_schema_filename);
 114         } else {
 115             s = validate(filenames, _schema_filename);
 116         }
 117
 118         //
 119         return s;
 120     }
 121
 122
 123     private String[] parseOptions(String[] args) throws CommandOptionException {
 124         Object[] ret = null;
 125         try {
 126             ret = Util.parseCommandOptions(args, "hvsmtlED", "f", null);
 127         } catch (CommandOptionException ex) {
 128             String error_symbol = ex.getErrorSymbol();
 129             if (error_symbol.equals("command.option.noarg")) {
 130                 switch (ex.getOption()) {
 131                 case 'f':   error_symbol = "command.option.noschema";  break;
 132                 default:
 133                     assert false;
 134                 }
 135             }
 136             throw optionError(error_symbol, ex.getOption());
 137         }
 138         //
 139         Map options        = (Map)ret[0];
 140         Map properties     = (Map)ret[1];
 141         String[] filenames = (String[])ret[2];
 142         //
 143         _flag_help     = options.get("h") != null;
 144         _flag_version  = options.get("v") != null;
 145         _flag_silent   = options.get("s") != null;
 146         _flag_meta     = options.get("m") != null;
 147         _flag_untabify = options.get("t") != null;
 148         _flag_emacs    = options.get("E") != null;
 149         _flag_linenum  = options.get("l") != null || _flag_emacs;
 150         _flag_debug    = options.get("D") != null;
 151         _schema_filename = (String)options.get("f");
 152         //
 153         //
 154         _properties = properties;
 155         if (_properties.get("help") != null) {
 156             _flag_help = true;
 157         }
 158         //
 159         return filenames;
 160     }
 161
 162
 163     private String validate(String[] filenames, String schema_filename) throws IOException, SyntaxException {
 164         String str = Util.readFile(schema_filename);
 165         if (_flag_untabify) {
 166             str = Util.untabify(str);
 167         }
 168         YamlParser parser = new YamlParser(str);
 169         Object schema = parser.parse();
 170         Validator validator = new Validator(schema);
 171         String s = validateFiles(validator, filenames);
 172         return s;
 173     }
 174
 175
 176     private String validateFiles(Validator validator, String[] filenames) throws IOException, SyntaxException {
 177         if (filenames.length == 0) {
 178             filenames = new String[] { null };
 179         }
 180         StringBuffer sb = new StringBuffer();
 181         for (int j = 0; j < filenames.length; j++) {
 182             String filename = filenames[j];
 183             String str = null;
 184             if (filename == null) {
 185                 str = Util.readInputStream(System.in);
 186                 filename = "(stdin)";
 187             } else {
 188                 str = Util.readFile(filename);
 189             }
 190             if (_flag_untabify) {
 191                 str = Util.untabify(str);
 192             }
 193             YamlParser parser = new YamlParser(str);
 194             int i = 0;
 195             while (parser.hasNext()) {
 196                 Object doc = parser.parse();
 197                 validateDocument(sb, validator, doc, filename, i, parser);
 198                 i++;
 199             }
 200         }
 201         return sb.toString();
 202     }
 203
 204
 205     private void validateDocument(StringBuffer sb, Validator validator, Object doc, String filename, int i, YamlParser parser) {
 206         if (doc == null) {
 207             Object[] args = { filename, new Integer(i) };
 208             String msg = Messages.buildMessage("validation.empty", null, args);
 209             sb.append(msg).append('\n');
 210             return;
 211         }
 212         List errors = validator.validate(doc);
 213         Object[] args = { filename, new Integer(i) };
 214         if (errors == null || errors.size() == 0) {
 215             if (! _flag_silent) {
 216                 String msg = Messages.buildMessage("validation.valid", args);
 217                 sb.append(msg).append('\n');
 218             }
 219         } else {
 220             String msg = Messages.buildMessage("validation.invalid", args);
 221             sb.append(msg).append('\n');
 222             if (_flag_linenum) {
 223                 assert parser != null;
 224                 parser.setErrorsLineNumber(errors);
 225                 Collections.sort(errors);
 226             }
 227             for (Iterator it = errors.iterator(); it.hasNext(); ) {
 228                 ValidationException error = (ValidationException)it.next();
 229                 if (_flag_emacs) {
 230                     assert _flag_linenum;
 231                     sb.append(filename).append(":").append(error.getLineNumber()).append(":");
 232                 } else if (_flag_linenum) {
 233                     sb.append("  - (line ").append(error.getLineNumber()).append(")");
 234                 } else {
 235                     sb.append("  -");
 236                 }
 237                 sb.append(" [").append(error.getPath()).append("] ").append(error.getMessage()).append('\n');
 238             }
 239         }
 240     }
 241
 242
 243     private String metaValidate(String[] filenames) throws IOException, SyntaxException {
 244         Validator meta_validator = MetaValidator.instance();
 245         String s = validateFiles(meta_validator, filenames);
 246         return s;
 247     }
 248
 249
 250     private String inspectSchemaFile(String schema_filename) throws IOException, SyntaxException {
 251         String filename = schema_filename;
 252         String content = filename != null ? Util.readFile(filename) : Util.readInputStream(System.in);
 253         YamlParser parser = new YamlParser(content);
 254         Object schema = parser.parse();
 255         if (schema == null) {
 256             return null;
 257         }
 258         Validator validator = new Validator(schema);  // SchemaException is thrown when schema is wrong
 259         String s = validator.getRule().inspect();
 260         if (s.charAt(s.length() - 1) != '\n') {
 261             s = s + '\n';
 262         }
 263         return s;
 264     }
 265
 266
 267     private static CommandOptionException optionError(String error_symbol, char option) {
 268         Object[] args = { Character.toString(option) };
 269         String message = Messages.buildMessage(error_symbol, null, args);
 270         return new CommandOptionException(message, option, error_symbol);
 271     }
 272
 273
 274     private String version() {
 275         Matcher m = Util.matcher(REVISION, "[.\\d]+");
 276         m.find();
 277         String version = m.group(0);
 278         return version;
 279     }
 280
 281
 282     private String help() {
 283         String help_msg = Messages.buildMessage("command.help", null, new Object[] { _command, _command });
 284         //String help = HELP.replaceAll("%s", _command);
 285         return help_msg;
 286     }
 287
 288
 289     public static void main(String[] args) throws Exception {
 290         int status = 0;
 291         Main main = null;
 292         try {
 293             main = new Main("kwalify-java");
 294             String result = main.execute(args);
 295             if (result != null) {
 296                 debugLogger.log(LogLevel.DEBUG, Main.class.getName(), result);
 297             }        } catch (Exception ex) {
 298             if (main != null && main.isDebug()) {
 299                 throw ex;
 300             }
 301             if (    ex instanceof CommandOptionException
 302                  || ex instanceof SyntaxException
 303                  || ex instanceof IOException) {
 304                 errLogger.log(LogLevel.ERROR, Main.class.getName(), "ERROR: {}", ex.getMessage());
 305                 status = 1;
 306             }
 307         }
 308         System.exit(status);
 309     }
 310
 311 }