← Back to branch summary

~pyneighborhood/pyneighborhood/0.5

« back to all changes in this revision

Viewing changes to threads.py

  • Committer: definer
  • Date: 2006-09-16 18:34:46 UTC
  • Revision ID: svn-v3-trunk0:918a6f1d-dd1c-0410-8c33-97c2c1a26c01:trunk:6

Show diffs side-by-side

added added

removed removed

Lines of Context:
threads.py
 
1
#!/usr/bin/env python
 
2
 
 
3
#Threads
 
4
 
 
5
import threading
 
6
import gobject 
 
7
import string
 
8
import time
 
9
import thread
 
10
from os import system, getenv
 
11
 
 
12
import getsmbshare
 
13
import checkmount
 
14
import sharmount
 
15
import readconfig
 
16
import pyNeighborhood
 
17
import dialog
 
18
 
 
19
class Monitor_Thread(threading.Thread):
 
20
    def __init__(self, treestore):
 
21
        self.treestore = treestore
 
22
        super(Monitor_Thread, self).__init__()
 
23
        self.quit = False
 
24
        return 
 
25
 
 
26
    def monitor_handler(self):
 
27
        i=0
 
28
        resource = []
 
29
        hosts, shares , mount_points = checkmount.checkmount()
 
30
        if self.hosts_old != hosts and self.shares_old != shares:
 
31
            self.treestore.clear()
 
32
            for host in hosts:
 
33
                resource.append(string.join(["/", host, shares[i]], '/'))
 
34
                iter = self.treestore.append(None, None)
 
35
                self.treestore.set(iter, 0, resource[i])
 
36
                self.treestore.set(iter, 1, mount_points[i])
 
37
                i = i+1
 
38
            self.hosts_old = hosts
 
39
            self.shares_old = shares
 
40
        return
 
41
 
 
42
    def run(self):
 
43
        self.hosts_old = []
 
44
        self.shares_old= []
 
45
        while not self.quit:
 
46
            gobject.idle_add(self.monitor_handler)
 
47
            time.sleep(2)
 
48
        return
 
49
 
 
50
class Append_Thread(threading.Thread):
 
51
    def __init__(self, treeview,  path, column, treestore):
 
52
        self.treeview = treeview
 
53
        self.path = path
 
54
        self.column = column
 
55
        self.treestore = treestore
 
56
 
 
57
        self.id = threading._get_ident()
 
58
        self.model = treeview.get_model()
 
59
        self.iter = self.model.get_iter(path)
 
60
        self.current_host = self.model.get_value(self.iter, 0)
 
61
        #cur_host_prev = current_host
 
62
 
 
63
        super(Append_Thread, self).__init__()
 
64
        #self._finished = threading.Event()
 
65
 
 
66
    def appendshar(self, treeview,  path, column, treestore):
 
67
        #get some necessary info 
 
68
        model = self.model
 
69
        iter = self.iter
 
70
        current_host = self.current_host
 
71
        cur_host_prev = current_host
 
72
        #get a list of shares with comments
 
73
        (hosts, shares, mount_points) = checkmount.checkmount()
 
74
        (hostsharlist, commentlist) = (self.hostsharlist, self.commentlist)
 
75
        if hostsharlist == 0:
 
76
            #print commentlist
 
77
            #thread.exit()
 
78
            return False
 
79
 
 
80
        i = 0
 
81
        #check whether we are trying to scan a last share
 
82
        if model.iter_next(iter) == None:
 
83
            useiter = None
 
84
        else:
 
85
            useiter = iter
 
86
 
 
87
        treestore.remove(iter)
 
88
        newiter = treestore.insert_before(None, useiter, [current_host, "host", "", ""])
 
89
        for child in hostsharlist:
 
90
            temiter = treestore.append(newiter, [hostsharlist[i], "share", commentlist[i], ""])
 
91
            for num in hosts:
 
92
                if num == cur_host_prev:
 
93
                    k = 0
 
94
                    for num1 in shares:
 
95
                        if shares[k] == hostsharlist[i] and hosts[k] == cur_host_prev: 
 
96
                            treestore.set_value(temiter, 3, mount_points[k])
 
97
                        k = k+ 1
 
98
            i = i+1
 
99
 
 
100
        treeview.expand_row(path, True)
 
101
        #thread.exit_thread()
 
102
        return False
 
103
 
 
104
    def run(self):
 
105
        (self.hostsharlist, self.commentlist) = getsmbshare.getsmbshare(self.current_host, self.id)
 
106
        gobject.idle_add(self.appendshar, self.treeview,  self.path, self.column, self.treestore)
 
107
        return
 
108
 
 
109
class Mount_Thread(threading.Thread):
 
110
    def __init__(self, treeview,  path, column, treestore, notebook):
 
111
        self.treestore = treestore
 
112
        self.treeview = treeview
 
113
        self.path = path
 
114
        self.column = column
 
115
        self.notebook = notebook
 
116
 
 
117
        super(Mount_Thread, self).__init__()
 
118
        self.quit = False
 
119
        self.flag_exit = 1
 
120
 
 
121
    def mountshar(self, treestore):
 
122
        f_thread = Fmanager_Thread(self.notebook, self.treeview)
 
123
        f_thread.start()
 
124
        treestore.set(self.iter, 3, self.mount_point)
 
125
        return
 
126
 
 
127
    def run(self):
 
128
        hostflag1=0
 
129
        hostflag2=0
 
130
        hostflag3=0
 
131
 
 
132
        #get a share properties         
 
133
        model = self.treeview.get_model()
 
134
        self.iter = model.get_iter(self.path)
 
135
        self.current_host = model.get_value(self.iter, 0)
 
