← Back to branch summary

~ubuntu-branches/ubuntu/precise/system-config-kickstart/precise

« back to all changes in this revision

Viewing changes to src/raidWindow.py

  • Committer: Bazaar Package Importer
  • Author(s): Colin Watson
  • Date: 2005-04-04 15:16:36 UTC
  • Revision ID: james.westby@ubuntu.com-20050404151636-ihn83k6dkgc1i3dj
Tags: upstream-2.5.20
Import upstream version 2.5.20

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/raidWindow.py
 
1
## raidWindow.py - code for redhat-config-kickstart's raid dialog
 
2
## Copyright (C) 2001, 2002, 2003 Red Hat, Inc.
 
3
## Copyright (C) 2001, 2002, 2003 Brent Fox <bfox@redhat.com>
 
4
## Copyright (C) 2001, 2002, 2003 Tammy Fox <tfox@redhat.com>
 
5
 
 
6
## This program is free software; you can redistribute it and/or modify
 
7
## it under the terms of the GNU General Public License as published by
 
8
## the Free Software Foundation; either version 2 of the License, or
 
9
## (at your option) any later version.
 
10
 
 
11
## This program is distributed in the hope that it will be useful,
 
12
## but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
## GNU General Public License for more details.
 
15
 
 
16
## You should have received a copy of the GNU General Public License
 
17
## along with this program; if not, write to the Free Software
 
18
## Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
19
 
 
20
import string
 
21
import gtk
 
22
import gobject
 
23
import getopt
 
24
import signal
 
25
import partWindow
 
26
import raidWindow
 
27
import partEntry
 
28
import kickstartGui
 
29
 
 
30
##
 
31
## I18N
 
32
## 
 
33
from rhpl.translate import _, N_
 
34
import rhpl.translate as translate
 
35
domain = 'system-config-kickstart'
 
36
translate.textdomain (domain)
 
37
gtk.glade.bindtextdomain(domain)
 
38
 
 
39
class raidWindow:
 
40
    def __init__(self, xml, part_store, part_view):
 
41
        self.xml = xml
 
42
        self.part_store = part_store
 
43
        self.part_view = part_view
 
44
        self.original_partitions = None
 
45
        
 
46
        self.raid_window = xml.get_widget("raid_window")
 
47
        self.raid_window.connect("delete-event", self.destroy)
 
48
        toplevel = self.xml.get_widget("main_window")
 
49
        self.raid_window.set_transient_for(toplevel)
 
50
        self.raid_window.set_icon(kickstartGui.iconPixbuf)
 
51
        self.raid_mp_combo = xml.get_widget("raid_mp_combo")
 
52
        self.raid_fsType_menu = xml.get_widget("raid_fsType_menu")
 
53
        self.raid_device_menu = xml.get_widget("raid_device_menu")
 
54
        self.raid_level_menu = xml.get_widget("raid_level_menu")
 
55
        self.raid_partitions_view = xml.get_widget("raid_partitions_view")
 
56
        self.raid_spares_spin = xml.get_widget("raid_spares_spin")
 
57
        self.raid_format_check = xml.get_widget("raid_format_check")
 
58
        self.raid_ok_button = xml.get_widget("raid_ok_button")
 
59
        self.raid_cancel_button = xml.get_widget("raid_cancel_button")        
 
60
 
 
61
        mountPoints = ["/", "/boot", "/home", "/var", "/tmp", "/usr", "/opt"]
 
62
        self.fsTypesList = [ "ext2", "ext3", "raid", "swap", "vfat" ]
 
63
        self.raidDeviceList = ['md0', 'md1', 'md2', 'md3', 'md4', 'md5',
 
64
                               'md6', 'md7', 'md8', 'md9', 'md10', 'md11',
 
65
                               'md12', 'md13', 'md14', 'md15']
 
66
        self.raidLevelList = [ "0", "1", "5" ]
 
67
        
 
68
        self.raid_mp_combo.set_popdown_strings(mountPoints)
 
