← Back to branch summary

~3v1n0/syspeek/gtk3-port

« back to all changes in this revision

Viewing changes to syspeek/supplier.py

  • Committer: Marco Trevisan (Treviño)
  • Date: 2014-06-05 15:38:26 UTC
  • Revision ID: mail@3v1n0.net-20140605153826-gwfbrtxil3iyc21f
Supplier: no need to use threads, just use glib timeouts for reading data

Show diffs side-by-side

added added

removed removed

Lines of Context:
syspeek/supplier.py
16
16
#
17
17
 
18
18
import os
19
 
import threading
20
 
import time
21
19
import traceback
22
 
from gi.repository import GObject as gobject
 
20
from gi.repository import GLib
23
21
from abc import ABCMeta, abstractmethod
24
22
 
25
 
class Supplier(threading.Thread):
 
23
class Supplier():
26
24
        __metaclass__ = ABCMeta
27
25
 
28
26
        def __init__(self, display, interval=1):
29
 
                threading.Thread.__init__(self)
30
27
                self.display = display
31
 
                self.interval = interval
32
 
                self._stop = threading.Event()
33
 
                self.setDaemon(True)
 
28
                self.__interval = interval
 
29
                self.timeout = None
 
30
 
 
31
        def __start_timeout(self):
 
32
                self.stop()
 
33
                interval = int(self.interval * 1000)
 
34
 
 
35
                if interval % 1000 == 0:
 
36
                        interval = interval / 1000
 
37
                        self.timeout = GLib.timeout_source_new_seconds(interval)
 
38
                else:
 
39
                        self.timeout = GLib.Timeout(interval)
 
40
 
 
41
                self.timeout.set_callback(self.__on_callback)
 
42
                self.timeout.attach()
 
43
 
 
44
        def __on_callback(self, data):
 
45
                try:
 
46
                        self.supply()
 
47
                except:
 
48
                        traceback.print_exc()
 
49
                return True
34
50
 
35
51
        def run(self):
36
 
                self.running = True
37
 
                while not self.stopped():
38
 
                        try:
39
 
                                self.supply()
40
 
                        except:
41
 
                                traceback.print_exc()
42
 
                        time.sleep(self.interval)
 
52
                if self.stopped():
 
53
                        self.__start_timeout()
 
54
                self.supply()
43
55
 
44
56
        def stop(self):
45
 
                self._stop.set()
 
57
                if self.timeout:
 
58
                        self.timeout.destroy()
 
59
                        self.timeout = None
46
60
 
47
61
        def stopped(self):
48
 
                return self._stop.isSet()
 
62
                return self.timeout == None or self.timeout.is_destroyed()
 
63
 
 
64
        @property
 
65
        def interval(self):
 
66
                return self.__interval;
 
67
 
 
68
        @interval.setter
 
69
        def interval(self, val):
 
70
                if self.__interval == val:
 
71
                        return
 
72
 
 
73
                self.__interval = val
 
74
 
 
75
                if not self.stopped():
 
76
                        self.__start_timeout()
49
77
 
50
78
        @abstractmethod
51
79
        def supply(self): pass
109
137
                                break
110
138
 
111
139
                if self.supply_average:
112
 
                        gobject.idle_add(self.display.update_cpu, percentages[0])
 
140
                        self.display.update_cpu(percentages[0])
113
141
 
114
142
                if self.supply_cores:
115
 
                        gobject.idle_add(self.display.update_cpu_cores, percentages[1:])
 
143
                        self.display.update_cpu_cores(percentages[1:])
116
144
 
117
145
class MemSwapSupplier(Supplier):
118
146
        def supply(self):
129
157
 
130
158
                mem_used = meminfo['MemTotal'] - meminfo['MemFree'] - meminfo['Buffers'] - meminfo['Cached']
131
159
                swap_used = meminfo['SwapTotal'] - meminfo['SwapFree']
132
 
                
133
 
                gobject.idle_add(self.display.update_memswap,
 
160
 
 
161
                self.display.update_memswap(
134
162
                        mem_used,
135
163
                        meminfo['MemTotal'],
136
164
                        swap_used,
166
194
                delta_receive = receive - self.last_receive
167
195
                delta_transmit = transmit - self.last_transmit
168
196
 
169
 
                gobject.idle_add(self.display.update_network,
 
197
                self.display.update_network(
170
198
                        int(delta_receive / self.interval),
171
199
                        int(delta_transmit / self.interval),
172
200
                        receive,
175
203
 
176
204
                self.last_receive = receive
177
205
                self.last_transmit = transmit
178
 
                                        
179
206
 
180
207
        def active_interface(self):
181
208
                f = open('/proc/net/route', 'r')
203
230
                        except:
204
231
                                print "ERROR: Could not get data for " + directory
205
232
 
206
 
                gobject.idle_add(self.display.update_disk, values)
 
233
                self.display.update_disk(values)
207
234