1 | /*************************************************************************** |
2 | * Copyright (C) 2005-2014 by the Quassel Project * |
3 | * devel@quassel-irc.org * |
4 | * * |
5 | * This program is free software; you can redistribute it and/or modify * |
6 | * it under the terms of the GNU General Public License as published by * |
7 | * the Free Software Foundation; either version 2 of the License, or * |
8 | * (at your option) version 3. * |
9 | * * |
10 | * This program is distributed in the hope that it will be useful, * |
11 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * |
12 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
13 | * GNU General Public License for more details. * |
14 | * * |
15 | * You should have received a copy of the GNU General Public License * |
16 | * along with this program; if not, write to the * |
17 | * Free Software Foundation, Inc., * |
18 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * |
19 | ***************************************************************************/ |
20 | |
21 | #include "clientbacklogmanager.h" |
22 | |
23 | #include "abstractmessageprocessor.h" |
24 | #include "backlogsettings.h" |
25 | #include "backlogrequester.h" |
26 | #include "client.h" |
27 | |
28 | #include <ctime> |
29 | |
30 | #include <QDebug> |
31 | |
32 | INIT_SYNCABLE_OBJECT(ClientBacklogManager) |
33 | ClientBacklogManager::ClientBacklogManager(QObject *parent) |
34 | : BacklogManager(parent), |
35 | _requester(0), |
36 | _initBacklogRequested(false) |
37 | { |
38 | } |
39 | |
40 | |
41 | QVariantList ClientBacklogManager::requestBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional) |
42 | { |
43 | _buffersRequested << bufferId; |
44 | return BacklogManager::requestBacklog(bufferId, first, last, limit, additional); |
45 | } |
46 | |
47 | |
48 | void ClientBacklogManager::receiveBacklog(BufferId bufferId, MsgId first, MsgId last, int limit, int additional, QVariantList msgs) |
49 | { |
50 | Q_UNUSED(first) Q_UNUSED(last) Q_UNUSED(limit) Q_UNUSED(additional) |
51 | |
52 | emit messagesReceived(bufferId, msgs.count()); |
53 | |
54 | MessageList msglist; |
55 | foreach(QVariant v, msgs) { |
56 | Message msg = v.value<Message>(); |
57 | msg.setFlags(msg.flags() | Message::Backlog); |
58 | msglist << msg; |
59 | } |
60 | |
61 | if (isBuffering()) { |
62 | bool lastPart = !_requester->buffer(bufferId, msglist); |
63 | updateProgress(_requester->totalBuffers() - _requester->buffersWaiting(), _requester->totalBuffers()); |
64 | if (lastPart) { |
65 | dispatchMessages(_requester->bufferedMessages(), true); |
66 | _requester->flushBuffer(); |
67 | } |
68 | } |
69 | else { |
70 | dispatchMessages(msglist); |
71 | } |
72 | } |
73 | |
74 | |
75 | void ClientBacklogManager::receiveBacklogAll(MsgId first, MsgId last, int limit, int additional, QVariantList msgs) |
76 | { |
77 | Q_UNUSED(first) Q_UNUSED(last) Q_UNUSED(limit) Q_UNUSED(additional) |
78 | |
79 | MessageList msglist; |
80 | foreach(QVariant v, msgs) { |
81 | Message msg = v.value<Message>(); |
82 | msg.setFlags(msg.flags() | Message::Backlog); |
83 | msglist << msg; |
84 | } |
85 | |
86 | dispatchMessages(msglist); |
87 | } |
88 | |
89 | |
90 | void ClientBacklogManager::requestInitialBacklog() |
91 | { |
92 | if (_initBacklogRequested) { |
93 | Q_ASSERT(_requester); |
94 | qWarning() << "ClientBacklogManager::requestInitialBacklog() called twice in the same session! (Backlog has already been requested)" ; |
95 | return; |
96 | } |
97 | |
98 | BacklogSettings settings; |
99 | switch (settings.requesterType()) { |
100 | case BacklogRequester::GlobalUnread: |
101 | _requester = new GlobalUnreadBacklogRequester(this); |
102 | break; |
103 | case BacklogRequester::PerBufferUnread: |
104 | _requester = new PerBufferUnreadBacklogRequester(this); |
105 | break; |
106 | case BacklogRequester::PerBufferFixed: |
107 | default: |
108 | _requester = new FixedBacklogRequester(this); |
109 | }; |
110 | |
111 | _requester->requestInitialBacklog(); |
112 | _initBacklogRequested = true; |
113 | if (_requester->isBuffering()) { |
114 | updateProgress(0, _requester->totalBuffers()); |
115 | } |
116 | } |
117 | |
118 | |
119 | BufferIdList ClientBacklogManager::filterNewBufferIds(const BufferIdList &bufferIds) |
120 | { |
121 | BufferIdList newBuffers; |
122 | QSet<BufferId> availableBuffers = Client::networkModel()->allBufferIds().toSet(); |
123 | foreach(BufferId bufferId, bufferIds) { |
124 | if (_buffersRequested.contains(bufferId) || !availableBuffers.contains(bufferId)) |
125 | continue; |
126 | newBuffers << bufferId; |
127 | } |
128 | return newBuffers; |
129 | } |
130 | |
131 | |
132 | void ClientBacklogManager::checkForBacklog(const QList<BufferId> &bufferIds) |
133 | { |
134 | // we ingore all backlogrequests until we had our initial request |
135 | if (!_initBacklogRequested) { |
136 | return; |
137 | } |
138 | |
139 | if (!_requester) { |
140 | // during client start up this message is to be expected in some situations. |
141 | qDebug() << "ClientBacklogManager::checkForBacklog(): no active backlog requester." ; |
142 | return; |
143 | } |
144 | switch (_requester->type()) { |
145 | case BacklogRequester::GlobalUnread: |
146 | break; |
147 | case BacklogRequester::PerBufferUnread: |
148 | case BacklogRequester::PerBufferFixed: |
149 | default: |
150 | { |
151 | BufferIdList buffers = filterNewBufferIds(bufferIds); |
152 | if (!buffers.isEmpty()) |
153 | _requester->requestBacklog(buffers); |
154 | } |
155 | }; |
156 | } |
157 | |
158 | |
159 | bool ClientBacklogManager::isBuffering() |
160 | { |
161 | return _requester && _requester->isBuffering(); |
162 | } |
163 | |
164 | |
165 | void ClientBacklogManager::dispatchMessages(const MessageList &messages, bool sort) |
166 | { |
167 | if (messages.isEmpty()) |
168 | return; |
169 | |
170 | MessageList msgs = messages; |
171 | |
172 | clock_t start_t = clock(); |
173 | if (sort) |
174 | qSort(msgs); |
175 | Client::messageProcessor()->process(msgs); |
176 | clock_t end_t = clock(); |
177 | |
178 | emit messagesProcessed(tr("Processed %1 messages in %2 seconds." ).arg(messages.count()).arg((float)(end_t - start_t) / CLOCKS_PER_SEC)); |
179 | } |
180 | |
181 | |
182 | void ClientBacklogManager::reset() |
183 | { |
184 | delete _requester; |
185 | _requester = 0; |
186 | _initBacklogRequested = false; |
187 | _buffersRequested.clear(); |
188 | } |
189 | |