[fanfix.git] / src / be / nikiroo / fanfix / library / WebLibraryServer.java

package be.nikiroo.fanfix.library;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.json.JSONArray;
import org.json.JSONObject;

import be.nikiroo.fanfix.Instance;
import be.nikiroo.fanfix.bundles.Config;
import be.nikiroo.fanfix.data.Chapter;
import be.nikiroo.fanfix.data.JsonIO;
import be.nikiroo.fanfix.data.MetaData;
import be.nikiroo.fanfix.data.Paragraph;
import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
import be.nikiroo.fanfix.data.Story;
import be.nikiroo.utils.Image;
import be.nikiroo.utils.LoginResult;
import be.nikiroo.utils.NanoHTTPD;
import be.nikiroo.utils.NanoHTTPD.Response;
import be.nikiroo.utils.NanoHTTPD.Response.Status;
import be.nikiroo.utils.Progress;

public class WebLibraryServer extends WebLibraryServerHtml {
	class WLoginResult extends LoginResult {
		public WLoginResult(boolean badLogin, boolean badCookie) {
			super(badLogin, badCookie);
		}

		public WLoginResult(String who, String key, String subkey, boolean rw,
				boolean wl, boolean bl) {
			super(who, key, subkey, (rw ? "|rw" : "") + (wl ? "|wl" : "")
					+ (bl ? "|bl" : "") + "|");
		}

		public WLoginResult(String cookie, String who, String key,
				List<String> subkeys) {
			super(cookie, who, key, subkeys,
					subkeys == null || subkeys.isEmpty());
		}

		public boolean isRw() {
			return getOption().contains("|rw|");
		}

		public boolean isWl() {
			return getOption().contains("|wl|");
		}

		public boolean isBl() {
			return getOption().contains("|bl|");
		}
	}

	private Map<String, Story> storyCache = new HashMap<String, Story>();
	private LinkedList<String> storyCacheOrder = new LinkedList<String>();
	private long storyCacheSize = 0;
	private long maxStoryCacheSize;

	private List<String> whitelist;
	private List<String> blacklist;

	private Map<String, Progress> imprts = new HashMap<String, Progress>();

	private boolean exiting;

	public WebLibraryServer(boolean secure) throws IOException {
		super(secure);

		int cacheMb = Instance.getInstance().getConfig()
				.getInteger(Config.SERVER_MAX_CACHE_MB, 100);
		maxStoryCacheSize = cacheMb * 1024 * 1024;

		setTraceHandler(Instance.getInstance().getTraceHandler());

		whitelist = Instance.getInstance().getConfig()
				.getList(Config.SERVER_WHITELIST, new ArrayList<String>());
		blacklist = Instance.getInstance().getConfig()
				.getList(Config.SERVER_BLACKLIST, new ArrayList<String>());
	}

	/**
	 * Start the server (listen on the network for new connections).
	 * <p>
	 * Can only be called once.
	 * <p>
	 * This call is asynchronous, and will just start a new {@link Thread} on
	 * itself (see {@link WebLibraryServer#run()}).
	 */
	public void start() {
		new Thread(this).start();
	}

	@Override
	protected Response stop(WLoginResult login) {
		if (!login.isRw()) {
			return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
					NanoHTTPD.MIME_PLAINTEXT, "Exit not allowed");
		}

