path: root/dozentenmodul/src/main/java/org/openslx/dozmod/gui/wizard/page/ImageUploadPage.java

package org.openslx.dozmod.gui.wizard.page;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.List;

import org.apache.log4j.Logger;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.KeyAdapter;
import org.eclipse.swt.events.KeyEvent;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.FileDialog;
import org.openslx.dozmod.Config;
import org.openslx.dozmod.filetransfer.TransferEvent;
import org.openslx.dozmod.filetransfer.TransferEventListener;
import org.openslx.dozmod.filetransfer.UploadTask;
import org.openslx.dozmod.gui.Gui;
import org.openslx.dozmod.gui.MainWindow;
import org.openslx.dozmod.gui.helper.MessageType;
import org.openslx.dozmod.gui.wizard.layout.ImageUploadPageLayout;
import org.openslx.dozmod.state.UploadWizardState;
import org.openslx.dozmod.thrift.MetaDataCache;
import org.openslx.dozmod.thrift.Session;
import org.openslx.thrifthelper.ThriftManager;
import org.openslx.util.QuickTimer;
import org.openslx.util.QuickTimer.Task;
import org.openslx.util.vm.VmMetaData.HardDisk;
import org.openslx.util.vm.VmwareMetaData;

public class ImageUploadPage extends ImageUploadPageLayout {

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

	private UploadWizardState state;
	protected final boolean editExistingImage;
	private String lastDetectedName = null;

	public ImageUploadPage(UploadWizardState uploadWizardState, boolean editExistingImage) {
		super();
		setPageComplete(false);
		this.editExistingImage = editExistingImage;
		this.state = uploadWizardState;
		setMessage("Bitte wählen Sie eine virtuelle Maschine zum Hochladen aus.");
	}

