« back to all changes in this revision
Viewing changes to lib/lp/app/longpoll/javascript/longpoll.js
- browse files at revision 13389
- compare with another revision
- compare with revision 7675.1202.7
- download diff
- download tarball
- view history from revision 13389
- Committer: Launchpad Patch Queue Manager
- Date: 2011-07-07 18:11:36 UTC
- mfrom: (13371.3.5 lp-app-longpoll-js)
- Revision ID: launchpad@pqm.canonical.com-20110707181136-ktyxnt0dpp3vw93f
[r=abentley][no-qa] New lp.app.longpoll package (js side).
- files added:
- lib/lp/app/longpoll/javascript
- lib/lp/app/longpoll/javascript/tests
- files modified:
- lib/lp/app/templates/base-layout-macros.pt
added
removed
lib/lp/app/longpoll/javascript/longpoll.js
1
/* Copyright 2009 Canonical Ltd. This software is licensed under the
2
* GNU Affero General Public License version 3 (see the file LICENSE).
3
*
4
* The Launchpad Longpoll module provides the functionnality to deal
5
* with longpolling on the JavaScript side.
6
*
7
* The module method setupLongPollManager is called in every template and
8
* the long poll machinery will only be started if LP.cache.longpoll
9
* is populated.
10
*
11
* Usually the only thing you will want to do to use the long polling feature
12
* is to make sure LP.cache.longpoll is populated and then create Javascript
13
* handlers for the events which will be fired.
14
* You also might create handlers for the generic long polling events
15
* (see below).
16
* @module longpoll
17
*/
18
YUI.add('lp.app.longpoll', function(Y) {
19
20
var namespace = Y.namespace('lp.app.longpoll');
21
22
// Event fired when the long polling request starts.
23
namespace.longpoll_start_event = 'lp.app.longpoll.start';
24
25
// Event fired each time the long polling request fails (to connect or
26
// to parse the returned result).
27
namespace.longpoll_fail_event = 'lp.app.longpoll.failure';
28
29
// Event fired when the delay between each failed connection is set to
30
// a long delay (after MAX_SHORT_DELAY_FAILED_ATTEMPTS failed attempts).
31
namespace.longpoll_longdelay = 'lp.app.longpoll.longdelay';
32
33
// Event fired when the delay between each failed connection is set back
34
// to a short delay.
35
namespace.longpoll_shortdelay = 'lp.app.longpoll.shortdelay';
36
37
namespace._manager = null;
38
39
// After MAX_SHORT_DELAY_FAILED_ATTEMPTS failed connections (real failed
40
// connections or connection getting an invalid return) separated
41
// by SHORT_DELAY (millisec), wait LONG_DELAY (millisec) between
42
// each failed connection.
43
namespace.MAX_SHORT_DELAY_FAILED_ATTEMPTS = 5;
44
namespace.SHORT_DELAY = 1000;
45
namespace.LONG_DELAY = 3*60*1000;
46
47
/**
48
*
49
* A Long Poll Manager creates and manages a long polling connexion
50
* to the server to fetch events. This class is not directly used
51
* but managed through 'setupLongPollManager' which creates and
52
* initialises a singleton LongPollManager.
53
*
54
* @class LongPollManager
55
*/
56
function LongPollManager(config) {
57
LongPollManager.superclass.constructor.apply(this, arguments);
58
}
59
60
LongPollManager.NAME = "longPollManager";
61
62
Y.extend(LongPollManager, Y.Base, {
63
initializer : function(cfg) {
64
this._started = false;
65
this._failed_attempts = 0;
66
this._repoll = true;
67
this._sequence = 0;
68
},
69
70
setConnectionInfos : function(key, uri) {
71
this.key = key;
72
this.uri = uri;
73
},
74
75
_io : function (uri, config) {
76
Y.io(uri, config);
77
},
78
79
successPoll : function (id, response) {
80
try {
81
var data = Y.JSON.parse(response.responseText);
82
var event_key = data.event_key;
83
var event_data = data.event_data;
84
Y.fire(event_key, event_data);
85
return true;
86
}
87
catch (e) {
88
Y.fire(namespace.longpoll_fail_event, e);
89
return false;
90
}
91
},
92
93
failurePoll : function () {
94
Y.fire(namespace.longpoll_fail_event);
95
},
96
97
/**
98
* Return the delay (milliseconds) to wait before trying to reconnect
99
* again after a failed connection.
100
*
101
* The rationale here is that:
102
* 1. We should not try to reconnect instantaneously after a failed
103
* connection.
104
* 2. After a certain number of failed connections, we should set the
105
* delay between two failed connection to a bigger number because
106
* the server may be having problems.
107
*
108
* @method _pollDelay
109
*/
110
_pollDelay : function() {
111
this._failed_attempts = this._failed_attempts + 1;
112
if (this._failed_attempts >=
113
namespace.MAX_SHORT_DELAY_FAILED_ATTEMPTS) {
114
Y.fire(namespace.longpoll_longdelay);
115
return namespace.LONG_DELAY;
116
}
117
else {
118
return namespace.SHORT_DELAY;
119
}
120
},
121
122
/**
123
* Relaunch a connection to the server after a successful or
124
* a failed connection.
125
*
126
* @method repoll
127
* @param {Boolean} failed: whether or not the previous connection
128
* has failed.
129
*/
130
repoll : function(failed) {
131
if (!failed) {
132
if (this._failed_attempts >=
133
namespace.MAX_SHORT_DELAY_FAILED_ATTEMPTS) {
134
Y.fire(namespace.longpoll_shortdelay);
135
}
136
this._failed_attempts = 0;
137
if (this._repoll) {
138
this.poll();
139
}
140
}
141
else {
142
var delay = this._pollDelay();
143
if (this._repoll) {
144
Y.later(delay, this, this.poll);
145
}
146
}
147
},
148
149
poll : function() {
150
var that = this;
151
var config = {
152
method: "GET",
153
sync: false,
154
on: {
155
failure: function() {
156
that.failurePoll();
157
that.repoll(true);
158
},
159
success: function(id, response) {
160
var res = that.successPoll(id, response);
161
that.repoll(res);
162
}
163
}
164
};
165
this._sequence = this._sequence + 1;
166
var queue_uri = this.uri +
167
"?uuid=" + this.key +
168
"&sequence=" + this._sequence;
169
if (!this._started) {
170
Y.fire(namespace.longpoll_start_event);
171
this._started = true;
172
}
173
this._io(queue_uri, config);
174
}
175
});
176
177
namespace.LongPollManager = LongPollManager;
178
179
namespace.getLongPollManager = function() {
180
if (!Y.Lang.isValue(namespace._manager)) {
181
namespace._manager = new namespace.LongPollManager();
182
}
183
return namespace._manager;
184
};
185
186
namespace.setupLongPollManager = function() {
187
if (Y.Lang.isValue(LP.cache.longpoll)) {
188
var key = LP.cache.longpoll.key;
189
var uri = LP.cache.longpoll.uri;
190
var longpollmanager = namespace.getLongPollManager();
191
longpollmanager.setConnectionInfos(key, uri);
192
longpollmanager.poll();
193
return longpollmanager;
194
}
195
};
196
197
}, "0.1", {"requires":["base", "event", "lang", "json", "io"]});
Loggerhead is a web-based interface for Breezy
Version: 2.0.1