path: root/dozentenmodul/src/main/java/org/openslx/dozmod/thrift/ThriftActions.java

package org.openslx.dozmod.thrift;

import java.awt.Frame;
import java.awt.Window;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.swing.JFileChooser;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransportException;
import org.openslx.bwlp.thrift.iface.*;
import org.openslx.bwlp.thrift.iface.SatelliteServer.Client;
import org.openslx.dozmod.App;
import org.openslx.dozmod.Config;
import org.openslx.dozmod.Config.SavedSession;
import org.openslx.dozmod.authentication.Authenticator.AuthenticationData;
import org.openslx.dozmod.filetransfer.DownloadTask;
import org.openslx.dozmod.filetransfer.TransferEvent;
import org.openslx.dozmod.filetransfer.TransferEventListener;
import org.openslx.dozmod.gui.GraphicalCertHandler;
import org.openslx.dozmod.gui.Gui;
import org.openslx.dozmod.gui.MainWindow;
import org.openslx.dozmod.gui.helper.I18n;
import org.openslx.dozmod.gui.helper.MessageType;
import org.openslx.dozmod.gui.helper.QFileChooser;
import org.openslx.dozmod.gui.window.SatelliteListWindow;
import org.openslx.dozmod.thrift.cache.ImageCache;
import org.openslx.dozmod.thrift.cache.LectureCache;
import org.openslx.dozmod.thrift.cache.MetaDataCache;
import org.openslx.dozmod.thrift.cache.UserCache;
import org.openslx.dozmod.util.FormatHelper;
import org.openslx.dozmod.util.ImageWrapper;
import org.openslx.dozmod.util.VmWrapper;
import org.openslx.sat.thrift.version.Version;
import org.openslx.thrifthelper.ThriftManager;
import org.openslx.util.QuickTimer;
import org.openslx.util.QuickTimer.Task;

public class ThriftActions {

	private static final Logger LOGGER = LogManager.getLogger(ThriftActions.class);
	private static final long SIZE_CHECK_EXTRA_DL = 50l * 1024l * 1024l;

