blob: bdded447bb5f9f4cccbd6f07169f817addb66f8a (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
package org.openslx.runvirt.plugin.qemu.configuration;
import java.util.ArrayList;
import java.util.List;
import org.openslx.libvirt.capabilities.Capabilities;
import org.openslx.libvirt.capabilities.guest.Guest;
import org.openslx.libvirt.capabilities.guest.Machine;
import org.openslx.libvirt.domain.Domain;
import org.openslx.libvirt.domain.Domain.OsType;
import org.openslx.libvirt.domain.Domain.Type;
import org.openslx.runvirt.plugin.qemu.cmdln.CommandLineArgs;
import org.openslx.runvirt.plugin.qemu.virtualization.LibvirtHypervisorQemu;
import org.openslx.runvirt.virtualization.LibvirtHypervisorException;
import org.openslx.virtualization.configuration.transformation.TransformationException;
import org.openslx.virtualization.configuration.transformation.TransformationSpecific;
public class TransformationSpecificQemuArchitecture extends TransformationSpecific<Domain, CommandLineArgs, LibvirtHypervisorQemu>
{
private static final String FILTER_NAME = "QEMU Architecture [CPU architecture, machine type, ...]";
// used as instance of an singelton, always use getCapabilities to retrieve caps instance
private Capabilities capabilities = null;
public TransformationSpecificQemuArchitecture( LibvirtHypervisorQemu hypervisor )
{
super( TransformationSpecificQemuArchitecture.FILTER_NAME, hypervisor );
}
private Capabilities getCapabilities() throws TransformationException
{
// retrieve capabilities from QEMU hypervisor only once
if ( this.capabilities == null ) {
try {
this.capabilities = this.getVirtualizer().getCapabilites();
} catch ( LibvirtHypervisorException e ) {
final String errorMsg = new String(
"Failed to get host capabilities from QEMU virtualizer: " + e.getLocalizedMessage() );
throw new TransformationException( errorMsg );
}
}
return this.capabilities;
}
private Guest getTargetGuestFromArchName( String architectureName ) throws TransformationException
{
final List<Guest> guests = this.getCapabilities().getGuests();
Guest targetGuest = null;
if ( architectureName == null ) {
return targetGuest;
}
for ( Guest guest : guests ) {
final String guestArchitectureName = guest.getArchName();
if ( architectureName.equals( guestArchitectureName ) ) {
targetGuest = guest;
break;
}
}
return targetGuest;
}
private Machine getTargetMachineFromGuest( Guest guest, String machineName ) throws TransformationException
{
final List<Machine> machines = guest.getArchMachines();
Machine targetMachine = null;
if ( machineName == null ) {
return targetMachine;
}
for ( Machine machine : machines ) {
if ( machineName.equals( machine.getName() ) ) {
targetMachine = machine;
break;
}
}
return targetMachine;
}
private List<String> getCanonicalNamesFromTargetMachines( Guest guest ) throws TransformationException
{
final List<Machine> machines = guest.getArchMachines();
final List<String> canonicalNames = new ArrayList<String>();
for ( Machine machine : machines ) {
final String canonicalName = machine.getCanonicalMachine();
if ( canonicalName != null ) {
canonicalNames.add( canonicalName );
}
}
return canonicalNames;
}
@Override
public void transform( Domain config, CommandLineArgs args ) throws TransformationException
{
// get source architecture, machine- and OS type
final String sourceArchitectureName = config.getOsArch();
final String sourceMachine = config.getOsMachine();
final OsType sourceOsType = config.getOsType();
final Type sourceDomainType = config.getType();
// check if source architecture is supported by one of the hypervisor's guests
Guest targetGuest = null;
if ( sourceArchitectureName == null ) {
final String errorMsg = new String( "Source architecture is not specified!" );
throw new TransformationException( errorMsg );
} else {
targetGuest = this.getTargetGuestFromArchName( sourceArchitectureName );
if ( targetGuest == null ) {
final String errorMsg = new String( "Source architecture is not supported by the virtualizer!" );
throw new TransformationException( errorMsg );
}
}
// check if source machine is supported by the hypervisor
Machine targetMachine = null;
if ( sourceMachine == null ) {
final String errorMsg = new String( "Source machine type is not specified!" );
throw new TransformationException( errorMsg );
} else {
// get all possible machine type for supported source architecture
targetMachine = this.getTargetMachineFromGuest( targetGuest, sourceMachine );
if ( targetMachine == null ) {
// source machine is not directly supported by the hypervisor
// check if up- or downgraded version of the chipset is supported by the hypervisor
List<String> targetMachineCanonicalNames = this.getCanonicalNamesFromTargetMachines( targetGuest );
// retrieve overwrite chipset name from canonical machine names
String sourceMachineOverwrite = null;
for ( String targetMachineCanonicalName : targetMachineCanonicalNames ) {
if ( sourceMachine.contains( targetMachineCanonicalName ) ) {
sourceMachineOverwrite = targetMachineCanonicalName;
break;
}
}
// if overwrite available, patch the machine type
if ( sourceMachineOverwrite != null ) {
config.setOsMachine( sourceMachineOverwrite );
} else {
final String errorMsg = new String( "Source machine type is not supported by the virtualizer!" );
throw new TransformationException( errorMsg );
}
}
}
// check if source OS type is supported by the hypervisor's architecture
if ( sourceOsType == null ) {
final String errorMsg = new String( "OS type is not specified!" );
throw new TransformationException( errorMsg );
} else {
if ( !sourceOsType.toString().equals( targetGuest.getOsType().toString() ) ) {
final String errorMsg = new String( "OS type is not supported by the virtualizer!" );
throw new TransformationException( errorMsg );
}
}
// check if source domain type is supported by the hypervisor's architecture
Type targetDomainType = null;
if ( sourceDomainType == null ) {
final String errorMsg = new String( "Source domain type is not specified!" );
throw new TransformationException( errorMsg );
} else {
final List<org.openslx.libvirt.capabilities.guest.Domain> targetDomains = targetGuest.getArchDomains();
// retrieve supported domain type
for ( org.openslx.libvirt.capabilities.guest.Domain domain : targetDomains ) {
final Type domainType = domain.getType();
if ( domainType == sourceDomainType ) {
targetDomainType = domainType;
break;
}
}
// check supported domain type
if ( targetDomainType == null ) {
final String errorMsg = new String( "Source domain type is not supported by the virtualizer!" );
throw new TransformationException( errorMsg );
}
}
// patch path of QEMU emulator binary
final String archEmulator = targetGuest.getArchEmulator();
if ( archEmulator == null ) {
final String errorMsg = new String( "Emulation of source architecture is not supported by the virtualizer!" );
throw new TransformationException( errorMsg );
} else {
config.setDevicesEmulator( targetGuest.getArchEmulator() );
}
}
}
|
