← Back to branch summary

~ubuntu-branches/ubuntu/quantal/virtinst/quantal-proposed

« back to all changes in this revision

Viewing changes to virtinst/VirtualGraphics.py

  • Committer: Bazaar Package Importer
  • Author(s): Marc Deslauriers
  • Date: 2011-02-01 15:40:11 UTC
  • mfrom: (1.3.16 experimental)
  • Revision ID: james.westby@ubuntu.com-20110201154011-op0nusgc240xajvb
Tags: 0.500.5-1ubuntu1
* Merge from debian experimental. Remaining changes:
  - debian/patches/9001_Ubuntu.patch:
     + Updated to add maverick and natty to OS list and enable virtio
       for them.
  - debian/patches/9003-fix-path-to-hvmloader-in-testsuite.patch: adjust
    testsuite for 0001-fix-path-to-hvmloader.patch and
    0002-Fix-path-to-pygrub.patch. (refreshed)
  - debian/control: added acl package to depends.
  - Demote virt-viewer to Suggests, as it's in universe.
  - Recommends libvirt-bin
* Removed patches:
  - debian/patches/9002-libvirt_disk_format.patch: Upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
virtinst/VirtualGraphics.py
23
23
import _util
24
24
import VirtualDevice
25
25
import support
 
26
from XMLBuilderDomain import _xml_property
26
27
from virtinst import _virtinst as _
27
28
 
 
29
def _get_mode_prop(channel_type):
 
30
    xpath = "./channel[@name='%s']/@mode" % channel_type
 
31
    def get_mode(s):
 
32
        return s._channels.get(channel_type, None)
 
33
    def set_mode(s, val):
 
34
        s._channels[channel_type] = val
 
35
    return _xml_property(get_mode, set_mode, xpath=xpath)
 
36
 
28
37
class VirtualGraphics(VirtualDevice.VirtualDevice):
29
38
 
30
39
    _virtual_device_type = VirtualDevice.VirtualDevice.VIRTUAL_DEV_GRAPHICS
31
40
 
32
41
    TYPE_SDL = "sdl"
33
42
    TYPE_VNC = "vnc"
 
43
    TYPE_RDP = "rdp"
 
44
    TYPE_SPICE = "spice"
 
45
    types = [TYPE_VNC, TYPE_SDL, TYPE_RDP, TYPE_SPICE]
 
46
 
 
47
    CHANNEL_TYPE_MAIN     = "main"
 
48
    CHANNEL_TYPE_DISPLAY  = "display"
 
49
    CHANNEL_TYPE_INPUTS   = "inputs"
 
50
    CHANNEL_TYPE_CURSOR   = "cursor"
 
51
    CHANNEL_TYPE_PLAYBACK = "playback"
 
52
    CHANNEL_TYPE_RECORD   = "record"
 
53
    channel_types = [CHANNEL_TYPE_MAIN, CHANNEL_TYPE_DISPLAY,
 
54
                     CHANNEL_TYPE_INPUTS, CHANNEL_TYPE_CURSOR,
 
55
                     CHANNEL_TYPE_PLAYBACK, CHANNEL_TYPE_RECORD]
 
56
 
 
57
    CHANNEL_MODE_SECURE   = "secure"
 
58
    CHANNEL_MODE_INSECURE = "insecure"
 
59
    CHANNEL_MODE_ANY      = "any"
 
60
    channel_modes = [CHANNEL_MODE_SECURE, CHANNEL_MODE_INSECURE,
 
61
                     CHANNEL_MODE_ANY]
34
62
 
35
63
    KEYMAP_LOCAL = "local"
 
64
    KEYMAP_DEFAULT = "default"
 
65
    _special_keymaps = [KEYMAP_LOCAL, KEYMAP_DEFAULT]
 
66
 
 
67
    @staticmethod
 
68
    def valid_keymaps():
 
69
        """
 
70
        Return a list of valid keymap values.
 
71
        """
 
72
        import keytable
 
73
 
 
74
        orig_list = keytable.keytable.values()
 
75
        sort_list = []
 
76
 
 
77
        orig_list.sort()
 
78
        for k in orig_list:
 
79
            if k not in sort_list:
 
80
                sort_list.append(k)
 
81
 
 
82
        return sort_list
36
83
 
37
84
    def __init__(self, type=TYPE_VNC, port=-1, listen=None, passwd=None,
38
 
                 keymap=None, conn=None):