	/* *******************************************************************************
	 * 
	 * SESSION
	 * 
	 * Session initialization
	 * 
	 * *******************************************************************************
	 */
	/**
	 * @param window the parentWindow
	 * @param data AuthenticationData as received from a successful login, or
	 *            null if trying to resume a saved sessions
	 * @param forceCustomSatellite show satellite selection dialog even if there
	 *            is just one
	 * @param loginWindow
	 * @return true if initialising the session worked, false otherwise
	 */
	public static boolean initSession(AuthenticationData data, boolean forceCustomSatellite, Window window) {
		final boolean interactive = (data != null);
		Client client = null;
		WhoamiInfo whoami = null;
		String address = null;
		String satToken = null;
		String masterToken = null;
		long remoteVersion = -1;

		if (interactive && !forceCustomSatellite && (data.satellites == null || data.satellites.isEmpty())) {
			Gui.asyncMessageBox(I18n.THRIFT.getString("ThriftActions.Message.error.satellitesNullOrEmpty"),
					MessageType.ERROR, LOGGER, null);
		}

		do {
			if (!interactive) {
				// in session resume
				SavedSession session = Config.getSavedSession();
				if (session == null)
					return false;
				address = session.address;
				satToken = session.token;
				masterToken = session.masterToken;
			} else {
				// determine which sat to connect to
				// first check if a sat selection was forced
				Satellite sat = null;
				if (forceCustomSatellite) {
					sat = SatelliteListWindow.open(window, data.satellites);
					if (sat == null)
						return false;
				}
				// not forced, do regular sat processing
				if (sat == null) {
					// if we received only one sat, use that one
					if (data.satellites != null && data.satellites.size() == 1) {
						sat = data.satellites.get(0);
					}
					// we had more than one, so check the list
					if (sat == null) {
						if (!forceCustomSatellite) {
							// Remove testing servers (those starting with {x}) if shift was not pressed
							for (Iterator<Satellite> it = data.satellites.iterator(); it.hasNext();) {
								Satellite entry = it.next();
								if (entry.displayName != null && entry.displayName.startsWith("{x}")) {
									it.remove();
								}
							}
						}
						// after removing the test sats, check if we have only one left and directly use that
						// instead of asking the user
						if (data.satellites.size() != 1) {
							sat = SatelliteListWindow.open(window, data.satellites);
							if (sat == null)
								return false;
						} else {
							sat = data.satellites.get(0);
						}
					}
				}
				if (sat.addressList == null || sat.addressList.isEmpty()) {
					Gui.asyncMessageBox(I18n.THRIFT.getString("ThriftActions.Message.error.addressListNullOrEmpty"),
							MessageType.ERROR, LOGGER, null);
					continue;
				}
				address = sat.addressList.get(0);
				satToken = data.satelliteToken;
				masterToken = data.masterToken;
				// In case we loop, make sure the window is shown on the second iteration
				forceCustomSatellite = true;
			}

			// common for resume and fresh login
			// try to get a new client
			client = ThriftManager.getNewSatelliteClient(GraphicalCertHandler.getSslContext(address),
					address, App.THRIFT_SSL_PORT, 5000);
			// RPC version check
			if (client != null) {
				try {
					remoteVersion = client.getVersion(Version.VERSION);
				} catch (TTransportException e) {
				} catch (TException e) {
					remoteVersion = 1; // Assume something old
				}
			}

			if (client == null || remoteVersion == -1) {
				if (interactive) {
					Gui.asyncMessageBox(I18n.THRIFT.getString("ThriftActions.Message.error.couldNotGetNewClient"),
							MessageType.ERROR, null, null);
					if (data.satellites.size() == 1) {
						return false;
					}
					continue;
				}
				return false;
			}

			if (remoteVersion < Version.MIN_VERSION || remoteVersion > Version.VERSION) {
				if (interactive) {
					Gui.asyncMessageBox(I18n.THRIFT.getString("ThriftActions.Message.error.versionNotCompatible",
							Version.VERSION, remoteVersion), MessageType.ERROR, LOGGER, null);
					continue;
				}
				return false;
			}

			// all good, try to get the whoami info
			try {
				whoami = client.whoami(satToken);
			} catch (TAuthorizationException e) {
				if (interactive) {
					ThriftError.showMessage(window, LOGGER, e,
							I18n.THRIFT.getString("ThriftActions.Message.error.authorizationException"));
				}
				return false;
			} catch (TException e) {
				if (interactive) {
					ThriftError.showMessage(window, LOGGER, e,
							I18n.THRIFT.getString("ThriftActions.Message.error.sessionInternalError"));
					continue;
				}
				return false;
			} catch (Exception e) {
				if (interactive) {
					Gui.asyncMessageBox(I18n.THRIFT.getString("ThriftActions.Message.error.sessionUnknownError"),
							MessageType.ERROR, LOGGER, e);
					continue;
				}
				return false;
			}
		} while (interactive && whoami == null);

		if (whoami != null) {
			Session.initialize(whoami, address, satToken, masterToken, remoteVersion);
			ThriftManager.setSatelliteAddress(
					GraphicalCertHandler.getSslContext(Session.getSatelliteAddress()),
					Session.getSatelliteAddress(), App.THRIFT_SSL_PORT, App.THRIFT_TIMEOUT_MS);
			QuickTimer.scheduleOnce(new Task() {
				@Override
				public void fire() {
					// Cache useful data from server
					MetaDataCache.getOperatingSystems();
					MetaDataCache.getVirtualizers();
					UserCache.getAll();
					ImageCache.get(false);
					LectureCache.get(false);
				}
			});
			return true;
		}
		return false;
	}

	/* *******************************************************************************
	 * 
	 * IMAGE CREATION
	 * 
	 * Creates a base image with the given name
	 * 
	 * *******************************************************************************
	 */
	/**
	 * GUI-BLOCKING Creates the image with the given name. Returns the uuid
	 * returned by the server
	 * 
	 * @param frame calling this action
	 * @return uuid as String, or null if the creation failed
	 */
	public static String createImage(final Frame frame, final String name) {
		String uuid = null;
		try {
			uuid = ThriftManager.getSatClient().createImage(Session.getSatelliteToken(), name);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.createImageFailed"));
		} catch (Exception e) {
			Gui.showMessageBox(frame, I18n.THRIFT.getString("ThriftActions.Message.error.createImageUnknownError"),
					MessageType.ERROR, LOGGER, e);
		}
		return uuid;
	}

	/**
	 * GUI-BLOCKING Pushes a new image base to the server with the given
	 * imageBaseId and the meta information in meta
	 * 
	 * @param imageBaseId image's id we are writing meta information of
	 * @param meta actual meta information as ImageBaseWrite
	 * @throws TException
	 * @throws TInvocationException
	 * @throws TNotFoundException
	 * @throws TAuthorizationException
	 */
	public static void updateImageBase(final String imageBaseId, final ImageBaseWrite meta)
			throws TAuthorizationException, TNotFoundException, TInvocationException, TException {
		ThriftManager.getSatClient().updateImageBase(Session.getSatelliteToken(), imageBaseId, meta);
	}

