blob: 407192a8620c8214f790edea26a46c4b14648688 [file] [log] [blame]
// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
part of dart._http;
const String _DART_SESSION_ID = "DARTSESSID";
// A _HttpSession is a node in a double-linked list, with _next and _prev being
// the previous and next pointers.
class _HttpSession implements HttpSession {
// Destroyed marked. Used by the http connection to see if a session is valid.
bool _destroyed = false;
bool _isNew = true;
DateTime _lastSeen;
Function? _timeoutCallback;
_HttpSessionManager _sessionManager;
// Pointers in timeout queue.
_HttpSession? _prev;
_HttpSession? _next;
final String id;
final Map _data = new HashMap();
_HttpSession(this._sessionManager, this.id) : _lastSeen = new DateTime.now();
void destroy() {
assert(!_destroyed);
_destroyed = true;
_sessionManager._removeFromTimeoutQueue(this);
_sessionManager._sessions.remove(id);
}
// Mark the session as seen. This will reset the timeout and move the node to
// the end of the timeout queue.
void _markSeen() {
_lastSeen = new DateTime.now();
_sessionManager._bumpToEnd(this);
}
DateTime get lastSeen => _lastSeen;
bool get isNew => _isNew;
void set onTimeout(void callback()?) {
_timeoutCallback = callback;
}
// Map implementation:
bool containsValue(value) => _data.containsValue(value);
bool containsKey(key) => _data.containsKey(key);
operator [](key) => _data[key];
void operator []=(key, value) {
_data[key] = value;
}
putIfAbsent(key, ifAbsent) => _data.putIfAbsent(key, ifAbsent);
addAll(Map other) => _data.addAll(other);
remove(key) => _data.remove(key);
void clear() {
_data.clear();
}
void forEach(void f(key, value)) {
_data.forEach(f);
}
Iterable<MapEntry> get entries => _data.entries;
void addEntries(Iterable<MapEntry> entries) {
_data.addEntries(entries);
}
Map<K, V> map<K, V>(MapEntry<K, V> transform(key, value)) =>
_data.map(transform);
void removeWhere(bool test(key, value)) {
_data.removeWhere(test);
}
Map<K, V> cast<K, V>() => _data.cast<K, V>();
update(key, update(value), {ifAbsent()?}) =>
_data.update(key, update, ifAbsent: ifAbsent);
void updateAll(update(key, value)) {
_data.updateAll(update);
}
Iterable get keys => _data.keys;
Iterable get values => _data.values;
int get length => _data.length;
bool get isEmpty => _data.isEmpty;
bool get isNotEmpty => _data.isNotEmpty;
String toString() => 'HttpSession id:$id $_data';
}
// Private class used to manage all the active sessions. The sessions are stored
// in two ways:
//
// * In a map, mapping from ID to HttpSession.
// * In a linked list, used as a timeout queue.
class _HttpSessionManager {
Map<String, _HttpSession> _sessions;
int _sessionTimeout = 20 * 60; // 20 mins.
_HttpSession? _head;
_HttpSession? _tail;
Timer? _timer;
_HttpSessionManager() : _sessions = {};
String createSessionId() {
const int _KEY_LENGTH = 16; // 128 bits.
var data = _CryptoUtils.getRandomBytes(_KEY_LENGTH);
return _CryptoUtils.bytesToHex(data);
}
_HttpSession? getSession(String id) => _sessions[id];
_HttpSession createSession() {
var id = createSessionId();
// TODO(ajohnsen): Consider adding a limit and throwing an exception.
// Should be very unlikely however.
while (_sessions.containsKey(id)) {
id = createSessionId();
}
var session = _sessions[id] = new _HttpSession(this, id);
_addToTimeoutQueue(session);
return session;
}
void set sessionTimeout(int timeout) {
_sessionTimeout = timeout;
_stopTimer();
_startTimer();
}
void close() {
_stopTimer();
}
void _bumpToEnd(_HttpSession session) {
_removeFromTimeoutQueue(session);
_addToTimeoutQueue(session);
}
void _addToTimeoutQueue(_HttpSession session) {
if (_head == null) {
assert(_tail == null);
_tail = _head = session;
_startTimer();
} else {
assert(_timer != null);
var tail = _tail!;
// Add to end.
tail._next = session;
session._prev = tail;
_tail = session;
}
}
void _removeFromTimeoutQueue(_HttpSession session) {
var next = session._next;
var prev = session._prev;
session._next = session._prev = null;
next?._prev = prev;
prev?._next = next;
if (_tail == session) {
_tail = prev;
}
if (_head == session) {
_head = next;
// We removed the head element, start new timer.
_stopTimer();
_startTimer();
}
}
void _timerTimeout() {
_stopTimer(); // Clear timer.
var session = _head!;
session.destroy(); // Will remove the session from timeout queue and map.
session._timeoutCallback?.call();
}
void _startTimer() {
assert(_timer == null);
var head = _head;
if (head != null) {
int seconds = new DateTime.now().difference(head.lastSeen).inSeconds;
_timer = new Timer(
new Duration(seconds: _sessionTimeout - seconds), _timerTimeout);
}
}
void _stopTimer() {
var timer = _timer;
if (timer != null) {
timer.cancel();
_timer = null;
}
}
}