← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libktorrent/oneiric

« back to all changes in this revision

Viewing changes to src/net/socketmonitor.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Modestas Vainius
  • Date: 2011-05-26 00:33:38 UTC
  • mfrom: (5.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20110526003338-2r4zwyzn8bovsxay
Tags: 1.1.1-2
Release to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/net/socketmonitor.cpp
32
32
namespace net
33
33
{
34
34
        SocketMonitor SocketMonitor::self;
 
35
        
 
36
        class SocketMonitor::Private
 
37
        {
 
38
        public:
 
39
                Private(SocketMonitor* p) : mutex(QMutex::Recursive),ut(0),dt(0),next_group_id(1)
 
40
                {
 
41
                        dt = new DownloadThread(p);
 
42
                        ut = new UploadThread(p);
 
43
                }
 
44
                
 
45
                ~Private()
 
46
                {
 
47
                        shutdown();
 
48
                }
 
49
                
 
50
                void shutdown();
 
51
                
 
52
                QMutex mutex;
 
53
                UploadThread* ut;
 
54
                DownloadThread* dt;
 
55
                Uint32 next_group_id;
 
56
        };
35
57
 
36
 
        SocketMonitor::SocketMonitor() : mutex(QMutex::Recursive),ut(0),dt(0),next_group_id(1)
 
58
        SocketMonitor::SocketMonitor() : d(new Private(this))
37
59
        {
38
 
                dt = new DownloadThread(this);
39
 
                ut = new UploadThread(this);
 
60
                
40
61
        }
41
62
 
42
63
 
43
64
        SocketMonitor::~SocketMonitor()
44
65
        {
45
 
                shutdown();
 
66
                delete d;
46
67
        }
47
68
        
48
69
        void SocketMonitor::shutdown()
49
70
        {
 
71
                d->shutdown();
 
72
        }
 
73
        
 
74
        void SocketMonitor::Private::shutdown()
 
75
        {
50
76
                if (ut && ut->isRunning())
51
77
                {
52
78
                        ut->stop();
79
105
        
80
106
        void SocketMonitor::lock()
81
107
        {
82
 
                mutex.lock();
 
108
                d->mutex.lock();
83
109
        }
84
110
        
85
111
        void SocketMonitor::unlock()
86
112
        {
87
 
                mutex.unlock();
 
113
                d->mutex.unlock();
88
114
        }
89
115
        
90
116
        void SocketMonitor::setDownloadCap(Uint32 bytes_per_sec)
92
118
                DownloadThread::setCap(bytes_per_sec);
93
119
        }
94
120
        
 
121
        Uint32 SocketMonitor::getDownloadCap()
 
122
        {
 
123
                return DownloadThread::cap();
 
124
        }
 
125
 
 
126
        
95
127
        void SocketMonitor::setUploadCap(Uint32 bytes_per_sec)
96
128
        {
97
129
                UploadThread::setCap(bytes_per_sec);
98
130
        }
99
131
        
 
132
        Uint32 SocketMonitor::getUploadCap()
 
133
        {
 
134
                return UploadThread::cap();
 
135
        }
 
136
 
 
137
        
100
138
        void SocketMonitor::setSleepTime(Uint32 sleep_time)
101
139
        {
102
140
                DownloadThread::setSleepTime(sleep_time);
105
143
        
106
144
        void SocketMonitor::add(BufferedSocket* sock)
107
145
        {
108
 
                QMutexLocker lock(&mutex);
109
 
                
110
 
                bool start_threads = smap.size() == 0;
111
 
                smap.push_back(sock);
 
146
                QMutexLocker lock(&d->mutex);
 
147
                
 
148
                if (!d->dt || !d->ut)
 
149
                        return;
 
150
                
 
151
                bool start_threads = sockets.size() == 0;
 
152
                sockets.push_back(sock);
112
153
                
113
154
                if (start_threads)
114
155
                {
115
156
                        Out(SYS_CON|LOG_DEBUG) << "Starting socketmonitor threads" << endl;
116
157
                                
117
 
                        if (!dt->isRunning())
118
 
                                dt->start(QThread::IdlePriority);
119
 
                        if (!ut->isRunning())
120
 
                                ut->start(QThread::IdlePriority);
 
158
                        if (!d->dt->isRunning())
 
159
                                d->dt->start(QThread::IdlePriority);
 
160
                        if (!d->ut->isRunning())
 
161
                                d->ut->start(QThread::IdlePriority);
121
162
                }
122
163
                // wake up download thread so that it can start polling the new socket
123
 
                dt->wakeUp();
 
164
                d->dt->wakeUp();
124
165
        }
125
166
        
126
167
        void SocketMonitor::remove(BufferedSocket* sock)
127
168
        {
128
 
                QMutexLocker lock(&mutex);
129
 
                if (smap.size() == 0)
 
169
                QMutexLocker lock(&d->mutex);
 
170
                if (sockets.size() == 0)
130
171
                        return;
131
172
                
132
 
                smap.remove(sock);
 
173
                sockets.remove(sock);
133
174
        }
134
175
        
135
176
        void SocketMonitor::signalPacketReady()
136
177
        {
137
 
                if (ut)
138
 
                        ut->signalDataReady();
 
178
                if (d->ut)
 
179
                        d->ut->signalDataReady();
139
180
        }
140
181
        
141
182
        Uint32 SocketMonitor::newGroup(GroupType type,Uint32 limit,Uint32 assured_rate)
142
183
        {
143
 
                lock();
144
 
                Uint32 gid = next_group_id++;
 
184
                QMutexLocker lock(&d->mutex);
 
185
                if (!d->dt || !d->ut)
 
186
                        return 0;
 
187
                
 
188
                Uint32 gid = d->next_group_id++;
145
189
                if (type == UPLOAD_GROUP)
146
 
                        ut->addGroup(gid,limit,assured_rate);
 
190
                        d->ut->addGroup(gid,limit,assured_rate);
147
191
                else
148
 
                        dt->addGroup(gid,limit,assured_rate);
149
 
                unlock();
 
192
                        d->dt->addGroup(gid,limit,assured_rate);
 
193
                
150
194
                return gid;
151
195
        }
152
196
                
153
197
        void SocketMonitor::setGroupLimit(GroupType type,Uint32 gid,Uint32 limit)
154
198
        {
155
 
                lock();
 
199
                QMutexLocker lock(&d->mutex);
 
200
                if (!d->dt || !d->ut)
 
201
                        return;
 
202
                
156
203
                if (type == UPLOAD_GROUP)
157
 
                        ut->setGroupLimit(gid,limit);
 
204
                        d->ut->setGroupLimit(gid,limit);
158
205
                else
159
 
                        dt->setGroupLimit(gid,limit);
160
 
                unlock();
 
206
                        d->dt->setGroupLimit(gid,limit);
161
207
        }
162
208
        
163
209
        void SocketMonitor::setGroupAssuredRate(GroupType type,Uint32 gid,Uint32 as)
164
210
        {
165
 
                lock();
 
211
                QMutexLocker lock(&d->mutex);
 
212
                if (!d->dt || !d->ut)
 
213
                        return;
 
214
                
166
215
                if (type == UPLOAD_GROUP)
167
 
                        ut->setGroupAssuredRate(gid,as);
 
216
                        d->ut->setGroupAssuredRate(gid,as);
168
217
                else
169
 
                        dt->setGroupAssuredRate(gid,as);
170
 
                unlock();
 
218
                        d->dt->setGroupAssuredRate(gid,as);
171
219
        }
172
220
                
173
221
        void SocketMonitor::removeGroup(GroupType type,Uint32 gid)
174
222
        {
175
 
                lock();
 
223
                QMutexLocker lock(&d->mutex);
 
224
                if (!d->dt || !d->ut)
 
225
                        return;
 
226
                
176
227
                if (type == UPLOAD_GROUP)
177
 
                        ut->removeGroup(gid);
 
228
                        d->ut->removeGroup(gid);
178
229
                else
179
 
                        dt->removeGroup(gid);
180
 
                unlock();
 
230
                        d->dt->removeGroup(gid);
181
231
        }
182
232
 
183
233
}