	/**
	 * GUI-BLOCKING Pushes the given permission map as custom permission for the
	 * given imageBaseId
	 * 
	 * @param imageBaseId image's id we are writing permissions of
	 * @param permissions actual permissions map to write
	 * @throws TException
	 * @throws TInvocationException
	 * @throws TNotFoundException
	 * @throws TAuthorizationException
	 */
	public static void writeImagePermissions(final String imageBaseId,
			final Map<String, ImagePermissions> permissions) throws TAuthorizationException,
			TNotFoundException, TInvocationException, TException {
		ThriftManager.getSatClient().writeImagePermissions(Session.getSatelliteToken(), imageBaseId,
				permissions);
	}

	/* *******************************************************************************
	 * 
	 * IMAGE VERSION UPLOAD
	 * 
	 * Methods to upload an image version. This is compromised of two distinct
	 * steps: - requestVersionUpload(..) to request the upload at the server -
	 * initUpload(..) to actually start the upload of the file
	 * 
	 * ******************************************************************************
	 */

	/**
	 * GUI-BLOCKING
	 * 
	 * @param frame
	 * @param transferInformation
	 * @param versionInfo
	 * @throws TException
	 * @throws TInvocationException
	 * @throws TNotFoundException
	 * @throws TAuthorizationException
	 */
	public static void updateImageVersion(final String versionId, final ImageVersionWrite versionInfo)
			throws TAuthorizationException, TNotFoundException, TInvocationException, TException {
		ThriftManager.getSatClient().updateImageVersion(Session.getSatelliteToken(), versionId, versionInfo);
	}

	/* *******************************************************************************
	 * 
	 * IMAGE VERSION DOWNLOAD
	 * 
	 * Download image version action composed of the interface
	 * 'DownloadCallback' and the actual static method 'initDownload' to start
	 * the download.
	 * 
	 * *******************************************************************************
	 */
	/**
	 * The callback interface to inform the GUI about the status of the
	 * operation
	 */
	public interface DownloadCallback {
		void downloadInitialized(boolean success);
	}

