1# _mc.py
2#
3# openipmi GUI handling for MCs
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#
32import OpenIPMI
33from openipmigui import gui_popup
34from openipmigui import gui_setdialog
35from openipmigui import _oi_logging
36from openipmigui import _sel
37from openipmigui import _mc_chan
38from openipmigui import _mc_pefparm
39
40class MCOpHandler:
41    def __init__(self, m, func, handler=None, boolval=None):
42        self.m = m
43        self.func = func
44        self.handler = handler
45        self.boolval = boolval
46        self.item = None
47        pass
48
49    def SetItem(self, item):
50        self.item = item
51        return
52
53    def DoOp(self):
54        if (self.boolval):
55            if (not getattr(self.m, self.boolval)):
56                if (self.item):
57                    self.m.ui.set_item_text(self.item, None)
58                    pass
59                return 0
60            pass
61        rv = self.m.mc_id.to_mc(self)
62        if (rv == 0):
63            rv = self.rv
64            pass
65        return
66
67    def DoUpdate(self):
68        if (self.boolval):
69            if (not getattr(self.m, self.boolval)):
70                if (self.item):
71                    self.m.ui.set_item_text(self.item, None)
72                    pass
73                return
74        self.m.mc_id.to_mc(self)
75        return
76
77    def mc_cb(self, mc):
78        self.rv = getattr(mc, self.func)(self.handler)
79        return
80
81    pass
82
83class MCRefreshData:
84    def __init__(self, m, func):
85        self.m = m;
86        self.item = None
87        self.func = func
88        return
89
90    def SetItem(self, item):
91        self.item = item
92        return
93
94    def DoUpdate(self):
95        if (not self.item):
96            return
97        if (not self.m.mc_id):
98            return
99        self.m.mc_id.to_mc(self)
100        return
101
102    def mc_cb(self, mc):
103        val = getattr(mc, self.func)()
104        self.m.ui.set_item_text(self.item, str(val))
105        return
106
107    pass
108
109class MCSelSet:
110    def __init__(self, m):
111        self.m = m;
112        self.refr = MCRefreshData(m, "get_sel_rescan_time")
113        return
114
115    def DoUpdate(self):
116        self.refr.DoUpdate()
117        return
118
119    def SetItem(self, item):
120        self.refr.SetItem(item)
121        return
122
123    def HandleMenu(self, event):
124        gui_popup.popup(self.m.ui, event,
125                        [ ("Modify Value", self.modval) ])
126        return
127
128    def modval(self, event):
129        self.init = True
130        self.m.mc_id.to_mc(self)
131
132        gui_setdialog.SetDialog("Set SEL Rescan Time for " + str(self.m),
133                                [ str(self.sel_rescan_time) ],
134                                1,
135                                self)
136        return
137
138    def ok(self, vals):
139        self.ival = int(vals[0])
140        self.init = False
141        rv = self.m.mc_id.to_mc(self)
142        if (rv == 0):
143            rv = self.err
144            pass
145        if (rv != 0):
146            return ("Error setting SEL rescan time: "
147                    + OpenIPMI.get_error_string(rv))
148        return
149
150    def mc_cb(self, mc):
151        if self.init:
152            self.sel_rescan_time = mc.get_sel_rescan_time()
153        else:
154            self.err = mc.set_sel_rescan_time(self.ival)
155            self.refr.DoUpdate()
156            pass
157        return
158
159    pass
160
161class PEFLockClearer:
162    def __init__(self, mc):
163        self.pef = mc.get_pef(self)
164        return
165
166    def got_pef_cb(self, pef, err):
167        pef.clear_lock();
168        return
169
170    pass
171
172class MC:
173    def __init__(self, d, mc):
174        self.d = d
175        self.mc_id = mc.get_id()
176        self.name = mc.get_name()
177        self.cb_state = ""
178        d.mcs[self.name] = self
179        self.ui = d.ui;
180        self.ui.add_mc(self.d, self)
181        mc.add_active_handler(self)
182        self.has_sel = (mc.sel_device_support() != 0)
183        self.event_gen = (mc.ipmb_event_generator_support() != 0)
184        self.has_dev_sdrs = (mc.provides_device_sdrs() != 0)
185        self.provides_device_sdrs = self.ui.append_item(self,
186                                          "Provides Device SDRs",
187                                          str(mc.provides_device_sdrs() != 0))
188        self.device_available = self.ui.append_item(self, "Device Available",
189                                          str(mc.device_available() != 0))
190        self.chassis_support = self.ui.append_item(self, "Chassis Support",
191                                          str(mc.chassis_support() != 0))
192        self.bridge_support = self.ui.append_item(self, "Bridge Support",
193                                          str(mc.bridge_support() != 0))
194        self.ipmb_event_generator_support = self.ui.append_item(self,
195                                   "IPMB Event Generator Support",
196                                   str(mc.ipmb_event_generator_support() != 0))
197        self.ipmb_event_receiver_support = self.ui.append_item(self,
198                                   "IPMB Event Receiver Support",
199                                   str(mc.ipmb_event_receiver_support() != 0))
200        self.fru_inventory_support = self.ui.append_item(self,
201                                   "FRU Inventory Support",
202                                   str(mc.fru_inventory_support() != 0))
203        self.sel_device_support = self.ui.append_item(self,
204                                   "SEL Device Support",
205                                   str(mc.sel_device_support() != 0))
206        self.sdr_repository_support = self.ui.append_item(self,
207                                   "SDR Repository Support",
208                                   str(mc.sdr_repository_support() != 0))
209        self.sensor_device_support = self.ui.append_item(self,
210                                   "Sensor Device Support",
211                                   str(mc.sensor_device_support() != 0))
212        self.device_id = self.ui.append_item(self, "Device ID",
213                                             str(mc.device_id()))
214        self.device_revision = self.ui.append_item(self, "Device Revision",
215                                                   str(mc.device_revision()))
216        self.fw_revision = self.ui.append_item(self, "Firmware Revisions",
217                                               str(mc.major_fw_revision())
218                                               + "."
219                                               + str(mc.minor_fw_revision()))
220        self.version = self.ui.append_item(self, "IPMI Version",
221                                           str(mc.major_version())
222                                           + "."
223                                           + str(mc.minor_version()))
224        self.manufacturer_id = self.ui.append_item(self,
225                                                   "Manufacturer ID",
226                                                   str(mc.manufacturer_id()))
227        self.product_id = self.ui.append_item(self, "Product ID",
228                                              str(mc.product_id()))
229        self.aux_fw_revision = self.ui.append_item(self,
230                                                   "Aux Firmware Revision",
231                                                   mc.aux_fw_revision())
232
233        self.mguid = self.ui.append_item(self, "GUID", mc.get_guid())
234
235        self.refreshers = [ ]
236        self.el_refr = MCOpHandler(self, "get_event_log_enable", self,
237                                   "has_sel")
238        self.el_item = self.ui.prepend_item(self, "Event Log Enabled",
239                                            None, self.el_refr)
240        self.refreshers.append(self.el_refr)
241        self.ee_refr = self.add_refr_item("Events Enabled",
242                                 MCRefreshData(self, "get_events_enable"))
243        self.add_refr_item("SEL Rescan Time", MCSelSet(self))
244
245        # Check for PEF capability, send a Get PEF Capabilities cmd
246        self.has_pef = False
247        mc.send_command(0, 4, 0x10, [ ], self)
248        return
249
250    def mc_cmd_cb(self, mc, netfn, cmd, rsp):
251        if (rsp[0] != 0):
252            # Error
253            return
254        if (len(rsp) < 4):
255            # Response too small
256            return
257        self.has_pef = True
258        return
259
260    def __str__(self):
261        return self.name
262
263    def add_refr_item(self, name, refr):
264        item = self.ui.prepend_item(self, name, None, refr)
265        refr.SetItem(item)
266        self.refreshers.append(refr)
267        return refr
268
269    def remove(self):
270        self.d.mcs.pop(self.name)
271        self.ui.remove_mc(self)
272        self.d = None
273        self.ui = None
274        self.el_refr = None
275        self.el_item = None
276        self.ee_refr = None
277        return
278
279    def Changed(self, mc):
280        self.has_sel = (mc.sel_device_support() != 0)
281        self.event_gen = (mc.ipmb_event_generator_support() != 0)
282        self.has_dev_sdrs = (mc.provides_device_sdrs() != 0)
283        self.ui.set_item_text(self.provides_device_sdrs,
284                              str(mc.provides_device_sdrs() != 0))
285        self.ui.set_item_text(self.device_available,
286                              str(mc.device_available() != 0))
287        self.ui.set_item_text(self.chassis_support,
288                              str(mc.chassis_support() != 0))
289        self.ui.set_item_text(self.bridge_support,
290                              str(mc.bridge_support() != 0))
291        self.ui.set_item_text(self.ipmb_event_generator_support,
292                                   str(mc.ipmb_event_generator_support() != 0))
293        self.ui.set_item_text(self.ipmb_event_receiver_support,
294                                   str(mc.ipmb_event_receiver_support() != 0))
295        self.ui.set_item_text(self.fru_inventory_support,
296                                   str(mc.fru_inventory_support() != 0))
297        self.ui.set_item_text(self.sel_device_support,
298                                   str(mc.sel_device_support() != 0))
299        self.ui.set_item_text(self.sdr_repository_support,
300                                   str(mc.sdr_repository_support() != 0))
301        self.ui.set_item_text(self.sensor_device_support,
302                                   str(mc.sensor_device_support() != 0))
303        self.ui.set_item_text(self.device_id, str(mc.device_id()))
304        self.ui.set_item_text(self.device_revision,
305                              str(mc.device_revision()))
306        self.ui.set_item_text(self.fw_revision,
307                              str(mc.major_fw_revision())
308                              + "."
309                              + str(mc.minor_fw_revision()))
310        self.ui.set_item_text(self.version,
311                              str(mc.major_version())
312                              + "."
313                              + str(mc.minor_version()))
314        self.ui.set_item_text(self.manufacturer_id, str(mc.manufacturer_id()))
315        self.ui.set_item_text(self.product_id, str(mc.product_id()))
316        self.ui.set_item_text(self.aux_fw_revision, mc.aux_fw_revision())
317
318        self.ui.set_item_text(self.mguid, mc.get_guid())
319        return
320
321    def HandleExpand(self, event):
322        for i in self.refreshers:
323            i.DoUpdate()
324            pass
325        return
326
327    def HandleMenu(self, event):
328        l = [ ]
329        if self.has_sel:
330            l.append( ("Reread SELs", self.RereadSelsHandler) )
331            l.append( ("Display SELs", self.DisplaySelsHandler) )
332            l.append( ("Enable Event Log", self.EnableEventLogHandler) )
333            l.append( ("Disable Event Log", self.DisableEventLogHandler) )
334            pass
335        if self.event_gen:
336            l.append( ("Enable Events", self.EnableEventsHandler) )
337            l.append( ("Disable Events", self.DisableEventsHandler) )
338            pass
339        if self.has_dev_sdrs:
340            l.append( ("Refetch SDRs", self.RefetchSDRsHandler) )
341            pass
342        if self.has_pef:
343            l.append( ("PEF Parms", self.PEFParms) )
344            l.append( ("Clear PEF Lock", self.PEFLockClear) )
345            pass
346        l.append( ("Cold Reset", self.ColdResetHandler) )
347        l.append( ("Warm Reset", self.WarmResetHandler) )
348        l.append( ("Channel Info", self.ChannelInfoHandler) )
349        gui_popup.popup(self.ui, event, l)
350        return
351
352    def RereadSelsHandler(self, event):
353        dop = MCOpHandler(self, "reread_sel")
354        dop.DoOp()
355        return
356
357    def DisplaySelsHandler(self, event):
358        _sel.MCSELDisplay(self.mc_id)
359        return
360
361    def EnableEventLogHandler(self, event):
362        self.cb_state = "enable_event_log"
363        self.mc_id.to_mc(self)
364        return
365
366    def DisableEventLogHandler(self, event):
367        self.cb_state = "disable_event_log"
368        self.mc_id.to_mc(self)
369        return
370
371    def EnableEventsHandler(self, event):
372        self.cb_state = "enable_events"
373        self.mc_id.to_mc(self)
374        return
375
376    def DisableEventsHandler(self, event):
377        self.cb_state = "disable_events"
378        self.mc_id.to_mc(self)
379        return
380
381    def ColdResetHandler(self, event):
382        self.cb_state = "cold_reset"
383        self.mc_id.to_mc(self)
384        return
385
386    def WarmResetHandler(self, event):
387        self.cb_state = "warm_reset"
388        self.mc_id.to_mc(self)
389        return
390
391    def ChannelInfoHandler(self, event):
392        self.cb_state = "channel_info"
393        self.mc_id.to_mc(self)
394        return
395
396    def RefetchSDRsHandler(self, event):
397        self.cb_state = "refetch_sdrs"
398        self.mc_id.to_mc(self)
399        return
400
401    def PEFParms(self, event):
402        self.cb_state = "pef_parms"
403        self.mc_id.to_mc(self)
404        return
405
406    def PEFLockClear(self, event):
407        self.cb_state = "pef_lock_clear"
408        self.mc_id.to_mc(self)
409        return
410
411    def mc_cb(self, mc):
412        if (self.cb_state == "enable_events"):
413            mc.set_events_enable(1, self)
414        elif (self.cb_state == "disable_events"):
415            mc.set_events_enable(0, self)
416        if (self.cb_state == "enable_event_log"):
417            mc.set_event_log_enable(1, self)
418        elif (self.cb_state == "disable_event_log"):
419            mc.set_event_log_enable(0, self)
420        elif (self.cb_state == "cold_reset"):
421            mc.reset(OpenIPMI.MC_RESET_COLD)
422        elif (self.cb_state == "warm_reset"):
423            mc.reset(OpenIPMI.MC_RESET_WARM)
424        elif (self.cb_state == "refetch_sdrs"):
425            mc.reread_sensors()
426        elif (self.cb_state == "reread_sel"):
427            mc.reread_sel()
428        elif (self.cb_state == "channel_info"):
429            _mc_chan.MCChan(self, mc)
430        elif (self.cb_state == "pef_parms"):
431            pp = mc.get_pef(self)
432            if (pp == None):
433                self.ui.ReportError("Unable to allocate PEF config");
434                return
435        elif (self.cb_state == "pef_lock_clear"):
436            PEFLockClearer(mc)
437            pass
438        return
439
440    def got_pef_cb(self, pef, err):
441        if (err):
442            self.ui.ReportError("Error fetching PEF: " +
443                                OpenIPMI.get_error_string(err))
444            return
445        rv = pef.get_config(self)
446        if (rv):
447            self.ui.ReportError("Error starting PEF config fetch: " +
448                                OpenIPMI.get_error_string(rv))
449            pass
450        return
451
452    def pef_got_config_cb(self, pef, err, pefconfig):
453        if (err):
454            if (err == OpenIPMI.eagain):
455                self.ui.ReportError("PEF already locked by another user, "
456                                    "Try clearing the lock.")
457                pass
458            else:
459                self.ui.ReportError("Error fetching PEF config: " +
460                                    OpenIPMI.get_error_string(err))
461                pass
462            return
463        _mc_pefparm.MCPefParm(self, pef, pefconfig)
464        return
465
466    def mc_events_enable_cb(self, mc, err):
467        if (err):
468            _oi_logging.error("Error setting MC events for "
469                              + self.name + ": "
470                              + OpenIPMI.get_error_string(err))
471            return
472        self.ee_refr.DoUpdate()
473
474    def mc_get_event_log_enable_cb(self, mc, err, val):
475        if (err):
476            _oi_logging.error("Error getting MC event log enable for "
477                              + self.name + ": "
478                              + OpenIPMI.get_error_string(err))
479            return
480        self.ui.set_item_text(self.el_item, str(val != 0))
481
482    def mc_set_event_log_enable_cb(self, mc, err):
483        if (err):
484            _oi_logging.error("Error setting MC event log enable for"
485                              + self.name + ": "
486                              + OpenIPMI.get_error_string(err))
487            return
488        self.el_refr.DoUpdate()
489        return
490
491    def mc_active_cb(self, mc, active):
492        if (active):
493            self.ui.set_item_active(self.treeroot)
494        else:
495            self.ui.set_item_inactive(self.treeroot)
496            pass
497        return
498
499    pass
500