39
 
 
40
 
        VirtualDevice.VirtualDevice.__init__(self, conn=conn)
41
 
 
42
 
        if type != self.TYPE_VNC and type != self.TYPE_SDL:
43
 
            raise ValueError(_("Unknown graphics type"))
44
 
 
45
 
        self._type   = type
46
 
        self._port = None
 
85
                 keymap=KEYMAP_DEFAULT, conn=None, parsexml=None,
 
86
                 parsexmlnode=None, tlsPort=-1, channels=None,
 
87
                 caps=None, passwdValidTo=None):
 
88
 
 
89
        VirtualDevice.VirtualDevice.__init__(self, conn,
 
90
                                             parsexml, parsexmlnode, caps)
 
91
 
 
92
        self._type   = None
 
93
        self._port   = None
 
94
        self._tlsPort = None
47
95
        self._listen = None
48
96
        self._passwd = None
 
97
        self._passwdValidTo = None
49
98
        self._keymap = None
50
 
 
51
 
        self.set_port(port)
52
 
        self.set_keymap(keymap)
53
 
        self.set_listen(listen)
54
 
        self.set_passwd(passwd)
 
99
        self._xauth = None
 
100
        self._display = None
 
101
        self._socket = None
 
102
        self._channels = {}
 
103
 
 
104
        if self._is_parse():
 
105
            return
 
106
 
 
107
        self.type = type
 
108
        self.port = port
 
109
        self.tlsPort = tlsPort
 
110
        self.keymap = keymap
 
111
        self.listen = listen
 
112
        self.passwd = passwd
 
113
        self.passwdValidTo = passwdValidTo
 
114
        if channels:
 
115
            self.channels = channels
 
116
 
55
117
 
56
118
    def _default_keymap(self):
