path: root/dozentenmodulserver/src/main/java/org/openslx/bwlp/sat/web/WebServer.java

package org.openslx.bwlp.sat.web;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.openslx.bwlp.sat.RuntimeConfig;
import org.openslx.bwlp.sat.database.mappers.DbImage;
import org.openslx.bwlp.sat.database.mappers.DbLecture;
import org.openslx.bwlp.sat.database.mappers.DbLecture.LaunchData;
import org.openslx.bwlp.sat.database.mappers.DbLecture.RunScript;
import org.openslx.bwlp.sat.fileserv.FileServer;
import org.openslx.bwlp.sat.fileserv.cow.CowSession;
import org.openslx.bwlp.sat.fileserv.cow.CowSessionManager;
import org.openslx.bwlp.sat.permissions.User;
import org.openslx.bwlp.sat.thrift.SessionManager;
import org.openslx.bwlp.sat.util.BashVars;
import org.openslx.bwlp.sat.util.Configuration;
import org.openslx.bwlp.thrift.iface.AuthorizationError;
import org.openslx.bwlp.thrift.iface.NetRule;
import org.openslx.bwlp.thrift.iface.NetShare;
import org.openslx.bwlp.thrift.iface.NetShareAuth;
import org.openslx.bwlp.thrift.iface.TNotFoundException;
import org.openslx.bwlp.thrift.iface.UserInfo;
import org.openslx.util.CascadedThreadPoolExecutor;
import org.openslx.util.Json;
import org.openslx.util.TarArchiveUtil.TarArchiveWriter;
import org.openslx.util.Util;
import org.simpleframework.xml.Serializer;
import org.simpleframework.xml.core.Persister;

import fi.iki.elonen.NanoHTTPD;

public class WebServer extends NanoHTTPD {

	private static final Logger LOGGER = LogManager.getLogger(WebServer.class);

	private static final ThreadPoolExecutor LECTURE_START_TPE = new CascadedThreadPoolExecutor(2, 8,
			1, TimeUnit.MINUTES, 1, "tgz-gen");

	private static final Serializer serializer = new Persister();

	public WebServer(int port, ExecutorService tpe) throws IOException {
		super(Configuration.getWebServerBindAddressLocal(), port, tpe);
		super.maxRequestSize = 65535;
	}

	@Override
	public Response serve(IHTTPSession session) {
		String uri = session.getUri();

		if (uri == null || uri.length() == 0) {
			return internalServerError();
		}

		// Sanitize
		if (uri.contains("//")) {
			uri = uri.replaceAll("//+", "/");
		}

		try {
			return handle(session, uri);
		} catch (Throwable t) {
			LOGGER.warn("Could not handle request", t);
			return internalServerError();
		}
	}

	private Response handle(IHTTPSession session, String uri) {
		// Our special stuff
		// REMEMBER: Call session.parseBody() if you need post params in session.getParms()
		// Normalize during split
		String[] parts = uri.replaceFirst("^/+", "").split("/+");
		if (parts.length < 2)
			return notFound();
		// /vmchooser/*
		if (parts[0].equals("vmchooser")) {
			if (parts[1].equals("list")) {
				try {
					return serveVmChooserList(session.getParms());
				} catch (Exception e) {
					LOGGER.debug("problem while retrieving the vmChooserList", e);
					return internalServerError();
				}
			}
			if (parts[1].equals("lecture")) {
				if (parts.length < 4)
					return badRequest("Bad Request");
				if (parts[3].equals("metadata"))
					return serveMetaData(parts[2], session.getParms());
				if (parts[3].equals("netrules"))
					return serveLectureNetRules(parts[2]);
				if (parts[3].equals("imagemeta"))
					return serveContainerImageMetaData(parts[2]);
			}
			return notFound();
		}
		// /cow/*
		if (parts[0].equals("cow")) {
			if (parts.length < 3)
				return badRequest("Bad request");
			if (session.getMethod() == Method.POST) {
				try {
					session.parseBody();
				} catch (IOException | ResponseException e) {
					LOGGER.debug("could not parse request body", e);
					return internalServerError();
				}
			}
			// Requests by dnbd3-fuse
			if (parts[1].equals("v1") && parts[2].equals("file")) {
				if (parts.length < 4)
					return badRequest("No action");
				if (parts[3].equals("merge"))
					return cowMerge(session.getParms());
				if (parts[3].equals("update"))
					return cowUploadCluster(session);
				return badRequest("No such API endpoint: " + parts[3]);
			}
			// Requests by the wrapper program
			if (parts[1].equals("status"))
				return cowServeStatus(parts[2]);
			if (parts[1].equals("finish"))
				return cowFinish(parts[2]);
			if (parts[1].equals("abort"))
				return cowAbort(parts[2], session.getMethod());
			// Huh?
			return badRequest("No such API endpoint");
		}
		if (uri.startsWith("/bwlp/container/clusterimages")) {
			return serverContainerImages();
		}
		if (uri.startsWith("/image/container/")) {
			if (parts.length < 4)
				return badRequest("Bad Request");
			if (parts[3].equals("metadata"))
				return serveContainerImageMetaData(parts[2]);
		}

		if (uri.startsWith("/status/fileserver")) {
			return serveStatus();
		}
		if (session.getMethod() == Method.POST && uri.startsWith("/do/")) {
			try {
				session.parseBody();
			} catch (IOException | ResponseException e) {
				LOGGER.debug("could not parse request body", e);
				return internalServerError();
			}
			return WebRpc.handle(uri.substring(4), session.getParms());
		}

		return notFound();
	}