69
 
 
70
        self.raid_partition_store = gtk.ListStore(gobject.TYPE_BOOLEAN, gobject.TYPE_STRING,
 
71
                                                  gobject.TYPE_PYOBJECT, gobject.TYPE_PYOBJECT)
 
72
 
 
73
        self.checkbox = gtk.CellRendererToggle()
 
74
        col = gtk.TreeViewColumn('', self.checkbox, active = 0)
 
75
        col.set_fixed_width(20)
 
76
        col.set_clickable(gtk.TRUE)
 
77
        self.checkbox.connect("toggled", self.partitionToggled)
 
78
        self.raid_partitions_view.append_column(col)
 
79
 
 
80
        col = gtk.TreeViewColumn("", gtk.CellRendererText(), text=1)
 
81
        self.raid_partitions_view.append_column(col)
 
82
 
 
83
        self.raid_partitions_view.set_model(self.raid_partition_store)
 
84
 
 
85
        self.raid_ok_button.connect("clicked", self.okClicked)
 
86
        self.raid_cancel_button.connect("clicked", self.destroy)
 
87
        self.raid_fsType_menu.connect("changed", self.on_raid_fsType_menu_changed)
 
88
 
 
89
    def on_raid_fsType_menu_changed(self, *args):
 
90
        if self.raid_fsType_menu.get_children()[0].get_text() == "swap":
 
91
            #it's a swap partition, so desensitize the mountPoint combo
 
92
            self.raid_mp_combo.set_sensitive(gtk.FALSE)
 
93
        else:
 
94
            self.raid_mp_combo.set_sensitive(gtk.TRUE)            
 
95
 
 
96
    def addPartition(self):
 
97
        self.raid_partition_store.clear()
 
98
        self.original_partitions = None
 
99
        self.original_iter = None
 
100
        self.part_store.foreach(self.countRaidPartitions)
 
101
        self.raid_window.show_all()
 
102
 
 
103
    def editDevice(self, iter, part_object):
 
104
        self.original_iter = iter
 
105
        self.raid_partition_store.clear()
 
106
        self.raid_mp_combo.entry.set_text(part_object.mountPoint)
 
107
 
 
108
        fsType = part_object.fsType
 
109
        index = self.fsTypesList.index(fsType)
 
110
        self.raid_fsType_menu.set_history(index)
 
111
 
 
112
        device = part_object.raidDevice
 
113
        index = self.raidDeviceList.index(device)
 
114
        self.raid_device_menu.set_history(index)
 
115
        
 
116
        level = part_object.raidLevel
 
117
        index = self.raidLevelList.index(level)
 
118
        self.raid_level_menu.set_history(index)
 
119
        
 
120
        self.original_partitions = part_object.raidPartitions
 
121
        self.part_store.foreach(self.countRaidPartitions, part_object.raidPartitions)
 
122
 
 
123
        self.raid_window.show_all()
 
124
 
 
125
    def countRaidPartitions(self, store, data, iter, raidPartitions = None):
 
126
        part_object = self.part_store.get_value(iter, 5)
 
127
 
 
128
        if part_object and part_object.raidNumber:
 
129
            new_iter = self.raid_partition_store.append()
 
130
 
 
131
            if raidPartitions and part_object.raidNumber in raidPartitions:
 
132
                self.raid_partition_store.set_value(new_iter, 0, gtk.TRUE)
 
133
            else:
 
134
                self.raid_partition_store.set_value(new_iter, 0, gtk.FALSE)
 
135
                
 
136
            self.raid_partition_store.set_value(new_iter, 1, part_object.raidNumber)
 
137
            self.raid_partition_store.set_value(new_iter, 2, iter)
 
138
            self.raid_partition_store.set_value(new_iter, 3, part_object)
 
139
 
 
140
    def partitionToggled(self, data, row):
 
141
        iter = self.raid_partition_store.get_iter((int(row),))
 
142
        val = self.raid_partition_store.get_value(iter, 0)
 
143
        self.raid_partition_store.set_value(iter, 0 , not val)
 
144
 
 
145
    def okClicked(self, *args):
 
146
        fsType = self.raid_fsType_menu.get_children()[0].get_text()
 