57
119
        if (self.conn and
63
125
 
64
126
    def get_type(self):
65
127
        return self._type
66
 
    type = property(get_type)
 
128
    def set_type(self, val):
 
129
        if val not in self.types:
 
130
            raise ValueError(_("Unknown graphics type"))
 
131
 
 
132
        self._type = val
 
133
    type = _xml_property(get_type, set_type,
 
134
                         xpath="./@type")
 
135
 
 
136
    def _get_xauth(self):
 
137
        return self._xauth
 
138
    def _set_xauth(self, val):
 
139
        self._xauth = val
 
140
    xauth = _xml_property(_get_xauth, _set_xauth,
 
141
                          xpath="./@xauth")
 
142
 
 
143
    def _get_display(self):
 
144
        return self._display
 
145
    def _set_display(self, val):
 
146
        self._display = val
 
147
    display = _xml_property(_get_display, _set_display,
 
148
                            xpath="./@display")
67
149
 
68
150
    def get_keymap(self):
 
151
        if self._keymap == self.KEYMAP_DEFAULT:
 
152
            return self._default_keymap()
 
153
        if self._keymap == self.KEYMAP_LOCAL:
 
154
            return _util.default_keymap()
69
155
        return self._keymap
70
156
    def set_keymap(self, val):
71
 
        if not val:
72
 
            val = self._default_keymap()
73
 
 
 
157
        # At this point, 'None' is a valid value
74
158
        if val == None:
75
 
            # At this point, 'None' is a valid value
 
159
            self._keymap = None
 
160
            return
 
161
 
 
162
        if val in self._special_keymaps:
76
163
            self._keymap = val
77
164
            return
78
165
 
79
 
        if type(val) != type("string"):
80
 
            raise ValueError, _("Keymap must be a string")
81
 
 
 
166
        if type(val) is not str:
 
167
            raise ValueError(_("Keymap must be a string"))
82
168
        if val.lower() == self.KEYMAP_LOCAL:
83
169
            val = _util.default_keymap()
84
170
        elif len(val) > 16:
85
 
            raise ValueError, _("Keymap must be less than 16 characters")
 
171
            raise ValueError(_("Keymap must be less than 16 characters"))
86
172
        elif re.match("^[a-zA-Z0-9_-]*$", val) == None:
87
 
            raise ValueError, _("Keymap can only contain alphanumeric, '_', or '-' characters")
 
173
            raise ValueError(_("Keymap can only contain alphanumeric, "
 
174
                               "'_', or '-' characters"))
88
175
 
89
176
        self._keymap = val
90
 
    keymap = property(get_keymap, set_keymap)
 
177
    keymap = _xml_property(get_keymap, set_keymap,
 
178
                           xpath="./@keymap")
91
179
 
92
180
    def get_port(self):
93
181
        return self._port
94
182
    def set_port(self, val):
95
183
        if val is None:
96
184
            val = -1
97
 
        elif type(val) is not int \
98
 
             or (val != -1 and (val < 5900 or val > 65535)):
99
 
            raise ValueError, _("VNC port must be a number between 5900 and 65535, or -1 for auto allocation")
 
185
 
 
186
        try:
 
187
            val = int(val)
 
188
        except:
 
189
            pass
 
190
 
 
191
        if (type(val) is not int or
 
192
            (val != -1 and (val < 5900 or val > 65535))):
 
193
            raise ValueError(_("VNC port must be a number between "
 
194
                               "5900 and 65535, or -1 for auto allocation"))
100
195
        self._port = val
101
 
    port = property(get_port, set_port)
 
196
    port = _xml_property(get_port, set_port,
 
197
                         get_converter=lambda s, x: int(x or -1),
 
198
                         xpath="./@port")
102
199
 
103
200
    def get_listen(self):
104
201
        return self._listen
105
202
    def set_listen(self, val):
106
203
        self._listen = val
107
 
    listen = property(get_listen, set_listen)
 
204
    listen = _xml_property(get_listen, set_listen,
 
205
                           xpath="./@listen")
108
206
 
109
207
    def get_passwd(self):
110
208
        return self._passwd
111
209
    def set_passwd(self, val):
112
210
        self._passwd = val
113
 
    passwd = property(get_passwd, set_passwd)
114
 
 
115
 
    def valid_keymaps(self):
116
 
        """
117
 
        Return a list of valid keymap values.
118
 
        """
119
 
        import keytable
120
 
 
121
 
        orig_list = keytable.keytable.values()
122
 
        sort_list = []
123
 
 
124
 
        orig_list.sort()
125
 
        for k in orig_list:
126
 
            if k not in sort_list:
127
 
                sort_list.append(k)
128
 
 
129
 
        return sort_list
 
211
    passwd = _xml_property(get_passwd, set_passwd,
 
212
                           xpath="./@passwd")
 
213
 
 
214
    def get_passwdValidTo(self):
 
215
        return self._passwdValidTo
 
216
    def set_passwdValidTo(self, val):
 
217
        self._passwdValidTo = val
 
218
    passwdValidTo = _xml_property(get_passwdValidTo, set_passwdValidTo,
 
219
                                  xpath="./@passwdValidTo")
 
220
 
 
221
    def _get_socket(self):
 
222
        return self._socket
 
223
    def _set_socket(self, val):
 
224
        self._socket = val
 
225
    socket = _xml_property(_get_socket, _set_socket,
 
226
                           xpath="./@socket")
 
227
 
 
228
    def get_tlsPort(self):
 
229
        return self._tlsPort
 
230
    def set_tlsPort(self, val):
 
231
        if val is None:
 
232
            val = -1
 
233
 
 
234
        try:
 
235
            val = int(val)
 
236
        except:
 
237
            pass
 
238
 
 
239
        if (type(val) is not int or
 
240
            (val != -1 and (val < 5900 or val > 65535))):
 
241
            raise ValueError(_("TLS port must be a number between "
 
242
                               "5900 and 65535, or -1 for auto allocation"))
 
243
        self._tlsPort = val
 
244
    tlsPort = _xml_property(get_tlsPort, set_tlsPort,
 
245
                            get_converter=lambda s, x: int(x or -1),
 
246
                            xpath="./@tlsPort")
 
247
 
 
248
    channel_main_mode = _get_mode_prop(CHANNEL_TYPE_MAIN)
 
249
    channel_display_mode = _get_mode_prop(CHANNEL_TYPE_DISPLAY)
 
250
    channel_inputs_mode = _get_mode_prop(CHANNEL_TYPE_INPUTS)
 
251
    channel_cursor_mode = _get_mode_prop(CHANNEL_TYPE_CURSOR)
 
252
    channel_playback_mode = _get_mode_prop(CHANNEL_TYPE_PLAYBACK)
 
253
    channel_record_mode = _get_mode_prop(CHANNEL_TYPE_RECORD)
 
254
 
 
255
    def _build_xml(self, port=None, listen=None, keymap=None, passwd=None,
 
256
                   display=None, xauth=None, tlsPort=None, autoport=False,
 
257
                   passwdValidTo=None, socket=None):
 
258
 
 
259
        doautoport = (autoport and (port == -1 or tlsPort == -1))
 
260
        portxml     = (port != None and (" port='%d'" % port) or "")
 
261
        tlsportxml  = (tlsPort != None and (" tlsPort='%d'" % tlsPort) or "")
 
262
        autoportxml = (doautoport and " autoport='yes'" or "")
 
263
 
 
264
        keymapxml   = (keymap and (" keymap='%s'" % keymap) or "")
 
265
        listenxml   = (listen and (" listen='%s'" % listen) or "")
 
266
        passwdxml   = (passwd and (" passwd='%s'" % passwd) or "")
 
267
        passwdValidToxml = (passwdValidTo and
 
268
                            ( "passwdValidTo='%s'" % passwdValidTo) or "")
 
269
 
 
270
        xauthxml    = (xauth and  (" xauth='%s'" % xauth) or "")
 
271
        displayxml  = (display and (" display='%s'" % display) or "")
 
272
 
 
273
        socketxml   = (socket and (" socket='%s'" % socket) or "")
 
274
 
 
275
        xml = ("    " +
 
276
               "<graphics type='%s'" % self.type +
 
277
               portxml +
 
278
               tlsportxml +
 
279
               autoportxml +
 
280
               keymapxml +
 
281
               listenxml +
 
282
               passwdxml +
 
283
               passwdValidToxml +
 
284
               socketxml +
 
285
               displayxml +
 
286
               xauthxml +
 
287
               "/>")
 
288
        return xml
130
289
 
131
290
    def _sdl_config(self):
132
 
        if not os.environ.has_key("DISPLAY"):
 
291
        if "DISPLAY" not in os.environ and not self.display:
133
292
            raise RuntimeError("No DISPLAY environment variable set.")
134
293
 
135
 
        disp  = os.environ["DISPLAY"]
136
 
        xauth = os.path.expanduser("~/.Xauthority")
137
 
 
138
 
        return """    <graphics type='sdl' display='%s' xauth='%s'/>""" % \
139
 
               (disp, xauth)
140
 
 
141
 
    def get_xml_config(self):
 
294
        disp  = self.display or os.environ["DISPLAY"]
 
295
        xauth = self.xauth or os.path.expanduser("~/.Xauthority")
 
296
 
 
297
        return self._build_xml(display=disp, xauth=xauth)
 
298
 
 
299
    def _spice_config(self):
 
300
        return self._build_xml(port=self.port, keymap=self.keymap,
 
301
                               passwd=self.passwd, listen=self.listen,
 
302
                               tlsPort=self.tlsPort, autoport=True,
 
303
                               passwdValidTo=self.passwdValidTo)
 
304
 
 
305
    def _vnc_config(self):
 
306
        return self._build_xml(port=self.port, keymap=self.keymap,
 
307
                               passwd=self.passwd, listen=self.listen,
 
308
                               passwdValidTo=self.passwdValidTo,
 
309
                               socket=self.socket)
 
310
 
 
311
    def _get_xml_config(self):
142
312
        if self._type == self.TYPE_SDL:
143
313
            return self._sdl_config()
144
 
        keymapxml = ""
145
 
        listenxml = ""
146
 
        passwdxml = ""
147
 
        if self.keymap:
148
 
            keymapxml = " keymap='%s'" % self._keymap
149
 
        if self.listen:
150
 
            listenxml = " listen='%s'" % self._listen
151
 
        if self.passwd:
152
 
            passwdxml = " passwd='%s'" % self._passwd
153
 
        xml = "    <graphics type='vnc' " + \
154
 
                   "port='%(port)d'" % { "port" : self._port } + \
155
 
                   "%(keymapxml)s"   % { "keymapxml" : keymapxml } + \
156
 
                   "%(listenxml)s"   % { "listenxml" : listenxml } + \
157
 
                   "%(passwdxml)s"   % { "passwdxml" : passwdxml } + \
158
 
                   "/>"
159
 
        return xml
 
314
        if self._type == self.TYPE_SPICE:
 
315
            return self._spice_config()
 
316
        if self._type == self.TYPE_VNC:
 
317
            return self._vnc_config()
 
318
        else:
 
319
            raise ValueError(_("Unknown graphics type"))