	/**
	 * NON-BLOCKING Initialises the download of the given imageVersionId saving
	 * it to the given imageName
	 * 
	 * @param frame caller of this method
	 * @param imageVersionId image version id to download
	 * @param imageName destination file name
	 * @param virtualizerId id of the virtualizer
	 * @param imageSize size in bytes of the image to download
	 * @param callback callback function to return status of this operation to
	 *            the GUI
	 */
	public static void initDownload(final Frame frame, final String imageVersionId, final String imageName,
			final String virtualizerId, final int osId, final long imageSize, final DownloadCallback callback) {
		// TODO: Return value? Callback?
		QFileChooser fc = new QFileChooser(Config.getDownloadPath(), true);
		fc.setDialogTitle(I18n.THRIFT.getString("ThriftActions.FileChooser.fc.dialogTitle"));
		int action = fc.showSaveDialog(frame);
		File selected = fc.getSelectedFile();
		if (action != JFileChooser.APPROVE_OPTION || selected == null) {
			if (callback != null)
				callback.downloadInitialized(false);
			return;
		}

		final File destDir = new File(selected, generateDirname(imageName, imageVersionId));
		final File tmpDiskFile = new File(destDir.getAbsolutePath(), VmWrapper.generateFilename(imageName,
				null) + ".part");

		if (destDir.exists()) {
			boolean ret = Gui.showMessageBox(frame, I18n.THRIFT.getString("ThriftActions.Message.yesNo.destDirExists",
					destDir.getAbsolutePath()), MessageType.QUESTION_YESNO, LOGGER, null);
			if (!ret) {
				// user aborted
				if (callback != null)
					callback.downloadInitialized(false);
				return;
			}
			// delete it
			if (!tmpDiskFile.delete() && tmpDiskFile.exists()) {
				Gui.showMessageBox(frame, I18n.THRIFT.getString("ThriftActions.Message.error.couldNotDeleteDiskFile"),
						MessageType.ERROR, LOGGER, null);
				if (callback != null)
					callback.downloadInitialized(false);
				return;
			}
		} else {
			destDir.getAbsoluteFile().mkdirs();
		}

		if (!destDir.isDirectory()) {
			Gui.showMessageBox(frame, I18n.THRIFT.getString("ThriftActions.Message.error.destDirNotWritable"),
					MessageType.ERROR, LOGGER, null);
			if (callback != null)
				callback.downloadInitialized(false);
			return;
		}

		// Check the free space on disk
		if (destDir.getUsableSpace() < imageSize + SIZE_CHECK_EXTRA_DL) {
			Gui.showMessageBox(frame, I18n.THRIFT.getString("ThriftActions.Message.error.destDirHasNotEnoughFreeSpace",
					FormatHelper.bytes(imageSize + SIZE_CHECK_EXTRA_DL, false),
					FormatHelper.bytes(destDir.getUsableSpace(), false)), MessageType.ERROR, LOGGER, null);
			if (callback != null)
				callback.downloadInitialized(false);
			return;
		}

		QuickTimer.scheduleOnce(new Task() {
			@Override
			public void fire() {
				// since this function (initDownload) supports both download from the satellite and from the masterserver
				// we simply try to download from the sat first and if that fails, we try to download from the masterserver
				// this has the nice side effect, that if a download from the masterserver is requested, it tries
				// to download that image from the sat first (which is probably faster than from the masterserver)
				TException transEx = null;
				String transHost = null;
				TransferInformation transInf = null;
				try {
					transInf = ThriftManager.getSatClient().requestDownload(Session.getSatelliteToken(),
							imageVersionId);
					transHost = Session.getSatelliteAddress();
				} catch (TException e) {
					transEx = e;
				}
				if (transInf == null) {
					// satellite denied download, try master
					transHost = null;
					try {
						transInf = ThriftManager.getMasterClient().downloadImage(Session.getSatelliteToken(),
								imageVersionId);
						transHost = App.getMasterServerAddress();
					} catch (TException e) {
						transEx = e;
					}
				}
				if (transInf == null) {
					// both download request failed, show user feedback
					ThriftError.showMessage(frame, LOGGER, transEx,
							I18n.THRIFT.getString("ThriftActions.Message.error.downloadRequestFailed"));
					if (callback != null)
						callback.downloadInitialized(false);
					return;
				}
				final String fTransHost = transHost;
				final TransferInformation fTransInf = transInf;
				final DownloadTask dlTask;
				try {
					dlTask = new DownloadTask(fTransHost, transInf.getPlainPort(),
							transInf.getToken(), tmpDiskFile, imageSize, null);
				} catch (FileNotFoundException e) {
					Gui.asyncMessageBox(I18n.THRIFT.getString("ThriftActions.Message.error.destinationNotWritable"),
							MessageType.ERROR, LOGGER, e);
					if (callback != null)
						callback.downloadInitialized(false);
					return;
				}

				dlTask.setMinConnections(Config.getTransferConnectionCount());
				dlTask.addListener(new TransferEventListener() {
					@Override
					public void update(TransferEvent event) {
						if (event.state != TransferState.FINISHED)
							return;
						ImageWrapper.unpack(virtualizerId, tmpDiskFile, imageName, destDir, osId,
								fTransInf.getMachineDescription());
					}
				});

				Gui.asyncExec(new Runnable() {
					@Override
					public void run() {
						MainWindow.addDownload(imageName, tmpDiskFile.getName(), dlTask);
					}
				});

				new Thread(dlTask, "DownloadTask").start();

				Config.setDownloadPath(destDir.getParentFile().getAbsolutePath());
				if (callback != null)
					callback.downloadInitialized(true);
			}
		});
	}

	/**
	 * Helper to generate a directory name for the given imageName and
	 * imageVersionId.
	 * Uses the given parameters to build a hopefully unique name as it takes
	 * the first 8
	 * chars of the version id...
	 * 
	 * @param imageName name of the image
	 * @param imageVersionId version id
	 * @return generated directory name as String
	 */
	private static String generateDirname(String imageName, String imageVersionId) {
		String fileName = imageName.replaceAll("[^a-zA-Z0-9_\\.\\-]+", "_");
		if (fileName.length() > 50) {
			fileName = fileName.substring(0, 50);
		}
		fileName += "--" + imageVersionId.substring(0, 8);
		return fileName;
	}

	/* *******************************************************************************
	 * 
	 * IMAGE METADATA
	 * 
	 * *******************************************************************************/

	/**
	 * Callback interface for image meta calls. 
	 * 
	 */
	public interface ImageMetaCallback {
		void fetchedImageDetails(ImageDetailsRead details, Map<String, ImagePermissions> permissions);
	}

