← Back to branch summary

~ubuntu-branches/ubuntu/vivid/openipmi/vivid

« back to all changes in this revision

Viewing changes to swig/python/openipmigui/_mc_user.py

  • Committer: Bazaar Package Importer
  • Author(s): Noèl Köthe
  • Date: 2006-09-15 17:56:24 UTC
  • mfrom: (1.1.2 upstream) (2.1.1 etch)
  • Revision ID: james.westby@ubuntu.com-20060915175624-ljk0mg3xtcm65tvm
Tags: 2.0.7-1
http://bugs.debian.org/380149
* new upstream release from 2006-06-08
  Thanks to John Wright <john.wright hp.com> for initial work
  (closes: Bug#380149)
* updated Standards Version
* new binaries openipmicmd, openipmish, rmcp_ping

Show diffs side-by-side

added added

removed removed

Lines of Context:
swig/python/openipmigui/_mc_user.py
 
1
# _mc_user.py
 
2
#
 
3
# openipmi GUI handling for MC users
 
4
#
 
5
# Author: MontaVista Software, Inc.
 
6
#         Corey Minyard <minyard@mvista.com>
 
7
#         source@mvista.com
 
8
#
 
9
# Copyright 2005 MontaVista Software Inc.
 
10
#
 
11
#  This program is free software; you can redistribute it and/or
 
12
#  modify it under the terms of the GNU Lesser General Public License
 
13
#  as published by the Free Software Foundation; either version 2 of
 
14
#  the License, or (at your option) any later version.
 
15
#
 
16
#
 
17
#  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 
18
#  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 
19
#  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 
20
#  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
21
#  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 
22
#  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 
23
#  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 
24
#  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 
25
#  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 
26
#  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
27
#
 
28
#  You should have received a copy of the GNU Lesser General Public
 
29
#  License along with this program; if not, write to the Free
 
30
#  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
31
#
 
32
 
 
33
import OpenIPMI
 
34
import gui_popup
 
35
import gui_treelist
 
36
import gui_setdialog
 
37
import _oi_logging
 
38
import _mc_lanparm
 
39
 
 
40
class BoolSetter:
 
41
    def __init__(self, mcusers, user, setter):
 
42
        self.mcusers = mcusers
 
43
        self.setter = setter
 
44
        self.user = user
 
45
        return
 
46
    
 
47
    def SetItem(self, item):
 
48
        self.item = item
 
49
        return
 
50
    
 
51
    def HandleMenu(self, event, eitem, point):
 
52
        gui_popup.popup(self.mcusers, event,
 
53
                        [ ("Toggle Value", self.togglevalue) ],
 
54
                        point)
 
55
        return
 
56
 
 
57
    def togglevalue(self, event):
 
58
        val = str(self.mcusers.GetColumn(self.item, 1))
 
59
        if (val == "True") or (val == "true"):
 
60
            val = "false"
 
61
            bval = 0
 
62
        else:
 
63
            val = "true"
 
64
            bval = 1
 
65
            pass
 
66
        rv = self.setter(bval)
 
67
        if (rv):
 
68
            self.mcusers.SetError("Could not toggle value: "
 
69
                                   + OpenIPMI.get_error_string(rv), 0)
 
70
            return
 
71
        self.user.changed = True
 
72
        self.mcusers.SetColumn(self.item, val, 1);
 
73
        return
 
74
 
 
75
    pass
 
76
 
 
77
class IntSetter:
 
78
    def __init__(self, mcusers, user, setter, name, currval):
 
79
        self.mcusers = mcusers
 
80
        self.setter = setter
 
81
        self.name = name
 
82
        self.currval = currval
 
83
        self.user = user
 
84
        return
 
85
    
 
86
    def SetItem(self, item):
 
87
        self.item = item
 
88
        return
 
89
    
 
90
    def HandleMenu(self, event, eitem, point):
 
91
        gui_popup.popup(self.mcusers, event,
 
92
                        [ ("Modify Value", self.modval) ],
 
93
                        point)
 
94
        return
 
95
 
 
96
    def modval(self, event):
 
97
        gui_setdialog.SetDialog("Set Value for " + self.name,
 
98
                                [ str(self.currval) ],
 
99
                                1,
 
100
                                self)
 
101
        return
 
102
 
 
103
    def ok(self, vals):
 
104
        val = int(vals[0])
 
105
        rv = self.setter(val)
 
106
        if (rv):
 
107
            return ("Could not set value: "
 
108
                    + OpenIPMI.get_error_string(rv))
 
109
        self.user.changed = True
 
110
        self.mcusers.SetColumn(self.item, str(val), 1)
 
111
        self.currval = val
 
112
        return
 
113
 
 
114
    pass
 
115
 
 
116
class StrSetter:
 
117
    def __init__(self, mcusers, user, setter, name, currval, prompt):
 
118
        self.mcusers = mcusers
 
119
        self.setter = setter
 
120
        self.name = name
 
121
        self.currval = currval
 
122
        self.user = user
 
123
        self.prompt = prompt
 
124
        return
 
125
    
 
126
    def SetItem(self, item):
 
127
        self.item = item
 
128
        return
 
129
    
 
130
    def HandleMenu(self, event, eitem, point):
 
131
        gui_popup.popup(self.mcusers, event,
 
132
                        [ (self.prompt, self.modval) ],
 
133
                        point)
 
134
        return
 
135
 
 
136
    def modval(self, event):
 
137
        gui_setdialog.SetDialog(self.prompt + " for " + self.name,
 
138
                                [ str(self.currval) ],
 
139
                                1,
 
140
                                self)
 
141
        return
 
142
 
 
143
    def ok(self, vals):
 
144
        val = str(vals[0])
 
145
        rv = self.setter(val)
 
146
        if (rv):
 
147
            return ("Could not set value: "
 
148
                    + OpenIPMI.get_error_string(rv))
 
149
        self.user.changed = True
 
150
        self.mcusers.SetColumn(self.item, str(val), 1)
 
151
        self.currval = val
 
152
        return
 
153
 
 
154
    pass
 
155
 
 
156
def GetPrivilegeString(val):
 
157
    if (val == 15):
 
158
        return "NO ACCESS"
 
159
    else:
 
160
        return OpenIPMI.privilege_string(val)
 
161
    return
 
162
 
 
163
class PrivSetter:
 
164
    def __init__(self, mcusers, user, setter):
 
165
        self.mcusers = mcusers
 
166
        self.setter = setter
 
167
        self.user = user
 
168
        return
 
169
    
 
170
    def SetItem(self, item):
 
171
        self.item = item
 
172
        return
 
173
    
 
174
    def HandleMenu(self, event, eitem, point):
 
175
        gui_popup.popup(self.mcusers, event,
 
176
                        [ ("Callback", self.callback),
 
177
                          ("User", self.handleuser),
 
178
                          ("Operator", self.operator),
 
179
                          ("Admin", self.admin),
 
180
                          ("OEM", self.oem),
 
181
                          ("NO ACCESS", self.noaccess) ],
 
182
                        point)
 
183
        return
 
184
 
 
185
    def setval(self, val):
 
186
        rv = self.setter(val)
 
187
        if (rv):
 
188
            mcusers.SetError("Could not set value: "
 
189
                             + OpenIPMI.get_error_string(rv))
 
190
            return
 
191
        self.user.changed = True
 
192
        self.mcusers.SetColumn(self.item, GetPrivilegeString(val), 1)
 
193
        return
 
194
        
 
195
    def callback(self, event):
 
196
        self.setval(OpenIPMI.PRIVILEGE_CALLBACK)
 
197
        return
 
198
 
 
199
    def handleuser(self, event):
 
200
        self.setval(OpenIPMI.PRIVILEGE_USER)
 
201
        return
 
202
 
 
203
    def operator(self, event):
 
204
        self.setval(OpenIPMI.PRIVILEGE_OPERATOR)
 
205
        return
 
206
 
 
207
    def admin(self, event):
 
208
        self.setval(OpenIPMI.PRIVILEGE_ADMIN)
 
209
        return
 
210
 
 
211
    def oem(self, event):
 
212
        self.setval(OpenIPMI.PRIVILEGE_OEM)
 
213
        return
 
214
 
 
215
    def noaccess(self, event):
 
216
        self.setval(15)
 
217
        return
 
218
 
 
219
    pass
 
220
 
 
221
def IntToBoolStr(v):
 
222
    if (v):
 
223
        return "true"
 
224
    else:
 
225
        return "false"
 
226
    return
 
227
 
 
228
class SetUserHandler:
 
229
    def __init__(self, mcusers, num):
 
230
        self.mcusers = mcusers
 
231
        self.num = num
 
232
        return
 
233
 
 
234
    def mc_channel_set_user_cb(self, mc, err):
 
235
        self.mcusers.user_set(mc, err, self.num)
 
236
        return
 
237
 
 
238
    pass
 
239
 
 
240
class MCUsers(gui_treelist.TreeList):
 
241
    def __init__(self, mc, channel, max_users, enabled_users, fixed_users,
 
242
                 users):
 
243
        gui_treelist.TreeList.__init__(self, "user info for " + mc.get_name()
 
244
                                       + " channel " + str(channel),
 
245
                                       "Users",
 
246
                                       [ ("Name", 300), ("Value", 400) ] )
 
247
        
 
248
        self.mc_id = mc.get_id()
 
249
        self.count = 0;
 
250
        self.users = users
 
251
        self.channel = channel
 
252
        self.in_save = False
 
253
 
 
254
        item = self.add_data(self.treeroot, "Max Users", [ str(max_users) ])
 
255
        item = self.add_data(self.treeroot, "Enabled Users",
 
256
                           [ str(enabled_users) ])
 
257
        item = self.add_data(self.treeroot, "Fixed Users", [str(fixed_users)])
 
258
        
 
259
        for u in users:
 
260
            v = [ 0 ]
 
261
            rv = u.get_num(v)
 
262
            u.changed = False
 
263
            num = v[0]
 
264
            if (rv == 0):
 
265
                u.num = num
 
266
                nm = u.get_name()
 
267
                setter = StrSetter(self, u, u.set_password_auto,
 
268
                                   "Password", "", "Set Password")
 
269
                if (nm):
 
270
                    nm = str(nm)
 
271
                    us = self.add_data(self.treeroot, str(num), [nm], setter)
 
272
                else:
 
273
                    us = self.add_data(self.treeroot, str(num), [], setter)
 
274
                    nm = ""
 
275
                    pass
 
276
                setter.SetItem(us)
 
277
                if (num > fixed_users):
 
278
                    setter = StrSetter(self, u, u.set_name, "Name", nm,
 
279
                                       "Modify Value")
 
280
                else:
 
281
                    setter = None;
 
282
                    pass
 
283
                item = self.add_data(us, "Name", [nm], setter)
 
284
 
 
285
                rv = u.get_enable(v)
 
286
                if (rv == 0):
 
287
                    s = IntToBoolStr(v[0])
 
288
                else:
 
289
                    s = "?"
 
290
                    pass
 
291
                item = self.add_data(us, "Enabled", [s],
 
292
                                     BoolSetter(self, u, u.set_enable))
 
293
 
 
294
                rv = u.get_link_auth_enabled(v)
 
295
                if (rv == 0):
 
296
                    s = IntToBoolStr(v[0])
 
297
                else:
 
298
                    s = "?"
 
299
                    pass
 
300
                item = self.add_data(us, "Link Auth Enabled", [s],
 
301
                                     BoolSetter(self, u,
 
302
                                                u.set_link_auth_enabled))
 
303
 
 
304
                rv = u.get_msg_auth_enabled(v)
 
305
                if (rv == 0):
 
306
                    s = IntToBoolStr(v[0])
 
307
                else:
 
308
                    s = "?"
 
309
                    pass
 
310
                item = self.add_data(us, "Msg Auth Enabled", [s],
 
311
                                     BoolSetter(self, u,
 
312
                                                u.set_msg_auth_enabled))
 
313
 
 
314
                rv = u.get_access_cb_only(v)
 
315
                if (rv == 0):
 
316
                    s = IntToBoolStr(v[0])
 
317
                else:
 
318
                    s = "?"
 
319
                    pass
 
320
                item = self.add_data(us, "Access Callback Only", [s],
 
321
                                     BoolSetter(self, u, u.set_access_cb_only))
 
322
 
 
323
                rv = u.get_privilege_limit(v)
 
324
                if (rv == 0):
 
325
                    s = GetPrivilegeString(v[0])
 
326
                else:
 
327
                    s = "?"
 
328
                    pass
 
329
                item = self.add_data(us, "Privilege Limit", [s],
 
330
                                     PrivSetter(self, u,
 
331
                                                u.set_privilege_limit))
 
332
 
 
333
                rv = u.get_session_limit(v)
 
334
                if (rv == 0):
 
335
                    s = str(v[0])
 
336
                else:
 
337
                    s = "?"
 
338
                    v[0] = 0
 
339
                    pass
 
340
                item = self.add_data(us, "Session Limit", [s],
 
341
                                     IntSetter(self, u, u.set_session_limit,
 
342
                                               "Session Limit", v[0]))
 
343
                pass
 
344
            pass
 
345
        
 
346
        self.AfterDone()
 
347
        return
 
348
 
 
349
    def cancel(self):
 
350
        if (self.in_save):
 
351
            return
 
352
        self.Close()
 
353
        return
 
354
    
 
355
    def save(self):
 
356
        if (self.in_save):
 
357
            return
 
358
        self.mc_id.to_mc(self)
 
359
        return
 
360
 
 
361
    def mc_cb(self, mc):
 
362
        self.errnum = 0
 
363
        self.waitcount = 0
 
364
        self.SetError("")
 
365
        for u in self.users:
 
366
            if (u.changed):
 
367
                rv = mc.set_user(u, self.channel, u.num,
 
368
                                 SetUserHandler(self, u.num))
 
369
                if (rv):
 
370
                    self.SetError("Error setting user "
 
371
                                  + str(u.num)  + ": "
 
372
                                  + OpenIPMI.get_error_string(rv))
 
373
                    self.errnum += 1
 
374
                else:
 
375
                    self.waitcount += 1
 
376
                    pass
 
377
                pass
 
378
            pass
 
379
        if ((self.errnum == 0) and (self.waitcount == 0)):
 
380
            self.Close()
 
381
        elif (self.waitcount > 0):
 
382
            self.in_save = True
 
383
        return
 
384
 
 
385
    def user_set(self, mc, err, num):
 
386
        if (err):
 
387
            self.SetError("Error setting user " + str(num) + ": "
 
388
                          + OpenIPMI.get_error_string(err))
 
389
            self.errnum += 1
 
390
            pass
 
391
        self.waitcount -= 1
 
392
        if (self.waitcount <= 0):
 
393
            self.in_save = False;
 
394
            if (self.errnum == 0):
 
395
                self.Close()
 
396
                pass
 
397
            pass
 
398
        return
 
399
    
 
400
    def do_on_close(self):
 
401
        self.users = None
 
402
        return
 
403
 
 
404
    pass