← Back to branch summary

~ubuntu-branches/ubuntu/precise/virtinst/precise-updates

« back to all changes in this revision

Viewing changes to virtinst/VirtualController.py

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2012-02-11 11:47:53 UTC
  • mfrom: (1.6.6 sid)
  • Revision ID: package-import@ubuntu.com-20120211114753-sq9f3xayrma8px2h
Tags: 0.600.1-1ubuntu1
* Merge from debian unstable. Remaining changes:
  - 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.
  - debian/patches/9004_ubuntu_fix_tree_support.patch: Fix tree detection
    for all ISO/HTTP source, to not longer fail with cobbler/koan.
  - debian/patches/9005_ubuntu_precise.patch: Add Ubuntu precise as a
    supported distro.
  - debian/{control,rules,pyversions}: Build using dh_python2, use
    debhelper v8 instead of cdbs; for some reason the package build an
    empty binary package when using dh_python2.
  - debian/control: added acl package to depends.
  - debian/control: added libvirt-bin to recommends

Show diffs side-by-side

added added

removed removed

Lines of Context:
virtinst/VirtualController.py
19
19
 
20
20
import VirtualDevice
21
21
#from virtinst import _gettext as _
22
 
from XMLBuilderDomain import _xml_property
 
22
from XMLBuilderDomain import XMLBuilderDomain, _xml_property
 
23
import logging
23
24
 
24
25
class VirtualController(VirtualDevice.VirtualDevice):
25
26
 
30
31
    CONTROLLER_TYPE_SCSI            = "scsi"
31
32
    CONTROLLER_TYPE_SATA            = "sata"
32
33
    CONTROLLER_TYPE_VIRTIOSERIAL    = "virtio-serial"
 
34
    CONTROLLER_TYPE_USB             = "usb"
33
35
    CONTROLLER_TYPES = [CONTROLLER_TYPE_IDE, CONTROLLER_TYPE_FDC,
34
36
                        CONTROLLER_TYPE_SCSI, CONTROLLER_TYPE_SATA,
35
 
                        CONTROLLER_TYPE_VIRTIOSERIAL]
 
37
                        CONTROLLER_TYPE_VIRTIOSERIAL, CONTROLLER_TYPE_USB]
36
38
 
37
39
    @staticmethod
38
40
    def pretty_type(ctype):
41
43
            VirtualController.CONTROLLER_TYPE_FDC           : "Floppy",
42
44
            VirtualController.CONTROLLER_TYPE_SCSI          : "SCSI",
43
45
            VirtualController.CONTROLLER_TYPE_SATA          : "SATA",
44
 
            VirtualController.CONTROLLER_TYPE_VIRTIOSERIAL  : "Virtio Serial"
 
46
            VirtualController.CONTROLLER_TYPE_VIRTIOSERIAL  : "Virtio Serial",
 
47
            VirtualController.CONTROLLER_TYPE_USB           : "USB"
45
48
        }
46
49
 
47
50
        if ctype not in pretty_mappings:
63
66
            return VirtualControllerSATA
64
67
        elif ctype == VirtualController.CONTROLLER_TYPE_VIRTIOSERIAL:
65
68
            return VirtualControllerVirtioSerial
 
69
        elif ctype == VirtualController.CONTROLLER_TYPE_USB:
 
70
            return VirtualControllerUSB
66
71
 
67
72
    _controller_type = None
68
73
 
69
 
    def __init__(self, conn, parsexml=None, parsexmlnode=None, caps=None):
 
74
    def __init__(self, conn, parsexml=None, parsexmlnode=None, caps=None,
 
75
                 model=None):
70
76
        VirtualDevice.VirtualDevice.__init__(self, conn,
71
77
                                             parsexml, parsexmlnode, caps)
72
78
 
73
79
        self._index = 0
74
80
        self._ports = None
75
81
        self._vectors = None
 
82
        self._model = None
 
83
        self._master = VirtualDeviceMaster(conn,
 
84
                                           parsexml=parsexml,
 
85
                                           parsexmlnode=parsexmlnode,
 
86
                                           caps=caps)
 
87
 
 
88
        if self._is_parse():
 
89
            return
 
90
 
 
91
        self.model = model
76
92
 
77
93
    def get_type(self):
78
94
        return self._controller_type
79
95
    type = _xml_property(get_type,
80
96
                         xpath="./@type")
81
97
 
 
98
    def get_model(self):
 
99
        return self._model
 
100
    def set_model(self, model):
 
101
        self._model = model
 
102
    model = _xml_property(get_model, set_model,
 
103
                         xpath="./@model")
 
104
 
82
105
    def get_index(self):
83
106
        return self._index
84
107
    def set_index(self, val):
100
123
    ports = _xml_property(get_ports, set_ports,
101
124
                          xpath="./@ports")
102
125
 
 
126
    def set_master(self, masterstr):
 
127
        self._master.parse_friendly_master(masterstr)
 
128
    def get_master(self):
 
129
        return self._master
 
130
 
103
131
    def _extra_config(self):
104
132
        return ""
105
133
 
107
135
        extra = self._extra_config()
108
136
 
109
137
        xml = "    <controller type='%s' index='%s'" % (self.type, self.index)
 
138
        if self.model:
 
139
            xml += " model='%s'" % self.model
110
140
        xml += extra
111
 
        xml += "/>"
112
 
 
 
141
        childxml = self.indent(self._master.get_xml_config(), 6)
 
142
        childxml += self.indent(self.address.get_xml_config(), 6)
 
143
        if len(childxml) == 0:
 
144
            return xml + "/>"
 
145
        xml += ">\n"
 
146
        xml += childxml
 
147
        xml += "    </controller>"
113
148
        return xml
114
149
 
115
150
 
136
171
            xml += " vectors='%s'" % self.vectors
137
172
 
138
173
        return xml
 
174
 
 
175
class VirtualControllerUSB(VirtualController):
 
176
    _controller_type = VirtualController.CONTROLLER_TYPE_USB
 
177
 
 
178
 
 
179
class VirtualDeviceMaster(XMLBuilderDomain):
 
180
    def __init__(self, conn, parsexml=None, parsexmlnode=None, caps=None):
 
181
        XMLBuilderDomain.__init__(self, conn, parsexml, parsexmlnode,
 
182
                                  caps=caps)
 
183
 
 
184
        self._startport = None
 
185
 
 
186
    def parse_friendly_master(self, masterstr):
 
187
        try:
 
188
            int(masterstr)
 
189
            self._startport = masterstr
 
190
        except:
 
191
            logging.exception("Error parsing device master.")
 
192
            return None
 
193
 
 
194
    def _get_startport(self):
 
195
        return self._startport
 
196
    def _set_startport(self, val):
 
197
        self._startport = val
 
198
    startport = _xml_property(_get_startport, _set_startport, xpath="./master/@startport")
 
199
 
 
200
    def _get_xml_config(self):
 
201
        if self.startport is None:
 
202
            return
 
203
 
 
204
        return "<master startport='%s'/>" % self.startport