	/**
	 * BLOCKING Gets the image details (w/o permissions) of the given
	 * imageBaseID
	 * 
	 * @param frame to display user feedback on
	 * @param imageBaseId image's id to get the details of
	 * @return details as ImageDetailsRead if fetching worked, null otherwise
	 */
	public static ImageDetailsRead getImageDetails(final Frame frame, final String imageBaseId) {
		ImageDetailsRead details = null;
		try {
			details = ThriftManager.getSatClient().getImageDetails(Session.getSatelliteToken(), imageBaseId);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.getImageDetailsFailed"));
		}
		return details;
	}

	/**
	 * NON-BLOCKING Gets the image details (without permissions) of the given
	 * imageBaseId.
	 * Will return the details (or null if fetching failed) back to the
	 * gui-thread
	 * through the given callback
	 * 
	 * @param frame to display user feedback on
	 * @param imageBaseId image's id to get the details of
	 * @param callback interface to return the details back to the gui
	 */
	public static void getImageDetails(final Frame frame, final String imageBaseId,
			final ImageMetaCallback callback) {
		QuickTimer.scheduleOnce(new Task() {
			ImageDetailsRead details = null;

			@Override
			public void fire() {
				details = ThriftActions.getImageDetails(frame, imageBaseId);
				Gui.asyncExec(new Runnable() {
					@Override
					public void run() {
						if (callback != null) {
							callback.fetchedImageDetails(details, null);
						}
					}
				});
			}
		});
	}
	/**
	 * BLOCKING Gets the data for image with UUID imageBaseId
	 * 
	 * @param imageBaseId
	 * @return ImagePublishData image's data if sucessful, null otherwise.
	 */
	public static ImagePublishData getImageData(final String imageBaseId) {
		ImagePublishData data = null;
		try {
			data = ThriftManager.getMasterClient().getImageData(Session.getSatelliteToken(), imageBaseId);
		} catch (TException e) {
			LOGGER.error("Could not query sat for ImagePublishData for '" + imageBaseId + "':", e); 
		}
		return data;
	}
	/**
	 * NON-BLOCKING Gets the user-specific permission list for the given
	 * imageBaseId
	 * 
	 * @param frame to display user feedback on
	 * @param imageBaseId image's id to get the permission list of
	 * @param callback interface to return the permission list back to the gui
	 */
	public static void getImagePermissions(final Frame frame, final String imageBaseId,
			final ImageMetaCallback callback) {
		QuickTimer.scheduleOnce(new Task() {
			Map<String, ImagePermissions> permissionMap = null;

			@Override
			public void fire() {
				permissionMap = ThriftActions.getImagePermissions(frame, imageBaseId);
				Gui.asyncExec(new Runnable() {
					@Override
					public void run() {
						if (callback != null) {
							callback.fetchedImageDetails(null, permissionMap);
						}
					}
				});
			}
		});
	}

	/**
	 * BLOCKING Gets the user-specific permission list for the given imageBaseId
	 * 
	 * @param frame to display user feedback on
	 * @param imageBaseId image's base id to get the user permissions of
	 * @return the map userid-permissions if fetching worked, null otherwise
	 */
	public static Map<String, ImagePermissions> getImagePermissions(final Frame frame,
			final String imageBaseId) {
		Map<String, ImagePermissions> permissionMap = null;
		try {
			permissionMap = ThriftManager.getSatClient().getImagePermissions(Session.getSatelliteToken(),
					imageBaseId);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.getImagePermissionsFailed"));
		}
		return permissionMap;
	}

	/**
	 * BLOCKING Sets the owner of the given lectureId to newOwner
	 * 
	 * @param frame to display user feedback on
	 * @param lectureId lecture's id to set the new owner of
	 * @param newOwner as UserInfo
	 * @return true if it worked, false otherwise
	 */
	public static boolean setImageOwner(final Frame frame, final String lectureId, final UserInfo newOwner) {
		try {
			ThriftManager.getSatClient().setImageOwner(Session.getSatelliteToken(), lectureId,
					newOwner.getUserId());
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.setImageOwnerFailed"));
			return false;
		}
		return true;
	}

	/* *******************************************************************************
	 * 
	 * IMAGE / VERSION DELETION
	 * 
	 * *******************************************************************************/
	/**
	 * Callback interface to be implemented by callers of
	 * ThriftActions.deleteImageVersion(..)
	 */
	public interface DeleteCallback {
		/**
		 * Called once the status of a delete operation is determined
		 * 
		 * @param success true if deleted successfully, false otherwise
		 */
		void isDeleted(boolean success);
	}

