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

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

import java.awt.Component;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;

import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.LookAndFeel;
import javax.swing.UIManager;
import javax.swing.filechooser.FileNameExtensionFilter;

import org.apache.log4j.Logger;
import org.openslx.bwlp.thrift.iface.TImageDataException;
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.helper.MessageType;
import org.openslx.dozmod.gui.wizard.Wizard;
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.Util;
import org.openslx.util.vm.VmMetaData.HardDisk;
import org.openslx.util.vm.VmwareMetaData;

@SuppressWarnings("serial")
public class ImageUploadPage extends ImageUploadPageLayout {

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

	private UploadWizardState state;
	private String lastDetectedName = null;

	public ImageUploadPage(Wizard wizard, UploadWizardState uploadWizardState) {
		super(wizard);
		setPageComplete(false);
		this.canComeBack = false;
		this.state = uploadWizardState;

		// Browse for *.vmx
		imageFileBrowseButton.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent e) {
				browseForVm();
			}
		});

		imageFileTextField.addMouseListener(new MouseAdapter() {
			@Override
			public void mouseClicked(MouseEvent e) {
				if (e.getClickCount() == 1)
					browseForVm();
			}
		});

		blockProgressBar.setVisible(false);
		imageFileBrowseButton.requestFocus();
	}

	private void browseForVm() {
		// Ugly hack to get a prettier file chooser with GTK - should be moved to helper/util class
		LookAndFeel old = UIManager.getLookAndFeel();
		if (!old.getName().toLowerCase().contains("gtk")) {
			old = null;
		} else {
			try {
				UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		JFileChooser fc = new JFileChooser(Config.getUploadPath());
		if (old != null) {
			fc.updateUI();
			try {
				UIManager.setLookAndFeel(old);
			} catch (Exception e) {
				e.printStackTrace();
			}
			refreshUI(fc, false);
		}
		FileNameExtensionFilter filter = new FileNameExtensionFilter("VMware Virtual Machine", "vmx");
		fc.setFileFilter(filter);
		fc.setFileSelectionMode(JFileChooser.FILES_ONLY);

		int action = fc.showOpenDialog(getDialog());
		File file = fc.getSelectedFile();
		if (action != JFileChooser.APPROVE_OPTION || file == null)
			return;
		vmxSelected(file.getAbsoluteFile());
	}

	private static void refreshUI(JComponent c, boolean includeParent) {
		if (includeParent)
			c.updateUI();

		for (int i = 0; i < c.getComponentCount(); i++) {
			Component child = c.getComponent(i);
			if (child instanceof JComponent) {
				refreshUI((JComponent) child, true);
			}
		}
	}

	private void vmxSelected(File file) {
		Config.setUploadPath(file.getParent());
		try {
			state.meta = new VmwareMetaData(MetaDataCache.getOperatingSystems(), file);
		} catch (IOException e) {
			Gui.showMessageBox(this, "Konnte " + file.getPath() + " nicht lesen", MessageType.ERROR, LOGGER,
					e);
			setPageComplete(false);
			return;
		}
		LOGGER.info(new String(state.meta.getFilteredDefinition().array(), StandardCharsets.UTF_8));
		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);
		setDescription("Sie können jetzt den Upload starten!");
		setPageComplete(true);
	}

	/**
	 * This function starts the image creation process. It is triggered by the
	 * "Next" 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.
	 * 
	 */
	@Override
	protected boolean wantNextOrFinish() {
		// first get the image name from the field
		// (either auto filled by VmwareMetaData or by user)
		state.name = imageNameTextField.getText();
		// and to request the upload once we received that UUID.

		// -- create image --
		if (state.uuid == null) {
			LOGGER.debug("Creating image...");
			try {
				state.uuid = ThriftManager.getSatClient()
						.createImage(Session.getSatelliteToken(), state.name);
			} catch (TImageDataException e) {
				Gui.showMessageBox(this, "Ungültige Angaben (" + e.getNumber() + ")\n" + e.getMessage(),
						MessageType.ERROR, null, null);
				return false;
			} catch (Exception e) {
				Gui.showMessageBox(this, "Unbekannter Fehler beim Erstellen der VM", MessageType.ERROR,
						LOGGER, e);
				return false;
			}
			imageNameTextField.setEnabled(false);
			imageFileBrowseButton.setEnabled(false);
			imageFileTextField.setEnabled(false);
		}
		// -- request upload --
		if (state.transferInformation == null) {
			LOGGER.debug("Requesting upload...");
			try {
				state.transferInformation = ThriftManager.getSatClient().requestImageVersionUpload(
						Session.getSatelliteToken(), state.uuid, state.diskFile.length(), null,
						state.meta.getFilteredDefinition());
			} catch (Exception e) {
				Gui.showMessageBox(this, "Fehler beim Aushandeln des Uploads", MessageType.ERROR, LOGGER, e);
				return false;
			}
		}
		if (state.uploadTask == 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) {
				Gui.showMessageBox(getTopLevelAncestor(), "Kann VM nicht hochladen: Datei nicht gefunden\n\n"
						+ state.diskFile.getAbsolutePath(), MessageType.ERROR, LOGGER, e);
				return false;
			}
			// -- add listener for upload status/progress --
			state.uploadTask.addListener(new TransferEventListener() {
				@Override
				public void update(final TransferEvent event) {
					final TransferEventListener listener = this;
					Gui.asyncExec(new Runnable() {
						@Override
						public void run() {
							// always callback to gui
							processTransferStatus(listener, event);
						}
					});
				}
			});
			new Thread(state.uploadTask).start();
			do {
				Util.sleep(5);
			} while (state.uploadTask.getConnectFailCount() == 0 && state.uploadTask.getTransferCount() == 0
					&& !state.uploadTask.isCanceled());
		}

		if (state.uploadTask.getTransferCount() == 0) {
			Gui.showMessageBox(this, "Aufbau der Verbindung zum Hochladen fehlgeschlagen", MessageType.ERROR,
					LOGGER, null);
			return false;
		}
		// -- check image creation --
		blockProgressBar.setVisible(true);
		return true;
	}

	/**
	 * 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 (!getTopLevelAncestor().isVisible()) {
			if (state.uploadTask != null) {
				state.uploadTask.removeListener(listener);
			}
			return;
		}
		if (!isVisible())
			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:
			Gui.showMessageBox(this, "Upload abgeschlossen.", MessageType.INFO, LOGGER, null);
			break;
		case ERROR:
			if (state.uploadTask != null && state.uploadTask.isCanceled())
				return;
			Gui.showMessageBox(this, "Fehler beim Upload: " + event.errorMessage, MessageType.ERROR, LOGGER,
					null);
			// user wants to try again, just reset transferInformation ...
			state.uploadTask = null;
			break;
		case WORKING:
		case IDLE:
			break;
		default:
			LOGGER.warn("Unhandled transfer state: " + event.state);
			break;
		}
	}

	// TODO: In main control in main window....
	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();
			}
		});
		setPageComplete(false);
		blockProgressBar.setVisible(false);
	}
}