root/octofuss/cluster/__init__.py @ 25ff87f4c677319266c0d98825500a028328f9c5

Revision 25ff87f4c677319266c0d98825500a028328f9c5, 24.1 KB (checked in by cgabriel <cgabriel@…>, 6 years ago)

integrazione SshMultiTerm?

git-svn-id:  https://labs.truelite.it/svn/octofuss/trunk@451 5a101938-5c21-0410-9b5a-a83d6f3706a9
  • Property mode set to 100644
Line 
1#!/usr/bin/env python
2#
3# -*- python -*-
4#
5#  Copyright (C) 2006 Christopher R. Gabriel <cgabriel@truelite.it>
6#
7#  This program is free software; you can redistribute it and/or modify
8#  it under the terms of the GNU General Public License as published by
9#  the Free Software Foundation; either version 2 of the License, or
10#  (at your option) any later version.
11#
12
13
14import gtk,gobject
15import os,math,time
16from gettext import gettext as _
17from octofuss.desktop import control as desktopcontrol
18from octofuss.utils import hostup
19from octofuss import art,config,log,firewall,utils,utils
20
21
22
23class Host:
24        def __init__(self,name):
25                self.name = name
26                self.isup = hostup.host_is_up(self.name)
27
28        def check_up(self):
29                self.isup = hostup.host_is_up(self.name)
30               
31# Basic cluster definition
32
33class Cluster(list):
34        def __init__(self):
35                list.__init__(self)
36
37        def add_host(self,host):
38                if not self.has_host(host):
39                        self.append(host)
40
41        def del_host(self,host):
42                for hostname in self:
43                        if host == hostname.name:
44                                index = self.index(hostname)
45                                del(self[index])
46
47        def load_from_list(self,host_list):
48                self.__add__(host_list)
49               
50        def has_host(self,host):
51                if host in self:
52                        return True
53                else:
54                        return False
55
56#cluster's cluster
57
58class Network(dict):
59        def __init__(self):
60                dict.__init__(self)
61                self.conf = config
62                self.loaded = False
63               
64        def load(self):
65                """
66
67                """
68                if self.loaded is False:
69                        # load clusters from cssh's main cluster file
70                        try:
71                                self.load_from_file("/etc/clusters")
72                        except IOError:
73                                pass
74
75                        # load clusters from custom cluster file
76                        try:
77                                self.load_from_file(os.path.join(os.getenv("HOME"),".clusters"))
78                        except IOError:
79                                pass
80                        self.loaded = True
81                       
82        def get_from_tuple(self,path):
83               
84                k = self.keys()
85               
86                #k.sort()
87
88                if len(path) is 1:
89                        cluster = path[0]
90                        return (k[cluster],)
91
92                if len(path) is 2:
93                        cluster = path[0]
94                        host = path[1]
95                        return (k[cluster],self[k[cluster]][host].name)
96                       
97        def load_from_file(self,file):
98                f = open(file).readlines()
99                for cluster in f:
100                        d = cluster.split()
101
102                        if len(d) > 0:
103                                cname = d[0]
104                                del(d[0])
105                                c = Cluster()
106                                for h in d:
107                                        # avoid duplicates with host's name
108                                        if h not in c:
109                                                host = Host(h)
110                                                c.append(host)
111                                self.__setitem__(cname,c)
112
113        def load_from_data(self,data):
114                for cluster in data:
115                        cname = cluster[0]
116                        c = Cluster()
117                        hosts = cluster[1].split()
118                        for host in hosts:
119                                if host not in c:
120                                        h = Host(host)
121                                        c.append(h)
122                        self.__setitem__(cname,c)
123
124        def save(self):
125                f = open(os.path.join(os.getenv("HOME"),".clusters"),"w")
126                for c in self.keys():
127                        f.write("%s\t\t" % c)
128                        for host in self[c]:
129                                f.write(" %s" % host.name)
130                        f.write("\n")
131                f.close()
132
133        def find_host(self,host):
134                for i in self.keys():
135                        if host in self[i]:
136                                return i
137
138       
139### UI STUFF
140
141class ClusterTreeModel(gtk.TreeStore):
142        def __init__(self,data):
143                gtk.TreeStore.__init__(self,gobject.TYPE_STRING)
144
145                self.network = data
146                self.network.load()
147                clusters = self.network.keys()
148                #clusters.sort()
149                for cluster in clusters:
150                        iter = self.append(None)
151                        self.set(iter, 0, cluster)
152                        for host in self.network[cluster]:
153                                child_iter = self.append(iter)
154                                self.set(child_iter,
155                                                  0, host.name)
156
157        def add_cluster(self,cname):
158                c = Cluster()
159                self.network[cname] = c
160                iter = self.append(None)
161                self.set(iter,0,cname)
162
163
164               
165        def add_host(self,path,cluster,host):
166                """ Add an host to cluster identified by cname """
167                iter = self.get_iter(path)
168                child_iter = self.append(iter)
169                self.set(child_iter,0,host)
170                self.network[cluster].append(Host(host))
171               
172
173        def has_host(self, clusterName, hostname):
174                """ Returns true if cluster has hostname """
175                return self.network[cname].has_host(hostname)
176
177       
178
179
180
181               
182
183class HostWindow(gtk.HBox):
184        def __init__(self):
185                gtk.HBox.__init__(self)
186                self.octofuss_name = _("Cluster/host management")
187                self.hpaned = gtk.HPaned()
188                self.hpaned.set_border_width(5)
189                self.pack_start(self.hpaned, True, True)
190                self.network = Network()
191
192                self.selected_cluster = None
193
194                #Check when cannot import some modules
195                self.restartRequired = False
196
197               
198                self.model = ClusterTreeModel(self.network)
199                #Host view
200                self.view = gtk.IconView()
201                #self.model = self.model.filter_new()
202                self.cluster_tree = gtk.TreeView(self.model)
203                self.cluster_tree.columns_autosize()
204                self.cluster_tree.connect("button_press_event", self.item_event)
205                cell = gtk.CellRendererText()
206
207                column = gtk.TreeViewColumn(_("Clusters"), cell, text=0)
208                column.set_clickable(True)
209                column.connect("clicked",self.show_cluster_icon_list)
210               
211                self.cluster_tree.append_column(column)
212
213                v = gtk.VBox()
214                self.hpaned.pack1(v,resize=True, shrink=False)
215               
216                frame = gtk.Frame()
217                frame.set_shadow_type(gtk.SHADOW_IN)
218                v.pack_start(frame)
219               
220                sw = gtk.ScrolledWindow()
221                sw.set_shadow_type(gtk.SHADOW_ETCHED_IN)
222                sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
223                sw.add(self.cluster_tree)
224               
225                frame.add(sw)
226
227                b = gtk.Button(stock='gtk-add')
228                b.connect("clicked", self.on_cluster_add,sw )
229                v.pack_start(b,False,False, 10)
230                bb = gtk.Button(stock='gtk-remove')
231                bb.connect("clicked", self.on_cluster_del,self.cluster_tree ,sw)
232                v.pack_start(bb,False,False, 10)
233               
234                self.app_container = gtk.Frame()
235                self.app_container.set_shadow_type(gtk.SHADOW_IN)
236                self.hpaned.add2(self.app_container)
237
238                self.app_container.add(self.get_cluster_icon_list())
239
240        def change_app_content(self,obj):
241                self.app_container.get_child().destroy()
242                self.app_container.add(obj)
243                obj.show_all()
244
245        def get_possible_button_event(self, event):
246                '''mouse or keyboard caused the event?'''
247                if event.type == gtk.gdk.KEY_PRESS:
248                        return 0 # no event.button so pass 0
249                return event.button
250
251        def on_cluster_add(self,button,sw):
252                dialog = gtk.Dialog("Add new cluster", None, 0,
253                                                        (gtk.STOCK_OK, gtk.RESPONSE_OK,
254                                                         gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
255                dialog.vbox.pack_start(gtk.Label("Cluster name:"))
256                entry = gtk.Entry()
257                dialog.vbox.pack_start(entry)
258                dialog.vbox.show_all()
259                response = dialog.run()
260                if response == gtk.RESPONSE_OK:
261                        cname = entry.get_text()
262                        if cname:
263                                if not self.network.has_key(cname):
264                                        self.model.add_cluster(cname)
265                                        self.network.save()
266                                        self.model =  ClusterTreeModel(self.network)
267                                        self.cluster_tree.set_model(self.model)
268                                        sw.show()
269                dialog.destroy()
270
271        def on_cluster_del(self,button,treeView,sw):
272                """ Delete cluster """
273                model = treeView.get_model()
274                treeSelection = treeView.get_selection()
275                selection = treeSelection.get_selected()
276                iter = selection[1]
277                try:
278                        value = model.get_value(iter,0)
279                        # Delete cluster from network
280                        del(self.network[value])
281
282                        # Save
283                        self.network.save()
284                        # Rebuild model
285                        self.model =  ClusterTreeModel(self.network)
286                        self.cluster_tree.set_model(self.model)
287                        sw.show()
288
289                except:
290                        dialog = gtk.MessageDialog(type=gtk.MESSAGE_WARNING, message_format="You must select a cluster!", buttons=gtk.BUTTONS_OK)             
291                        dialog.show_all()
292                        response = dialog.run()
293                        dialog.destroy()   
294                        return 
295
296               
297
298        def on_host_select(self,icon_view, clusterPath):
299                selected = icon_view.get_selected_items()
300                if selected:
301                        self.show_context_menu_host(None, (clusterPath,selected[0][0]))
302
303               
304        def get_host_icon_list(self,cluster, clusterPath):
305                hbox = gtk.HBox()
306                swin = gtk.ScrolledWindow()
307                swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
308                swin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
309                hbox.pack_start(swin)
310                self.view = gtk.IconView()
311                self.view.set_text_column(0)
312                self.view.set_pixbuf_column(1)
313                self.view.set_selection_mode(gtk.SELECTION_SINGLE)
314                self.view.set_size_request(200, 150)
315                model = gtk.ListStore(str, gtk.gdk.Pixbuf)
316                for host in cluster:
317                        logged_user = None
318                        #statusList = (LoggedUser, screenLocked)
319
320                        statusList = None
321                       
322                        if host.isup:
323                                statusList = desktopcontrol.machine_status(host.name)
324                               
325                        if statusList is None:
326                                statusList = ["",False]
327
328                       
329                        if host.isup:
330                                pix = art.get_pixbuf_from_name("system-up")
331                                logged_user = statusList[0] 
332                        else:
333                                pix = art.get_pixbuf_from_name("system-down")
334
335                        if firewall.host_is_listed_no_wan(host.name):
336                                pix = art.get_blocked_pixbuf(pix)
337
338                        if statusList[1]:
339                                pix = art.get_screen_lock_pixbuf(pix)
340
341
342                        if logged_user:
343                                model.append([host.name+"\n"+logged_user,pix])
344                        else:
345                                model.append([host.name,pix])
346
347               
348                self.view.set_model(model)
349                #view.connect('selection-changed', self.on_host_select, clusterPath)
350
351                self.view.connect("button_press_event", self.host_item_event, cluster, clusterPath)
352                self.view.unparent()
353                swin.add(self.view)
354                hbox.show_all()
355                return hbox
356       
357        def show_cluster_icon_list(self,obj):
358                s = self.get_cluster_icon_list()
359                self.change_app_content(s)
360               
361        def show_host_icon_list(self,event,path):
362                res = self.network.get_from_tuple(path)
363                hostNumber = len(self.network[res[0]])
364                if len(res) is 1:
365                        #self.selected_cluster = path[0]
366                        s = self.get_host_icon_list(self.network[res[0]],path[0])
367                        self.change_app_content(s)
368                if hostNumber == 0:       
369                        hboxEmpty = gtk.HBox()
370                        label = gtk.Label("No hosts in selected cluster!")
371                        hboxEmpty.pack_start(label)
372                        hboxEmpty.show_all()
373                        self.change_app_content(hboxEmpty)
374
375                   
376       
377        def on_cluster_select(self,icon_view,model=None):
378                selected = icon_view.get_selected_items()
379
380                self.selected_cluster = selected[0][0]
381
382                if len(selected) == 0: return
383                if len(selected) == 1:
384                        self.show_host_icon_list(None,selected[0])
385               
386        def get_cluster_icon_list(self):
387                hbox = gtk.HBox()
388                swin = gtk.ScrolledWindow()
389                swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
390                swin.set_shadow_type(gtk.SHADOW_ETCHED_IN)
391                hbox.pack_start(swin)
392                view = gtk.IconView()
393
394                view.set_text_column(0)
395                view.set_pixbuf_column(1)
396                view.set_selection_mode(gtk.SELECTION_SINGLE)
397                view.set_size_request(200, 150)
398                model = gtk.ListStore(str, gtk.gdk.Pixbuf)
399                cList = self.network.keys()
400                #cList.sort()
401                for cluster in cList:
402                        pix = art.get_pixbuf_from_name("cluster-new")
403                        model.append([cluster,pix])
404                view.set_model(model)
405                view.connect('selection-changed', self.on_cluster_select, model)
406                swin.add(view)
407                hbox.show_all()
408                return hbox
409
410        def remote_shell(self,obj,path):
411                # check if we'got a cluster or a host
412
413                if len(path) is 1:
414                        from octofuss.sshterm import SshMultiTerm
415                        hosts = []
416                        for host in self.network[path[0]]:
417                                hosts.append(host.name)
418                        if len(hosts) > 0:
419                                s = SshMultiTerm(hosts)
420                                self.change_app_content(s)
421                               
422                elif len(path) is 2:
423                        from octofuss.sshterm import SshTerm
424                        s = SshTerm(path[1])
425                        self.change_app_content(s)
426
427        def install_software(self,obj,path):
428                try:
429                        if self.restartRequired:
430                                raise Exception("You need to check some problems!\nRestart needed.")
431                        from octofuss.packages import PackagesAdmin
432                        if len(path) is 1:
433                                s = PackagesAdmin(self.network[path[0]])
434                        elif len(path) is 2:
435                                s = PackagesAdmin(Host(path[1]))
436                        self.change_app_content(s)
437                except Exception, e:
438                        log.debug(str(e))
439                        self.restartRequired = True
440                        self.__error_dialog(str(e))
441
442        def dialogYesNo(self, message):
443                dialog = gtk.MessageDialog(None, 0, gtk.MESSAGE_INFO, gtk.BUTTONS_YES_NO, message )
444                dialog.show()
445                # Close dialog on user response
446                resp = dialog.run()
447                dialog.destroy()
448                return resp
449
450        def shutdown_now(self, obj, path, res):
451                shutdownHostList = []
452                if len(res) > 1:
453                        if self.dialogYesNo("Are you sure to shutdown the host?") == gtk.RESPONSE_NO:
454                                return
455                        # add a single to host list to be shutted down
456                        shutdownHostList.append(res[1])
457                elif len(res) == 1:
458                        # add a list to host list to be shutted down
459                        if self.dialogYesNo("Are you sure to shutdown the cluster?") == gtk.RESPONSE_NO:
460                                return
461
462                        cluster = self.network[res[0]]
463                        for host in cluster:
464                                shutdownHostList.append(host.name)
465                from octofuss.utils import remotecmd
466                remotecmd.shutdown(shutdownHostList)
467
468        def unlock_desktop(self, obj, path, res):
469                lockdesktoplist = []
470                if len(res) > 1:
471                        if self.dialogYesNo("Are you sure to unlock desktop for this host?") == gtk.RESPONSE_NO:
472                                return
473                        # add a single to host list to be shutted down
474                        lockdesktoplist.append(res[1])
475                elif len(res) == 1:
476                        # add a list to host list to be shutted down
477                        if self.dialogYesNo("Are you sure to lock desktop to this cluster?") == gtk.RESPONSE_NO:
478                                return
479
480                        cluster = self.network[res[0]]
481                        for host in cluster:
482                                lockdesktoplist.append(host.name)
483                for host in lockdesktoplist:
484                        desktopcontrol.screen_release(host)
485                #Update view
486                self.show_host_icon_list(obj,(path[0],))
487
488
489        def lock_desktop(self, obj, path, res):
490                lockdesktoplist = []
491                if len(res) > 1:
492                        if self.dialogYesNo("Are you sure to lock desktop for this host?") == gtk.RESPONSE_NO:
493                                return
494                        # add a single to host list to be shutted down
495                        lockdesktoplist.append(res[1])
496                elif len(res) == 1:
497                        # add a list to host list to be shutted down
498                        if self.dialogYesNo("Are you sure to lock desktop to this cluster?") == gtk.RESPONSE_NO:
499                                return
500
501                        cluster = self.network[res[0]]
502                        for host in cluster:
503                                lockdesktoplist.append(host.name)
504                for host in lockdesktoplist:
505                        desktopcontrol.screen_lock(host, "Lock from network administrator")
506                #Update view
507                self.show_host_icon_list(obj,(path[0],))
508
509
510        def popup_message(self, obj, path, res):
511                PopupMessageHostList = []
512                if len(res) > 1:
513                        # add a single to host list to be shutted down
514                        PopupMessageHostList.append(res[1])
515                elif len(res) == 1:
516                        cluster = self.network[res[0]]
517                        for host in cluster:
518                                PopupMessageHostList.append(host.name)
519
520                desktopcontrol.PopupMessageWindow(PopupMessageHostList)
521
522                       
523        def add_host(self, obj,path, res):
524                """ Add host to cluster """
525                dialog = gtk.Dialog("Add new host", None, 0,
526                                                        (gtk.STOCK_OK, gtk.RESPONSE_OK,
527                                                         gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL))
528                dialog.vbox.pack_start(gtk.Label("Host name:"))
529                entry = gtk.Entry()
530                dialog.vbox.pack_start(entry)
531                dialog.vbox.show_all()
532                response = dialog.run()
533                if response == gtk.RESPONSE_OK:
534                        hostname = entry.get_text()
535                        clustername = res[0]
536                        if not self.network[clustername].has_host(hostname):
537                                self.model.add_host(path,clustername,hostname)
538                                self.show_host_icon_list(obj,path)
539                                self.network.save()
540                dialog.destroy()
541
542        def remove_host(self, obj,path, res, treeView):
543                """ Delete host from cluster """
544                cluster = res[0]
545                host = res[1]
546                log.debug("Removing host "+host+" in cluster "+cluster)
547                self.network[cluster].del_host(host)
548                self.network.save()
549                # Update the model
550                self.model =  ClusterTreeModel(self.network)
551                self.cluster_tree.set_model(self.model)
552                self.cluster_tree.show()
553                #TODO: update the icon view model
554                self.show_host_icon_list(obj,(path[0],))
555
556
557
558        def show_context_menu(self,event,path):
559                menu = gtk.Menu()
560                res = self.network.get_from_tuple(path)
561                if len(res) is 2:
562                        menufor = "%s: %s" % (res[0],res[1])
563                else:
564                        self.selected_cluster = res[0]
565                        menufor = res[0]
566                item = gtk.MenuItem(menufor)
567                item.set_sensitive(False)
568                menu.append(item)
569
570                # remote shell
571                item = gtk.MenuItem(_("Remote shell"))
572                item.connect("activate", self.remote_shell, res)
573                menu.append(item)
574                # install software
575                item = gtk.MenuItem(_("Install software"))
576                item.connect("activate", self.install_software,res)
577                menu.append(item)
578
579
580                # message
581                item = gtk.MenuItem(_("Send message"))
582                item.connect("activate", self.popup_message,path,res)
583                menu.append(item)
584
585
586                # separator
587                item = gtk.SeparatorMenuItem()
588                menu.append(item)
589
590                # lockdown
591                item = gtk.MenuItem(_("Lock desktop"))
592                item.connect("activate", self.lock_desktop,path,res)
593                menu.append(item)
594
595                # shutdown pcs
596                item = gtk.MenuItem(_("Shutdown now"))
597                item.connect("activate", self.shutdown_now,path,res)
598                menu.append(item)
599
600                # separator
601                item = gtk.SeparatorMenuItem()
602                menu.append(item)
603
604                # new host
605                item = gtk.MenuItem(_("Add host"))
606                item.connect("activate", self.add_host,path,res)
607                menu.append(item)
608
609                #event_button = self.get_possible_button_event(event)
610                menu.attach_to_widget(self.cluster_tree, None)
611
612                #menu.popup(None,None,None,3,0)
613                menu.popup(None, None, None, 3,0)
614                menu.show_all()
615
616        def show_context_menu_host(self,event,path):
617                menu = gtk.Menu()
618                res = self.network.get_from_tuple(path)
619                host = self.network[res[0]][path[1]]
620
621                #host = Host(res[1])
622               
623                if len(res) is 2:
624                        menufor = "%s: %s" % (res[0],res[1])
625                else:
626                        self.selected_cluster = res[0]
627                        menufor = res[0]
628                       
629                item = gtk.MenuItem(menufor)
630                item.set_sensitive(False)
631                menu.append(item)
632               
633                # separator
634                item = gtk.SeparatorMenuItem()
635                menu.append(item)
636               
637                ### HOST OPERATIONS
638               
639                # remote shell
640                item = gtk.MenuItem(_("Remote shell"))
641                item.set_sensitive(host.isup)
642                item.connect("activate", self.remote_shell, res)
643                menu.append(item)
644               
645               
646                # install software
647                item = gtk.MenuItem(_("Install software"))
648                item.connect("activate", self.install_software,res)
649                menu.append(item)
650
651                #Block internet
652                if firewall.host_is_listed_no_wan(res[1]):
653                        #Host blocked
654                        item = gtk.MenuItem(_("Enable Internet"))
655                        item.connect("activate", self.enable_wan_services,res[1],path)
656                        menu.append(item)
657                else:
658                        #Host no blocked
659                        item = gtk.MenuItem(_("Disable Internet"))
660                        item.connect("activate", self.disable_wan_services,res[1],path)
661                        menu.append(item)
662
663
664                # remote desktop
665                rdesktop_client = "vncviewer"
666                self.command =  utils.which(rdesktop_client)
667                item = gtk.MenuItem(_("Show Desktop"))
668                item.connect("activate", self.execute_command,rdesktop_client,res[1])
669                item.set_sensitive(False)
670                if self.command and host.isup:
671                        item.set_sensitive(True)
672                menu.append(item)
673               
674                # message
675                item = gtk.MenuItem(_("Send message"))
676                item.connect("activate", self.popup_message,path,res)
677                if not host.isup:
678                        item.set_sensitive(False)
679                menu.append(item)
680               
681               
682                # separator
683                item = gtk.SeparatorMenuItem()
684                menu.append(item)
685               
686               
687                #lockdown
688                if host.isup:
689                        screen_locked = desktopcontrol.screen_is_locked(host.name)
690                else:
691                        screen_locked = None
692                       
693                if screen_locked == True:
694                        item = gtk.MenuItem(_("Unlock desktop"))
695                        item.connect("activate", self.unlock_desktop, path, res)
696
697                elif screen_locked == False:
698                        item = gtk.MenuItem(_("Lock desktop"))
699                        item.connect("activate", self.lock_desktop, path, res)
700                else:
701                        item = gtk.MenuItem(_("Lock desktop"))
702                        item.set_sensitive(False)
703                       
704                menu.append(item)
705
706                # shutdown host
707                item = gtk.MenuItem(_("Shutdown now"))
708                item.connect("activate", self.shutdown_now,path,res)
709                if not host.isup:
710                        item.set_sensitive(False)
711                menu.append(item)
712
713               
714                # separator
715                item = gtk.SeparatorMenuItem()
716                menu.append(item)
717               
718                # delete host
719                item = gtk.MenuItem(_("Delete host"))
720                item.connect("activate", self.remove_host,path,res, self.cluster_tree)
721                menu.append(item)
722               
723               
724               
725                menu.attach_to_widget(self.cluster_tree, None)
726               
727                #menu.popup(None,None,None,3,0)
728                menu.popup(None, None, None, 3,0)
729                menu.show_all()
730
731        def execute_command(self,a,command, host):
732                """ Execute a command """
733                import os
734                os.system(command + " " + host + "&")
735
736        def enable_wan_services(self, a,host,path):
737                """ Enable wan services """
738               
739                if not firewall.host_remove_no_wan(host):
740                        log.debug("Problem enabling wan services for host "+host)
741                else:
742                        #Update view
743                        self.show_host_icon_list(a,(path[0],))
744
745                       
746
747        def disable_wan_services(self,a,host,path):
748                """ Disable wan services """
749                if not firewall.host_no_wan(host):
750                        log.debug("Problem disabling wan services for host "+host)
751                else:
752                        #Update view
753                        self.show_host_icon_list(a,(path[0],))
754
755                       
756
757
758               
759        def item_event(self,obj,event):
760                try:
761                        path, column, x, y = self.cluster_tree.get_path_at_pos(int(event.x), int(event.y))
762                        if len(path) == 1:
763       
764                                if event.button == 1:
765                                        self.show_host_icon_list(event,path)
766                                       
767                                       
768                                if event.button == 3:
769                                        self.show_context_menu(event,path)
770                        else:
771                                if len(path) == 2:
772                                        if event.button == 3:
773                                                self.show_context_menu_host(event,path)
774                               
775                except TypeError,e:
776                        log.debug(str(e))
777                except Exception, e:
778                        log.debug(str(e))
779
780        def host_item_event(self,obj,event, cluster, clusterPath):
781                try:
782                        try:
783                                subpath = self.view.get_path_at_pos(int(event.x), int(event.y))
784                                path = (clusterPath, subpath[0])
785                                if event.button == 3:
786                                        self.show_context_menu_host(event,path)
787                        except Exception, e:
788                                log.debug(str(e))
789                               
790                except TypeError,e:
791                        log.debug(str(e))
792                except Exception, e:
793                        log.debug(str(e))
794
795                       
796
797
798        def __error_dialog(self, error):
799                dialog = gtk.MessageDialog(type=gtk.MESSAGE_ERROR, message_format=error, buttons=gtk.BUTTONS_OK) 
800                dialog.show_all()
801                response = dialog.run()
802                dialog.destroy()   
803
804                               
805
806
807
808               
809# routine test         
810if __name__ == "__main__":
811        w = gtk.Window()
812        w.set_title("Cluster window test")
813        w.connect("delete_event", gtk.main_quit)
814        w.connect("destroy_event", gtk.main_quit)
815        s = HostWindow()
816        w.add(s)
817        w.show_all()
818        gtk.main()
819       
820                       
Note: See TracBrowser for help on using the browser.