	/**
	 * BLOCKING Deletes the base image with the given id. Will call the given
	 * callback to report about the status of this operation
	 * 
	 * @param frame to display user feedback on
	 * @param imageBaseId image base id to delete
	 */
	public static void deleteImageBase(final Frame frame, final String imageBaseId) {
		if (imageBaseId == null || imageBaseId.isEmpty())
			return;
		// first look if we have versions
		ImageDetailsRead details = null;
		// these help construct the question text for the user, bit ugly...
		List<LectureSummary> lecturesToBeDeleted = null;
		List<ImageVersionDetails> versionToBeDeleted = null;
		try {
			details = ThriftManager.getSatClient().getImageDetails(Session.getSatelliteToken(), imageBaseId);
			List<LectureSummary> lectureList = ThriftManager.getSatClient().getLectureList(
					Session.getSatelliteToken(), 100);
			for (LectureSummary lecture : lectureList) {
				if (imageBaseId.equals(lecture.getImageBaseId())) {
					if (lecturesToBeDeleted == null)
						lecturesToBeDeleted = new ArrayList<LectureSummary>();
					lecturesToBeDeleted.add(lecture);
				}
			}
			for (ImageVersionDetails version : details.getVersions()) {
				if (version.isValid) {
					if (versionToBeDeleted == null)
						versionToBeDeleted = new ArrayList<ImageVersionDetails>();
					versionToBeDeleted.add(version);
				}
			}

		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.couldNotGetImageBase", imageBaseId));
			return;
		}
		String questionText;
		if (versionToBeDeleted != null && !versionToBeDeleted.isEmpty()) {
			questionText = I18n.THRIFT.getString("ThriftActions.deleteImageBase.String.questionText.0", details.getImageName());
			for (ImageVersionDetails version : versionToBeDeleted) {
				questionText += version.getVersionId() + "\n";
			}
			questionText += "\n";
		} else {
			questionText = "";
		}
		if (lecturesToBeDeleted != null && !lecturesToBeDeleted.isEmpty()) {
			questionText += I18n.THRIFT.getString("ThriftActions.deleteImageBase.String.questionText.1");
			for (LectureSummary lecture : lecturesToBeDeleted) {
				questionText += lecture.getLectureName() + "\n";
			}
			questionText += "\n";
		}
		questionText += I18n.THRIFT.getString("ThriftActions.deleteImageBase.String.questionText.2");
		if (!userConfirmed(frame, questionText))
			return;
		try {
			ThriftManager.getSatClient().deleteImageBase(Session.getSatelliteToken(), imageBaseId);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.couldNotDeleteImageBase"));
		}
	}

	/**
	 * BLOCKING Deletes either an image base or an image version depending
	 * on the parameters. To delete an image base, give the imageBaseId and let
	 * imageVersionId be null. To delete an image version, set both imageBaseId
	 * and imageVersionId. The success of the operation will be forwarded to the
	 * GUI through the DeleteCallback.
	 * 
	 * @param frame next parent frame of the caller of this method
	 * @param imageBaseId uuid of the image that belongs to the version
	 * @param version id of the image version to be deleted
	 * @param callback called to inform the GUI about the deletion status (see
	 *            DeleteCallback interface)
	 */
	public static void deleteImageVersion(final Frame frame, final ImageVersionDetails version,
			final DeleteCallback callback) {
		if (version == null || version.versionId == null || version.versionId.isEmpty())
			return;
		String versionId = version.versionId;
		boolean success = false;
		List<LectureSummary> lectureList = null;
		try {
			// fetch lectures
			lectureList = ThriftManager.getSatClient().getLectureList(Session.getSatelliteToken(), 100);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.couldNotGetImageVersion"));
			if (callback != null)
				callback.isDeleted(success);
			return;
		}
		String questionText = "";
		// represents if we found matches of not, needed to make a proper
		// message
		boolean matches = false;
		if (lectureList != null && !lectureList.isEmpty()) {
			for (LectureSummary lecture : lectureList) {
				if (versionId.equals(lecture.getImageVersionId())) {
					if (!matches)
						questionText = I18n.THRIFT.getString("ThriftActions.deleteImageVersion.String.questionText.0");
					matches = true;
					questionText += lecture.getLectureName() + "\n";
				}
			}
			if (matches)
				questionText += I18n.THRIFT.getString("ThriftActions.deleteImageVersion.String.questionText.1");
		}
		if (!matches)
			questionText = I18n.THRIFT.getString("ThriftActions.deleteImageVersion.String.questionText.2",
					FormatHelper.shortDate(version.createTime));

		if (!userConfirmed(frame, questionText))
			return;
		try {
			ThriftManager.getSatClient().deleteImageVersion(Session.getSatelliteToken(), versionId);
			LOGGER.info("Deleted version '" + versionId + "'.");
			success = true;
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.couldNotDeleteImageVersion"));
			if (callback != null)
				callback.isDeleted(success);
			return;
		}
		final boolean fSuccess = success;
		Gui.asyncExec(new Runnable() {
			@Override
			public void run() {
				if (callback != null)
					callback.isDeleted(fSuccess);
			}
		});
	}

