path: root/src/main/java/org/openslx/util/vm/VmMetaData.java

package org.openslx.util.vm;

import java.io.File;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map.Entry;

import javax.print.attribute.standard.PrinterMessageFromOperator;
import javax.swing.JOptionPane;

import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.openslx.bwlp.thrift.iface.OperatingSystem;
import org.openslx.bwlp.thrift.iface.Virtualizer;

/**
 * Describes a configured virtual machine. This class is parsed from a machine description, like a
 * *.vmx for VMware machines.
 */
public abstract class VmMetaData
{
	private static final Logger LOGGER = Logger.getLogger( VmMetaData.class );
	/*
	 * Helper types
	 */

	public static enum TypeOf {
		VMX,
		VBOX;
	}
	
	public static TypeOf typeOf = null;
	public static enum DriveBusType
	{
		SCSI,
		IDE,
		SATA;
	}

	public static class HardDisk
	{
		public final String chipsetDriver;
		public final DriveBusType bus;
		public final String diskImage;

		public HardDisk( String chipsetDriver, DriveBusType bus, String diskImage )
		{
			this.chipsetDriver = chipsetDriver;
			this.bus = bus;
			this.diskImage = diskImage;
		}
	}

	/*
	 * Members
	 */

	protected final List<HardDisk> hdds = new ArrayList<>();

	private final List<OperatingSystem> osList;

	private OperatingSystem os = null;

	protected String displayName = null;
	/*
	 * Guettas
	 */

	/**
	 * Get operating system of this VM.
	 */
	public OperatingSystem getOs()
	{
		return os;
	}

	/**
	 * Get all hard disks of this VM.
	 */
	public List<HardDisk> getHdds()
	{
		return Collections.unmodifiableList( hdds );
	}

	/**
	 * Get display name of VM.
	 */
	public String getDisplayName()
	{
		return displayName;
	}

	/**
	 * This method should return a minimal representation of the input meta data. The representation
	 * is platform dependent, and should be stripped of all non-essential configuration, such as
	 * CD/DVD/FLoppy drives, serial or parallel ports, shared folders, or anything else that could be
	 * considered sensible information (absolute paths containing the local user's name).
	 */
	public abstract byte[] getFilteredDefinitionArray();

	public final ByteBuffer getFilteredDefinition()
	{
		return ByteBuffer.wrap( getFilteredDefinitionArray() );
	}

	/*
	 * Methods
	 */

	public VmMetaData( List<OperatingSystem> osList )
	{
		this.osList = osList;
	}

	/**
	 * Called from subclass to set the OS. If the OS cannot be determined from the given parameters,
	 * it will not be set.
	 * 
	 * @param virtId virtualizer, eg "vmware" for VMware
	 * @param virtOsId the os identifier used by the virtualizer, eg. windows7-64 for 64bit Windows 7
	 *           on VMware
	 */
	protected final void setOs( String virtId, String virtOsId )
	{
		OperatingSystem lazyMatch = null;
		boolean x = false;
		for ( OperatingSystem os : osList ) {
			if ( os.getVirtualizerOsId() == null )
				continue;
			for ( Entry<String, String> entry : os.getVirtualizerOsId().entrySet() ) {
				if ( !entry.getValue().equals( virtOsId ) )
					continue;
				if ( entry.getKey().equals( virtId ) ) {
					this.os = os;
					x = true;
					return;
				} else {
					lazyMatch = os;
				}
			}
		}
		
		/*if(!x) {
			//LOGGER.debug( "os with " + virtId + " " + virtOsId + " is not in list");
		}*/
		this.os = lazyMatch;
	}
	
	public abstract void reWrite();
	public abstract Virtualizer getVirtualizer();
	
	public abstract void enableUsb(boolean enabled);
	
	/**
	 * Apply config options that are desired when locally editing a VM.
	 * for vmware, this disables automatic DPI scaling of the guest.
	 */
	public abstract void applySettingsForLocalEdit();
	
	// meta object needed when reading vm from file
	public static VmMetaData getInstance(List<OperatingSystem> osList, File file) throws IOException {

		VmMetaData meta = null;
		try {
			meta = new VmwareMetaData(osList, file);
		} catch ( UnsupportedVirtualizerFormatException e ) {
			LOGGER.debug( "datei war nicht .vmx; versuche mit VBox");
			try {
				meta = new VboxMetaData(osList, file);
			}
			catch (UnsupportedVirtualizerFormatException ex) {
				LOGGER.debug( "datei war nicht .vbox; unterbrochen!" , ex);
				// TODO ok so or throw new IOException?
			}
		}
		if (meta != null) {
			return meta;
		}
		return null;
	}
	
	// meta object needed when reading from configarray
	public static VmMetaData getInstance(List<OperatingSystem> osList, byte[] vmContent, int length) throws IOException {
		
		VmMetaData meta = null;
		try {
			meta = new VmwareMetaData( osList, vmContent, length );
		} catch (UnsupportedVirtualizerFormatException e) {
			LOGGER.debug( "machine Description entspricht nicht vmx format; versuche mit VBox" );
			try {
				meta = new VboxMetaData( osList, vmContent, length );
			} catch (UnsupportedVirtualizerFormatException ex) {
				LOGGER.debug( "machine Description entspricht nicht vbox format ); unterbrochen!", ex);
			}
			if (meta != null) {
				return meta;
			}
			return null;
		}
		
		return null;
	}

	public abstract boolean addHddTemplate( String diskImagePath, String hddMode, String redoDir );

	public abstract boolean addDefaultNat();

	public abstract void setOs( String vendorOsId );

	public abstract boolean addDisplayName( String name );

	public abstract boolean addRam( int mem );

	public abstract void addFloppy( int index, String image, boolean readOnly );

	public abstract boolean addCdrom( String image );
	
	public abstract void setTypeOf ( );
	
	public TypeOf getTypeOf () {
		return typeOf;
	}
}