f83186c1d89bffdd01b1c837a1b29b6047cb5f33
[nikiroo-utils.git] / Main.java
1 package be.nikiroo.fanfix;
2
3 import java.io.File;
4 import java.io.IOException;
5 import java.net.MalformedURLException;
6 import java.net.URL;
7 import java.util.List;
8
9 import be.nikiroo.fanfix.bundles.StringId;
10 import be.nikiroo.fanfix.data.Chapter;
11 import be.nikiroo.fanfix.data.MetaData;
12 import be.nikiroo.fanfix.data.Story;
13 import be.nikiroo.fanfix.library.BasicLibrary;
14 import be.nikiroo.fanfix.library.CacheLibrary;
15 import be.nikiroo.fanfix.library.LocalLibrary;
16 import be.nikiroo.fanfix.library.RemoteLibrary;
17 import be.nikiroo.fanfix.library.RemoteLibraryServer;
18 import be.nikiroo.fanfix.output.BasicOutput;
19 import be.nikiroo.fanfix.output.BasicOutput.OutputType;
20 import be.nikiroo.fanfix.reader.BasicReader;
21 import be.nikiroo.fanfix.reader.Reader;
22 import be.nikiroo.fanfix.reader.Reader.ReaderType;
23 import be.nikiroo.fanfix.supported.BasicSupport;
24 import be.nikiroo.fanfix.supported.SupportType;
25 import be.nikiroo.utils.Progress;
26 import be.nikiroo.utils.Version;
27 import be.nikiroo.utils.serial.server.ServerObject;
28
29 /**
30 * Main program entry point.
31 *
32 * @author niki
33 */
34 public class Main {
35 private enum MainAction {
36 IMPORT, EXPORT, CONVERT, READ, READ_URL, LIST, HELP, SET_READER, START, VERSION, SERVER, STOP_SERVER, REMOTE,
37 }
38
39 /**
40 * Main program entry point.
41 * <p>
42 * Known environment variables:
43 * <ul>
44 * <li>NOUTF: if set to 1 or 'true', the program will prefer non-unicode
45 * {@link String}s when possible</li>
46 * <li>CONFIG_DIR: a path where to look for the <tt>.properties</tt> files
47 * before taking the usual ones; they will also be saved/updated into this
48 * path when the program starts</li>
49 * <li>DEBUG: if set to 1 or 'true', the program will override the DEBUG_ERR
50 * configuration value with 'true'</li>
51 * </ul>
52 * <p>
53 * <ul>
54 * <li>--import [URL]: import into library</li>
55 * <li>--export [id] [output_type] [target]: export story to target</li>
56 * <li>--convert [URL] [output_type] [target] (+info): convert URL into
57 * target</li>
58 * <li>--read [id] ([chapter number]): read the given story from the library
59 * </li>
60 * <li>--read-url [URL] ([chapter number]): convert on the fly and read the
61 * story, without saving it</li>
62 * <li>--list ([type]): list the stories present in the library</li>
63 * <li>--set-reader [reader type]: set the reader type to CLI, TUI or LOCAL
64 * for this command</li>
65 * <li>--version: get the version of the program</li>
66 * <li>--server [key] [port]: start a server on this port</li>
67 * <li>--stop-server [key] [port]: stop the running server on this port if
68 * any</li>
69 * <li>--remote [key] [host] [port]: use a the given remote library</li>
70 * </ul>
71 *
72 * @param args
73 * see method description
74 */
75 public static void main(String[] args) {
76 String urlString = null;
77 String luid = null;
78 String sourceString = null;
79 String chapString = null;
80 String target = null;
81 String key = null;
82 MainAction action = MainAction.START;
83 Boolean plusInfo = null;
84 String host = null;
85 Integer port = null;
86
87 boolean noMoreActions = false;
88
89 int exitCode = 0;
90 for (int i = 0; exitCode == 0 && i < args.length; i++) {
91 // Action (--) handling:
92 if (!noMoreActions && args[i].startsWith("--")) {
93 if (args[i].equals("--")) {
94 noMoreActions = true;
95 } else {
96 try {
97 action = MainAction.valueOf(args[i].substring(2)
98 .toUpperCase().replace("-", "_"));
99 } catch (Exception e) {
100 Instance.getTraceHandler().error(
101 new IllegalArgumentException("Unknown action: "
102 + args[i], e));
103 exitCode = 255;
104 }
105 }
106
107 continue;
108 }
109
110 switch (action) {
111 case IMPORT:
112 if (urlString == null) {
113 urlString = args[i];
114 } else {
115 exitCode = 255;
116 }
117 break;
118 case EXPORT:
119 if (luid == null) {
120 luid = args[i];
121 } else if (sourceString == null) {
122 sourceString = args[i];
123 } else if (target == null) {
124 target = args[i];
125 } else {
126 exitCode = 255;
127 }
128 break;
129 case CONVERT:
130 if (urlString == null) {
131 urlString = args[i];
132 } else if (sourceString == null) {
133 sourceString = args[i];
134 } else if (target == null) {
135 target = args[i];
136 } else if (plusInfo == null) {
137 if ("+info".equals(args[i])) {
138 plusInfo = true;
139 } else {
140 exitCode = 255;
141 }
142 } else {
143 exitCode = 255;
144 }
145 break;
146 case LIST:
147 if (sourceString == null) {
148 sourceString = args[i];
149 } else {
150 exitCode = 255;
151 }
152 break;
153 case READ:
154 if (luid == null) {
155 luid = args[i];
156 } else if (chapString == null) {
157 chapString = args[i];
158 } else {
159 exitCode = 255;
160 }
161 break;
162 case READ_URL:
163 if (urlString == null) {
164 urlString = args[i];
165 } else if (chapString == null) {
166 chapString = args[i];
167 } else {
168 exitCode = 255;
169 }
170 break;
171 case HELP:
172 exitCode = 255;
173 break;
174 case SET_READER:
175 exitCode = setReaderType(args[i]);
176 action = MainAction.START;
177 break;
178 case START:
179 exitCode = 255; // not supposed to be selected by user
180 break;
181 case VERSION:
182 exitCode = 255; // no arguments for this option
183 break;
184 case SERVER:
185 case STOP_SERVER:
186 if (key == null) {
187 key = args[i];
188 } else if (port == null) {
189 port = Integer.parseInt(args[i]);
190 } else {
191 exitCode = 255;
192 }
193 break;
194 case REMOTE:
195 if (key == null) {
196 key = args[i];
197 } else if (host == null) {
198 host = args[i];
199 } else if (port == null) {
200 port = Integer.parseInt(args[i]);
201
202 BasicLibrary lib = new RemoteLibrary(key, host, port);
203 lib = new CacheLibrary(Instance.getRemoteDir(host), lib);
204
205 BasicReader.setDefaultLibrary(lib);
206
207 action = MainAction.START;
208 } else {
209 exitCode = 255;
210 }
211 break;
212 }
213 }
214
215 final Progress mainProgress = new Progress(0, 80);
216 mainProgress.addProgressListener(new Progress.ProgressListener() {
217 private int current = mainProgress.getMin();
218
219 @Override
220 public void progress(Progress progress, String name) {
221 int diff = progress.getProgress() - current;
222 current += diff;
223
224 if (diff <= 0)
225 return;
226
227 StringBuilder builder = new StringBuilder();
228 for (int i = 0; i < diff; i++) {
229 builder.append('.');
230 }
231
232 System.err.print(builder.toString());
233
234 if (progress.isDone()) {
235 System.err.println("");
236 }
237 }
238 });
239 Progress pg = new Progress();
240 mainProgress.addProgress(pg, mainProgress.getMax());
241
242 VersionCheck updates = VersionCheck.check();
243 if (updates.isNewVersionAvailable()) {
244 // Sent to syserr so not to cause problem if one tries to capture a
245 // story content in text mode
246 System.err
247 .println("A new version of the program is available at https://github.com/nikiroo/fanfix/releases");
248 System.err.println("");
249 for (Version v : updates.getNewer()) {
250 System.err.println("\tVersion " + v);
251 System.err.println("\t-------------");
252 System.err.println("");
253 for (String item : updates.getChanges().get(v)) {
254 System.err.println("\t- " + item);
255 }
256 System.err.println("");
257 }
258 }
259
260 if (exitCode != 255) {
261 switch (action) {
262 case IMPORT:
263 exitCode = imprt(urlString, pg);
264 updates.ok(); // we consider it read
265 break;
266 case EXPORT:
267 exitCode = export(luid, sourceString, target, pg);
268 updates.ok(); // we consider it read
269 break;
270 case CONVERT:
271 exitCode = convert(urlString, sourceString, target,
272 plusInfo == null ? false : plusInfo, pg);
273 updates.ok(); // we consider it read
274 break;
275 case LIST:
276 if (BasicReader.getReader() == null) {
277 Instance.getTraceHandler()
278 .error(new Exception(
279 "No reader type has been configured"));
280 exitCode = 10;
281 break;
282 }
283 exitCode = list(sourceString);
284 break;
285 case READ:
286 if (BasicReader.getReader() == null) {
287 Instance.getTraceHandler()
288 .error(new Exception(
289 "No reader type has been configured"));
290 exitCode = 10;
291 break;
292 }
293 exitCode = read(luid, chapString, true);
294 break;
295 case READ_URL:
296 if (BasicReader.getReader() == null) {
297 Instance.getTraceHandler()
298 .error(new Exception(
299 "No reader type has been configured"));
300 exitCode = 10;
301 break;
302 }
303 exitCode = read(urlString, chapString, false);
304 break;
305 case HELP:
306 syntax(true);
307 exitCode = 0;
308 break;
309 case SET_READER:
310 exitCode = 255;
311 break;
312 case VERSION:
313 System.out
314 .println(String.format("Fanfix version %s"
315 + "%nhttps://github.com/nikiroo/fanfix/"
316 + "%n\tWritten by Nikiroo",
317 Version.getCurrentVersion()));
318 updates.ok(); // we consider it read
319 break;
320 case START:
321 if (BasicReader.getReader() == null) {
322 Instance.getTraceHandler()
323 .error(new Exception(
324 "No reader type has been configured"));
325 exitCode = 10;
326 break;
327 }
328 BasicReader.getReader().browse(null);
329 break;
330 case SERVER:
331 if (port == null) {
332 exitCode = 255;
333 break;
334 }
335 try {
336 ServerObject server = new RemoteLibraryServer(key, port);
337 server.setTraceHandler(Instance.getTraceHandler());
338 server.run();
339 } catch (IOException e) {
340 Instance.getTraceHandler().error(e);
341 }
342 return;
343 case STOP_SERVER:
344 if (port == null) {
345 exitCode = 255;
346 break;
347 }
348
349 new RemoteLibrary(key, host, port).exit();
350 break;
351 case REMOTE:
352 exitCode = 255; // should not be reachable (REMOTE -> START)
353 break;
354 }
355 }
356
357 try {
358 Instance.getTempFiles().close();
359 } catch (IOException e) {
360 Instance.getTraceHandler()
361 .error(new IOException(
362 "Cannot dispose of the temporary files", e));
363 }
364
365 if (exitCode == 255) {
366 syntax(false);
367 }
368
369 if (exitCode != 0) {
370 System.exit(exitCode);
371 }
372 }
373
374 /**
375 * Import the given resource into the {@link LocalLibrary}.
376 *
377 * @param urlString
378 * the resource to import
379 * @param pg
380 * the optional progress reporter
381 *
382 * @return the exit return code (0 = success)
383 */
384 public static int imprt(String urlString, Progress pg) {
385 try {
386 Story story = Instance.getLibrary().imprt(
387 BasicReader.getUrl(urlString), pg);
388 System.out.println(story.getMeta().getLuid() + ": \""
389 + story.getMeta().getTitle() + "\" imported.");
390 } catch (IOException e) {
391 Instance.getTraceHandler().error(e);
392 return 1;
393 }
394
395 return 0;
396 }
397
398 /**
399 * Export the {@link Story} from the {@link LocalLibrary} to the given
400 * target.
401 *
402 * @param luid
403 * the story LUID
404 * @param typeString
405 * the {@link OutputType} to use
406 * @param target
407 * the target
408 * @param pg
409 * the optional progress reporter
410 *
411 * @return the exit return code (0 = success)
412 */
413 public static int export(String luid, String typeString, String target,
414 Progress pg) {
415 OutputType type = OutputType.valueOfNullOkUC(typeString, null);
416 if (type == null) {
417 Instance.getTraceHandler().error(
418 new Exception(trans(StringId.OUTPUT_DESC, typeString)));
419 return 1;
420 }
421
422 try {
423 Instance.getLibrary().export(luid, type, target, pg);
424 } catch (IOException e) {
425 Instance.getTraceHandler().error(e);
426 return 4;
427 }
428
429 return 0;
430 }
431
432 /**
433 * List the stories of the given source from the {@link LocalLibrary}
434 * (unless NULL is passed, in which case all stories will be listed).
435 *
436 * @param source
437 * the source to list the known stories of, or NULL to list all
438 * stories
439 *
440 * @return the exit return code (0 = success)
441 */
442 private static int list(String source) {
443 List<MetaData> stories;
444 stories = BasicReader.getReader().getLibrary().getListBySource(source);
445
446 for (MetaData story : stories) {
447 String author = "";
448 if (story.getAuthor() != null && !story.getAuthor().isEmpty()) {
449 author = " (" + story.getAuthor() + ")";
450 }
451
452 System.out.println(story.getLuid() + ": " + story.getTitle()
453 + author);
454 }
455 return 0;
456 }
457
458 /**
459 * Start the current reader for this {@link Story}.
460 *
461 * @param story
462 * the LUID of the {@link Story} in the {@link LocalLibrary}
463 * <b>or</b> the {@link Story} {@link URL}
464 * @param chapString
465 * which {@link Chapter} to read (starting at 1), or NULL to get
466 * the {@link Story} description
467 * @param library
468 * TRUE if the source is the {@link Story} LUID, FALSE if it is a
469 * {@link URL}
470 *
471 * @return the exit return code (0 = success)
472 */
473 private static int read(String story, String chapString, boolean library) {
474 try {
475 Reader reader = BasicReader.getReader();
476 if (library) {
477 reader.setMeta(story);
478 } else {
479 reader.setMeta(BasicReader.getUrl(story), null);
480 }
481
482 if (chapString != null) {
483 try {
484 reader.setChapter(Integer.parseInt(chapString));
485 reader.read(true);
486 } catch (NumberFormatException e) {
487 Instance.getTraceHandler().error(
488 new IOException("Chapter number cannot be parsed: "
489 + chapString, e));
490 return 2;
491 }
492 } else {
493 reader.read(true);
494 }
495 } catch (IOException e) {
496 Instance.getTraceHandler().error(e);
497 return 1;
498 }
499
500 return 0;
501 }
502
503 /**
504 * Convert the {@link Story} into another format.
505 *
506 * @param urlString
507 * the source {@link Story} to convert
508 * @param typeString
509 * the {@link OutputType} to convert to
510 * @param target
511 * the target file
512 * @param infoCover
513 * TRUE to also export the cover and info file, even if the given
514 * {@link OutputType} does not usually save them
515 * @param pg
516 * the optional progress reporter
517 *
518 * @return the exit return code (0 = success)
519 */
520 public static int convert(String urlString, String typeString,
521 String target, boolean infoCover, Progress pg) {
522 int exitCode = 0;
523
524 Instance.getTraceHandler().trace("Convert: " + urlString);
525 String sourceName = urlString;
526 try {
527 URL source = BasicReader.getUrl(urlString);
528 sourceName = source.toString();
529 if (source.toString().startsWith("file://")) {
530 sourceName = sourceName.substring("file://".length());
531 }
532
533 OutputType type = OutputType.valueOfAllOkUC(typeString, null);
534 if (type == null) {
535 Instance.getTraceHandler().error(
536 new IOException(trans(StringId.ERR_BAD_OUTPUT_TYPE,
537 typeString)));
538
539 exitCode = 2;
540 } else {
541 try {
542 BasicSupport support = BasicSupport.getSupport(source);
543
544 if (support != null) {
545 Instance.getTraceHandler().trace(
546 "Support found: " + support.getClass());
547 Progress pgIn = new Progress();
548 Progress pgOut = new Progress();
549 if (pg != null) {
550 pg.setMax(2);
551 pg.addProgress(pgIn, 1);
552 pg.addProgress(pgOut, 1);
553 }
554
555 Story story = support.process(pgIn);
556 try {
557 target = new File(target).getAbsolutePath();
558 BasicOutput.getOutput(type, infoCover, infoCover)
559 .process(story, target, pgOut);
560 } catch (IOException e) {
561 Instance.getTraceHandler().error(
562 new IOException(trans(StringId.ERR_SAVING,
563 target), e));
564 exitCode = 5;
565 }
566 } else {
567 Instance.getTraceHandler().error(
568 new IOException(trans(
569 StringId.ERR_NOT_SUPPORTED, source)));
570
571 exitCode = 4;
572 }
573 } catch (IOException e) {
574 Instance.getTraceHandler().error(
575 new IOException(trans(StringId.ERR_LOADING,
576 sourceName), e));
577 exitCode = 3;
578 }
579 }
580 } catch (MalformedURLException e) {
581 Instance.getTraceHandler()
582 .error(new IOException(trans(StringId.ERR_BAD_URL,
583 sourceName), e));
584 exitCode = 1;
585 }
586
587 return exitCode;
588 }
589
590 /**
591 * Simple shortcut method to call {link Instance#getTrans()#getString()}.
592 *
593 * @param id
594 * the ID to translate
595 *
596 * @return the translated result
597 */
598 private static String trans(StringId id, Object... params) {
599 return Instance.getTrans().getString(id, params);
600 }
601
602 /**
603 * Display the correct syntax of the program to the user to stdout, or an
604 * error message if the syntax used was wrong on stderr.
605 *
606 * @param showHelp
607 * TRUE to show the syntax help, FALSE to show "syntax error"
608 */
609 private static void syntax(boolean showHelp) {
610 if (showHelp) {
611 StringBuilder builder = new StringBuilder();
612 for (SupportType type : SupportType.values()) {
613 builder.append(trans(StringId.ERR_SYNTAX_TYPE, type.toString(),
614 type.getDesc()));
615 builder.append('\n');
616 }
617
618 String typesIn = builder.toString();
619 builder.setLength(0);
620
621 for (OutputType type : OutputType.values()) {
622 builder.append(trans(StringId.ERR_SYNTAX_TYPE, type.toString(),
623 type.getDesc(true)));
624 builder.append('\n');
625 }
626
627 String typesOut = builder.toString();
628
629 System.out.println(trans(StringId.HELP_SYNTAX, typesIn, typesOut));
630 } else {
631 System.err.println(trans(StringId.ERR_SYNTAX));
632 }
633 }
634
635 /**
636 * Set the default reader type for this session only (it can be changed in
637 * the configuration file, too, but this value will override it).
638 *
639 * @param readerTypeString
640 * the type
641 */
642 private static int setReaderType(String readerTypeString) {
643 try {
644 ReaderType readerType = ReaderType.valueOf(readerTypeString
645 .toUpperCase());
646 BasicReader.setDefaultReaderType(readerType);
647 return 0;
648 } catch (IllegalArgumentException e) {
649 Instance.getTraceHandler().error(
650 new IOException("Unknown reader type: " + readerTypeString,
651 e));
652 return 1;
653 }
654 }
655 }