136
        par_iter = model.iter_parent(self.iter)
 
137
        self.h_name = model.get_value(par_iter, 0)
 
138
 
 
139
        #resolve mountpoint
 
140
        self.mount_dir = pyNeighborhood.parser.optdict["mount_directory"]
 
141
 
 
142
        self.mount_point = string.join([self.mount_dir, "/" ,self.h_name , "/" , self.current_host], '')
 
143
        
 
144
        (hosts, shares, mount_points) = checkmount.checkmount()
 
145
        flag = 0
 
146
        for num in hosts:
 
147
            if num == self.h_name: hostflag1 = 1
 
148
        for num in shares:
 
149
            if num == self.current_host: hostflag2 = 1
 
150
        for num in mount_points:
 
151
            if num == self.mount_point: hostflag3 = 1
 
152
        if hostflag3==1:
 
153
            print "Mount point already in use!!!"
 
154
            gobject.idle_add(dialog.dialog,"Mount point already in use.", None)
 
155
            self.flag_exit = 0
 
156
            flag = 1
 
157
            #return
 
158
        if hostflag1==1 and hostflag2==1 and flag == 0:
 
159
            print "According to mtab already mounted!!!"
 
160
            gobject.idle_add(dialog.dialog,"According to mtab already mounted.", None)
 
161
            self.flag_exit = 0
 
162
            #return
 
163
        if self.flag_exit != 0:
 
164
            sharmount.sharmount(self.h_name, self.current_host)
 
165
            gobject.idle_add(self.mountshar, self.treestore)
 
166
                                
 
167
 
 
168
class Umount_Thread(threading.Thread):
 
169
    def __init__(self, notebook, treeview, treestore, treeview_mon, treestore_mon):
 
170
        self.notebook = notebook
 
171
        self.treestore = treestore
 
172
        self.treestore_mon = treestore_mon
 
173
        self.treeview = treeview
 
174
        self.treeview_mon = treeview_mon
 
175
 
 
176
        super(Umount_Thread, self).__init__()
 
177
        return 
 
178
 
 
179
    def run(self):
 
180
        notebook = self.notebook
 
181
        treestore = self.treestore
 
182
        treestore_mon = self.treestore_mon
 
183
        treeview =self.treeview
 
184
        treeview_mon = self.treeview_mon
 
185
        page = notebook.get_current_page()
 
186
        if page == 0:
 
187
            treeselection = treeview.get_selection()
 
188
            (model, iter) = treeselection.get_selected()
 
189
            par_iter = model.iter_parent(iter)
 
190
            if not par_iter == None:
 
191
                h_name = model.get_value(iter, 3)
 
192
                flag = sharmount.sharumount(h_name)
 
193
                if flag == True: gobject.idle_add(treestore.set, iter, 3, '')
 
194
                else: 
 
195
                    print "Could not unmount current share"
 
196
                    gobject.idle_add(dialog.dialog,"Could not unmount current share.", None)
 
197
 
 
198
            else: print "Probably not smb-filesystem "
 
199
            return
 
200
        if page == 1:
 
201
            treeselection = treeview_mon.get_selection()
 
202
            (model, iter) = treeselection.get_selected()
 
203
            try:
 
204
                host_share = model.get_value(iter, 0)
 
205
            except:
 
206
                return
 
207
            mountpoint = model.get_value(iter, 1)
 
208
            line = host_share.split('/')
 
209
            flag = sharmount.sharumount(mountpoint)
 
210
            if flag == True: 
 
211
                gobject.idle_add(treestore_mon.remove, iter)
 
212
 
 
213
                try:
 
214
                    hostlist = readconfig.readconfig()
 
215
                    n = 0
 
216
                    k = 0
 
217
                    for host in hostlist:
 
218
                        iter = treestore.get_iter((n, ))
 
219
                        value = treestore.get_value(iter, 0)
 
220
                        n = n+1
 
221
                        if value == line[2]:
 
222
                            break
 
223
                        value_sh = ''
 
224
                    while 1:
 
225
                        iter_sh = treestore.get_iter((n-1, k))
 
226
                        value_sh = treestore.get_value(iter_sh, 0)
 
227
                        k = k + 1
 
228
                        if value_sh == line[3]:
 
229
                            break
 
230
                    gobject.idle_add(treestore.set,iter_sh, 3, '')
 
231
                except:
 
232
                    return
 
233
            else:
 
234
                print "Could not unmount current share"
 
235
                gobject.idle_add(dialog.dialog,"Could not unmount current share.", None)
 
236
            return
 
237
        return
 
238
 
 
239
class Fmanager_Thread(threading.Thread):
 
240
    def __init__(self, notebook, treeview):
 
241
        self.notebook = notebook
 
242
        self.treeview = treeview
 
243
 
 
244
        super(Fmanager_Thread, self).__init__()
 
245
        return 
 
246
 
 
247
    def filemanager(self, notebook, treeview):
 
248
        page = notebook.get_current_page()
 
249
        treeselection = treeview.get_selection()
 
250
        (model, iter) = treeselection.get_selected()
 
251
        if page == 0:
 
252
            par_iter = model.iter_parent(iter)
 
253
            if not par_iter == None:
 
254
                h_name = model.get_value(iter, 3)
 
255
                sharmount.file_mng(h_name)
 
256
            return
 
257
        if page == 1:
 
258
            try:
 
259
                mountpoint = model.get_value(iter, 1)
 
260
            except:
 
261
                return
 
262
            sharmount.file_mng(mountpoint)
 
263
        return
 
264
                
 
265
    def run(self):
 
266
        self.filemanager(self.notebook, self.treeview)
 
267
        return
 
268