Rename VmMetaData classes

13 files changed, 352 insertions, 350 deletions

diff --git a/src/main/java/org/openslx/util/ThriftUtil.java b/src/main/java/org/openslx/util/ThriftUtil.java
index 2cfc770..a9035c1 100644
--- a/src/main/java/org/openslx/util/ThriftUtil.java
+++ b/src/main/java/org/openslx/util/ThriftUtil.java
@@ -7,7 +7,7 @@ import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.List;
 
-import org.openslx.virtualization.configuration.machine.VmwareConfig;
+import org.openslx.virtualization.configuration.VirtualizationConfigurationVmwareFileFormat;
 
 public class ThriftUtil {
 
@@ -41,7 +41,7 @@ public class ThriftUtil {
 		BufferedReader reader;
 		StringBuffer content = new StringBuffer("");
 		try {
-			reader = VmwareConfig.getVmxReader(bytes, bytes.length);
+			reader = VirtualizationConfigurationVmwareFileFormat.getVmxReader(bytes, bytes.length);
 			String line="";
 			while ((line=reader.readLine()) != null) {
 				content.append(line + "\n");
diff --git a/src/main/java/org/openslx/virtualization/configuration/VmMetaData.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfiguration.java
index ae94fe0..4f00b92 100644
--- a/src/main/java/org/openslx/virtualization/configuration/VmMetaData.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfiguration.java
@@ -13,19 +13,15 @@ import java.util.Map.Entry;
 import org.apache.log4j.Logger;
 import org.openslx.bwlp.thrift.iface.OperatingSystem;
 import org.openslx.bwlp.thrift.iface.Virtualizer;
-import org.openslx.virtualization.configuration.container.DockerMetaDataDummy;
-import org.openslx.virtualization.configuration.machine.QemuMetaData;
-import org.openslx.virtualization.configuration.machine.VboxMetaData;
-import org.openslx.virtualization.configuration.machine.VmwareMetaData;
 import org.openslx.vm.disk.DiskImage;
 
 /**
  * Describes a configured virtual machine. This class is parsed from a machine
  * description, like a *.vmx for VMware machines.
  */
-public abstract class VmMetaData<T, U, V, W, X>
+public abstract class VirtualizationConfiguration<T, U, V, W, X>
 {
-	private static final Logger LOGGER = Logger.getLogger( VmMetaData.class );
+	private static final Logger LOGGER = Logger.getLogger( VirtualizationConfiguration.class );
 
 	/*
 	 * Helper types
@@ -253,7 +249,7 @@ public abstract class VmMetaData<T, U, V, W, X>
 	 * Methods
 	 */
 
-	public VmMetaData( List<OperatingSystem> osList )
+	public VirtualizationConfiguration( List<OperatingSystem> osList )
 	{
 		this.osList = osList;
 
@@ -311,26 +307,26 @@ public abstract class VmMetaData<T, U, V, W, X>
 	 * @param file VM's machine description file to get the metadata instance from
 	 * @return VmMetaData object representing the relevant parts of the given machine description
 	 */
-	public static VmMetaData<?, ?, ?, ?, ?> getInstance( List<OperatingSystem> osList, File file )
+	public static VirtualizationConfiguration<?, ?, ?, ?, ?> getInstance( List<OperatingSystem> osList, File file )
 			throws IOException
 	{
 		try {
-			return new VmwareMetaData( osList, file );
-		} catch ( UnsupportedVirtualizerFormatException e ) {
+			return new VirtualizationConfigurationVmware( osList, file );
+		} catch ( VirtualizationConfigurationException e ) {
 			LOGGER.info( "Not a VMware file", e );
 		}
 		try {
-			return new VboxMetaData( osList, file );
-		} catch ( UnsupportedVirtualizerFormatException e ) {
+			return new VirtualizationConfigurationVirtualBox( osList, file );
+		} catch ( VirtualizationConfigurationException e ) {
 			LOGGER.info( "Not a VirtualBox file", e );
 		}
 		try {
-			return new QemuMetaData( osList, file );
-		} catch ( UnsupportedVirtualizerFormatException e ) {
+			return new VirtualizationConfigurationQemu( osList, file );
+		} catch ( VirtualizationConfigurationException e ) {
 			LOGGER.info( "Not a Libvirt file", e );
 		}
 		try {
-			return new DockerMetaDataDummy(osList, file);
+			return new VirtualizationConfigurationDocker(osList, file);
 		} catch ( Exception e ) {
 			LOGGER.info( "Not a tar.gz file, for docker container", e );
 		}
@@ -348,27 +344,27 @@ public abstract class VmMetaData<T, U, V, W, X>
 	 * @return VmMetaData object representing the relevant parts of the given machine description
 	 * @throws IOException
 	 */
-	public static VmMetaData<?, ?, ?, ?, ?> getInstance( List<OperatingSystem> osList, byte[] vmContent, int length )
+	public static VirtualizationConfiguration<?, ?, ?, ?, ?> getInstance( List<OperatingSystem> osList, byte[] vmContent, int length )
 			throws IOException
 	{
 		try {
-			return new VmwareMetaData( osList, vmContent, length );
-		} catch ( UnsupportedVirtualizerFormatException e ) {
+			return new VirtualizationConfigurationVmware( osList, vmContent, length );
+		} catch ( VirtualizationConfigurationException e ) {
 			LOGGER.info( "Not a VMware file", e );
 		}
 		try {
-			return new VboxMetaData( osList, vmContent, length );
-		} catch ( UnsupportedVirtualizerFormatException e ) {
+			return new VirtualizationConfigurationVirtualBox( osList, vmContent, length );
+		} catch ( VirtualizationConfigurationException e ) {
 			LOGGER.info( "Not a VirtualBox file", e );
 		}
 		try {
-			return new QemuMetaData( osList, vmContent, length );
-		} catch ( UnsupportedVirtualizerFormatException e ) {
+			return new VirtualizationConfigurationQemu( osList, vmContent, length );
+		} catch ( VirtualizationConfigurationException e ) {
 			LOGGER.info( "Not a Libvirt file", e );
 		}
 		try {
-			return new DockerMetaDataDummy( osList, vmContent, length );
-		} catch ( UnsupportedVirtualizerFormatException e ) {
+			return new VirtualizationConfigurationDocker( osList, vmContent, length );
+		} catch ( VirtualizationConfigurationException e ) {
 			LOGGER.info( "Not a tar.gz file, for docker container", e );
 		}
 
diff --git a/src/main/java/org/openslx/virtualization/configuration/container/DockerMetaDataDummy.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationDocker.java
index 321953e..b6f237b 100644
--- a/src/main/java/org/openslx/virtualization/configuration/container/DockerMetaDataDummy.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationDocker.java
@@ -1,11 +1,9 @@
-package org.openslx.virtualization.configuration.container;
+package org.openslx.virtualization.configuration;
 
 import org.apache.log4j.Logger;
 import org.openslx.bwlp.thrift.iface.OperatingSystem;
 import org.openslx.bwlp.thrift.iface.Virtualizer;
 import org.openslx.thrifthelper.TConst;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
-import org.openslx.virtualization.configuration.VmMetaData;
 import org.openslx.vm.disk.DiskImage;
 import org.openslx.vm.disk.DiskImage.ImageFormat;
 
@@ -37,7 +35,7 @@ class DockerUsbSpeedMeta
 {
 }
 
-public class DockerMetaDataDummy extends VmMetaData<DockerSoundCardMeta, DockerDDAccelMeta, DockerHWVersionMeta, DockerEthernetDevTypeMeta, DockerUsbSpeedMeta> {
+public class VirtualizationConfigurationDocker extends VirtualizationConfiguration<DockerSoundCardMeta, DockerDDAccelMeta, DockerHWVersionMeta, DockerEthernetDevTypeMeta, DockerUsbSpeedMeta> {
 
 	/**
 	 * List of supported image formats by the Docker hypervisor.
@@ -45,7 +43,7 @@ public class DockerMetaDataDummy extends VmMetaData<DockerSoundCardMeta, DockerD
 	private static final List<DiskImage.ImageFormat> SUPPORTED_IMAGE_FORMATS = Collections.unmodifiableList(
 			Arrays.asList( ImageFormat.NONE ) );
 	
-	private static final Logger LOGGER = Logger.getLogger( DockerMetaDataDummy.class);
+	private static final Logger LOGGER = Logger.getLogger( VirtualizationConfigurationDocker.class);
 
 	private final Virtualizer virtualizer = new Virtualizer(TConst.VIRT_DOCKER, "Docker");
 
@@ -61,7 +59,7 @@ public class DockerMetaDataDummy extends VmMetaData<DockerSoundCardMeta, DockerD
 	 */
 	private byte[] containerDefinition;
 
-	public DockerMetaDataDummy(List<OperatingSystem> osList, File file) throws UnsupportedVirtualizerFormatException {
+	public VirtualizationConfigurationDocker(List<OperatingSystem> osList, File file) throws VirtualizationConfigurationException {
 		super(osList);
 
 		BufferedInputStream bis = null;
@@ -72,7 +70,7 @@ public class DockerMetaDataDummy extends VmMetaData<DockerSoundCardMeta, DockerD
 			bis.read(containerDefinition);
 
 			checkIsTarGz();
-		} catch (IOException | UnsupportedVirtualizerFormatException e) {
+		} catch (IOException | VirtualizationConfigurationException e) {
 			LOGGER.error("Couldn't read dockerfile", e);
 		} finally {
 			try {
@@ -83,8 +81,8 @@ public class DockerMetaDataDummy extends VmMetaData<DockerSoundCardMeta, DockerD
 		}
 	}
 
-	public DockerMetaDataDummy(List<OperatingSystem> osList, byte[] vmContent, int length)
-			throws UnsupportedVirtualizerFormatException {
+	public VirtualizationConfigurationDocker(List<OperatingSystem> osList, byte[] vmContent, int length)
+			throws VirtualizationConfigurationException {
 		super(osList);
 
 		containerDefinition = vmContent;
@@ -99,12 +97,12 @@ public class DockerMetaDataDummy extends VmMetaData<DockerSoundCardMeta, DockerD
 	 * Checks if the first two bytes of the content identifies a tar.gz archive.
 	 * The first byte is 31 == 0x1f, the second byte has to be -117 == 0x8b.
 	 *
-	 * @throws UnsupportedVirtualizerFormatException
+	 * @throws VirtualizationConfigurationException
 	 */
-	private void checkIsTarGz() throws UnsupportedVirtualizerFormatException {
+	private void checkIsTarGz() throws VirtualizationConfigurationException {
 		if (!((31 == containerDefinition[0]) && (-117 == containerDefinition[1]))) {
 			LOGGER.warn("Not Supported Content.");
-			throw new UnsupportedVirtualizerFormatException(
+			throw new VirtualizationConfigurationException(
 					"DockerMetaDataDummy: Not tar.gz encoded content!");
 		}
 	}
@@ -116,7 +114,7 @@ public class DockerMetaDataDummy extends VmMetaData<DockerSoundCardMeta, DockerD
 	@Override
 	public List<DiskImage.ImageFormat> getSupportedImageFormats()
 	{
-		return DockerMetaDataDummy.SUPPORTED_IMAGE_FORMATS;
+		return VirtualizationConfigurationDocker.SUPPORTED_IMAGE_FORMATS;
 	}
 
 	@Override public void applySettingsForLocalEdit() {
diff --git a/src/main/java/org/openslx/virtualization/configuration/UnsupportedVirtualizerFormatException.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationException.java
index 3040669..2d401b1 100644
--- a/src/main/java/org/openslx/virtualization/configuration/UnsupportedVirtualizerFormatException.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationException.java
@@ -1,13 +1,13 @@
 package org.openslx.virtualization.configuration;
 
-public class UnsupportedVirtualizerFormatException extends Exception
+public class VirtualizationConfigurationException extends Exception
 {
 	/**
 	 * Version for serialization.
 	 */
 	private static final long serialVersionUID = 5794121065945636839L;
 
-	public UnsupportedVirtualizerFormatException(String message) {
+	public VirtualizationConfigurationException(String message) {
 		super(message);
 	}
 }
\ No newline at end of file
diff --git a/src/main/java/org/openslx/virtualization/configuration/machine/QemuMetaData.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemu.java
index 5dd86be..91bb9ae 100644
--- a/src/main/java/org/openslx/virtualization/configuration/machine/QemuMetaData.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemu.java
@@ -1,4 +1,4 @@
-package org.openslx.virtualization.configuration.machine;
+package org.openslx.virtualization.configuration;
 
 import java.io.File;
 import java.math.BigInteger;
@@ -27,8 +27,6 @@ import org.openslx.libvirt.xml.LibvirtXmlDocumentException;
 import org.openslx.libvirt.xml.LibvirtXmlSerializationException;
 import org.openslx.libvirt.xml.LibvirtXmlValidationException;
 import org.openslx.thrifthelper.TConst;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
-import org.openslx.virtualization.configuration.VmMetaData;
 import org.openslx.vm.disk.DiskImage;
 import org.openslx.vm.disk.DiskImage.ImageFormat;
 
@@ -225,8 +223,8 @@ class QemuUsbSpeedMeta
  * @author Manuel Bentele
  * @version 1.0
  */
-public class QemuMetaData extends
-		VmMetaData<QemuSoundCardMeta, QemuDDAccelMeta, QemuHWVersionMeta, QemuEthernetDevTypeMeta, QemuUsbSpeedMeta>
+public class VirtualizationConfigurationQemu extends
+		VirtualizationConfiguration<QemuSoundCardMeta, QemuDDAccelMeta, QemuHWVersionMeta, QemuEthernetDevTypeMeta, QemuUsbSpeedMeta>
 {
 	/**
 	 * Name of the network bridge for the LAN.
@@ -285,9 +283,9 @@ public class QemuMetaData extends
 	 * @param osList list of operating systems.
 	 * @param file image file for the QEMU hypervisor.
 	 * 
-	 * @throws UnsupportedVirtualizerFormatException Libvirt XML configuration cannot be processed.
+	 * @throws VirtualizationConfigurationException Libvirt XML configuration cannot be processed.
 	 */
-	public QemuMetaData( List<OperatingSystem> osList, File file ) throws UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationQemu( List<OperatingSystem> osList, File file ) throws VirtualizationConfigurationException
 	{
 		super( osList );
 
@@ -295,7 +293,7 @@ public class QemuMetaData extends
 			// read and parse Libvirt domain XML configuration document
 			this.vmConfig = new Domain( file );
 		} catch ( LibvirtXmlDocumentException | LibvirtXmlSerializationException | LibvirtXmlValidationException e ) {
-			throw new UnsupportedVirtualizerFormatException( e.getLocalizedMessage() );
+			throw new VirtualizationConfigurationException( e.getLocalizedMessage() );
 		}
 
 		// parse VM config and initialize fields of QemuMetaData class
@@ -309,10 +307,10 @@ public class QemuMetaData extends
 	 * @param vmContent file content for the QEMU hypervisor.
 	 * @param length number of bytes of the file content.
 	 * 
-	 * @throws UnsupportedVirtualizerFormatException Libvirt XML configuration cannot be processed.
+	 * @throws VirtualizationConfigurationException Libvirt XML configuration cannot be processed.
 	 */
-	public QemuMetaData( List<OperatingSystem> osList, byte[] vmContent, int length )
-			throws UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationQemu( List<OperatingSystem> osList, byte[] vmContent, int length )
+			throws VirtualizationConfigurationException
 	{
 		super( osList );
 
@@ -320,7 +318,7 @@ public class QemuMetaData extends
 			// read and parse Libvirt domain XML configuration document
 			this.vmConfig = new Domain( new String( vmContent ) );
 		} catch ( LibvirtXmlDocumentException | LibvirtXmlSerializationException | LibvirtXmlValidationException e ) {
-			throw new UnsupportedVirtualizerFormatException( e.getLocalizedMessage() );
+			throw new VirtualizationConfigurationException( e.getLocalizedMessage() );
 		}
 
 		// parse VM config and initialize fields of QemuMetaData class
@@ -358,7 +356,7 @@ public class QemuMetaData extends
 	private void addHddMetaData( DiskStorage storageDiskDevice )
 	{
 		String hddChipsetModel = null;
-		DriveBusType hddChipsetBus = QemuMetaDataUtils.convertBusType( storageDiskDevice.getBusType() );
+		DriveBusType hddChipsetBus = VirtualizationConfigurationQemuUtils.convertBusType( storageDiskDevice.getBusType() );
 		String hddImagePath = storageDiskDevice.getStorageSource();
 
 		this.hdds.add( new HardDisk( hddChipsetModel, hddChipsetBus, hddImagePath ) );
@@ -381,7 +379,7 @@ public class QemuMetaData extends
 	@Override
 	public List<DiskImage.ImageFormat> getSupportedImageFormats()
 	{
-		return QemuMetaData.SUPPORTED_IMAGE_FORMATS;
+		return VirtualizationConfigurationQemu.SUPPORTED_IMAGE_FORMATS;
 	}
 
 	@Override
@@ -415,14 +413,14 @@ public class QemuMetaData extends
 	public boolean addHddTemplate( int index, String diskImagePath, String hddMode, String redoDir )
 	{
 		ArrayList<DiskStorage> storageDiskDevices = this.vmConfig.getDiskStorageDevices();
-		DiskStorage storageDiskDevice = QemuMetaDataUtils.getArrayIndex( storageDiskDevices, index );
+		DiskStorage storageDiskDevice = VirtualizationConfigurationQemuUtils.getArrayIndex( storageDiskDevices, index );
 
 		if ( storageDiskDevice == null ) {
 			// HDD does not exist, so create new storage (HDD) device
 			storageDiskDevice = this.vmConfig.addDiskStorageDevice();
 			storageDiskDevice.setReadOnly( false );
 			storageDiskDevice.setBusType( BusType.VIRTIO );
-			String targetDevName = QemuMetaDataUtils.createAlphabeticalDeviceName( "vd", index );
+			String targetDevName = VirtualizationConfigurationQemuUtils.createAlphabeticalDeviceName( "vd", index );
 			storageDiskDevice.setTargetDevice( targetDevName );
 			storageDiskDevice.setStorage( StorageType.FILE, diskImagePath );
 
@@ -476,13 +474,13 @@ public class QemuMetaData extends
 	public void addFloppy( int index, String image, boolean readOnly )
 	{
 		ArrayList<DiskFloppy> floppyDiskDevices = this.vmConfig.getDiskFloppyDevices();
-		DiskFloppy floppyDiskDevice = QemuMetaDataUtils.getArrayIndex( floppyDiskDevices, index );
+		DiskFloppy floppyDiskDevice = VirtualizationConfigurationQemuUtils.getArrayIndex( floppyDiskDevices, index );
 
 		if ( floppyDiskDevice == null ) {
 			// floppy device does not exist, so create new floppy device
 			floppyDiskDevice = this.vmConfig.addDiskFloppyDevice();
 			floppyDiskDevice.setBusType( BusType.FDC );
-			String targetDevName = QemuMetaDataUtils.createAlphabeticalDeviceName( "fd", index );
+			String targetDevName = VirtualizationConfigurationQemuUtils.createAlphabeticalDeviceName( "fd", index );
 			floppyDiskDevice.setTargetDevice( targetDevName );
 			floppyDiskDevice.setReadOnly( readOnly );
 			floppyDiskDevice.setStorage( StorageType.FILE, image );
@@ -509,13 +507,13 @@ public class QemuMetaData extends
 	public boolean addCdrom( int index, String image )
 	{
 		ArrayList<DiskCdrom> cdromDiskDevices = this.vmConfig.getDiskCdromDevices();
-		DiskCdrom cdromDiskDevice = QemuMetaDataUtils.getArrayIndex( cdromDiskDevices, index );
+		DiskCdrom cdromDiskDevice = VirtualizationConfigurationQemuUtils.getArrayIndex( cdromDiskDevices, index );
 
 		if ( cdromDiskDevice == null ) {
 			// CDROM device does not exist, so create new CDROM device
 			cdromDiskDevice = this.vmConfig.addDiskCdromDevice();
 			cdromDiskDevice.setBusType( BusType.SATA );
-			String targetDevName = QemuMetaDataUtils.createAlphabeticalDeviceName( "sd", index );
+			String targetDevName = VirtualizationConfigurationQemuUtils.createAlphabeticalDeviceName( "sd", index );
 			cdromDiskDevice.setTargetDevice( targetDevName );
 			cdromDiskDevice.setReadOnly( true );
 
@@ -579,7 +577,7 @@ public class QemuMetaData extends
 		} else {
 			// the VM configuration at least one sound card device, so return the type of the first one
 			Sound.Model soundDeviceModel = soundDevices.get( 0 ).getModel();
-			soundDeviceType = QemuMetaDataUtils.convertSoundDeviceModel( soundDeviceModel );
+			soundDeviceType = VirtualizationConfigurationQemuUtils.convertSoundDeviceModel( soundDeviceModel );
 		}
 
 		return soundDeviceType;
@@ -690,7 +688,7 @@ public class QemuMetaData extends
 	{
 		QemuEthernetDevTypeMeta networkDeviceConfig = this.networkCards.get( type );
 		ArrayList<Interface> networkDevices = this.vmConfig.getInterfaceDevices();
-		Interface networkDevice = QemuMetaDataUtils.getArrayIndex( networkDevices, cardIndex );
+		Interface networkDevice = VirtualizationConfigurationQemuUtils.getArrayIndex( networkDevices, cardIndex );
 		Interface.Model networkDeviceModel = networkDeviceConfig.getModel();
 
 		if ( networkDevice != null ) {
@@ -702,7 +700,7 @@ public class QemuMetaData extends
 	public EthernetDevType getEthernetDevType( int cardIndex )
 	{
 		ArrayList<Interface> networkDevices = this.vmConfig.getInterfaceDevices();
-		Interface networkDevice = QemuMetaDataUtils.getArrayIndex( networkDevices, cardIndex );
+		Interface networkDevice = VirtualizationConfigurationQemuUtils.getArrayIndex( networkDevices, cardIndex );
 		EthernetDevType networkDeviceType = EthernetDevType.NONE;
 
 		if ( networkDevice == null ) {
@@ -711,7 +709,7 @@ public class QemuMetaData extends
 		} else {
 			// get model of existing network interface device
 			Interface.Model networkDeviceModel = networkDevice.getModel();
-			networkDeviceType = QemuMetaDataUtils.convertNetworkDeviceModel( networkDeviceModel );
+			networkDeviceType = VirtualizationConfigurationQemuUtils.convertNetworkDeviceModel( networkDeviceModel );
 		}
 
 		return networkDeviceType;
@@ -740,7 +738,7 @@ public class QemuMetaData extends
 	public UsbSpeed getMaxUsbSpeed()
 	{
 		ArrayList<ControllerUsb> usbControllerDevices = this.vmConfig.getUsbControllerDevices();
-		UsbSpeed maxUsbSpeed = VmMetaData.UsbSpeed.NONE;
+		UsbSpeed maxUsbSpeed = VirtualizationConfiguration.UsbSpeed.NONE;
 		int maxUsbSpeedNumeric = 0;
 
 		for ( ControllerUsb usbControllerDevice : usbControllerDevices ) {
@@ -790,7 +788,7 @@ public class QemuMetaData extends
 	{
 		QemuEthernetDevTypeMeta defaultNetworkDeviceConfig = this.networkCards.get( EthernetDevType.AUTO );
 		ArrayList<Interface> interfaceDevices = this.vmConfig.getInterfaceDevices();
-		Interface interfaceDevice = QemuMetaDataUtils.getArrayIndex( interfaceDevices, index );
+		Interface interfaceDevice = VirtualizationConfigurationQemuUtils.getArrayIndex( interfaceDevices, index );
 
 		final Interface.Model defaultNetworkDeviceModel = defaultNetworkDeviceConfig.getModel();
 
@@ -801,19 +799,19 @@ public class QemuMetaData extends
 				// add network bridge interface device
 				interfaceDevice = this.vmConfig.addInterfaceBridgeDevice();
 				interfaceDevice.setModel( defaultNetworkDeviceModel );
-				interfaceDevice.setSource( QemuMetaData.NETWORK_BRIDGE_LAN_DEFAULT );
+				interfaceDevice.setSource( VirtualizationConfigurationQemu.NETWORK_BRIDGE_LAN_DEFAULT );
 				break;
 			case HOST_ONLY:
 				// add network interface device with link to the isolated host network
 				interfaceDevice = this.vmConfig.addInterfaceBridgeDevice();
 				interfaceDevice.setModel( defaultNetworkDeviceModel );
-				interfaceDevice.setSource( QemuMetaData.NETWORK_BRIDGE_HOST_ONLY_DEFAULT );
+				interfaceDevice.setSource( VirtualizationConfigurationQemu.NETWORK_BRIDGE_HOST_ONLY_DEFAULT );
 				break;
 			case NAT:
 				// add network interface device with link to the NAT network
 				interfaceDevice = this.vmConfig.addInterfaceBridgeDevice();
 				interfaceDevice.setModel( defaultNetworkDeviceModel );
-				interfaceDevice.setSource( QemuMetaData.NETWORK_BRIDGE_NAT_DEFAULT );
+				interfaceDevice.setSource( VirtualizationConfigurationQemu.NETWORK_BRIDGE_NAT_DEFAULT );
 				break;
 			}
 		} else {
@@ -821,15 +819,15 @@ public class QemuMetaData extends
 			switch ( type ) {
 			case BRIDGED:
 				interfaceDevice.setType( Interface.Type.BRIDGE );
-				interfaceDevice.setSource( QemuMetaData.NETWORK_BRIDGE_LAN_DEFAULT );
+				interfaceDevice.setSource( VirtualizationConfigurationQemu.NETWORK_BRIDGE_LAN_DEFAULT );
 				break;
 			case HOST_ONLY:
 				interfaceDevice.setType( Interface.Type.BRIDGE );
-				interfaceDevice.setSource( QemuMetaData.NETWORK_BRIDGE_HOST_ONLY_DEFAULT );
+				interfaceDevice.setSource( VirtualizationConfigurationQemu.NETWORK_BRIDGE_HOST_ONLY_DEFAULT );
 				break;
 			case NAT:
 				interfaceDevice.setType( Interface.Type.BRIDGE );
-				interfaceDevice.setSource( QemuMetaData.NETWORK_BRIDGE_NAT_DEFAULT );
+				interfaceDevice.setSource( VirtualizationConfigurationQemu.NETWORK_BRIDGE_NAT_DEFAULT );
 				break;
 			}
 		}
@@ -840,7 +838,7 @@ public class QemuMetaData extends
 	@Override
 	public Virtualizer getVirtualizer()
 	{
-		return QemuMetaData.VIRTUALIZER;
+		return VirtualizationConfigurationQemu.VIRTUALIZER;
 	}
 
 	@Override
@@ -854,30 +852,30 @@ public class QemuMetaData extends
 	public void registerVirtualHW()
 	{
 		// @formatter:off
-		soundCards.put( VmMetaData.SoundCardType.NONE,          new QemuSoundCardMeta( null ) );
-		soundCards.put( VmMetaData.SoundCardType.DEFAULT,       new QemuSoundCardMeta( Sound.Model.ICH9 ) );
-		soundCards.put( VmMetaData.SoundCardType.SOUND_BLASTER, new QemuSoundCardMeta( Sound.Model.SB16 ) );
-		soundCards.put( VmMetaData.SoundCardType.ES,            new QemuSoundCardMeta( Sound.Model.ES1370 ) );
-		soundCards.put( VmMetaData.SoundCardType.AC,            new QemuSoundCardMeta( Sound.Model.AC97 ) );
-		soundCards.put( VmMetaData.SoundCardType.HD_AUDIO,      new QemuSoundCardMeta( Sound.Model.ICH9 ) );
-
-		ddacc.put( VmMetaData.DDAcceleration.OFF, new QemuDDAccelMeta( false ) );
-		ddacc.put( VmMetaData.DDAcceleration.ON,  new QemuDDAccelMeta( true ) );
-
-		hwversion.put( VmMetaData.HWVersion.DEFAULT, new QemuHWVersionMeta( 0 ) );
-
-		networkCards.put( VmMetaData.EthernetDevType.NONE,      new QemuEthernetDevTypeMeta( null ) );
-		networkCards.put( VmMetaData.EthernetDevType.AUTO,      new QemuEthernetDevTypeMeta( Interface.Model.VIRTIO_NET_PCI ) );
-		networkCards.put( VmMetaData.EthernetDevType.PCNETPCI2, new QemuEthernetDevTypeMeta( Interface.Model.PCNET ) );
-		networkCards.put( VmMetaData.EthernetDevType.E1000,     new QemuEthernetDevTypeMeta( Interface.Model.E1000 ) );
-		networkCards.put( VmMetaData.EthernetDevType.E1000E,    new QemuEthernetDevTypeMeta( Interface.Model.E1000E ) );
-		networkCards.put( VmMetaData.EthernetDevType.VMXNET3,   new QemuEthernetDevTypeMeta( Interface.Model.VMXNET3 ) );
-		networkCards.put( VmMetaData.EthernetDevType.PARAVIRT,  new QemuEthernetDevTypeMeta( Interface.Model.VIRTIO_NET_PCI ) );
-
-		usbSpeeds.put( VmMetaData.UsbSpeed.NONE,   new QemuUsbSpeedMeta( 0, ControllerUsb.Model.NONE ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB1_1, new QemuUsbSpeedMeta( 1, ControllerUsb.Model.ICH9_UHCI1 ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB2_0, new QemuUsbSpeedMeta( 2, ControllerUsb.Model.ICH9_EHCI1 ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB3_0, new QemuUsbSpeedMeta( 3, ControllerUsb.Model.QEMU_XHCI ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.NONE,          new QemuSoundCardMeta( null ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.DEFAULT,       new QemuSoundCardMeta( Sound.Model.ICH9 ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.SOUND_BLASTER, new QemuSoundCardMeta( Sound.Model.SB16 ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.ES,            new QemuSoundCardMeta( Sound.Model.ES1370 ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.AC,            new QemuSoundCardMeta( Sound.Model.AC97 ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.HD_AUDIO,      new QemuSoundCardMeta( Sound.Model.ICH9 ) );
+
+		ddacc.put( VirtualizationConfiguration.DDAcceleration.OFF, new QemuDDAccelMeta( false ) );
+		ddacc.put( VirtualizationConfiguration.DDAcceleration.ON,  new QemuDDAccelMeta( true ) );
+
+		hwversion.put( VirtualizationConfiguration.HWVersion.DEFAULT, new QemuHWVersionMeta( 0 ) );
+
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.NONE,      new QemuEthernetDevTypeMeta( null ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.AUTO,      new QemuEthernetDevTypeMeta( Interface.Model.VIRTIO_NET_PCI ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PCNETPCI2, new QemuEthernetDevTypeMeta( Interface.Model.PCNET ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.E1000,     new QemuEthernetDevTypeMeta( Interface.Model.E1000 ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.E1000E,    new QemuEthernetDevTypeMeta( Interface.Model.E1000E ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.VMXNET3,   new QemuEthernetDevTypeMeta( Interface.Model.VMXNET3 ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PARAVIRT,  new QemuEthernetDevTypeMeta( Interface.Model.VIRTIO_NET_PCI ) );
+
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.NONE,   new QemuUsbSpeedMeta( 0, ControllerUsb.Model.NONE ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB1_1, new QemuUsbSpeedMeta( 1, ControllerUsb.Model.ICH9_UHCI1 ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB2_0, new QemuUsbSpeedMeta( 2, ControllerUsb.Model.ICH9_EHCI1 ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB3_0, new QemuUsbSpeedMeta( 3, ControllerUsb.Model.QEMU_XHCI ) );
 		// @formatter:on
 	}
 }
diff --git a/src/main/java/org/openslx/virtualization/configuration/machine/QemuMetaDataUtils.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuUtils.java
index 34510e5..a29005c 100644
--- a/src/main/java/org/openslx/virtualization/configuration/machine/QemuMetaDataUtils.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuUtils.java
@@ -1,13 +1,13 @@
-package org.openslx.virtualization.configuration.machine;
+package org.openslx.virtualization.configuration;
 
 import java.util.ArrayList;
 
 import org.openslx.libvirt.domain.device.Disk;
 import org.openslx.libvirt.domain.device.Interface;
 import org.openslx.libvirt.domain.device.Disk.BusType;
-import org.openslx.virtualization.configuration.VmMetaData.DriveBusType;
-import org.openslx.virtualization.configuration.VmMetaData.EthernetDevType;
-import org.openslx.virtualization.configuration.VmMetaData.SoundCardType;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.DriveBusType;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.EthernetDevType;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.SoundCardType;
 import org.openslx.libvirt.domain.device.Sound;
 
 /**
@@ -16,7 +16,7 @@ import org.openslx.libvirt.domain.device.Sound;
  * @author Manuel Bentele
  * @version 1.0
  */
-public class QemuMetaDataUtils
+public class VirtualizationConfigurationQemuUtils
 {
 	/**
 	 * Converts a Libvirt disk device bus type to a VM metadata driver bus type.
diff --git a/src/main/java/org/openslx/virtualization/configuration/machine/VboxMetaData.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBox.java
index 63e734d..39e78ea 100644
--- a/src/main/java/org/openslx/virtualization/configuration/machine/VboxMetaData.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualBox.java
@@ -1,4 +1,4 @@
-package org.openslx.virtualization.configuration.machine;
+package org.openslx.virtualization.configuration;
 
 import java.io.File;
 import java.io.IOException;
@@ -15,9 +15,7 @@ import org.apache.log4j.Logger;
 import org.openslx.bwlp.thrift.iface.OperatingSystem;
 import org.openslx.bwlp.thrift.iface.Virtualizer;
 import org.openslx.thrifthelper.TConst;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
-import org.openslx.virtualization.configuration.VmMetaData;
-import org.openslx.virtualization.configuration.machine.VboxConfig.PlaceHolder;
+import org.openslx.virtualization.configuration.VirtualizationConfigurationVirtualboxFileFormat.PlaceHolder;
 import org.openslx.vm.disk.DiskImage;
 import org.openslx.vm.disk.DiskImage.ImageFormat;
 import org.w3c.dom.Attr;
@@ -80,7 +78,7 @@ class VBoxUsbSpeedMeta
 	}
 }
 
-public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta, VBoxHWVersionMeta, VBoxEthernetDevTypeMeta, VBoxUsbSpeedMeta>
+public class VirtualizationConfigurationVirtualBox extends VirtualizationConfiguration<VBoxSoundCardMeta, VBoxDDAccelMeta, VBoxHWVersionMeta, VBoxEthernetDevTypeMeta, VBoxUsbSpeedMeta>
 {
 	/**
 	 * List of supported image formats by the VirtualBox hypervisor.
@@ -88,11 +86,11 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	private static final List<DiskImage.ImageFormat> SUPPORTED_IMAGE_FORMATS = Collections.unmodifiableList(
 			Arrays.asList( ImageFormat.VDI ) );
 	
-	private static final Logger LOGGER = Logger.getLogger( VboxMetaData.class );
+	private static final Logger LOGGER = Logger.getLogger( VirtualizationConfigurationVirtualBox.class );
 
 	private static final Virtualizer virtualizer = new Virtualizer( TConst.VIRT_VIRTUALBOX, "VirtualBox" );
 
-	private final VboxConfig config;
+	private final VirtualizationConfigurationVirtualboxFileFormat config;
 
 	public static enum EthernetType
 	{
@@ -106,17 +104,17 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 		}
 	}
 
-	public VboxMetaData( List<OperatingSystem> osList, File file ) throws IOException, UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVirtualBox( List<OperatingSystem> osList, File file ) throws IOException, VirtualizationConfigurationException
 	{
 		super( osList );
-		this.config = new VboxConfig( file );
+		this.config = new VirtualizationConfigurationVirtualboxFileFormat( file );
 		init();
 	}
 
-	public VboxMetaData( List<OperatingSystem> osList, byte[] vmContent, int length ) throws IOException, UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVirtualBox( List<OperatingSystem> osList, byte[] vmContent, int length ) throws IOException, VirtualizationConfigurationException
 	{
 		super( osList );
-		this.config = new VboxConfig( vmContent, length );
+		this.config = new VirtualizationConfigurationVirtualboxFileFormat( vmContent, length );
 		init();
 	}
 
@@ -139,7 +137,7 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	@Override
 	public List<DiskImage.ImageFormat> getSupportedImageFormats()
 	{
-		return VboxMetaData.SUPPORTED_IMAGE_FORMATS;
+		return VirtualizationConfigurationVirtualBox.SUPPORTED_IMAGE_FORMATS;
 	}
 
 	@Override
@@ -288,7 +286,7 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 				LOGGER.error( "Failed to add <Image> to floppy device." );
 				return;
 			}
-			floppyImage.setAttribute( "uuid", VboxConfig.PlaceHolder.FLOPPYUUID.toString() );
+			floppyImage.setAttribute( "uuid", VirtualizationConfigurationVirtualboxFileFormat.PlaceHolder.FLOPPYUUID.toString() );
 			// register the image in the media registry
 			Element floppyImages = (Element)config.addNewNode( "/VirtualBox/Machine/MediaRegistry", "FloppyImages" );
 			if ( floppyImages == null ) {
@@ -300,8 +298,8 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 				LOGGER.error( "Failed to add <Image> to floppy images in the media registry." );
 				return;
 			}
-			floppyImageReg.setAttribute( "uuid", VboxConfig.PlaceHolder.FLOPPYUUID.toString() );
-			floppyImageReg.setAttribute( "location", VboxConfig.PlaceHolder.FLOPPYLOCATION.toString() );
+			floppyImageReg.setAttribute( "uuid", VirtualizationConfigurationVirtualboxFileFormat.PlaceHolder.FLOPPYUUID.toString() );
+			floppyImageReg.setAttribute( "location", VirtualizationConfigurationVirtualboxFileFormat.PlaceHolder.FLOPPYLOCATION.toString() );
 		}
 	}
 
@@ -319,7 +317,7 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	}
 
 	@Override
-	public void setSoundCard( org.openslx.virtualization.configuration.VmMetaData.SoundCardType type )
+	public void setSoundCard( org.openslx.virtualization.configuration.VirtualizationConfiguration.SoundCardType type )
 	{
 		VBoxSoundCardMeta sound = soundCards.get( type );
 		config.changeAttribute( "/VirtualBox/Machine/Hardware/AudioAdapter", "enabled", Boolean.toString( sound.isPresent ) );
@@ -327,21 +325,21 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	}
 
 	@Override
-	public VmMetaData.SoundCardType getSoundCard()
+	public VirtualizationConfiguration.SoundCardType getSoundCard()
 	{
 		// initialize here to type None to avoid all null pointer exceptions thrown for unknown user written sound cards
-		VmMetaData.SoundCardType returnsct = VmMetaData.SoundCardType.NONE;
+		VirtualizationConfiguration.SoundCardType returnsct = VirtualizationConfiguration.SoundCardType.NONE;
 		Element x = (Element)config.findNodes( "/VirtualBox/Machine/Hardware/AudioAdapter" ).item( 0 );
 		if ( !x.hasAttribute( "enabled" ) || ( x.hasAttribute( "enabled" ) && x.getAttribute( "enabled" ).equals( "false" ) ) ) {
 			return returnsct;
 		} else {
 			// extra separate case for the non-existing argument}
 			if ( !x.hasAttribute( "controller" ) ) {
-				returnsct = VmMetaData.SoundCardType.AC;
+				returnsct = VirtualizationConfiguration.SoundCardType.AC;
 			} else {
 				String controller = x.getAttribute( "controller" );
 				VBoxSoundCardMeta soundMeta = null;
-				for ( VmMetaData.SoundCardType type : VmMetaData.SoundCardType.values() ) {
+				for ( VirtualizationConfiguration.SoundCardType type : VirtualizationConfiguration.SoundCardType.values() ) {
 					soundMeta = soundCards.get( type );
 					if ( soundMeta != null ) {
 						if ( controller.equals( soundMeta.value ) ) {
@@ -355,25 +353,25 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	}
 
 	@Override
-	public void setDDAcceleration( VmMetaData.DDAcceleration type )
+	public void setDDAcceleration( VirtualizationConfiguration.DDAcceleration type )
 	{
 		VBoxDDAccelMeta accel = ddacc.get( type );
 		config.changeAttribute( "/VirtualBox/Machine/Hardware/Display", "accelerate3D", Boolean.toString( accel.isPresent ) );
 	}
 
 	@Override
-	public VmMetaData.DDAcceleration getDDAcceleration()
+	public VirtualizationConfiguration.DDAcceleration getDDAcceleration()
 	{
-		VmMetaData.DDAcceleration returndda = null;
+		VirtualizationConfiguration.DDAcceleration returndda = null;
 		Element x = (Element)config.findNodes( "/VirtualBox/Machine/Hardware/Display" ).item( 0 );
 		if ( x.hasAttribute( "accelerate3D" ) ) {
 			if ( x.getAttribute( "accelerate3D" ).equals( "true" ) ) {
-				returndda = VmMetaData.DDAcceleration.ON;
+				returndda = VirtualizationConfiguration.DDAcceleration.ON;
 			} else {
-				returndda = VmMetaData.DDAcceleration.OFF;
+				returndda = VirtualizationConfiguration.DDAcceleration.OFF;
 			}
 		} else {
-			returndda = VmMetaData.DDAcceleration.OFF;
+			returndda = VirtualizationConfiguration.DDAcceleration.OFF;
 		}
 		return returndda;
 	}
@@ -388,10 +386,10 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	}
 
 	@Override
-	public VmMetaData.HWVersion getHWVersion()
+	public VirtualizationConfiguration.HWVersion getHWVersion()
 	{
 		// Virtual Box uses only one virtual hardware version and can't be changed
-		return VmMetaData.HWVersion.DEFAULT;
+		return VirtualizationConfiguration.HWVersion.DEFAULT;
 	}
 
 	@Override
@@ -405,20 +403,20 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	}
 
 	@Override
-	public VmMetaData.EthernetDevType getEthernetDevType( int cardIndex )
+	public VirtualizationConfiguration.EthernetDevType getEthernetDevType( int cardIndex )
 	{
-		VmMetaData.EthernetDevType returnedt = VmMetaData.EthernetDevType.NONE;
+		VirtualizationConfiguration.EthernetDevType returnedt = VirtualizationConfiguration.EthernetDevType.NONE;
 		Element x = (Element)config.findNodes( "/VirtualBox/Machine/Hardware/Network/Adapter" ).item( 0 );
 		if ( !x.hasAttribute( "enabled" ) || ( x.hasAttribute( "enabled" ) && x.getAttribute( "enabled" ).equals( "false" ) ) ) {
 			return returnedt;
 		} else {
 			// extra separate case for the non-existing argument}
 			if ( !x.hasAttribute( "type" ) ) {
-				returnedt = VmMetaData.EthernetDevType.PCNETFAST3;
+				returnedt = VirtualizationConfiguration.EthernetDevType.PCNETFAST3;
 			} else {
 				String temp = x.getAttribute( "type" );
 				VBoxEthernetDevTypeMeta etherMeta = null;
-				for ( VmMetaData.EthernetDevType type : VmMetaData.EthernetDevType.values() ) {
+				for ( VirtualizationConfiguration.EthernetDevType type : VirtualizationConfiguration.EthernetDevType.values() ) {
 					etherMeta = networkCards.get( type );
 					if ( etherMeta != null ) {
 						if ( temp.equals( etherMeta.value ) ) {
@@ -435,33 +433,33 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	{
 		// none type needs to have a valid value; it takes the value of AC97; if value is left null or empty vm will not start because value is not valid
 		// TODO: Maybe just remove the entire section from the XML? Same for ethernet...
-		soundCards.put( VmMetaData.SoundCardType.NONE, new VBoxSoundCardMeta( false, "AC97" ) );
-		soundCards.put( VmMetaData.SoundCardType.SOUND_BLASTER, new VBoxSoundCardMeta( true, "SB16" ) );
-		soundCards.put( VmMetaData.SoundCardType.HD_AUDIO, new VBoxSoundCardMeta( true, "HDA" ) );
-		soundCards.put( VmMetaData.SoundCardType.AC, new VBoxSoundCardMeta( true, "AC97" ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.NONE, new VBoxSoundCardMeta( false, "AC97" ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.SOUND_BLASTER, new VBoxSoundCardMeta( true, "SB16" ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.HD_AUDIO, new VBoxSoundCardMeta( true, "HDA" ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.AC, new VBoxSoundCardMeta( true, "AC97" ) );
 
-		ddacc.put( VmMetaData.DDAcceleration.OFF, new VBoxDDAccelMeta( false ) );
-		ddacc.put( VmMetaData.DDAcceleration.ON, new VBoxDDAccelMeta( true ) );
+		ddacc.put( VirtualizationConfiguration.DDAcceleration.OFF, new VBoxDDAccelMeta( false ) );
+		ddacc.put( VirtualizationConfiguration.DDAcceleration.ON, new VBoxDDAccelMeta( true ) );
 
-		hwversion.put( VmMetaData.HWVersion.DEFAULT, new VBoxHWVersionMeta( 0 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.DEFAULT, new VBoxHWVersionMeta( 0 ) );
 
 		// none type needs to have a valid value; it takes the value of pcnetcpi2; if value is left null or empty vm will not start because value is not valid
-		networkCards.put( VmMetaData.EthernetDevType.NONE, new VBoxEthernetDevTypeMeta( false, "Am79C970A" ) );
-		networkCards.put( VmMetaData.EthernetDevType.PCNETPCI2, new VBoxEthernetDevTypeMeta( true, "Am79C970A" ) );
-		networkCards.put( VmMetaData.EthernetDevType.PCNETFAST3, new VBoxEthernetDevTypeMeta( true, "Am79C973" ) );
-		networkCards.put( VmMetaData.EthernetDevType.PRO1000MTD, new VBoxEthernetDevTypeMeta( true, "82540EM" ) );
-		networkCards.put( VmMetaData.EthernetDevType.PRO1000TS, new VBoxEthernetDevTypeMeta( true, "82543GC" ) );
-		networkCards.put( VmMetaData.EthernetDevType.PRO1000MTS, new VBoxEthernetDevTypeMeta( true, "82545EM" ) );
-		networkCards.put( VmMetaData.EthernetDevType.PARAVIRT, new VBoxEthernetDevTypeMeta( true, "virtio" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.NONE, new VBoxEthernetDevTypeMeta( false, "Am79C970A" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PCNETPCI2, new VBoxEthernetDevTypeMeta( true, "Am79C970A" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PCNETFAST3, new VBoxEthernetDevTypeMeta( true, "Am79C973" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PRO1000MTD, new VBoxEthernetDevTypeMeta( true, "82540EM" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PRO1000TS, new VBoxEthernetDevTypeMeta( true, "82543GC" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PRO1000MTS, new VBoxEthernetDevTypeMeta( true, "82545EM" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PARAVIRT, new VBoxEthernetDevTypeMeta( true, "virtio" ) );
 		
-		usbSpeeds.put( VmMetaData.UsbSpeed.NONE, new VBoxUsbSpeedMeta( null, 0 ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB1_1, new VBoxUsbSpeedMeta( "OHCI", 1 ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB2_0, new VBoxUsbSpeedMeta( "EHCI", 2 ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB3_0, new VBoxUsbSpeedMeta( "XHCI", 3 ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.NONE, new VBoxUsbSpeedMeta( null, 0 ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB1_1, new VBoxUsbSpeedMeta( "OHCI", 1 ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB2_0, new VBoxUsbSpeedMeta( "EHCI", 2 ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB3_0, new VBoxUsbSpeedMeta( "XHCI", 3 ) );
 	}
 
 	@Override
-	public boolean addEthernet( VmMetaData.EtherType type )
+	public boolean addEthernet( VirtualizationConfiguration.EtherType type )
 	{
 		Node hostOnlyInterfaceNode = config.addNewNode( "/VirtualBox/Machine/Hardware/Network/Adapter[@slot='0']", "HostOnlyInterface" );
 		if ( hostOnlyInterfaceNode == null ) {
@@ -490,11 +488,11 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	}
 
 	@Override
-	public void setMaxUsbSpeed( VmMetaData.UsbSpeed speed )
+	public void setMaxUsbSpeed( VirtualizationConfiguration.UsbSpeed speed )
 	{
 		// Wipe existing ones
 		config.removeNodes( "/VirtualBox/Machine/Hardware", "USB" );
-		if ( speed == null || speed == VmMetaData.UsbSpeed.NONE ) {
+		if ( speed == null || speed == VirtualizationConfiguration.UsbSpeed.NONE ) {
 			// Add marker so we know it's not an old config and we really want no USB
 			Element node = config.createNodeRecursive( "/VirtualBox/OpenSLX/USB" );
 			if ( node != null ) {
@@ -514,18 +512,18 @@ public class VboxMetaData extends VmMetaData<VBoxSoundCardMeta, VBoxDDAccelMeta,
 	}
 
 	@Override
-	public VmMetaData.UsbSpeed getMaxUsbSpeed()
+	public VirtualizationConfiguration.UsbSpeed getMaxUsbSpeed()
 	{
 		NodeList nodes = config.findNodes( "/VirtualBox/Machine/Hardware/USB/Controllers/Controller/@type" );
 		int maxSpeed = 0;
-		VmMetaData.UsbSpeed maxItem = VmMetaData.UsbSpeed.NONE;
+		VirtualizationConfiguration.UsbSpeed maxItem = VirtualizationConfiguration.UsbSpeed.NONE;
 		for ( int i = 0; i < nodes.getLength(); ++i ) {
 			if ( nodes.item( i ).getNodeType() != Node.ATTRIBUTE_NODE ) {
 				LOGGER.info( "Not ATTRIBUTE type" );
 				continue;
 			}
 			String type = ((Attr)nodes.item( i )).getValue();
-			for ( Entry<VmMetaData.UsbSpeed, VBoxUsbSpeedMeta> s : usbSpeeds.entrySet() ) {
+			for ( Entry<VirtualizationConfiguration.UsbSpeed, VBoxUsbSpeedMeta> s : usbSpeeds.entrySet() ) {
 				if ( s.getValue().speed > maxSpeed && type.equals( s.getValue().value ) ) {
 					maxSpeed = s.getValue().speed;
 					maxItem = s.getKey();
diff --git a/src/main/java/org/openslx/virtualization/configuration/machine/VboxConfig.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualboxFileFormat.java
index 82b7384..6a1f5a5 100644
--- a/src/main/java/org/openslx/virtualization/configuration/machine/VboxConfig.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVirtualboxFileFormat.java
@@ -1,4 +1,4 @@
-package org.openslx.virtualization.configuration.machine;
+package org.openslx.virtualization.configuration;
 
 import java.io.ByteArrayInputStream;
 import java.io.File;
@@ -20,9 +20,8 @@ import javax.xml.xpath.XPathExpressionException;
 import org.apache.log4j.Logger;
 import org.openslx.util.Util;
 import org.openslx.util.XmlHelper;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
-import org.openslx.virtualization.configuration.VmMetaData.DriveBusType;
-import org.openslx.virtualization.configuration.VmMetaData.HardDisk;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.DriveBusType;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.HardDisk;
 import org.w3c.dom.DOMException;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
@@ -33,9 +32,9 @@ import org.xml.sax.SAXException;
 /**
  * Class handling the parsing of a .vbox machine description file
  */
-public class VboxConfig
+public class VirtualizationConfigurationVirtualboxFileFormat
 {
-	private static final Logger LOGGER = Logger.getLogger( VboxConfig.class );
+	private static final Logger LOGGER = Logger.getLogger( VirtualizationConfigurationVirtualboxFileFormat.class );
 
 	// key information set during initial parsing of the XML file
 	private String osName = new String();
@@ -84,15 +83,15 @@ public class VboxConfig
 	 * 
 	 * @param file the VirtualBox machine configuration file
 	 * @throws IOException if an error occurs while reading the file
-	 * @throws UnsupportedVirtualizerFormatException if the given file is not a valid VirtualBox
+	 * @throws VirtualizationConfigurationException if the given file is not a valid VirtualBox
 	 *            configuration file.
 	 */
-	public VboxConfig( File file ) throws IOException, UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVirtualboxFileFormat( File file ) throws IOException, VirtualizationConfigurationException
 	{
 		// first validate xml
 		try {
 			SchemaFactory factory = SchemaFactory.newInstance( XMLConstants.W3C_XML_SCHEMA_NS_URI );
-			InputStream xsdStream = VboxConfig.class.getResourceAsStream( "/master-sync-shared/xml/VirtualBox-settings.xsd" );
+			InputStream xsdStream = VirtualizationConfigurationVirtualboxFileFormat.class.getResourceAsStream( "/master-sync-shared/xml/VirtualBox-settings.xsd" );
 			if ( xsdStream == null ) {
 				LOGGER.warn( "Cannot validate Vbox XML: No XSD found in JAR" );
 			} else {
@@ -107,7 +106,7 @@ public class VboxConfig
 		doc = XmlHelper.parseDocumentFromStream( new FileInputStream( file ) );
 		doc = XmlHelper.removeFormattingNodes( doc );
 		if ( doc == null )
-			throw new UnsupportedVirtualizerFormatException( "Could not create DOM from given VirtualBox machine configuration file!" );
+			throw new VirtualizationConfigurationException( "Could not create DOM from given VirtualBox machine configuration file!" );
 		init();
 	}
 
@@ -119,25 +118,25 @@ public class VboxConfig
 	 * @param length of the machine description byte array.
 	 * @throws IOException if an
 	 */
-	public VboxConfig( byte[] machineDescription, int length ) throws UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVirtualboxFileFormat( byte[] machineDescription, int length ) throws VirtualizationConfigurationException
 	{
 		ByteArrayInputStream is = new ByteArrayInputStream( machineDescription );
 		doc = XmlHelper.parseDocumentFromStream( is );
 		if ( doc == null ) {
 			LOGGER.error( "Failed to create a DOM from given machine description." );
-			throw new UnsupportedVirtualizerFormatException( "Could not create DOM from given machine description as. byte array." );
+			throw new VirtualizationConfigurationException( "Could not create DOM from given machine description as. byte array." );
 		}
 		init();
 	}
 
 	/**
 	 * Main initialization functions parsing the document created during the constructor.
-	 * @throws UnsupportedVirtualizerFormatException 
+	 * @throws VirtualizationConfigurationException 
 	 */
-	private void init() throws UnsupportedVirtualizerFormatException
+	private void init() throws VirtualizationConfigurationException
 	{
 		if ( Util.isEmptyString( getDisplayName() ) ) {
-			throw new UnsupportedVirtualizerFormatException( "Machine doesn't have a name" );
+			throw new VirtualizationConfigurationException( "Machine doesn't have a name" );
 		}
 		try {
 			ensureHardwareUuid();
@@ -187,21 +186,21 @@ public class VboxConfig
 	 * believing in a hardware change.
 	 *
 	 * @throws XPathExpressionException
-	 * @throws UnsupportedVirtualizerFormatException 
+	 * @throws VirtualizationConfigurationException 
 	 */
-	private void ensureHardwareUuid() throws XPathExpressionException, UnsupportedVirtualizerFormatException
+	private void ensureHardwareUuid() throws XPathExpressionException, VirtualizationConfigurationException
 	{
 		// we will need the machine uuid, so get it
 		String machineUuid = XmlHelper.XPath.compile( "/VirtualBox/Machine/@uuid" ).evaluate( this.doc );
 		if ( machineUuid.isEmpty() ) {
 			LOGGER.error( "Machine UUID empty, should never happen!" );
-			throw new UnsupportedVirtualizerFormatException( "XML doesn't contain a machine uuid" );
+			throw new VirtualizationConfigurationException( "XML doesn't contain a machine uuid" );
 		}
 
 		NodeList hwNodes = findNodes( "/VirtualBox/Machine/Hardware" );
 		int count = hwNodes.getLength();
 		if ( count != 1 ) {
-			throw new UnsupportedVirtualizerFormatException( "Zero or more '/VirtualBox/Machine/Hardware' node were found, should never happen!" );
+			throw new VirtualizationConfigurationException( "Zero or more '/VirtualBox/Machine/Hardware' node were found, should never happen!" );
 		}
 		Element hw = (Element)hwNodes.item( 0 );
 		String hwUuid = hw.getAttribute( "uuid" );
diff --git a/src/main/java/org/openslx/virtualization/configuration/machine/VmwareMetaData.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVmware.java
index 114d4f7..5dfd5f9 100644
--- a/src/main/java/org/openslx/virtualization/configuration/machine/VmwareMetaData.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVmware.java
@@ -1,4 +1,4 @@
-package org.openslx.virtualization.configuration.machine;
+package org.openslx.virtualization.configuration;
 
 import java.io.File;
 import java.io.IOException;
@@ -17,9 +17,7 @@ import org.openslx.bwlp.thrift.iface.OperatingSystem;
 import org.openslx.bwlp.thrift.iface.Virtualizer;
 import org.openslx.thrifthelper.TConst;
 import org.openslx.util.Util;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
-import org.openslx.virtualization.configuration.VmMetaData;
-import org.openslx.virtualization.configuration.machine.VmwareConfig.ConfigEntry;
+import org.openslx.virtualization.configuration.VirtualizationConfigurationVmwareFileFormat.ConfigEntry;
 import org.openslx.vm.disk.DiskImage;
 import org.openslx.vm.disk.DiskImage.ImageFormat;
 
@@ -77,7 +75,7 @@ class VmwareUsbSpeed
 	}
 }
 
-public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAccelMeta, VmWareHWVersionMeta, VmWareEthernetDevTypeMeta, VmwareUsbSpeed>
+public class VirtualizationConfigurationVmware extends VirtualizationConfiguration<VmWareSoundCardMeta, VmWareDDAccelMeta, VmWareHWVersionMeta, VmWareEthernetDevTypeMeta, VmwareUsbSpeed>
 {
 	/**
 	 * List of supported image formats by the VMware hypervisor.
@@ -85,7 +83,7 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 	private static final List<DiskImage.ImageFormat> SUPPORTED_IMAGE_FORMATS = Collections.unmodifiableList(
 			Arrays.asList( ImageFormat.VMDK ) );
 	
-	private static final Logger LOGGER = Logger.getLogger( VmwareMetaData.class );
+	private static final Logger LOGGER = Logger.getLogger( VirtualizationConfigurationVmware.class );
 
 	private static final Virtualizer virtualizer = new Virtualizer( TConst.VIRT_VMWARE, "VMware" );
 
@@ -94,7 +92,7 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 	// Lowercase list of allowed settings for upload (as regex)
 	private static final Pattern[] whitelist;
 
-	private final VmwareConfig config;
+	private final VirtualizationConfigurationVmwareFileFormat config;
 
 	// Init static members
 	static {
@@ -122,17 +120,17 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 
 	private final Map<String, Controller> disks = new HashMap<>();
 
-	public VmwareMetaData( List<OperatingSystem> osList, File file ) throws IOException, UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVmware( List<OperatingSystem> osList, File file ) throws IOException, VirtualizationConfigurationException
 	{
 		super( osList );
-		this.config = new VmwareConfig( file );
+		this.config = new VirtualizationConfigurationVmwareFileFormat( file );
 		init();
 	}
 
-	public VmwareMetaData( List<OperatingSystem> osList, byte[] vmxContent, int length ) throws UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVmware( List<OperatingSystem> osList, byte[] vmxContent, int length ) throws VirtualizationConfigurationException
 	{
 		super( osList );
-		this.config = new VmwareConfig( vmxContent, length ); // still unfiltered
+		this.config = new VirtualizationConfigurationVmwareFileFormat( vmxContent, length ); // still unfiltered
 		init(); // now filtered
 	}
 
@@ -259,7 +257,7 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 	@Override
 	public List<DiskImage.ImageFormat> getSupportedImageFormats()
 	{
-		return VmwareMetaData.SUPPORTED_IMAGE_FORMATS;
+		return VirtualizationConfigurationVmware.SUPPORTED_IMAGE_FORMATS;
 	}
 	
 	@Override
@@ -324,7 +322,7 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 		return true;
 	}
 
-	public boolean addEthernet( VmMetaData.EtherType type )
+	public boolean addEthernet( VirtualizationConfiguration.EtherType type )
 	{
 		boolean ret = false;
 		int index = 0;
@@ -494,7 +492,7 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 		return config.get( key );
 	}
 
-	public void setSoundCard( VmMetaData.SoundCardType type )
+	public void setSoundCard( VirtualizationConfiguration.SoundCardType type )
 	{
 		VmWareSoundCardMeta soundCardMeta = soundCards.get( type );
 		addFiltered( "sound.present", vmBoolean( soundCardMeta.isPresent ) );
@@ -505,15 +503,15 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 		}
 	}
 
-	public VmMetaData.SoundCardType getSoundCard()
+	public VirtualizationConfiguration.SoundCardType getSoundCard()
 	{
 		if ( !isSetAndTrue( "sound.present" ) || !isSetAndTrue( "sound.autodetect" ) ) {
-			return VmMetaData.SoundCardType.NONE;
+			return VirtualizationConfiguration.SoundCardType.NONE;
 		}
 		String current = config.get( "sound.virtualDev" );
 		if ( current != null ) {
 			VmWareSoundCardMeta soundCardMeta = null;
-			for ( VmMetaData.SoundCardType type : VmMetaData.SoundCardType.values() ) {
+			for ( VirtualizationConfiguration.SoundCardType type : VirtualizationConfiguration.SoundCardType.values() ) {
 				soundCardMeta = soundCards.get( type );
 				if ( soundCardMeta != null ) {
 					if ( current.equals( soundCardMeta.value ) ) {
@@ -522,35 +520,35 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 				}
 			}
 		}
-		return VmMetaData.SoundCardType.DEFAULT;
+		return VirtualizationConfiguration.SoundCardType.DEFAULT;
 	}
 
-	public void setDDAcceleration( VmMetaData.DDAcceleration type )
+	public void setDDAcceleration( VirtualizationConfiguration.DDAcceleration type )
 	{
 		VmWareDDAccelMeta ddaMeta = ddacc.get( type );
 		addFiltered( "mks.enable3d", vmBoolean( ddaMeta.isPresent ) );
 	}
 
-	public VmMetaData.DDAcceleration getDDAcceleration()
+	public VirtualizationConfiguration.DDAcceleration getDDAcceleration()
 	{
 		if ( isSetAndTrue( "mks.enable3d" ) ) {
-			return VmMetaData.DDAcceleration.ON;
+			return VirtualizationConfiguration.DDAcceleration.ON;
 		} else {
-			return VmMetaData.DDAcceleration.OFF;
+			return VirtualizationConfiguration.DDAcceleration.OFF;
 		}
 	}
 
-	public void setHWVersion( VmMetaData.HWVersion type )
+	public void setHWVersion( VirtualizationConfiguration.HWVersion type )
 	{
 		VmWareHWVersionMeta hwVersionMeta = hwversion.get( type );
 		addFiltered( "virtualHW.version", vmInteger( hwVersionMeta.version ) );
 	}
 
-	public VmMetaData.HWVersion getHWVersion()
+	public VirtualizationConfiguration.HWVersion getHWVersion()
 	{
 		int currentValue = Util.parseInt( config.get( "virtualHW.version" ), -1 );
 		VmWareHWVersionMeta hwVersionMeta = null;
-		for ( VmMetaData.HWVersion ver : VmMetaData.HWVersion.values() ) {
+		for ( VirtualizationConfiguration.HWVersion ver : VirtualizationConfiguration.HWVersion.values() ) {
 			hwVersionMeta = hwversion.get( ver );
 			if ( hwVersionMeta == null ) {
 				continue;
@@ -562,7 +560,7 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 		return HWVersion.NONE;
 	}
 
-	public void setEthernetDevType( int cardIndex, VmMetaData.EthernetDevType type )
+	public void setEthernetDevType( int cardIndex, VirtualizationConfiguration.EthernetDevType type )
 	{
 		VmWareEthernetDevTypeMeta ethernetDevTypeMeta = networkCards.get( type );
 		if ( ethernetDevTypeMeta.value != null ) {
@@ -572,12 +570,12 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 		}
 	}
 
-	public VmMetaData.EthernetDevType getEthernetDevType( int cardIndex )
+	public VirtualizationConfiguration.EthernetDevType getEthernetDevType( int cardIndex )
 	{
 		String temp = config.get( "ethernet" + cardIndex + ".virtualDev" );
 		if ( temp != null ) {
 			VmWareEthernetDevTypeMeta ethernetDevTypeMeta = null;
-			for ( VmMetaData.EthernetDevType type : VmMetaData.EthernetDevType.values() ) {
+			for ( VirtualizationConfiguration.EthernetDevType type : VirtualizationConfiguration.EthernetDevType.values() ) {
 				ethernetDevTypeMeta = networkCards.get( type );
 				if ( ethernetDevTypeMeta == null ) {
 					continue;
@@ -587,14 +585,14 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 				}
 			}
 		}
-		return VmMetaData.EthernetDevType.AUTO;
+		return VirtualizationConfiguration.EthernetDevType.AUTO;
 	}
 
 	@Override
-	public void setMaxUsbSpeed( VmMetaData.UsbSpeed newSpeed )
+	public void setMaxUsbSpeed( VirtualizationConfiguration.UsbSpeed newSpeed )
 	{
 		if ( newSpeed == null ) {
-			newSpeed = VmMetaData.UsbSpeed.NONE;
+			newSpeed = VirtualizationConfiguration.UsbSpeed.NONE;
 		}
 		VmwareUsbSpeed newSpeedMeta = usbSpeeds.get( newSpeed );
 		if ( newSpeedMeta == null ) {
@@ -620,11 +618,11 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 	}
 
 	@Override
-	public VmMetaData.UsbSpeed getMaxUsbSpeed()
+	public VirtualizationConfiguration.UsbSpeed getMaxUsbSpeed()
 	{
 		int max = 0;
-		VmMetaData.UsbSpeed maxEnum = VmMetaData.UsbSpeed.NONE;
-		for ( Entry<VmMetaData.UsbSpeed, VmwareUsbSpeed> entry : usbSpeeds.entrySet() ) {
+		VirtualizationConfiguration.UsbSpeed maxEnum = VirtualizationConfiguration.UsbSpeed.NONE;
+		for ( Entry<VirtualizationConfiguration.UsbSpeed, VmwareUsbSpeed> entry : usbSpeeds.entrySet() ) {
 			VmwareUsbSpeed v = entry.getValue();
 			if ( v.speedNumeric > max && isSetAndTrue( v.keyName ) ) {
 				max = v.speedNumeric;
@@ -643,42 +641,42 @@ public class VmwareMetaData extends VmMetaData<VmWareSoundCardMeta, VmWareDDAcce
 
 	public void registerVirtualHW()
 	{
-		soundCards.put( VmMetaData.SoundCardType.NONE, new VmWareSoundCardMeta( false, null ) );
-		soundCards.put( VmMetaData.SoundCardType.DEFAULT, new VmWareSoundCardMeta( true, null ) );
-		soundCards.put( VmMetaData.SoundCardType.SOUND_BLASTER, new VmWareSoundCardMeta( true, "sb16" ) );
-		soundCards.put( VmMetaData.SoundCardType.ES, new VmWareSoundCardMeta( true, "es1371" ) );
-		soundCards.put( VmMetaData.SoundCardType.HD_AUDIO, new VmWareSoundCardMeta( true, "hdaudio" ) );
-
-		ddacc.put( VmMetaData.DDAcceleration.OFF, new VmWareDDAccelMeta( false ) );
-		ddacc.put( VmMetaData.DDAcceleration.ON, new VmWareDDAccelMeta( true ) );
-
-		hwversion.put( VmMetaData.HWVersion.NONE, new VmWareHWVersionMeta( 0 ) );
-		hwversion.put( VmMetaData.HWVersion.THREE, new VmWareHWVersionMeta( 3 ) );
-		hwversion.put( VmMetaData.HWVersion.FOUR, new VmWareHWVersionMeta( 4 ) );
-		hwversion.put( VmMetaData.HWVersion.SIX, new VmWareHWVersionMeta( 6 ) );
-		hwversion.put( VmMetaData.HWVersion.SEVEN, new VmWareHWVersionMeta( 7 ) );
-		hwversion.put( VmMetaData.HWVersion.EIGHT, new VmWareHWVersionMeta( 8 ) );
-		hwversion.put( VmMetaData.HWVersion.NINE, new VmWareHWVersionMeta( 9 ) );
-		hwversion.put( VmMetaData.HWVersion.TEN, new VmWareHWVersionMeta( 10 ) );
-		hwversion.put( VmMetaData.HWVersion.ELEVEN, new VmWareHWVersionMeta( 11 ) );
-		hwversion.put( VmMetaData.HWVersion.TWELVE, new VmWareHWVersionMeta( 12 ) );
-		hwversion.put( VmMetaData.HWVersion.FOURTEEN, new VmWareHWVersionMeta( 14 ) );
-		hwversion.put( VmMetaData.HWVersion.FIFTEEN, new VmWareHWVersionMeta( 15 ) );
-		hwversion.put( VmMetaData.HWVersion.FIFTEEN_ONE, new VmWareHWVersionMeta( 16 ) );
-		hwversion.put( VmMetaData.HWVersion.SIXTEEN, new VmWareHWVersionMeta( 17 ) );
-		hwversion.put( VmMetaData.HWVersion.SIXTEEN_ONE, new VmWareHWVersionMeta( 18 ) );
-
-		networkCards.put( VmMetaData.EthernetDevType.AUTO, new VmWareEthernetDevTypeMeta( null ) );
-		networkCards.put( VmMetaData.EthernetDevType.PCNET32, new VmWareEthernetDevTypeMeta( "vlance" ) );
-		networkCards.put( VmMetaData.EthernetDevType.E1000, new VmWareEthernetDevTypeMeta( "e1000" ) );
-		networkCards.put( VmMetaData.EthernetDevType.E1000E, new VmWareEthernetDevTypeMeta( "e1000e" ) );
-		networkCards.put( VmMetaData.EthernetDevType.VMXNET, new VmWareEthernetDevTypeMeta( "vmxnet" ) );
-		networkCards.put( VmMetaData.EthernetDevType.VMXNET3, new VmWareEthernetDevTypeMeta( "vmxnet3" ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.NONE, new VmWareSoundCardMeta( false, null ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.DEFAULT, new VmWareSoundCardMeta( true, null ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.SOUND_BLASTER, new VmWareSoundCardMeta( true, "sb16" ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.ES, new VmWareSoundCardMeta( true, "es1371" ) );
+		soundCards.put( VirtualizationConfiguration.SoundCardType.HD_AUDIO, new VmWareSoundCardMeta( true, "hdaudio" ) );
+
+		ddacc.put( VirtualizationConfiguration.DDAcceleration.OFF, new VmWareDDAccelMeta( false ) );
+		ddacc.put( VirtualizationConfiguration.DDAcceleration.ON, new VmWareDDAccelMeta( true ) );
+
+		hwversion.put( VirtualizationConfiguration.HWVersion.NONE, new VmWareHWVersionMeta( 0 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.THREE, new VmWareHWVersionMeta( 3 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.FOUR, new VmWareHWVersionMeta( 4 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.SIX, new VmWareHWVersionMeta( 6 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.SEVEN, new VmWareHWVersionMeta( 7 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.EIGHT, new VmWareHWVersionMeta( 8 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.NINE, new VmWareHWVersionMeta( 9 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.TEN, new VmWareHWVersionMeta( 10 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.ELEVEN, new VmWareHWVersionMeta( 11 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.TWELVE, new VmWareHWVersionMeta( 12 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.FOURTEEN, new VmWareHWVersionMeta( 14 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.FIFTEEN, new VmWareHWVersionMeta( 15 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.FIFTEEN_ONE, new VmWareHWVersionMeta( 16 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.SIXTEEN, new VmWareHWVersionMeta( 17 ) );
+		hwversion.put( VirtualizationConfiguration.HWVersion.SIXTEEN_ONE, new VmWareHWVersionMeta( 18 ) );
+
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.AUTO, new VmWareEthernetDevTypeMeta( null ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.PCNET32, new VmWareEthernetDevTypeMeta( "vlance" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.E1000, new VmWareEthernetDevTypeMeta( "e1000" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.E1000E, new VmWareEthernetDevTypeMeta( "e1000e" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.VMXNET, new VmWareEthernetDevTypeMeta( "vmxnet" ) );
+		networkCards.put( VirtualizationConfiguration.EthernetDevType.VMXNET3, new VmWareEthernetDevTypeMeta( "vmxnet3" ) );
 		
-		usbSpeeds.put( VmMetaData.UsbSpeed.NONE, new VmwareUsbSpeed( 0, null ));
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB1_1, new VmwareUsbSpeed( 1, "usb" ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB2_0, new VmwareUsbSpeed( 2, "ehci" ) );
-		usbSpeeds.put( VmMetaData.UsbSpeed.USB3_0, new VmwareUsbSpeed( 3, "usb_xhci" ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.NONE, new VmwareUsbSpeed( 0, null ));
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB1_1, new VmwareUsbSpeed( 1, "usb" ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB2_0, new VmwareUsbSpeed( 2, "ehci" ) );
+		usbSpeeds.put( VirtualizationConfiguration.UsbSpeed.USB3_0, new VmwareUsbSpeed( 3, "usb_xhci" ) );
 	}
 
 }
diff --git a/src/main/java/org/openslx/virtualization/configuration/machine/VmwareConfig.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVmwareFileFormat.java
index e5d05b3..24df02f 100644
--- a/src/main/java/org/openslx/virtualization/configuration/machine/VmwareConfig.java
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationVmwareFileFormat.java
@@ -1,4 +1,4 @@
-package org.openslx.virtualization.configuration.machine;
+package org.openslx.virtualization.configuration;
 
 import java.io.BufferedReader;
 import java.io.ByteArrayInputStream;
@@ -18,21 +18,32 @@ import java.util.regex.Pattern;
 
 import org.apache.log4j.Logger;
 import org.openslx.util.Util;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
 
-public class VmwareConfig
+class KeyValuePair
 {
+	public final String key;
+	public final String value;
 
-	private static final Logger LOGGER = Logger.getLogger( VmwareConfig.class );
+	public KeyValuePair( String key, String value )
+	{
+		this.key = key;
+		this.value = value;
+	}
+}
+
+public class VirtualizationConfigurationVmwareFileFormat
+{
+
+	private static final Logger LOGGER = Logger.getLogger( VirtualizationConfigurationVmwareFileFormat.class );
 
 	private Map<String, ConfigEntry> entries = new TreeMap<>( String.CASE_INSENSITIVE_ORDER );
 
-	public VmwareConfig()
+	public VirtualizationConfigurationVmwareFileFormat()
 	{
 		// (void)
 	}
 
-	public VmwareConfig( File file ) throws IOException, UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVmwareFileFormat( File file ) throws IOException, VirtualizationConfigurationException
 	{
 		int todo = (int)Math.min( 100000, file.length() );
 		int offset = 0;
@@ -54,7 +65,7 @@ public class VmwareConfig
 
 	}
 
-	public VmwareConfig( InputStream is ) throws IOException, UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVmwareFileFormat( InputStream is ) throws IOException, VirtualizationConfigurationException
 	{
 		int todo = Math.max( 4000, Math.min( 100000, is.available() ) );
 		int offset = 0;
@@ -69,13 +80,13 @@ public class VmwareConfig
 		init( data, offset );
 	}
 
-	public VmwareConfig( byte[] vmxContent, int length ) throws UnsupportedVirtualizerFormatException
+	public VirtualizationConfigurationVmwareFileFormat( byte[] vmxContent, int length ) throws VirtualizationConfigurationException
 	{
 		init( vmxContent, length );
 	}
 
 	// function is used for both .vmx and .vmdk files
-	private void init( byte[] vmxContent, int length ) throws UnsupportedVirtualizerFormatException
+	private void init( byte[] vmxContent, int length ) throws VirtualizationConfigurationException
 	{
 		try {
 			boolean isValid = false;
@@ -95,7 +106,7 @@ public class VmwareConfig
 				}
 			}
 			if ( !isValid ) {
-				throw new UnsupportedVirtualizerFormatException( "Not in VMX format." );
+				throw new VirtualizationConfigurationException( "Not in VMX format." );
 			}
 		} catch ( IOException e ) {
 			LOGGER.warn( "Exception when loading vmx from byte array (how!?)", e );
diff --git a/src/main/java/org/openslx/virtualization/configuration/machine/KeyValuePair.java b/src/main/java/org/openslx/virtualization/configuration/machine/KeyValuePair.java
deleted file mode 100644
index ecd4f2a..0000000
--- a/src/main/java/org/openslx/virtualization/configuration/machine/KeyValuePair.java
+++ /dev/null
@@ -1,13 +0,0 @@
-package org.openslx.virtualization.configuration.machine;
-
-class KeyValuePair
-{
-	public final String key;
-	public final String value;
-
-	public KeyValuePair( String key, String value )
-	{
-		this.key = key;
-		this.value = value;
-	}
-}
\ No newline at end of file
diff --git a/src/main/java/org/openslx/vm/disk/DiskImageVmdk.java b/src/main/java/org/openslx/vm/disk/DiskImageVmdk.java
index 591be3d..1f475d9 100644
--- a/src/main/java/org/openslx/vm/disk/DiskImageVmdk.java
+++ b/src/main/java/org/openslx/vm/disk/DiskImageVmdk.java
@@ -6,8 +6,8 @@ import java.io.IOException;
 import java.io.RandomAccessFile;
 
 import org.openslx.util.Util;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
-import org.openslx.virtualization.configuration.machine.VmwareConfig;
+import org.openslx.virtualization.configuration.VirtualizationConfigurationVmwareFileFormat;
+import org.openslx.virtualization.configuration.VirtualizationConfigurationException;
 
 /**
  * VMDK (sparse extent) disk image for virtual machines.
@@ -35,7 +35,7 @@ public class DiskImageVmdk extends DiskImage
 	/**
 	 * Stores disk configuration if VMDK disk image contains an embedded descriptor file.
 	 */
-	private final VmwareConfig vmdkConfig;
+	private final VirtualizationConfigurationVmwareFileFormat vmdkConfig;
 
 	/**
 	 * Creates a new VMDK disk image from an existing VMDK image file.
@@ -99,7 +99,7 @@ public class DiskImageVmdk extends DiskImage
 	 */
 	private String getCreationType()
 	{
-		final VmwareConfig vmdkConfig = this.getVmdkConfig();
+		final VirtualizationConfigurationVmwareFileFormat vmdkConfig = this.getVmdkConfig();
 		final String vmdkCreationType;
 
 		if ( vmdkConfig == null ) {
@@ -122,10 +122,10 @@ public class DiskImageVmdk extends DiskImage
 	 * 
 	 * @throws DiskImageException parsing of the VMDK's embedded descriptor file failed.
 	 */
-	protected VmwareConfig parseVmdkConfig() throws DiskImageException
+	protected VirtualizationConfigurationVmwareFileFormat parseVmdkConfig() throws DiskImageException
 	{
 		final RandomAccessFile diskFile = this.getDiskImage();
-		final VmwareConfig vmdkConfig;
+		final VirtualizationConfigurationVmwareFileFormat vmdkConfig;
 
 		// get offset and size of descriptor file embedded into the VMDK disk image
 		final long vmdkDescriptorSectorOffset = Long.reverseBytes( DiskImageUtils.readLong( diskFile, 28 ) );
@@ -152,8 +152,8 @@ public class DiskImageVmdk extends DiskImage
 
 			// create configuration instance from content of the descriptor file
 			try {
-				vmdkConfig = new VmwareConfig( configStr.getBytes(), vmdkDescriptorSize );
-			} catch ( UnsupportedVirtualizerFormatException e ) {
+				vmdkConfig = new VirtualizationConfigurationVmwareFileFormat( configStr.getBytes(), vmdkDescriptorSize );
+			} catch ( VirtualizationConfigurationException e ) {
 				throw new DiskImageException( e.getLocalizedMessage() );
 			}
 		} else {
@@ -169,7 +169,7 @@ public class DiskImageVmdk extends DiskImage
 	 * 
 	 * @return parsed configuration of the VMDK's embedded descriptor file.
 	 */
-	protected VmwareConfig getVmdkConfig()
+	protected VirtualizationConfigurationVmwareFileFormat getVmdkConfig()
 	{
 		return this.vmdkConfig;
 	}
@@ -186,7 +186,7 @@ public class DiskImageVmdk extends DiskImage
 	 */
 	public int getHwVersion() throws DiskImageException
 	{
-		final VmwareConfig vmdkConfig = this.getVmdkConfig();
+		final VirtualizationConfigurationVmwareFileFormat vmdkConfig = this.getVmdkConfig();
 		final int hwVersion;
 
 		if ( vmdkConfig != null ) {
@@ -252,7 +252,7 @@ public class DiskImageVmdk extends DiskImage
 	@Override
 	public boolean isSnapshot() throws DiskImageException
 	{
-		final VmwareConfig vmdkConfig = this.getVmdkConfig();
+		final VirtualizationConfigurationVmwareFileFormat vmdkConfig = this.getVmdkConfig();
 		final boolean vmdkSnapshot;
 
 		if ( vmdkConfig == null ) {
diff --git a/src/test/java/org/openslx/virtualization/configuration/machine/QemuMetaDataTest.java b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java
index 3ede8e6..fe82a53 100644
--- a/src/test/java/org/openslx/virtualization/configuration/machine/QemuMetaDataTest.java
+++ b/src/test/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuTest.java
@@ -1,4 +1,4 @@
-package org.openslx.virtualization.configuration.machine;
+package org.openslx.virtualization.configuration;
 
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -32,22 +32,20 @@ import org.openslx.libvirt.domain.device.DiskStorage;
 import org.openslx.libvirt.domain.device.Interface;
 import org.openslx.libvirt.domain.device.Sound;
 import org.openslx.libvirt.xml.LibvirtXmlTestResources;
-import org.openslx.virtualization.configuration.UnsupportedVirtualizerFormatException;
-import org.openslx.virtualization.configuration.VmMetaData;
-import org.openslx.virtualization.configuration.VmMetaData.EtherType;
-import org.openslx.virtualization.configuration.VmMetaData.EthernetDevType;
-import org.openslx.virtualization.configuration.VmMetaData.SoundCardType;
-import org.openslx.virtualization.configuration.VmMetaData.UsbSpeed;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.EtherType;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.EthernetDevType;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.SoundCardType;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.UsbSpeed;
 import org.openslx.vm.disk.DiskImage;
 import org.openslx.vm.disk.DiskImageTestResources;
 import org.openslx.vm.disk.DiskImage.ImageFormat;
 
-public class QemuMetaDataTest
+public class VirtualizationConfigurationQemuTest
 {
-	private static Domain getPrivateDomainFromQemuMetaData( QemuMetaData qemuMetadata )
+	private static Domain getPrivateDomainFromQemuMetaData( VirtualizationConfigurationQemu qemuMetadata )
 			throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException
 	{
-		Field privateDomainField = QemuMetaData.class.getDeclaredField( "vmConfig" );
+		Field privateDomainField = VirtualizationConfigurationQemu.class.getDeclaredField( "vmConfig" );
 		privateDomainField.setAccessible( true );
 		return Domain.class.cast( privateDomainField.get( qemuMetadata ) );
 	}
@@ -62,13 +60,14 @@ public class QemuMetaDataTest
 	@Test
 	@DisplayName( "Test display name from VM configuration" )
 	public void testQemuMetaDataGetDisplayName()
-			throws UnsupportedVirtualizerFormatException, IOException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final String displayName = vmConfig.getDisplayName();
 
@@ -80,13 +79,14 @@ public class QemuMetaDataTest
 	@Test
 	@DisplayName( "Test machine snapshot state from VM configuration" )
 	public void testQemuMetaDataIsMachineSnapshot()
-			throws UnsupportedVirtualizerFormatException, IOException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final boolean isVmSnapshot = vmConfig.isMachineSnapshot();
 
@@ -98,13 +98,14 @@ public class QemuMetaDataTest
 	@Test
 	@DisplayName( "Test supported image formats from VM configuration" )
 	public void testQemuMetaDataGetSupportedImageFormats()
-			throws UnsupportedVirtualizerFormatException, IOException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final List<DiskImage.ImageFormat> supportedImageFormats = vmConfig.getSupportedImageFormats();
 
@@ -119,15 +120,16 @@ public class QemuMetaDataTest
 	@Test
 	@DisplayName( "Test output of HDDs from VM configuration" )
 	public void testQemuMetaDataGetHdds()
-			throws UnsupportedVirtualizerFormatException, IOException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
-		final List<VmMetaData.HardDisk> hdds = vmConfig.getHdds();
+		final List<VirtualizationConfiguration.HardDisk> hdds = vmConfig.getHdds();
 
 		assertNotNull( hdds );
 		assertEquals( 1, hdds.size() );
@@ -139,13 +141,14 @@ public class QemuMetaDataTest
 	@Test
 	@DisplayName( "Test output of unfiltered VM configuration" )
 	public void testQemuMetaDataGetDefinitionArray()
-			throws UnsupportedVirtualizerFormatException, IOException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numberOfDeletedElements = 1;
 
@@ -165,13 +168,14 @@ public class QemuMetaDataTest
 	@Test
 	@DisplayName( "Test output of filtered VM configuration" )
 	public void testQemuMetaDataGetFilteredDefinitionArray()
-			throws UnsupportedVirtualizerFormatException, IOException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, IOException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numberOfDeletedElements = 2;
 
@@ -192,14 +196,15 @@ public class QemuMetaDataTest
 	@DisplayName( "Test add HDD to VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-hdd.xml" } )
 	public void testQemuMetaDataAddHdd( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" );
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numHddsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskStorageDevices().size();
 		final int numHddsQemuMetaDataBeforeAdd = vmConfig.getHdds().size();
@@ -233,14 +238,15 @@ public class QemuMetaDataTest
 	@DisplayName( "Test add CDROM to VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-cdrom.xml" } )
 	public void testQemuMetaDataAddCdrom( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" );
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numCdromsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size();
 
@@ -261,13 +267,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test add physical CDROM drive to VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-cdrom.xml" } )
 	public void testQemuMetaDataAddPhysicalCdromDrive( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numCdromsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskCdromDevices().size();
 
@@ -279,7 +286,7 @@ public class QemuMetaDataTest
 		assertTrue( numCdromsLibvirtDomainXmlAfterAdd > 0 );
 
 		DiskCdrom addedCdromDevice = vmLibvirtDomainConfig.getDiskCdromDevices().get( 0 );
-		assertEquals( QemuMetaData.CDROM_DEFAULT_PHYSICAL_DRIVE, addedCdromDevice.getStorageSource() );
+		assertEquals( VirtualizationConfigurationQemu.CDROM_DEFAULT_PHYSICAL_DRIVE, addedCdromDevice.getStorageSource() );
 
 		assertDoesNotThrow( () -> vmLibvirtDomainConfig.validateXml() );
 	}
@@ -288,14 +295,15 @@ public class QemuMetaDataTest
 	@DisplayName( "Test add floppy to VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-floppy.xml" } )
 	public void testQemuMetaDataAddFloppy( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File diskFile = DiskImageTestResources.getDiskFile( "image-default.qcow2" );
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numFloppiesLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getDiskFloppyDevices().size();
 
@@ -317,13 +325,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test add CPU core count to VM configuration" )
 	@ValueSource( ints = { 2, 4, 6, 8 } )
 	public void testQemuMetaDataAddCpuCoreCount( int coreCount )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( "qemu-kvm_default-archlinux-vm.xml" );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		vmConfig.addCpuCoreCount( coreCount );
 
@@ -336,13 +345,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test get sound card from VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-sound.xml" } )
 	public void testQemuMetaDataGetSoundCardType( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		SoundCardType soundCardType = vmConfig.getSoundCard();
 
@@ -359,13 +369,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test set sound card in VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-sound.xml" } )
 	public void testQemuMetaDataSetSoundCardType( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numSoundDevsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getSoundDevices().size();
 
@@ -386,13 +397,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test get ethernet device type from VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-nic.xml" } )
 	public void testQemuMetaDataGetEthernetDevType( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		EthernetDevType ethernetDeviceType = vmConfig.getEthernetDevType( 0 );
 
@@ -409,13 +421,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test set ethernet device type in VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-nic.xml" } )
 	public void testQemuMetaDataSetEthernetDevType( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		vmConfig.setEthernetDevType( 0, EthernetDevType.E1000E );
 
@@ -431,13 +444,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test get maximal USB speed from VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-usb.xml" } )
 	public void testQemuMetaDataGetMaxUsbSpeed( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		UsbSpeed maxUsbSpeed = vmConfig.getMaxUsbSpeed();
 
@@ -454,13 +468,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test set maximal USB speed in VM configuration" )
 	@ValueSource( strings = { "qemu-kvm_default-archlinux-vm.xml", "qemu-kvm_default-archlinux-vm-no-usb.xml" } )
 	public void testQemuMetaDataSetMaxUsbSpeed( String xmlFileName )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numUsbControllersLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getUsbControllerDevices().size();
 
@@ -492,13 +507,14 @@ public class QemuMetaDataTest
 	@DisplayName( "Test add ethernet device to VM configuration" )
 	@MethodSource( "configAndEthernetTypeProvider" )
 	public void testQemuMetaDataAddEthernet( String xmlFileName, EtherType ethernetType )
-			throws UnsupportedVirtualizerFormatException, NoSuchFieldException, SecurityException,
+			throws VirtualizationConfigurationException, NoSuchFieldException, SecurityException,
 			IllegalArgumentException, IllegalAccessException
 	{
 		File file = LibvirtXmlTestResources.getLibvirtXmlFile( xmlFileName );
-		QemuMetaData vmConfig = new QemuMetaData( null, file );
+		VirtualizationConfigurationQemu vmConfig = new VirtualizationConfigurationQemu( null, file );
 
-		final Domain vmLibvirtDomainConfig = QemuMetaDataTest.getPrivateDomainFromQemuMetaData( vmConfig );
+		final Domain vmLibvirtDomainConfig = VirtualizationConfigurationQemuTest
+				.getPrivateDomainFromQemuMetaData( vmConfig );
 
 		final int numEthernetDevsLibvirtDomainXmlBeforeAdd = vmLibvirtDomainConfig.getInterfaceDevices().size();
 
@@ -514,17 +530,18 @@ public class QemuMetaDataTest
 		case BRIDGED:
 			assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() );
 			assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() );
-			assertEquals( QemuMetaData.NETWORK_BRIDGE_LAN_DEFAULT, addedEthernetDevice.getSource() );
+			assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_LAN_DEFAULT, addedEthernetDevice.getSource() );
 			break;
 		case HOST_ONLY:
 			assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() );
 			assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() );
-			assertEquals( QemuMetaData.NETWORK_BRIDGE_HOST_ONLY_DEFAULT, addedEthernetDevice.getSource() );
+			assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_HOST_ONLY_DEFAULT,
+					addedEthernetDevice.getSource() );
 			break;
 		case NAT:
 			assertEquals( Interface.Type.BRIDGE, addedEthernetDevice.getType() );
 			assertEquals( Interface.Model.VIRTIO, addedEthernetDevice.getModel() );
-			assertEquals( QemuMetaData.NETWORK_BRIDGE_NAT_DEFAULT, addedEthernetDevice.getSource() );
+			assertEquals( VirtualizationConfigurationQemu.NETWORK_BRIDGE_NAT_DEFAULT, addedEthernetDevice.getSource() );
 			break;
 		}