	private Response cowUploadCluster(IHTTPSession session) {
		if (session.getMethod() != Method.POST && session.getMethod() != Method.PUT)
			return badRequest("Not PUT or POST");
		InputStream is = session.getInputStream();
		if (is == null)
			return internalServerError("Cannot get input stream");
		String uuid = session.getParms().get("uuid");
		String sIdx = session.getParms().get("clusterindex");
		if (uuid == null || sIdx == null)
			return badRequest("uuid or clusterindex missing");
		long clusterIndex = Util.parseLong(sIdx, -1);
		if (clusterIndex < 0)
			return badRequest("Invalid clusterindex");
		CowSession cowSession = CowSessionManager.get(uuid);
		if (cowSession == null)
			return notFound("Invalid session ID");
		byte[] data;
		try (ByteArrayOutputStream baos = new ByteArrayOutputStream(9001)) {
			int n;
			byte[] b = new byte[65536];
			while ((n = is.read(b)) > 0) {
				baos.write(b, 0, n);
			}
			data = baos.toByteArray();
		} catch (IOException e) {
			LOGGER.warn("Cannot read cluster", e);
			return internalServerError("Cannot read cluster data from http stream");
		}
		int cowRet = cowSession.addCluster(clusterIndex, data);
		if (cowRet == 0)
			return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "text/plain; charset=utf-8", "OK");
		// Error?
		if (cowRet < 0)
			return internalServerError("Error writing received chunk to disk");
		// Throttle request
		Response reply = new NanoHTTPD.Response(NanoHTTPD.Response.Status.SERVICE_UNAVAILABLE,
				"text/plain; charset=utf-8", "Slow down!");
		reply.addHeader("Retry-After", Integer.toString(cowRet));
		return reply;
	}

	/**
	 * dnbd3-fuse is requesting merge. We take that as signal that the upload is
	 * done.
	 */
	private Response cowMerge(Map<String, String> parms) {
		String uuid = parms.get("uuid");
		String newSz = parms.get("newFileSize");
		if (uuid == null || newSz == null)
			return badRequest("uuid or newFileSize missing");
		CowSession session = CowSessionManager.get(uuid);
		if (session == null)
			return notFound("Invalid session ID");
		long finalSize = Util.parseLong(newSz, -1);
		long limit = (RuntimeConfig.getVmSizeLimit() * 12) / 10;
		if (limit <= 0) {
			limit = 300_000_000_000l;
		}
		if (finalSize < 0 || finalSize > limit)
			return badRequest("Illegal final file size");
		try {
			session.uploadFinished(finalSize);
		} catch (Exception e) {
			return badRequest("Cannot finish upload: " + e.getMessage());
		}
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "text/plain; charset=utf-8", "OK");
	}

	/**
	 * User-facing tool on the client was used to confirm keeping the modified
	 * image.
	 */
	private Response cowFinish(String sessionId) {
		CowSession session = CowSessionManager.get(sessionId);
		if (session == null)
			return notFound("Invalid session ID");
		try {
			session.requestFinalization();
		} catch (Exception e) {
			return badRequest("Cannot finalize image version: " + e.getMessage());
		}
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "text/plain; charset=utf-8", "OK");
	}

	/**
	 * Abort a COW session, delete temporary files.
	 */
	private Response cowAbort(String sessionId, Method method) {
		if (method != Method.POST)
			return badRequest("Need abort request as POST");
		CowSession session = CowSessionManager.get(sessionId);
		if (session == null)
			return notFound("Invalid session ID");
		session.abort();
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "text/plain; charset=utf-8", "OK");
	}

	private Response cowServeStatus(String sessionId) {
		CowSession session = CowSessionManager.get(sessionId);
		if (session == null)
			return notFound("Invalid session ID");
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "application/json; charset=utf-8",
				session.getStatusJson());
	}

	private Response serveStatus() {
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "application/json; charset=utf-8",
				Json.serialize(FileServer.instance().getStatus()));
	}

	/**
	 * Return meta data (eg. *.vmx) required to start the given lecture.
	 */
	private Response serveMetaData(final String lectureId, Map<String, String> parms) {
		PipedInputStream sink = new PipedInputStream(10000);
		try {
			final BashVars vars = new BashVars();
			final TarArchiveWriter tarArchiveWriter = new TarArchiveWriter(new PipedOutputStream(sink));
			final LaunchData ld;
			try {
				ld = DbLecture.getClientLaunchData(lectureId);
			} catch (TNotFoundException e) {
				// TODO better virt error handling
				return notFound();
			} catch (SQLException e) {
				return internalServerError();
			}
			vars.addVar("DMSD_IMAGE_PATH", ld.imagePath);
			// See if a CoW session is requested
			try {
				String sessionType = parms.get("cow-type");
				String cowUserId = parms.get("cow-user");
				if (cowUserId != null) {
					String cowSession = CowSessionManager.create(cowUserId, ld, sessionType);
					vars.addVar("DMSD_COW_SESSION", cowSession);
				}
			} catch (Exception e) {
				LOGGER.warn("Error creating cow session for " + ld.imageBaseId + ", " + ld.imagePath, e);
				return internalServerError("Cannot create COW session: " + e.getMessage());
			}
			// Meta is required, everything else is optional
			LECTURE_START_TPE.execute(new Runnable() {
				@Override
				public void run() {
					try {
						tarArchiveWriter.writeFile("vmx", ld.configuration);
						tarArchiveWriter.writeFile("config.inc", vars.toString());
						tarArchiveWriter.writeFile("runscript", ld.legacyRunScript);
						tarArchiveWriter.writeFile("netshares", serializeNetShares(ld.netShares));
						if (ld.runScript != null) {
							int cnt = 0;
							for (RunScript rs : ld.runScript) {
								tarArchiveWriter.writeFile(
										String.format("adminrun/%04d-%d-%d.%s", cnt++, rs.visibility,
												rs.passCreds ? 1 : 0, rs.extension),
										rs.content);
							}
						}
					} catch (IOException e) {
						LOGGER.warn("Error writing to tar stream", e);
					} finally {
						Util.safeClose(tarArchiveWriter);
					}
				}
			});
		} catch (IOException e1) {
			LOGGER.warn("Could not create tar output stream", e1);
			return internalServerError();
		} catch (RejectedExecutionException e2) {
			LOGGER.warn("Server overloaded; rejecting VM Metadata request", e2);
			return internalServerError();
		}
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "application/gzip", sink);
	}

	private Response serveLectureNetRules(String lectureId) {
		List<NetRule> list = new ArrayList<>();
		boolean defaultAllowed;
		try {
			defaultAllowed = DbLecture.getFirewallRules(lectureId, list);
		} catch (SQLException e) {
			return internalServerError();
		} catch (TNotFoundException e) {
			return notFound();
		}
		StringBuilder sb = new StringBuilder();
		for (NetRule rule : list) {
			sb.append(rule.direction.name());
			sb.append(' ');
			sb.append(rule.host);
			sb.append(' ');
			sb.append(rule.port);
			sb.append(' ');
			sb.append(defaultAllowed ? "REJECT" : "ACCEPT");
			sb.append('\n');
		}
		if (defaultAllowed) {
			sb.append("IN * 0 ACCEPT\n");
			sb.append("OUT * 0 ACCEPT\n");
		} else {
			sb.append("IN * 0 REJECT\n");
			sb.append("OUT * 0 REJECT\n");
		}
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "text/plain; charset=utf-8",
				sb.toString());
	}

	private String serializeNetShares(List<NetShare> list) {
		// openslx.exe expects shares in the following format
		// <path> <letter> <shortcut> <username> <password>
		// letter is either a drive letter for Windows VMs,
		// or a mount point for Linux VMs.
		StringBuilder sb = new StringBuilder();
		if (!list.isEmpty()) {
			for (NetShare share : list) {
				sb.append(share.path);
				sb.append('\t');
				sb.append(share.mountpoint);
				sb.append('\t');
				sb.append(share.displayname);
				if (share.auth == NetShareAuth.LOGIN_USER) {
					// TODO how to mark that it should use the logged in user's credentials
				}
				if (share.auth == NetShareAuth.OTHER_USER && share.isSetUsername()) {
					sb.append('\t');
					sb.append(share.username);
					if (share.isSetPassword()) {
						sb.append('\t');
						sb.append(share.password); // TODO fixme
					}
				}
				sb.append("\n");
			}
		}
		return sb.toString();
	}

	/**
	 * Return full list of lectures matching given location(s).
	 * 
	 * @return
	 * @throws Exception
	 */
	private Response serveVmChooserList(Map<String, String> params) throws Exception {
		String locations = params.get("locations");
		String userToken = params.get("cow-user");
		boolean exams = params.containsKey("exams");
		String addUserError = null;
		UserInfo user = null;
		
		if (!Util.isEmptyString(userToken)) {
			user = SessionManager.get(userToken);
			if (user == null || user.userId == null) {
				addUserError = "Invalid session token, edit mode not available\n"
						+ "Ungültiges Sitzungstoken, Editiermodus nicht verfügbar";
			} else {
				AuthorizationError err = User.canLogin(user);
				if (err != null) {
					user = null;
					addUserError = "You are not allowed to edit VMs\n"
							+ "Sie haben keine Berechtigung, um VMs zu bearbeiten.";
				}
			}
		}

		VmChooserListXml listXml = DbLecture.getUsableListXml(exams, locations, user);
		if (addUserError != null) {
			listXml.setError(addUserError);
		}
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		serializer.write(listXml, baos);
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.OK, "text/xml; charset=utf-8",
				new ByteArrayInputStream(baos.toByteArray()));
	}

	/**
	 * Helper for returning "Internal Server Error" Status
	 * 
	 * @param body Message
	 */
	public static Response internalServerError(String body) {
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.INTERNAL_ERROR, "text/plain", body);
	}

	public static Response internalServerError() {
		return internalServerError("Internal Server Error");
	}

	/**
	 * Helper for returning "404 Not Found" Status
	 */
	public static Response notFound() {
		return notFound("Nicht gefunden");
	}

	/**
	 * Helper for returning "404 Not Found" Status with custom body
	 */
	private static Response notFound(String string) {
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.NOT_FOUND, "text/plain", string);
	}

	/**
	 * Helper for returning "Bad Request" Status
	 */
	public static Response badRequest(String message) {
		if (message == null) {
			message = "Schlechte Anfrage!";
		}
		return new NanoHTTPD.Response(NanoHTTPD.Response.Status.BAD_REQUEST, "text/plain", message);
	}

	/**
	 * create a json response with information about existing container images
	 * in
	 * bwlehrpool
	 */
	private Response serverContainerImages() {
		try {
			return new Response(Response.Status.OK, "application/json; charset=utf-8",
					Json.serialize(DbImage.getContainerImageCluster()));
		} catch (SQLException e) {
			LOGGER.error("error -- could not server container images", e);
			return internalServerError();
		}
	}

	private Response serveContainerImageMetaData(String imageBaseId) {
		try {
			return new Response(Response.Status.OK, "application/json; charset=utf-8",
					DbImage.getContainerImageMetadata(imageBaseId));
		} catch (SQLException e) {
			LOGGER.error("error -- could not server container image", e);
			return internalServerError();
		}
	}
}