147
        if fsType == "swap":
 
148
            mount_point = "swap"
 
149
        else:
 
150
            mount_point = self.raid_mp_combo.entry.get_text()
 
151
            
 
152
        raid_device = self.raid_device_menu.get_children()[0].get_text()
 
153
        raid_level = self.raid_level_menu.get_children()[0].get_text()
 
154
 
 
155
        raid_object = partEntry.partEntry()
 
156
        raid_object.mountPoint = mount_point
 
157
        raid_object.raidDevice = raid_device
 
158
        raid_object.raidLevel = raid_level
 
159
        raid_object.fsType = fsType
 
160
        raid_object.isRaidDevice = 1
 
161
 
 
162
        self.partition_list = []
 
163
        self.addRaidDeviceToTree(raid_object)
 
164
 
 
165
        self.raid_window.hide()
 
166
 
 
167
    def addRaidDeviceToTree(self, raid_object):        
 
168
        self.raid_partition_store.foreach(self.isRowToggled, raid_object)
 
169
 
 
170
        if raid_object.raidLevel == "0" or raid_object.raidLevel == "1":
 
171
            if len(self.partition_list) < 2:
 
172
                device_is_valid = self.deviceNotValid(_("You must select at least 2 partitions in order to use "
 
173
                                      "RAID %s" % raid_object.raidLevel))
 
174
            else:
 
175
                device_is_valid = 1
 
176
        elif raid_object.raidLevel == "5":
 
177
            if len(self.partition_list) < 3:
 
178
                device_is_valid = self.deviceNotValid(_("You must select at least 3 partitions in order to use "
 
179
                                      "RAID %s" % raid_object.raidLevel))
 
180
            else:
 
181
                device_is_valid = 1
 
182
 
 
183
        if device_is_valid:
 
184
 
 
185
            if not self.original_partitions:
 
186
                #then this is a new raid device, not one we're just editing
 
187
                self.raid_parent_iter = None
 
188
                self.part_store.foreach(self.checkForRaidParent)
 
189
 
 
190
                if self.raid_parent_iter == None:
 
191
                    self.raid_parent_iter = self.part_store.append(None)
 
192
                    self.part_store.set_value(self.raid_parent_iter, 0, (_("Raid Devices")))
 
193
 
 
194
                raid_device_iter = self.part_store.append(self.raid_parent_iter)
 
195
                self.part_store.set_value(raid_device_iter, 0, raid_object.mountPoint)
 
196
 
 
197
                self.num_raid_devices = None
 
198
                self.part_store.foreach(self.countRaidDevices)
 
199
 
 
200
            if self.original_iter:
 
201
                raid_device_iter = self.original_iter
 
202
                
 
203
            self.part_store.set_value(raid_device_iter, 0, raid_object.raidDevice)
 
204
            self.part_store.set_value(raid_device_iter, 1, raid_object.mountPoint)
 
205
            self.part_store.set_value(raid_device_iter, 2, raid_object.fsType)
 
206
            self.part_store.set_value(raid_device_iter, 5, raid_object)
 
207
 
 
208
            if self.raid_format_check.get_active() == gtk.TRUE:
 
209
                raid_object.doFormat = 1
 
210
 
 
211
            if raid_object.doFormat == 1:
 
212
                self.part_store.set_value(raid_device_iter, 3, (_("Yes")))
 
213
            else:
 
214
                self.part_store.set_value(raid_device_iter, 3, (_("No")))
 
215
        self.part_view.expand_all()
 
216
 
 
217
    def checkForRaidParent(self, store, data, iter):
 
218
        if self.part_store.get_value(iter, 0) == (_("Raid Devices")):
 
219
            self.raid_parent_iter = iter
 
220
 
 
221
    def isRowToggled(self, store, data, iter, raid_object):
 
222
        if self.raid_partition_store.get_value(iter, 0) == gtk.TRUE:
 
223
            self.partition_list.append(self.raid_partition_store.get_value(iter, 1))
 
224
            partition_iter = self.raid_partition_store.get_value(iter,2)
 