	@Override
	public void createControl(Composite parent) {
		super.createControl(parent);
		imageNameTextField.setEnabled(!editExistingImage);
		imageNameTextField.addKeyListener(new KeyAdapter() {
			@Override
			public void keyReleased(KeyEvent e) {
				if (!imageNameTextField.getText().isEmpty()) {
					setPageComplete(state.descriptionFile != null && state.uuid != null
							&& state.transferInformation != null);
				} else
					setPageComplete(false);
			}
		});

		// Browse for *.vmx
		imageFileBrowseButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				browseForVm();
			}
		});
		imageFileTextField.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseUp(MouseEvent e) {
				if (e.button == 1 && imageFileTextField.getClientArea().contains(e.x, e.y))
					browseForVm();
			}
		});

		// Start upload
		startUploadButton.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				createAndUploadImage();
			}
		});
		startUploadButton.setEnabled(false);

		// Cancel upload
		cancelUpload.addSelectionListener(new SelectionAdapter() {
			@Override
			public void widgetSelected(SelectionEvent e) {
				cancelUpload();
			}
		});
		cancelUpload.setVisible(false);
		blockProgressBar.setVisible(false);
		imageFileBrowseButton.setFocus();
	}

	private void browseForVm() {
		FileDialog dialog = new FileDialog(getWizard().getContainer().getShell(), SWT.OPEN);
		dialog.setFilterNames(new String[] { "VMware Virtuelle Maschine (Beschreibungsdatei)" });
		dialog.setFilterExtensions(new String[] { "*.vmx" });
		dialog.setFilterPath(Config.getUploadPath());
		String ret = dialog.open();
		if (ret != null) {
			vmxSelected(new File(ret).getAbsoluteFile());
		}
	}

	private void vmxSelected(File file) {
		Config.setUploadPath(file.getParent());
		try {
			state.meta = new VmwareMetaData(MetaDataCache.getOperatingSystems(), file);
		} catch (IOException e) {
			MainWindow.showMessageBox("Konnte " + file.getPath() + " nicht lesen", MessageType.ERROR, LOGGER,
					e);
			setPageComplete(false);
			return;
		}
		if (state.meta == null || state.meta.getDisplayName() == null) {
			setErrorMessage("Keine gültige vmx-Datei ausgewählt!");
			setPageComplete(false);
			return;
		}
		List<HardDisk> hdds = state.meta.getHdds();
		if (hdds.size() == 0 || hdds.get(0).diskImage == null) {
			setErrorMessage("Die gewählte VM enthält keine HDD");
			setPageComplete(false);
			return;
		}
		if (hdds.size() > 1) {
			setErrorMessage("Die gewählte VM enthält mehr als eine virtuelle HDD");
			setPageComplete(false);
			return;
			// Allow to continue!? 
		}

		// now check the disk files
		File vmDiskFileInfo = new File(hdds.get(0).diskImage);
		if (!vmDiskFileInfo.isAbsolute()) {
			// it's relative, compose path using the vmx location
			File vmxBaseDirectory = file.getParentFile();
			vmDiskFileInfo = new File(vmxBaseDirectory, hdds.get(0).diskImage);
		}
		if (vmDiskFileInfo.canRead()) {
			state.diskFile = vmDiskFileInfo;
		} else {
			setErrorMessage("'" + vmDiskFileInfo.getPath() + "' kann nicht gelesen werden!");
			setPageComplete(false);
			return;
		}

		// vmx ok, set it as our description file
		state.descriptionFile = file;

		// User didn't enter a name yet or didn't change it -> set
		String txtName = imageNameTextField.getText();
		if (txtName.isEmpty() || txtName.equals(lastDetectedName)) {
			imageNameTextField.setText(state.meta.getDisplayName());
		}
		lastDetectedName = state.meta.getDisplayName();

		state.detectedOs = state.meta.getOs();
		imageFileTextField.setText(file.getAbsolutePath());
		// let the user know the upload is ready
		setErrorMessage(null);
		setMessage("Sie können jetzt den Upload starten!");
		startUploadButton.setEnabled(true);
		startUploadButton.setFocus();
	}

	/* Override setVisible() to inject some code when this page is set visible
	 * Note that this also gets called when we go back to this page.
	 * 
	 * @see org.eclipse.jface.dialogs.DialogPage#setVisible(boolean)
	 */
	@Override
	public void setVisible(boolean visible) {
		if (getControl().isVisible() && !visible) {
			LOGGER.debug("Leaving ImageUploadPage...");
		} else if (!getControl().isVisible() && visible) {
			//
		}
		super.setVisible(visible);
	}

	/**
	 * This function starts the image creation process. It is triggered by the
	 * "Upload" button.
	 * 
	 * Depending on the state, it will first try to get a UUID for the new image
	 * by calling
	 * createImage() of the thrift API. If a UUID is received, it will request
	 * an upload with
	 * requestImageVersionUpload(). If granted, it will finally start a thread
	 * for the UploadTask.
	 * 
	 * Then a callback to the Gui is executed where we can process the upload
	 * state and give the
	 * user feedback about it.
	 * 
	 */
	private void createAndUploadImage() {
		// first get the image name from the field
		// (either auto filled by VmwareMetaData or by user)
		state.name = imageNameTextField.getText();

		// schedule task to create the image if we have no UUID
		// and to request the upload once we received that UUID. 
		QuickTimer.scheduleOnce(new Task() {
			@Override
			public void fire() {
				// -- create image --
				if (state.uuid == null) {
					LOGGER.debug("Creating image...");
					try {
						state.uuid = ThriftManager.getSatClient().createImage(Session.getSatelliteToken(),
								state.name);
					} catch (Exception e) {
						LOGGER.error("Error while creating image: ", e);
					}
				}
				if (state.transferInformation == null && state.uuid != null) {
					// -- request upload --
					LOGGER.debug("Requesting upload...");
					try {
						state.transferInformation = ThriftManager.getSatClient().requestImageVersionUpload(
								Session.getSatelliteToken(), state.uuid, state.diskFile.length(), null,
								state.meta.getFilteredDefinition());
					} catch (Exception e) {
						LOGGER.error("Error while requesting download for: " + state.uuid, e);
					}
				}
				if (state.uploadTask == null && state.transferInformation != null && state.uuid != null) {
					// do actually start the upload now
					LOGGER.debug("Starting upload for : " + state.diskFile.toPath());
					try {
						state.uploadTask = new UploadTask(Session.getSatelliteAddress(),
								state.transferInformation.getPlainPort(),
								state.transferInformation.getToken(), state.diskFile);
					} catch (FileNotFoundException e) {
						MainWindow.showMessageBox("Cannot upload file: Not found", MessageType.ERROR, LOGGER,
								e);
						return;
					}
					// -- add listener for upload status/progress --
					state.uploadTask.addListener(new TransferEventListener() {
						@Override
						public void update(final TransferEvent event) {
							final TransferEventListener listener = this;
							Gui.display.asyncExec(new Runnable() {
								@Override
								public void run() {
									// always callback to gui
									processTransferStatus(listener, event);
								}
							});
						}
					});
					new Thread(state.uploadTask).start();
				}
				Gui.display.asyncExec(new Runnable() {
					@Override
					public void run() {
						createAndUploadImageCallback();
					}
				});
			}
		});
	}

	/**
	 * Callback for the QuickTimer executing the thrift calls (see
	 * createAndUploadImage())
	 * 
	 * createAndUploadImage() starts the image upload process by creating the
	 * image,
	 * requesting upload transfer, starting the upload task and finally query
	 * the upload
	 * status to check if the upload is actually running.
	 * 
	 * Each step will update the UploadWizardState which we will evaluate here
	 * to
	 * know which step failed and handle the error accordingly.
	 */
	public void createAndUploadImageCallback() {
		if (getShell().isDisposed())
			return;
		// always disable "Browse" and "Image Name" field
		imageNameTextField.setEnabled(false);
		imageFileBrowseButton.setEnabled(false);
		imageFileTextField.setEnabled(false);
		// -- check image creation --
		if (state.uuid == null) {
			LOGGER.debug("No UUID in upload state!");
			setErrorMessage("Konnte das Image nicht auf dem Satelliten erstellen!");
		} else if (state.transferInformation == null) {
			LOGGER.debug("No transfer information in upload state!");
			setErrorMessage("Fehler bei der Upload-Anfrage!");
		} else if (state.uploadTask != null) {
			cancelUpload.setVisible(true);
			blockProgressBar.setVisible(true);
			setMessage("Der Upload wurde gestartet");
		}
		setPageComplete(state.uploadTask != null);
	}

	/**
	 * Evaluates the transfer's state and show feedback to the user based on the
	 * state.
	 * 
	 * @param listener
	 */
	private void processTransferStatus(TransferEventListener listener, TransferEvent event) {
		if (getControl().isDisposed()) {
			if (state.uploadTask != null) {
				state.uploadTask.removeListener(listener);
			}
			return;
		}
		// always update progress bar
		if (event.progress != null) {
			// TODO: Maybe only display percentage in the wizard pages once we have the status bar in mainwindow
			blockProgressBar.setStatus(event.progress);
		}
		if (event.state == null)
			return;
		// TODO: Move user interaction to central listener when we have it
		switch (event.state) {
		case FINISHED:
			cancelUpload.setEnabled(false);
			MainWindow.showMessageBox("Upload abgeschlossen.", MessageType.INFO, LOGGER, null);
			break;
		case ERROR:
			if (state.uploadTask != null && state.uploadTask.isCanceled())
				return;
			if (MainWindow.showMessageBox("Fehler beim Upload: " + event.errorMessage
					+ "\nNochmal versuchen?", MessageType.ERROR_RETRY, LOGGER, null)) {
				// user wants to try again, just reset transferInformation ...
				state.uploadTask = null;
				// ... since this function will then do the upload process again.
				createAndUploadImage();
			}
			break;
		case WORKING:
		case IDLE:
			break;
		default:
			LOGGER.warn("Unhandled transfer state: " + event.state);
			break;
		}
	}

	private void cancelUpload() {
		LOGGER.debug("Cancelling upload ...");
		// first tell the server about this
		QuickTimer.scheduleOnce(new Task() {
			@Override
			public void fire() {
				try {
					ThriftManager.getSatClient().cancelUpload(state.transferInformation.getToken());
				} catch (Exception e) {
					LOGGER.debug("Remote error while canceling upload for " + state.uuid, e);
				}
				// Then cancel the task
				state.uploadTask.cancel();
				Gui.asyncExec(new Runnable() {
					@Override
					public void run() {
						cancelUpload.setVisible(false);
					}
				});
			}
		});
		cancelUpload.setEnabled(false);
		setPageComplete(false);
		blockProgressBar.setVisible(false);
	}
}