	/* *******************************************************************************
	 * 
	 * LECTURE CREATION
	 * 
	 * *******************************************************************************/
	/**
	 * BLOCKING Creates a lecture with the given meta data
	 * 
	 * @param frame to show user feedback on
	 * @param meta actual meta data as LectureWrite
	 * @return the created lecture's id if it worked, null otherwise
	 */
	public static String createLecture(final Frame frame, final LectureWrite meta) {
		if (meta == null)
			return null;
		String uuid = null;
		try {
			// push to sat
			uuid = ThriftManager.getSatClient().createLecture(Session.getSatelliteToken(), meta);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.createLectureFailed"));
		}
		return uuid;
	}

	/**
	 * BLOCKING Writes custom lecture permissions (permissions param) for
	 * the given lectureId.
	 * 
	 * @param frame to show user feedback on
	 * @param lectureId lecture's id to write custom permissions for
	 * @param permissions actual permission map to push
	 */
	public static boolean writeLecturePermissions(final Frame frame, final String lectureId,
			final Map<String, LecturePermissions> permissions) {
		try {
			ThriftManager.getSatClient().writeLecturePermissions(Session.getSatelliteToken(), lectureId,
					permissions);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.writeLecturePermissionsFailed"));
			return false;
		}
		return true;
	}

	/* *******************************************************************************
	 * 
	 * LECTURE METADATA
	 * 
	 * *******************************************************************************/

	/**
	 * Interface for GUI-classes running async lecture meta calls
	 */
	public interface LectureMetaCallback {
		void fetchedLectureAndImageDetails(LectureRead lecture, ImageDetailsRead image);
	}

	/**
	 * NON-BLOCKING Gets the lecture and image details of the given lectureId.
	 * IF the lecture does not exist, both fields returned will be null. If the
	 * lecture exists, the image can still be null, since not all lectures link
	 * to an image at all times.
	 * 
	 * @param frame to display user feedback on
	 * @param lectureId lecture to get the full details of
	 * @param callback interface to return the details to the gui
	 */
	public static void getLectureAndImageDetails(final Frame frame, final String lectureId,
			final LectureMetaCallback callback) {
		QuickTimer.scheduleOnce(new Task() {
			@Override
			public void fire() {
				final LectureRead lecture = ThriftActions.getLectureDetails(frame, lectureId);
				final ImageDetailsRead fImage;
				if (lecture != null && lecture.imageBaseId != null) {
					fImage = ThriftActions.getImageDetails(frame, lecture.getImageBaseId());
				} else {
					fImage = null;
				}
				Gui.asyncExec(new Runnable() {
					@Override
					public void run() {
						if (callback != null) {
							callback.fetchedLectureAndImageDetails(lecture, fImage);
						}
					}
				});
			}
		});
	}

	/**
	 * BLOCKING Gets the lecture details of the lecture with given lectureId
	 * 
	 * @param frame to display user feedback on
	 * @param lectureId lecture to get the details of
	 * @return LectureRead if fetching details worked, null otherwise
	 */
	public static LectureRead getLectureDetails(final Frame frame, final String lectureId) {
		LectureRead lecture = null;
		try {
			lecture = ThriftManager.getSatClient().getLectureDetails(Session.getSatelliteToken(), lectureId);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.getLectureDetailsFailed"));
		}
		return lecture;
	}

	/**
	 * BLOCKING Updates the lecture with given lectureId to the given lecture
	 * 
	 * @param frame to show user feedback on
	 * @param lectureId lecture's is to update
	 * @param lecture LectureWrite data to update the lecture with
	 * @return
	 */
	public static boolean updateLecture(final Frame frame, final String lectureId,
			final LectureWrite lectureWrite) {
		try {
			ThriftManager.getSatClient().updateLecture(Session.getSatelliteToken(), lectureId, lectureWrite);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.updateLectureFailed"));
			return false;
		}
		return true;
	}

