1 files changed, 404 insertions, 0 deletions
diff --git a/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuUtils.java b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuUtils.java
new file mode 100644
index 0000000..86216a0
--- /dev/null
+++ b/src/main/java/org/openslx/virtualization/configuration/VirtualizationConfigurationQemuUtils.java
@@ -0,0 +1,404 @@
+package org.openslx.virtualization.configuration;
+
+import java.util.ArrayList;
+import java.util.function.Predicate;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.openslx.libvirt.domain.Domain;
+import org.openslx.libvirt.domain.device.Disk;
+import org.openslx.libvirt.domain.device.Disk.BusType;
+import org.openslx.virtualization.Version;
+import org.openslx.virtualization.configuration.VirtualizationConfiguration.DriveBusType;
+
+/**
+ * Collection of utils to convert data types from bwLehrpool to Libvirt and vice versa.
+ * 
+ * @author Manuel Bentele
+ * @version 1.0
+ */
+public class VirtualizationConfigurationQemuUtils
+{
+	/**
+	 * Separator symbol between Libvirt/QEMU machine name and machine version.
+	 */
+	private static final String OS_MACHINE_NAME_VERSION_SEPARATOR = "-";
+
+	/**
+	 * Converts a Libvirt disk device bus type to a VM metadata driver bus type.
+	 * 
+	 * @param busType Libvirt disk device bus type.
+	 * @return VM metadata bus type of the disk drive.
+	 */
+	public static DriveBusType convertBusType( Disk.BusType busType )
+	{
+		DriveBusType type = null;
+
+		if ( busType == null )
+			return null;
+
+		switch ( busType ) {
+		case IDE:
+			type = DriveBusType.IDE;
+			break;
+		case SATA:
+			type = DriveBusType.SATA;
+			break;
+		case SCSI:
+			type = DriveBusType.SCSI;
+			break;
+		default:
+			type = null;
+			break;
+		}
+
+		return type;
+	}
+
+	/**
+	 * Converts a VM metadata driver bus type to a Libvirt disk device bus type.
+	 * 
+	 * @param busType VM metadata bus type of the disk drive.
+	 * @return Libvirt disk device bus type.
+	 */
+	public static Disk.BusType convertBusType( DriveBusType busType )
+	{
+		Disk.BusType type = null;
+
+		switch ( busType ) {
+		case IDE:
+			type = BusType.IDE;
+			break;
+		case NVME:
+			type = null;
+			break;
+		case SATA:
+			type = BusType.SATA;
+			break;
+		case SCSI:
+			type = BusType.SCSI;
+			break;
+		}
+
+		return type;
+	}
+
+	/**
+	 * Returns an item from a given {@link ArrayList}.
+	 * 
+	 * The item is selected by a given index. If the item is not available within the
+	 * {@link ArrayList}, <code>null</code> is returned.
+	 * 
+	 * @param <T> type of the {@link ArrayList}.
+	 * @param array {@link ArrayList} of type <code>T</code>.
+	 * @param index selects the item from the {@link ArrayList}.
+	 * @return selected item of the {@link ArrayList}.
+	 */
+	public static <T> T getArrayIndex( ArrayList<T> array, int index )
+	{
+		T ret;
+
+		try {
+			ret = array.get( index );
+		} catch ( IndexOutOfBoundsException e ) {
+			ret = null;
+		}
+
+		return ret;
+	}
+
+	/**
+	 * Creates an alphabetical device name constructed from a device prefix and a device number.
+	 * 
+	 * @param devicePrefix prefix of the constructed device name.
+	 * @param deviceNumber number of the device.
+	 * @return alphabetical device name.
+	 */
+	private static String createAlphabeticalDeviceName( String devicePrefix, int deviceNumber )
+	{
+		if ( deviceNumber < 0 || deviceNumber >= ( 'z' - 'a' ) ) {
+			String errorMsg = "Device number is out of range to be able to create a valid device name.";
+			throw new IllegalArgumentException( errorMsg );
+		}
+
+		return devicePrefix + Character.valueOf( (char) ( 'a' + deviceNumber ) ).toString();
+	}
+
+	/**
+	 * Creates an alphabetical device name for a disk device with a bus <i>type</i> that is unique in
+	 * a Libvirt domain XML configuration.
+	 * 
+	 * @param config Libvirt domain XML configuration.
+	 * @param type device type for device name.
+	 * @return alphabetical device name.
+	 */
+	public static String createDeviceName( final Domain config, final BusType type ) throws IllegalArgumentException
+	{
+		final String devicePrefix;
+		final int deviceNumber;
+
+		switch ( type ) {
+		case FDC:
+			devicePrefix = "fd";
+			break;
+		case IDE:
+			devicePrefix = "hd";
+			break;
+		case SATA:
+			devicePrefix = "sd";
+			break;
+		case VIRTIO:
+			devicePrefix = "vd";
+			break;
+		default:
+			return null;
+		}
+
+		final Predicate<Disk> bySpecifiedBusType = d -> d.getBusType() == type;
+		deviceNumber = Long.valueOf( config.getDiskDevices().stream().filter( bySpecifiedBusType ).count() ).intValue();
+
+		return VirtualizationConfigurationQemuUtils.createAlphabeticalDeviceName( devicePrefix, deviceNumber );
+	}
+
+	/**
+	 * Data container to store a Libvirt/QEMU machine name with version information.
+	 * 
+	 * @author Manuel Bentele
+	 * @version 1.0
+	 */
+	static class OsMachineNameAndVersion
+	{
+		/**
+		 * Stores the machine name.
+		 */
+		final private String osMachineName;
+
+		/**
+		 * Stores the machine version.
+		 */
+		final private Version osMachineVersion;
+
+		/**
+		 * Creates a data container for a machine name with version information.
+		 * 
+		 * @param osMachineName name of the machine.
+		 * @param osMachineVersion version of the machine.
+		 */
+		public OsMachineNameAndVersion( String osMachineName, Version osMachineVersion )
+		{
+			this.osMachineName = osMachineName;
+			this.osMachineVersion = osMachineVersion;
+		}
+
+		/**
+		 * Returns the machine name.
+		 * 
+		 * @return machine name.
+		 */
+		public String getOsMachineName()
+		{
+			return this.osMachineName;
+		}
+
+		/**
+		 * Returns the version information.
+		 * 
+		 * @return version information.
+		 */
+		public Version getOsMachineVersion()
+		{
+			return this.osMachineVersion;
+		}
+	}
+
+	/**
+	 * Parses a machine name with version information from a Libvirt/QEMU machine description.
+	 * 
+	 * @param osMachine Libvirt/QEMU machine description as {@link String}.
+	 * @return data container containing the parsed machine name with version information.
+	 */
+	private static OsMachineNameAndVersion parseOsMachineNameAndVersion( String osMachine )
+	{
+		final String osMachineName;
+		final Version osMachineVersion;
+
+		if ( osMachine == null || osMachine.isEmpty() ) {
+			// there is no machine description given, so we can not parse anything
+			osMachineName = null;
+			osMachineVersion = null;
+		} else {
+			// create regular expression based matcher to extract machine name and version number
+			final Pattern osMachineNameAndVersionPattern = Pattern.compile( "^([a-z0-9\\-]+)"
+					+ VirtualizationConfigurationQemuUtils.OS_MACHINE_NAME_VERSION_SEPARATOR + "([0-9]+).([0-9]+)$" );
+			final Matcher osMachineNameAndVersionMatcher = osMachineNameAndVersionPattern.matcher( osMachine );
+
+			final boolean matches = osMachineNameAndVersionMatcher.find();
+
+			if ( matches ) {
+				// get results of regular expression based matcher
+				osMachineName = osMachineNameAndVersionMatcher.group( 1 );
+				final String osMachineMajorString = osMachineNameAndVersionMatcher.group( 2 );
+				final String osMachineMinorString = osMachineNameAndVersionMatcher.group( 3 );
+
+				// create version representation
+				final short osMachineMajor = Short.valueOf( osMachineMajorString );
+				final short osMachineMinor = Short.valueOf( osMachineMinorString );
+				osMachineVersion = new Version( osMachineMajor, osMachineMinor );
+			} else {
+				osMachineName = null;
+				osMachineVersion = null;
+			}
+		}
+
+		return new OsMachineNameAndVersion( osMachineName, osMachineVersion );
+	}
+
+	/**
+	 * Parses a machine name from a Libvirt/QEMU machine description.
+	 * 
+	 * @param osMachine Libvirt/QEMU machine description as {@link String}.
+	 * @return parsed machine name.
+	 */
+	public static String getOsMachineName( String osMachine )
+	{
+		final OsMachineNameAndVersion machineNameAndVersion = VirtualizationConfigurationQemuUtils
+				.parseOsMachineNameAndVersion( osMachine );
+		return machineNameAndVersion.getOsMachineName();
+	}
+
+	/**
+	 * Parses a machine version from a Libvirt/QEMU machine description.
+	 * 
+	 * @param osMachine Libvirt/QEMU machine description as {@link String}.
+	 * @return parsed machine version.
+	 */
+	public static Version getOsMachineVersion( String osMachine )
+	{
+		final OsMachineNameAndVersion machineNameAndVersion = VirtualizationConfigurationQemuUtils
+				.parseOsMachineNameAndVersion( osMachine );
+		return machineNameAndVersion.getOsMachineVersion();
+	}
+
+	/**
+	 * Combines a machine name with a machine version and returns a Libvirt/QEMU machine description.
+	 * 
+	 * @param osMachineName name of the machine.
+	 * @param osMachineVersion version of the machine.
+	 * @return Libvirt/QEMU machine description.
+	 */
+	public static String getOsMachine( String osMachineName, String osMachineVersion )
+	{
+		return osMachineName + VirtualizationConfigurationQemuUtils.OS_MACHINE_NAME_VERSION_SEPARATOR + osMachineVersion;
+	}
+
+	/**
+	 * Converts a {@link Version} to a Libvirt/QEMU machine version.
+	 * 
+	 * @param version Libvirt/QEMU machine version as {@link Version}.
+	 * @return Libvirt/QEMU machine version.
+	 */
+	public static String getOsMachineVersion( Version version )
+	{
+		return String.format( "%d.%d", version.getMajor(), version.getMinor() );
+	}
+
+	/**
+	 * Returns the size of a given architecture {@link String}.
+	 * 
+	 * @param osArch Libvirt/QEMU machine architecture as {@link String}.
+	 * @return Size of the Libvirt/QEMU machine architecture.
+	 */
+	public static int getOsArchSize( String osArch )
+	{
+		final int archSize;
+
+		if ( osArch == null || osArch.isEmpty() ) {
+			archSize = 0;
+		} else {
+			switch ( osArch ) {
+			case "alpha":
+				archSize = 64;
+				break;
+			case "armv6l":
+				archSize = 32;
+				break;
+			case "armv7l":
+				archSize = 32;
+				break;
+			case "aarch64":
+				archSize = 64;
+				break;
+			case "cris":
+				archSize = 32;
+				break;
+			case "i686":
+				archSize = 32;
+				break;
+			case "m68k":
+				archSize = 32;
+				break;
+			case "microblaze":
+				archSize = 32;
+				break;
+			case "microblazeel":
+				archSize = 32;
+				break;
+			case "mips":
+				archSize = 32;
+				break;
+			case "mipsel":
+				archSize = 32;
+				break;
+			case "mips64":
+				archSize = 64;
+				break;
+			case "mips64el":
+				archSize = 64;
+				break;
+			case "ppc":
+				archSize = 32;
+				break;
+			case "ppc64":
+				archSize = 64;
+				break;
+			case "ppc64le":
+				archSize = 64;
+				break;
+			case "riscv32":
+				archSize = 32;
+				break;
+			case "riscv64":
+				archSize = 64;
+				break;
+			case "s390x":
+				archSize = 64;
+				break;
+			case "sh4":
+				archSize = 32;
+				break;
+			case "sh4eb":
+				archSize = 64;
+				break;
+			case "sparc":
+				archSize = 32;
+				break;
+			case "sparc64":
+				archSize = 64;
+				break;
+			case "x86_64":
+				archSize = 64;
+				break;
+			case "xtensa":
+				archSize = 32;
+				break;
+			case "xtensaeb":
+				archSize = 32;
+				break;
+			default:
+				archSize = 0;
+			}
+		}
+
+		return archSize;
+	}
+}