		if (exiting) {
			return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
					NanoHTTPD.MIME_PLAINTEXT, "Server is already exiting...");
		}

		exiting = true;
		Instance.getInstance().getTraceHandler().trace("Exiting");

		boolean ok;
		do {
			synchronized (imprts) {
				ok = imprts.isEmpty();
			}
			if (!ok) {
				try {
					Thread.sleep(2000);
				} catch (InterruptedException e) {
					Instance.getInstance().getTraceHandler()
							.trace("Waiting to exit...");
				}
			}
		} while (!ok);

		doStop();

		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					Thread.sleep(1500);
				} catch (InterruptedException e) {
				}

				Instance.getInstance().getTraceHandler()
						.trace("Exit timeout: force-quit");
				System.exit(0);
			}
		}, "Exit program after timeout of 1500 ms").start();

		return NanoHTTPD.newFixedLengthResponse(Status.OK,
				NanoHTTPD.MIME_PLAINTEXT, "Exited");
	}

	@Override
	protected WLoginResult login(boolean badLogin, boolean badCookie) {
		return new WLoginResult(false, false);
	}

	@Override
	protected WLoginResult login(String who, String cookie) {
		List<String> subkeys = Instance.getInstance().getConfig()
				.getList(Config.SERVER_ALLOWED_SUBKEYS);
		String realKey = Instance.getInstance().getConfig()
				.getString(Config.SERVER_KEY);

		return new WLoginResult(cookie, who, realKey, subkeys);
	}

	// allow rw/wl
	@Override
	protected WLoginResult login(String who, String key, String subkey) {
		String realKey = Instance.getInstance().getConfig()
				.getString(Config.SERVER_KEY, "");

		// I don't like NULLs...
		key = key == null ? "" : key;
		subkey = subkey == null ? "" : subkey;

		if (!realKey.equals(key)) {
			return new WLoginResult(true, false);
		}

		// defaults are true (as previous versions without the feature)
		boolean rw = true;
		boolean wl = true;
		boolean bl = true;

		rw = Instance.getInstance().getConfig().getBoolean(Config.SERVER_RW,
				rw);

		List<String> allowed = Instance.getInstance().getConfig().getList(
				Config.SERVER_ALLOWED_SUBKEYS, new ArrayList<String>());

		if (!allowed.isEmpty()) {
			if (!allowed.contains(subkey)) {
				return new WLoginResult(true, false);
			}

			if ((subkey + "|").contains("|rw|")) {
				rw = true;
			}
			if ((subkey + "|").contains("|wl|")) {
				wl = false; // |wl| = bypass whitelist
			}
			if ((subkey + "|").contains("|bl|")) {
				bl = false; // |bl| = bypass blacklist
			}
		}

		return new WLoginResult(who, key, subkey, rw, wl, bl);
	}

	@Override
	protected Response getList(String uri, WLoginResult login)
			throws IOException {
		if (WebLibraryUrls.LIST_URL_METADATA.equals(uri)) {
			List<JSONObject> jsons = new ArrayList<JSONObject>();
			for (MetaData meta : metas(login)) {
				jsons.add(JsonIO.toJson(meta));
			}

			return newInputStreamResponse("application/json",
					new ByteArrayInputStream(
							new JSONArray(jsons).toString().getBytes()));
		}

		return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
				NanoHTTPD.MIME_PLAINTEXT, null);
	}

	// /story/luid/chapter/para <-- text/image
	// /story/luid/cover <-- image
	// /story/luid/metadata <-- json
	// /story/luid/json <-- json, whole chapter (no images)
	@Override
	protected Response getStoryPart(String uri, WLoginResult login) {
		String[] uriParts = uri.split("/");
		int off = 2;

		if (uriParts.length < off + 2) {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT, null);
		}

		String luid = uriParts[off + 0];
		String chapterStr = uriParts[off + 1];
		String imageStr = uriParts.length < off + 3 ? null : uriParts[off + 2];

		// 1-based (0 = desc)
		int chapter = 0;
		if (chapterStr != null && !"cover".equals(chapterStr)
				&& !"metadata".equals(chapterStr)
				&& !"json".equals(chapterStr)) {
			try {
				chapter = Integer.parseInt(chapterStr);
				if (chapter < 0) {
					throw new NumberFormatException();
				}
			} catch (NumberFormatException e) {
				return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
						NanoHTTPD.MIME_PLAINTEXT, "Chapter is not valid");
			}
		}

		// 1-based
		int paragraph = 1;
		if (imageStr != null) {
			try {
				paragraph = Integer.parseInt(imageStr);
				if (paragraph < 0) {
					throw new NumberFormatException();
				}
			} catch (NumberFormatException e) {
				return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
						NanoHTTPD.MIME_PLAINTEXT, "Paragraph is not valid");
			}
		}

		String mimeType = NanoHTTPD.MIME_PLAINTEXT;
		InputStream in = null;
		try {
			if ("cover".equals(chapterStr)) {
				Image img = storyCover(luid, login);
				if (img != null) {
					in = img.newInputStream();
				}
				// TODO: get correct image type
				mimeType = "image/png";
			} else if ("metadata".equals(chapterStr)) {
				MetaData meta = meta(luid, login);
				JSONObject json = JsonIO.toJson(meta);
				mimeType = "application/json";
				in = new ByteArrayInputStream(json.toString().getBytes());
			} else if ("json".equals(chapterStr)) {
				Story story = story(luid, login);
				JSONObject json = JsonIO.toJson(story);
				mimeType = "application/json";
				in = new ByteArrayInputStream(json.toString().getBytes());
			} else {
				Story story = story(luid, login);
				if (story != null) {
					if (chapter == 0) {
						StringBuilder builder = new StringBuilder();
						for (Paragraph p : story.getMeta().getResume()) {
							if (builder.length() == 0) {
								builder.append("\n");
							}
							builder.append(p.getContent());
						}

						in = new ByteArrayInputStream(
								builder.toString().getBytes("utf-8"));
					} else {
						Paragraph para = story.getChapters().get(chapter - 1)
								.getParagraphs().get(paragraph - 1);
						Image img = para.getContentImage();
						if (para.getType() == ParagraphType.IMAGE) {
							// TODO: get correct image type
							mimeType = "image/png";
							in = img.newInputStream();
						} else {
							in = new ByteArrayInputStream(
									para.getContent().getBytes("utf-8"));
						}
					}
				}
			}
		} catch (IndexOutOfBoundsException e) {
			return NanoHTTPD.newFixedLengthResponse(Status.NOT_FOUND,
					NanoHTTPD.MIME_PLAINTEXT,
					"Chapter or paragraph does not exist");
		} catch (IOException e) {
			Instance.getInstance().getTraceHandler()
					.error(new IOException("Cannot get image: " + uri, e));
			return NanoHTTPD.newFixedLengthResponse(Status.INTERNAL_ERROR,
					NanoHTTPD.MIME_PLAINTEXT, "Error when processing request");
		}

		return newInputStreamResponse(mimeType, in);
	}

	// /story/luid/source
	// /story/luid/title
	// /story/luid/author
	@Override
	protected Response setStoryPart(String uri, String value,
			WLoginResult login) throws IOException {
		String[] uriParts = uri.split("/");
		int off = 2; // "" and "story"

		if (uriParts.length < off + 2) {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT, "Invalid story part request");
		}

		if (!login.isRw()) {
			return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
					NanoHTTPD.MIME_PLAINTEXT, "SET story part not allowed");
		}

		if (exiting) {
			return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
					NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
		}

		String luid = uriParts[off + 0];
		String type = uriParts[off + 1];

		if (!Arrays.asList("source", "title", "author").contains(type)) {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT,
					"Invalid SET story part: " + type);
		}

		if (meta(luid, login) != null) {
			BasicLibrary lib = Instance.getInstance().getLibrary();
			if ("source".equals(type)) {
				lib.changeSource(luid, value, null);
			} else if ("title".equals(type)) {
				lib.changeTitle(luid, value, null);
			} else if ("author".equals(type)) {
				lib.changeAuthor(luid, value, null);
			}
		}

		return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
	}

	@Override
	protected Response getCover(String uri, WLoginResult login)
			throws IOException {
		String[] uriParts = uri.split("/");
		int off = 2; // "" and "cover"

		if (uriParts.length < off + 2) {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT, "Invalid cover request");
		}

		String type = uriParts[off + 0];
		String id = uriParts[off + 1];

		InputStream in = null;

		if ("story".equals(type)) {
			Image img = storyCover(id, login);
			if (img != null) {
				in = img.newInputStream();
			}
		} else if ("source".equals(type)) {
			Image img = sourceCover(id, login);
			if (img != null) {
				in = img.newInputStream();
			}
		} else if ("author".equals(type)) {
			Image img = authorCover(id, login);
			if (img != null) {
				in = img.newInputStream();
			}
		} else {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT,
					"Invalid GET cover type: " + type);
		}

		// TODO: get correct image type
		return newInputStreamResponse("image/png", in);
	}

	@Override
	protected Response setCover(String uri, String luid, WLoginResult login)
			throws IOException {
		String[] uriParts = uri.split("/");
		int off = 2; // "" and "cover"

		if (uriParts.length < off + 2) {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT, "Invalid cover request");
		}

		if (!login.isRw()) {
			return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
					NanoHTTPD.MIME_PLAINTEXT, "Cover request not allowed");
		}

		if (exiting) {
			return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
					NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
		}

		String type = uriParts[off + 0];
		String id = uriParts[off + 1];

		if ("source".equals(type)) {
			sourceCover(id, login, luid);
		} else if ("author".equals(type)) {
			authorCover(id, login, luid);
		} else {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT,
					"Invalid SET cover type: " + type);
		}

		return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
	}

	@Override
	protected Response imprt(String uri, String urlStr, WLoginResult login)
			throws IOException {
		final BasicLibrary lib = Instance.getInstance().getLibrary();

		if (!login.isRw()) {
			return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
					NanoHTTPD.MIME_PLAINTEXT, "Import not allowed");
		}

		if (exiting) {
			return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
					NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
		}

		final URL url = new URL(urlStr);
		final Progress pg = new Progress();
		final String luid = lib.getNextId();

		synchronized (imprts) {
			imprts.put(luid, pg);
		}

		new Thread(new Runnable() {
			@Override
			public void run() {
				try {
					lib.imprt(url, luid, pg);
				} catch (IOException e) {
					Instance.getInstance().getTraceHandler().error(e);
				} finally {
					synchronized (imprts) {
						imprts.remove(luid);
					}
				}
			}
		}, "Import story: " + urlStr).start();

		return NanoHTTPD.newFixedLengthResponse(Status.OK,
				NanoHTTPD.MIME_PLAINTEXT, luid);
	}

	@Override
	protected Response imprtProgress(String uri, WLoginResult login) {
		String[] uriParts = uri.split("/");
		int off = 2; // "" and "import"

		if (uriParts.length < off + 1) {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT, "Invalid cover request");
		}

		String luid = uriParts[off + 0];

		Progress pg = null;
		synchronized (imprts) {
			pg = imprts.get(luid);
		}
		if (pg != null) {
			return NanoHTTPD.newFixedLengthResponse(Status.OK,
					"application/json", JsonIO.toJson(pg).toString());
		}

		return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
	}

	@Override
	protected Response delete(String uri, WLoginResult login)
			throws IOException {
		String[] uriParts = uri.split("/");
		int off = 2; // "" and "delete"

		if (uriParts.length < off + 1) {
			return NanoHTTPD.newFixedLengthResponse(Status.BAD_REQUEST,
					NanoHTTPD.MIME_PLAINTEXT, "Invalid delete request");
		}

		if (!login.isRw()) {
			return NanoHTTPD.newFixedLengthResponse(Status.FORBIDDEN,
					NanoHTTPD.MIME_PLAINTEXT, "Delete not allowed");
		}

		if (exiting) {
			return NanoHTTPD.newFixedLengthResponse(Status.SERVICE_UNAVAILABLE,
					NanoHTTPD.MIME_PLAINTEXT, "Server is exiting...");
		}

		String luid = uriParts[off + 0];

		BasicLibrary lib = Instance.getInstance().getLibrary();
		lib.delete(luid);

		return newInputStreamResponse(NanoHTTPD.MIME_PLAINTEXT, null);
	}

	@Override
	protected List<MetaData> metas(WLoginResult login) throws IOException {
		BasicLibrary lib = Instance.getInstance().getLibrary();
		List<MetaData> metas = new ArrayList<MetaData>();
		for (MetaData meta : lib.getList().getMetas()) {
			if (isAllowed(meta, login)) {
				metas.add(meta);
			}
		}

		return metas;
	}

	// NULL if not whitelist OK or if not found
	@Override
	protected Story story(String luid, WLoginResult login) throws IOException {
		synchronized (storyCache) {
			if (storyCache.containsKey(luid)) {
				Story story = storyCache.get(luid);
				if (!isAllowed(story.getMeta(), login))
					return null;

				return story;
			}
		}

		Story story = null;
		MetaData meta = meta(luid, login);
		if (meta != null) {
			BasicLibrary lib = Instance.getInstance().getLibrary();
			story = lib.getStory(luid, null);
			long size = sizeOf(story);

			synchronized (storyCache) {
				// Could have been added by another request
				if (!storyCache.containsKey(luid)) {
					while (!storyCacheOrder.isEmpty()
							&& storyCacheSize + size > maxStoryCacheSize) {
						String oldestLuid = storyCacheOrder.removeFirst();
						Story oldestStory = storyCache.remove(oldestLuid);
						maxStoryCacheSize -= sizeOf(oldestStory);
					}

					storyCacheOrder.add(luid);
					storyCache.put(luid, story);
				}
			}
		}

		return story;
	}

	private MetaData meta(String luid, WLoginResult login) throws IOException {
		BasicLibrary lib = Instance.getInstance().getLibrary();
		MetaData meta = lib.getInfo(luid);
		if (!isAllowed(meta, login))
			return null;

		return meta;
	}

	private Image storyCover(String luid, WLoginResult login)
			throws IOException {
		MetaData meta = meta(luid, login);
		if (meta != null) {
			BasicLibrary lib = Instance.getInstance().getLibrary();
			return lib.getCover(meta.getLuid());
		}

		return null;
	}

	private Image authorCover(String author, WLoginResult login)
			throws IOException {
		Image img = null;

		List<MetaData> metas = new MetaResultList(metas(login)).filter(null,
				author, null);
		if (metas.size() > 0) {
			BasicLibrary lib = Instance.getInstance().getLibrary();
			img = lib.getCustomAuthorCover(author);
			if (img == null)
				img = lib.getCover(metas.get(0).getLuid());
		}

		return img;

	}

	private void authorCover(String author, WLoginResult login, String luid)
			throws IOException {
		if (meta(luid, login) != null) {
			List<MetaData> metas = new MetaResultList(metas(login)).filter(null,
					author, null);
			if (metas.size() > 0) {
				BasicLibrary lib = Instance.getInstance().getLibrary();
				lib.setAuthorCover(author, luid);
			}
		}
	}

	private Image sourceCover(String source, WLoginResult login)
			throws IOException {
		Image img = null;

		List<MetaData> metas = new MetaResultList(metas(login)).filter(source,
				null, null);
		if (metas.size() > 0) {
			BasicLibrary lib = Instance.getInstance().getLibrary();
			img = lib.getCustomSourceCover(source);
			if (img == null)
				img = lib.getCover(metas.get(0).getLuid());
		}

		return img;
	}

	private void sourceCover(String source, WLoginResult login, String luid)
			throws IOException {
		if (meta(luid, login) != null) {
			List<MetaData> metas = new MetaResultList(metas(login))
					.filter(source, null, null);
			if (metas.size() > 0) {
				BasicLibrary lib = Instance.getInstance().getLibrary();
				lib.setSourceCover(source, luid);
			}
		}
	}

	private boolean isAllowed(MetaData meta, WLoginResult login) {
		MetaResultList one = new MetaResultList(Arrays.asList(meta));
		if (login.isWl() && !whitelist.isEmpty()) {
			if (one.filter(whitelist, null, null).isEmpty()) {
				return false;
			}
		}
		if (login.isBl() && !blacklist.isEmpty()) {
			if (!one.filter(blacklist, null, null).isEmpty()) {
				return false;
			}
		}

		return true;
	}

	private long sizeOf(Story story) {
		long size = 0;
		for (Chapter chap : story) {
			for (Paragraph para : chap) {
				if (para.getType() == ParagraphType.IMAGE) {
					size += para.getContentImage().getSize();
				} else {
					size += para.getContent().length();
				}
			}
		}

		return size;
	}

	public static void main(String[] args) throws IOException {
		Instance.init();
		WebLibraryServer web = new WebLibraryServer(false);
		web.run();
	}
}
Commit	Line	Data
	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	}