	/**
	 * BLOCKING Gets the list of user-specific permission for the lecture with
	 * the
	 * given lectureId
	 * 
	 * @param frame to display user feedback on
	 * @param lectureId lecture's id to get the permission list of
	 * @return the map of the userid-permissions if fetching worked, null
	 *         otherwise
	 */
	public static Map<String, LecturePermissions> getLecturePermissions(final Frame frame,
			final String lectureId) {
		Map<String, LecturePermissions> permissions = null;
		try {

			permissions = ThriftManager.getSatClient().getLecturePermissions(Session.getSatelliteToken(),
					lectureId);
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.getLecturePermissionsFailed"));
		}
		return permissions;

	}

	/**
	 * BLOCKING Sets the owner of the given lectureId to newOwner
	 * 
	 * @param frame to display user feedback on
	 * @param lectureId lecture's id to set the new owner of
	 * @param newOwner as UserInfo
	 * @return true if it worked, false otherwise
	 */
	public static boolean setLectureOwner(final Frame frame, final String lectureId, final UserInfo newOwner) {
		try {
			ThriftManager.getSatClient().setLectureOwner(Session.getSatelliteToken(), lectureId,
					newOwner.getUserId());
		} catch (TException e) {
			ThriftError.showMessage(frame, LOGGER, e,
					I18n.THRIFT.getString("ThriftActions.Message.error.setLectureOwnerFailed"));
			return false;
		}
		return true;
	}

	/* *******************************************************************************
	 * 
	 * LECTURE DELETION
	 * 
	 * *******************************************************************************/
	/**
	 * Callback interface reporting the status of the deletion back to the gui
	 */
	public interface DeleteLectureCallback {
		void deleted(Map<LectureSummary, TException> failedLectures);
	}

	/**
	 * NON-BLOCKING Deletes the lectures of the given list
	 * 
	 * @param frame to display user feedback on
	 * @param list of lectures to be deleted
	 * @param callback interface to report the lectures, which haven't been
	 *            deleted.
	 */
	public static void deleteLecture(final Frame frame, final List<LectureSummary> lectures,
			final DeleteLectureCallback callback) {
		if (lectures == null)
			return;
		String messageText = lectures.size() == 1
				? I18n.THRIFT.getString("ThriftActions.deleteLecture.String.messageText.0")
				: I18n.THRIFT.getString("ThriftActions.deleteLecture.String.messageText.1", lectures.size());
		if (!userConfirmed(frame, messageText))
			return;

		QuickTimer.scheduleOnce(new Task() {
			Map<LectureSummary, TException> failedLectures = new HashMap<LectureSummary, TException>();

			@Override
			public void fire() {
				for (final LectureSummary l : lectures) {
					if (l == null)
						continue;
					try {
						ThriftManager.getSatClient().deleteLecture(Session.getSatelliteToken(), l.lectureId);
					} catch (TException e) {
						failedLectures.put(l, e);
					}
				}
				Gui.asyncExec(new Runnable() {
					@Override
					public void run() {
						if (callback != null) {
							callback.deleted(failedLectures);
						}
					}
				});
			}
		});
	}
	/* *******************************************************************************
	 * 
	 * PUBLIC IMAGES
	 * 
	 * *******************************************************************************/
	/**
	 * BLOCKING Gets the image details of an image on the masterserver
	 * 
	 * @param imageVersionId
	 * @return ImageDetailsRead if fetching the details worked, null otherwise.
	 */
	public static ImageDetailsRead getPublishedImageDetails(final String imageBaseId) {
		ImageDetailsRead data = null;
		try {
			data = ThriftManager.getMasterClient().getImageDetails(Session.getMasterToken(), imageBaseId);
		} catch (TException e) {
			LOGGER.error("Could not query masterserver for ImageDetailsRead for version '" + imageBaseId + "':", e); 
		}
		return data;
	}
	/* *******************************************************************************
	 * 
	 * PRIVATE HELPERS
	 * 
	 * *******************************************************************************/

	/**
	 * Helper to ask the user for confirmation. Returns his choice.
	 * 
	 * @param frame frame to show this message box on
	 * @param message question message to display to the user
	 * @return true if the user confirmed (clicked yes), false otherwise
	 */
	private static boolean userConfirmed(final Frame frame, final String message) {
		return Gui.showMessageBox(frame, message, MessageType.QUESTION_YESNO, null, null);
	}

}