weblib: add mimetypes for ico/png/java
[fanfix.git] / src / be / nikiroo / fanfix / library / WebLibraryServer.java
1 package be.nikiroo.fanfix.library;
2
3 import java.io.ByteArrayInputStream;
4 import java.io.IOException;
5 import java.io.InputStream;
6 import java.net.URL;
7 import java.util.ArrayList;
8 import java.util.Arrays;
9 import java.util.HashMap;
10 import java.util.LinkedList;
11 import java.util.List;
12 import java.util.Map;
13
14 import org.json.JSONArray;
15 import org.json.JSONObject;
16
17 import be.nikiroo.fanfix.Instance;
18 import be.nikiroo.fanfix.bundles.Config;
19 import be.nikiroo.fanfix.data.Chapter;
20 import be.nikiroo.fanfix.data.JsonIO;
21 import be.nikiroo.fanfix.data.MetaData;
22 import be.nikiroo.fanfix.data.Paragraph;
23 import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
24 import be.nikiroo.fanfix.data.Story;
25 import be.nikiroo.utils.Image;
26 import be.nikiroo.utils.LoginResult;
27 import be.nikiroo.utils.NanoHTTPD;
28 import be.nikiroo.utils.NanoHTTPD.Response;
29 import be.nikiroo.utils.NanoHTTPD.Response.Status;
30 import be.nikiroo.utils.Progress;
31
32 public class WebLibraryServer extends WebLibraryServerHtml {
33 class WLoginResult extends LoginResult {
34 public WLoginResult(boolean badLogin, boolean badCookie) {
35 super(badLogin, badCookie);
36 }
37
38 public WLoginResult(String who, String key, String subkey, boolean rw,
39 boolean wl, boolean bl) {
40 super(who, key, subkey, (rw ? "|rw" : "") + (wl ? "|wl" : "")
41 + (bl ? "|bl" : "") + "|");
42 }
43
44 public WLoginResult(String cookie, String who, String key,
45 List<String> subkeys) {
46 super(cookie, who, key, subkeys,
47 subkeys == null || subkeys.isEmpty());
48 }
49
50 public boolean isRw() {
51 return getOption().contains("|rw|");
52 }
53
54 public boolean isWl() {
55 return getOption().contains("|wl|");
56 }
57
58 public boolean isBl() {
59 return getOption().contains("|bl|");
60 }
61 }
62
63 private Map<String, Story> storyCache = new HashMap<String, Story>();
64 private LinkedList<String> storyCacheOrder = new LinkedList<String>();
65 private long storyCacheSize = 0;
66 private long maxStoryCacheSize;
67
68 private List<String> whitelist;
69 private List<String> blacklist;
70
71 private Map<String, Progress> imprts = new HashMap<String, Progress>();
72
73 private boolean exiting;
74
75 public WebLibraryServer(boolean secure) throws IOException {
76 super(secure);
77
78 int cacheMb = Instance.getInstance().getConfig()
79 .getInteger(Config.SERVER_MAX_CACHE_MB, 100);
80 maxStoryCacheSize = cacheMb * 1024 * 1024;
81
82 setTraceHandler(Instance.getInstance().getTraceHandler());
83
84 whitelist = Instance.getInstance().getConfig()
85 .getList(Config.SERVER_WHITELIST, new ArrayList<String>());
86 blacklist = Instance.getInstance().getConfig()
87 .getList(Config.SERVER_BLACKLIST, new ArrayList<String>());
88 }
89
90 /**
91 * Start the server (listen on the network for new connections).
92 * <p>
93 * Can only be called once.
94 * <p>
95 * This call is asynchronous, and will just start a new {@link Thread} on
96 * itself (see {@link WebLibraryServer#run()}).
97 */
98 public void start() {
99 new Thread(this).start();
100 }
101
102 @Override
103 protected Response stop(WLoginResult login) {
104 if (!login.isRw()) {
105 return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
106 NanoHTTPD.MIME_PLAINTEXT, "Exit not allowed");
107 }
108
109 if (exiting) {
110 return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
111 NanoHTTPD.MIME_PLAINTEXT, "Server is already exiting...");
112 }
113
114 exiting = true;
115 Instance.getInstance().getTraceHandler().trace("Exiting");
116
117 boolean ok;
118 do {
119 synchronized (imprts) {
120 ok = imprts.isEmpty();
121 }
122 if (!ok) {
123 try {
124 Thread.sleep(2000);
125 } catch (InterruptedException e) {
126 Instance.getInstance().getTraceHandler()
127 .trace("Waiting to exit...");
128 }
129 }
130 } while (!ok);
131
132 doStop();
133
134 new Thread(new Runnable() {
135 @Override
136 public void run() {
137 try {
138 Thread.sleep(1500);
139 } catch (InterruptedException e) {
140 }
141
142 Instance.getInstance().getTraceHandler()
143 .trace("Exit timeout: force-quit");
144 System.exit(0);
145 }
146 }, "Exit program after timeout of 1500 ms").start();
147
148 return NanoHTTPD.newFixedLengthResponse(Status.OK,
149 NanoHTTPD.MIME_PLAINTEXT, "Exited");
150 }
151
152 @Override
153 protected WLoginResult login(boolean badLogin, boolean badCookie) {
154 return new WLoginResult(false, false);
155 }
156
157 @Override
158 protected WLoginResult login(String who, String cookie) {
159 List<String> subkeys = Instance.getInstance().getConfig()
160 .getList(Config.SERVER_ALLOWED_SUBKEYS);
161 String realKey = Instance.getInstance().getConfig()
162 .getString(Config.SERVER_KEY);
163
164 return new WLoginResult(cookie, who, realKey, subkeys);
165 }
166
167 // allow rw/wl
168 @Override
169 protected WLoginResult login(String who, String key, String subkey) {
170 String realKey = Instance.getInstance().getConfig()
171 .getString(Config.SERVER_KEY, "");
172
173 // I don't like NULLs...
174 key = key == null ? "" : key;
175 subkey = subkey == null ? "" : subkey;
176
177 if (!realKey.equals(key)) {
178 return new WLoginResult(true, false);
179 }
180
181 // defaults are true (as previous versions without the feature)
182 boolean rw = true;
183 boolean wl = true;
184 boolean bl = true;
185
186 rw = Instance.getInstance().getConfig().getBoolean(Config.SERVER_RW,
187 rw);
188
189 List<String> allowed = Instance.getInstance().getConfig().getList(
190 Config.SERVER_ALLOWED_SUBKEYS, new ArrayList<String>());
191
192 if (!allowed.isEmpty()) {
193 if (!allowed.contains(subkey)) {
194 return new WLoginResult(true, false);
195 }
196
197 if ((subkey + "|").contains("|rw|")) {
198 rw = true;
199 }
200 if ((subkey + "|").contains("|wl|")) {
201 wl = false; // |wl| = bypass whitelist
202 }
203 if ((subkey + "|").contains("|bl|")) {
204 bl = false; // |bl| = bypass blacklist
205 }
206 }
207
208 return new WLoginResult(who, key, subkey, rw, wl, bl);
209 }
210
211 @Override
212 protected Response getList(String uri, WLoginResult login)
213 throws IOException {
214 if (WebLibraryUrls.LIST_URL_METADATA.equals(uri)) {
215 List<JSONObject> jsons = new ArrayList<JSONObject>();
216 for (MetaData meta : metas(login)) {
217 jsons.add(JsonIO.toJson(meta));
218 }
219
220 return newInputStreamResponse("application/json",
221 new ByteArrayInputStream(
222 new JSONArray(jsons).toString().getBytes()));
223 }
224
225 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
226 NanoHTTPD.MIME_PLAINTEXT, null);
227 }
228
229 // /story/luid/chapter/para <-- text/image
230 // /story/luid/cover <-- image
231 // /story/luid/metadata <-- json
232 // /story/luid/json <-- json, whole chapter (no images)
233 @Override
234 protected Response getStoryPart(String uri, WLoginResult login) {
235 String[] uriParts = uri.split("/");
236 int off = 2;
237
238 if (uriParts.length < off + 2) {
239 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
240 NanoHTTPD.MIME_PLAINTEXT, null);
241 }
242
243 String luid = uriParts[off + 0];
244 String chapterStr = uriParts[off + 1];
245 String imageStr = uriParts.length < off + 3 ? null : uriParts[off + 2];
246
247 // 1-based (0 = desc)
248 int chapter = 0;
249 if (chapterStr != null && !"cover".equals(chapterStr)
250 && !"metadata".equals(chapterStr)
251 && !"json".equals(chapterStr)) {
252 try {
253 chapter = Integer.parseInt(chapterStr);
254 if (chapter < 0) {
255 throw new NumberFormatException();
256 }
257 } catch (NumberFormatException e) {
258 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
259 NanoHTTPD.MIME_PLAINTEXT, "Chapter is not valid");
260 }
261 }
262
263 // 1-based
264 int paragraph = 1;
265 if (imageStr != null) {
266 try {
267 paragraph = Integer.parseInt(imageStr);
268 if (paragraph < 0) {
269 throw new NumberFormatException();
270 }
271 } catch (NumberFormatException e) {
272 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
273 NanoHTTPD.MIME_PLAINTEXT, "Paragraph is not valid");
274 }
275 }
276
277 String mimeType = NanoHTTPD.MIME_PLAINTEXT;
278 InputStream in = null;
279 try {
280 if ("cover".equals(chapterStr)) {
281 Image img = storyCover(luid, login);
282 if (img != null) {
283 in = img.newInputStream();
284 }
285 // TODO: get correct image type
286 mimeType = "image/png";
287 } else if ("metadata".equals(chapterStr)) {
288 MetaData meta = meta(luid, login);
289 JSONObject json = JsonIO.toJson(meta);
290 mimeType = "application/json";
291 in = new ByteArrayInputStream(json.toString().getBytes());
292 } else if ("json".equals(chapterStr)) {
293 Story story = story(luid, login);
294 JSONObject json = JsonIO.toJson(story);
295 mimeType = "application/json";
296 in = new ByteArrayInputStream(json.toString().getBytes());
297 } else {
298 Story story = story(luid, login);
299 if (story != null) {
300 if (chapter == 0) {
301 StringBuilder builder = new StringBuilder();
302 for (Paragraph p : story.getMeta().getResume()) {
303 if (builder.length() == 0) {
304 builder.append("\n");
305 }
306 builder.append(p.getContent());
307 }
308
309 in = new ByteArrayInputStream(
310 builder.toString().getBytes("utf-8"));
311 } else {
312 Paragraph para = story.getChapters().get(chapter - 1)
313 .getParagraphs().get(paragraph - 1);
314 Image img = para.getContentImage();
315 if (para.getType() == ParagraphType.IMAGE) {
316 // TODO: get correct image type
317 mimeType = "image/png";
318 in = img.newInputStream();
319 } else {
320 in = new ByteArrayInputStream(
321 para.getContent().getBytes("utf-8"));
322 }
323 }
324 }
325 }
326 } catch (IndexOutOfBoundsException e) {
327 return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
328 NanoHTTPD.MIME_PLAINTEXT,
329 "Chapter or paragraph does not exist");
330 } catch (IOException e) {
331 Instance.getInstance().getTraceHandler()
332 .error(new IOException("Cannot get image: " + uri, e));
333 return NanoHTTPD.newFixedLengthResponse(Status.INTERNAL_ERROR,
334 NanoHTTPD.MIME_PLAINTEXT, "Error when processing request");
335 }
336
337 return newInputStreamResponse(mimeType, in);
338 }
339
340 // /story/luid/source
341 // /story/luid/title
342 // /story/luid/author
343 @Override
344 protected Response setStoryPart(String uri, String value,
345 WLoginResult login) throws IOException {
346 String[] uriParts = uri.split("/");
347 int off = 2; // "" and "story"
348
349 if (uriParts.length < off + 2) {
350 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
351 NanoHTTPD.MIME_PLAINTEXT, "Invalid story part request");
352 }
353
354 if (!login.isRw()) {
355 return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
356 NanoHTTPD.MIME_PLAINTEXT, "SET story part not allowed");
357 }
358
359 if (exiting) {
360 return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
361 NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
362 }
363
364 String luid = uriParts[off + 0];
365 String type = uriParts[off + 1];
366
367 if (!Arrays.asList("source", "title", "author").contains(type)) {
368 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
369 NanoHTTPD.MIME_PLAINTEXT,
370 "Invalid SET story part: " + type);
371 }
372
373 if (meta(luid, login) != null) {
374 BasicLibrary lib = Instance.getInstance().getLibrary();
375 if ("source".equals(type)) {
376 lib.changeSource(luid, value, null);
377 } else if ("title".equals(type)) {
378 lib.changeTitle(luid, value, null);
379 } else if ("author".equals(type)) {
380 lib.changeAuthor(luid, value, null);
381 }
382 }
383
384 return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
385 }
386
387 @Override
388 protected Response getCover(String uri, WLoginResult login)
389 throws IOException {
390 String[] uriParts = uri.split("/");
391 int off = 2; // "" and "cover"
392
393 if (uriParts.length < off + 2) {
394 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
395 NanoHTTPD.MIME_PLAINTEXT, "Invalid cover request");
396 }
397
398 String type = uriParts[off + 0];
399 String id = uriParts[off + 1];
400
401 InputStream in = null;
402
403 if ("story".equals(type)) {
404 Image img = storyCover(id, login);
405 if (img != null) {
406 in = img.newInputStream();
407 }
408 } else if ("source".equals(type)) {
409 Image img = sourceCover(id, login);
410 if (img != null) {
411 in = img.newInputStream();
412 }
413 } else if ("author".equals(type)) {
414 Image img = authorCover(id, login);
415 if (img != null) {
416 in = img.newInputStream();
417 }
418 } else {
419 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
420 NanoHTTPD.MIME_PLAINTEXT,
421 "Invalid GET cover type: " + type);
422 }
423
424 // TODO: get correct image type
425 return newInputStreamResponse("image/png", in);
426 }
427
428 @Override
429 protected Response setCover(String uri, String luid, WLoginResult login)
430 throws IOException {
431 String[] uriParts = uri.split("/");
432 int off = 2; // "" and "cover"
433
434 if (uriParts.length < off + 2) {
435 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
436 NanoHTTPD.MIME_PLAINTEXT, "Invalid cover request");
437 }
438
439 if (!login.isRw()) {
440 return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
441 NanoHTTPD.MIME_PLAINTEXT, "Cover request not allowed");
442 }
443
444 if (exiting) {
445 return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
446 NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
447 }
448
449 String type = uriParts[off + 0];
450 String id = uriParts[off + 1];
451
452 if ("source".equals(type)) {
453 sourceCover(id, login, luid);
454 } else if ("author".equals(type)) {
455 authorCover(id, login, luid);
456 } else {
457 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
458 NanoHTTPD.MIME_PLAINTEXT,
459 "Invalid SET cover type: " + type);
460 }
461
462 return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
463 }
464
465 @Override
466 protected Response imprt(String uri, String urlStr, WLoginResult login)
467 throws IOException {
468 final BasicLibrary lib = Instance.getInstance().getLibrary();
469
470 if (!login.isRw()) {
471 return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
472 NanoHTTPD.MIME_PLAINTEXT, "Import not allowed");
473 }
474
475 if (exiting) {
476 return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
477 NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
478 }
479
480 final URL url = new URL(urlStr);
481 final Progress pg = new Progress();
482 final String luid = lib.getNextId();
483
484 synchronized (imprts) {
485 imprts.put(luid, pg);
486 }
487
488 new Thread(new Runnable() {
489 @Override
490 public void run() {
491 try {
492 lib.imprt(url, luid, pg);
493 } catch (IOException e) {
494 Instance.getInstance().getTraceHandler().error(e);
495 } finally {
496 synchronized (imprts) {
497 imprts.remove(luid);
498 }
499 }
500 }
501 }, "Import story: " + urlStr).start();
502
503 return NanoHTTPD.newFixedLengthResponse(Status.OK,
504 NanoHTTPD.MIME_PLAINTEXT, luid);
505 }
506
507 @Override
508 protected Response imprtProgress(String uri, WLoginResult login) {
509 String[] uriParts = uri.split("/");
510 int off = 2; // "" and "import"
511
512 if (uriParts.length < off + 1) {
513 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
514 NanoHTTPD.MIME_PLAINTEXT, "Invalid cover request");
515 }
516
517 String luid = uriParts[off + 0];
518
519 Progress pg = null;
520 synchronized (imprts) {
521 pg = imprts.get(luid);
522 }
523 if (pg != null) {
524 return NanoHTTPD.newFixedLengthResponse(Status.OK,
525 "application/json", JsonIO.toJson(pg).toString());
526 }
527
528 return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
529 }
530
531 @Override
532 protected Response delete(String uri, WLoginResult login)
533 throws IOException {
534 String[] uriParts = uri.split("/");
535 int off = 2; // "" and "delete"
536
537 if (uriParts.length < off + 1) {
538 return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
539 NanoHTTPD.MIME_PLAINTEXT, "Invalid delete request");
540 }
541
542 if (!login.isRw()) {
543 return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
544 NanoHTTPD.MIME_PLAINTEXT, "Delete not allowed");
545 }
546
547 if (exiting) {
548 return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
549 NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
550 }
551
552 String luid = uriParts[off + 0];
553
554 BasicLibrary lib = Instance.getInstance().getLibrary();
555 lib.delete(luid);
556
557 return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
558 }
559
560 @Override
561 protected List<MetaData> metas(WLoginResult login) throws IOException {
562 BasicLibrary lib = Instance.getInstance().getLibrary();
563 List<MetaData> metas = new ArrayList<MetaData>();
564 for (MetaData meta : lib.getList().getMetas()) {
565 if (isAllowed(meta, login)) {
566 metas.add(meta);
567 }
568 }
569
570 return metas;
571 }
572
573 // NULL if not whitelist OK or if not found
574 @Override
575 protected Story story(String luid, WLoginResult login) throws IOException {
576 synchronized (storyCache) {
577 if (storyCache.containsKey(luid)) {
578 Story story = storyCache.get(luid);
579 if (!isAllowed(story.getMeta(), login))
580 return null;
581
582 return story;
583 }
584 }
585
586 Story story = null;
587 MetaData meta = meta(luid, login);
588 if (meta != null) {
589 BasicLibrary lib = Instance.getInstance().getLibrary();
590 story = lib.getStory(luid, null);
591 long size = sizeOf(story);
592
593 synchronized (storyCache) {
594 // Could have been added by another request
595 if (!storyCache.containsKey(luid)) {
596 while (!storyCacheOrder.isEmpty()
597 && storyCacheSize + size > maxStoryCacheSize) {
598 String oldestLuid = storyCacheOrder.removeFirst();
599 Story oldestStory = storyCache.remove(oldestLuid);
600 maxStoryCacheSize -= sizeOf(oldestStory);
601 }
602
603 storyCacheOrder.add(luid);
604 storyCache.put(luid, story);
605 }
606 }
607 }
608
609 return story;
610 }
611
612 private MetaData meta(String luid, WLoginResult login) throws IOException {
613 BasicLibrary lib = Instance.getInstance().getLibrary();
614 MetaData meta = lib.getInfo(luid);
615 if (!isAllowed(meta, login))
616 return null;
617
618 return meta;
619 }
620
621 private Image storyCover(String luid, WLoginResult login)
622 throws IOException {
623 MetaData meta = meta(luid, login);
624 if (meta != null) {
625 BasicLibrary lib = Instance.getInstance().getLibrary();
626 return lib.getCover(meta.getLuid());
627 }
628
629 return null;
630 }
631
632 private Image authorCover(String author, WLoginResult login)
633 throws IOException {
634 Image img = null;
635
636 List<MetaData> metas = new MetaResultList(metas(login)).filter(null,
637 author, null);
638 if (metas.size() > 0) {
639 BasicLibrary lib = Instance.getInstance().getLibrary();
640 img = lib.getCustomAuthorCover(author);
641 if (img == null)
642 img = lib.getCover(metas.get(0).getLuid());
643 }
644
645 return img;
646
647 }
648
649 private void authorCover(String author, WLoginResult login, String luid)
650 throws IOException {
651 if (meta(luid, login) != null) {
652 List<MetaData> metas = new MetaResultList(metas(login)).filter(null,
653 author, null);
654 if (metas.size() > 0) {
655 BasicLibrary lib = Instance.getInstance().getLibrary();
656 lib.setAuthorCover(author, luid);
657 }
658 }
659 }
660
661 private Image sourceCover(String source, WLoginResult login)
662 throws IOException {
663 Image img = null;
664
665 List<MetaData> metas = new MetaResultList(metas(login)).filter(source,
666 null, null);
667 if (metas.size() > 0) {
668 BasicLibrary lib = Instance.getInstance().getLibrary();
669 img = lib.getCustomSourceCover(source);
670 if (img == null)
671 img = lib.getCover(metas.get(0).getLuid());
672 }
673
674 return img;
675 }
676
677 private void sourceCover(String source, WLoginResult login, String luid)
678 throws IOException {
679 if (meta(luid, login) != null) {
680 List<MetaData> metas = new MetaResultList(metas(login))
681 .filter(source, null, null);
682 if (metas.size() > 0) {
683 BasicLibrary lib = Instance.getInstance().getLibrary();
684 lib.setSourceCover(source, luid);
685 }
686 }
687 }
688
689 private boolean isAllowed(MetaData meta, WLoginResult login) {
690 MetaResultList one = new MetaResultList(Arrays.asList(meta));
691 if (login.isWl() && !whitelist.isEmpty()) {
692 if (one.filter(whitelist, null, null).isEmpty()) {
693 return false;
694 }
695 }
696 if (login.isBl() && !blacklist.isEmpty()) {
697 if (!one.filter(blacklist, null, null).isEmpty()) {
698 return false;
699 }
700 }
701
702 return true;
703 }
704
705 private long sizeOf(Story story) {
706 long size = 0;
707 for (Chapter chap : story) {
708 for (Paragraph para : chap) {
709 if (para.getType() == ParagraphType.IMAGE) {
710 size += para.getContentImage().getSize();
711 } else {
712 size += para.getContent().length();
713 }
714 }
715 }
716
717 return size;
718 }
719
720 public static void main(String[] args) throws IOException {
721 Instance.init();
722 WebLibraryServer web = new WebLibraryServer(false);
723 web.run();
724 }
725 }