225
            part_object = self.raid_partition_store.get_value(iter, 3)
 
226
 
 
227
            raid_object.raidPartitions.append(part_object.raidNumber)
 
228
            raid_object.raidPartitionObjects.append(part_object)
 
229
            self.part_store.set_value(partition_iter, 1, raid_object.raidDevice)
 
230
 
 
231
        elif self.raid_partition_store.get_value(iter, 0) == gtk.FALSE:
 
232
            partition_iter = self.raid_partition_store.get_value(iter,2)
 
233
            part_object = self.raid_partition_store.get_value(iter, 3)            
 
234
            if self.original_partitions:
 
235
                if part_object.raidNumber in self.original_partitions:
 
236
                    part_object.raidDevice = ""
 
237
                    self.part_store.set_value(partition_iter, 1, "")
 
238
 
 
239
    def countRaidDevices(self, store, data, iter):
 
240
        part_object = self.part_store.get_value(iter, 5)
 
241
        if part_object:
 
242
            if part_object.device and part_object.device[:2] == 'md':
 
243
                self.num_raid_devices = self.num_raid_devices + 1
 
244
        
 
245
    def deviceNotValid(self, label):
 
246
        dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, label)
 
247
        dlg.set_title(_("Error"))
 
248
        dlg.set_default_size(100, 100)
 
249
        dlg.set_position (gtk.WIN_POS_CENTER)
 
250
        dlg.set_border_width(2)
 
251
        dlg.set_modal(gtk.TRUE)
 
252
        dlg.set_transient_for(self.raid_window)
 
253
        rc = dlg.run()
 
254
        if rc == gtk.RESPONSE_OK:
 
255
            dlg.hide()
 
256
        return None
 
257
 
 
258
    def destroy(self, *args):
 
259
        self.raid_window.hide()
 
260
        return gtk.TRUE
 
261
 
 
262
    def populateRaid(self, line):
 
263
        raid_object = partEntry.partEntry()
 
264
        raid_object.isRaidDevice = 1
 
265
        self.original_iter = None
 
266
        result = self.parseRaidLine(raid_object, line)
 
267
 
 
268
        if result is None:
 
269
            return
 
270
        else:
 
271
#            self.markRaidPartitions(raid_object)
 
272
            self.raid_partition_store.foreach(self.markRaidPartitions, raid_object)
 
273
            self.addRaidDeviceToTree(raid_object)
 
274
 
 
275
    def parseRaidLine(self, raid_object, line):
 
276
        opts, raidPartitions = getopt.getopt(line[1:], "d:h", ["level=", "device=", "spares=", "fstype=", "noformat"])
 
277
 
 
278
        for (opt, value) in opts:
 
279
            if line[0] == "swap":
 
280
                raid_object.fsType = "swap"
 
281
                raid_object.mountPoint = "swap"
 
282
            elif opt == "--fstype":
 
283
                raid_object.fsType = value
 
284
                raid_object.mountPoint = line[0]
 
285
 
 
286
            if opt == "--level":
 
287
                raid_object.raidLevel = value
 
288
            if opt == "--device":
 
289
                raid_object.raidDevice = value
 
290
            if opt == "--noformat":
 
291
                raid_object.doFormat = 0
 
292
            else:
 
293
                raid_object.doFormat = 1
 
294
 
 
295
        self.partition_list = raidPartitions
 
296
        raid_object.raidPartitions = raidPartitions
 
297
 
 
298
        self.raid_partition_store.clear()
 
299
        self.part_store.foreach(self.countRaidPartitions)
 
300
 
 
301
        return 0
 
302
    
 
303
    def markRaidPartitions(self, store, data, iter, raid_object):
 
304
        if self.raid_partition_store.get_value(iter, 1) in raid_object.raidPartitions:
 
305
 
 
306
            partition_iter = self.raid_partition_store.get_value(iter, 2)
 
307
            part_object = self.raid_partition_store.get_value(iter, 3)
 
308
            self.part_store.set_value(partition_iter, 1, raid_object.raidDevice)