Commit 428d97dd by Romain Courteaud

Add mutex implementation.

Mutex execution should be cancellable.
callback should always be cancellable without preventing the mutex to be released.
1 parent f7281a1e
......@@ -75,7 +75,7 @@ module.exports = function (grunt) {
test: {
src: ['test/embedded.js', 'test/renderjs_test.js',
'test/embedded.js', 'test/inject_script.js',
'test/not_declared_gadget.js',
'test/mutex_test.js', 'test/not_declared_gadget.js',
'test/trigger_rjsready_event_on_ready_gadget.js'],
directives: {
maxlen: 79,
......
......@@ -142,6 +142,7 @@
gadget_loading_klass_list = [],
renderJS,
Monitor,
Mutex,
scope_increment = 0,
isAbsoluteOrDataURL = new RegExp('^(?:[a-z]+:)?//|data:', 'i'),
is_page_unloaded = false,
......@@ -159,6 +160,64 @@
});
/////////////////////////////////////////////////////////////////
// Mutex
/////////////////////////////////////////////////////////////////
Mutex = function createMutex() {
if (!(this instanceof Mutex)) {
return new Mutex();
}
this._latest_defer = null;
};
Mutex.prototype = {
constructor: Mutex,
lock: function lockMutex() {
var previous_defer = this._latest_defer,
current_defer = RSVP.defer(),
queue = new RSVP.Queue();
this._latest_defer = current_defer;
if (previous_defer !== null) {
queue.push(function acquireMutex() {
return previous_defer.promise;
});
}
// Create a new promise (.then) not cancellable
// to allow external cancellation of the callback
// without breaking the mutex implementation
queue
.fail(current_defer.resolve.bind(current_defer));
return queue
.push(function generateMutexUnlock() {
return function runAndUnlock(callback) {
return new RSVP.Queue()
.push(function executeMutexCallback() {
return callback();
})
.push(function releaseMutexAfterSuccess(result) {
current_defer.resolve(result);
return result;
}, function releaseMutexAfterError(error) {
current_defer.resolve(error);
throw error;
});
};
});
},
lockAndRun: function (callback) {
return this.lock()
.push(function executeLockAndRunCallback(runAndUnlock) {
return runAndUnlock(callback);
});
}
};
/////////////////////////////////////////////////////////////////
// Helper functions
/////////////////////////////////////////////////////////////////
function removeHash(url) {
......@@ -1371,6 +1430,7 @@
/////////////////////////////////////////////////////////////////
// global
/////////////////////////////////////////////////////////////////
renderJS.Mutex = Mutex;
window.rJS = window.renderJS = renderJS;
window.__RenderJSGadget = RenderJSGadget;
window.__RenderJSEmbeddedGadget = RenderJSEmbeddedGadget;
......
......@@ -11,6 +11,7 @@
<script src="../node_modules/URIjs/src/URI.js"></script>
<script src="../dist/renderjs-latest.js" type="text/javascript"></script>
<script src="renderjs_test.js" type="text/javascript"></script>
<script src="mutex_test.js" type="text/javascript"></script>
</head>
<body>
<h1 id="qunit-header">QUnit renderJS test suite</h1>
......
(function (Mutex, QUnit) {
"use strict";
var test = QUnit.test,
stop = QUnit.stop,
start = QUnit.start,
ok = QUnit.ok,
expect = QUnit.expect,
equal = QUnit.equal,
module = QUnit.module;
/////////////////////////////////////////////////////////////////
// parseGadgetHTMLDocument
/////////////////////////////////////////////////////////////////
module("renderJS.Mutex");
test('constructor', function () {
equal(Mutex.length, 0);
var mutex = new Mutex();
equal(Object.getPrototypeOf(mutex), Mutex.prototype);
equal(mutex.constructor, Mutex);
equal(Mutex.prototype.constructor, Mutex);
});
test('lockAndRun execute callback', function () {
var mutex = new Mutex(),
counter = 0;
stop();
expect(6);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback1() {
assertCounter(0);
return new RSVP.Queue()
.push(function () {
return RSVP.delay(100);
})
.push(function () {
assertCounter(1);
return 'callback1 result';
});
}
function callback2() {
assertCounter(3);
}
return new RSVP.Queue()
.push(function () {
return mutex.lockAndRun(callback1);
})
.push(function (result) {
equal(result, 'callback1 result');
assertCounter(2);
return mutex.lockAndRun(callback2);
})
.push(function () {
assertCounter(4);
})
.always(function () {
start();
});
});
test('lockAndRun handle exception', function () {
var mutex = new Mutex(),
counter = 0;
stop();
expect(5);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback1() {
assertCounter(0);
throw new Error('Error in callback1');
}
function callback2() {
assertCounter(2);
}
return new RSVP.Queue()
.push(function () {
return mutex.lockAndRun(callback1);
})
.push(undefined, function (error) {
equal(error.message, 'Error in callback1');
assertCounter(1);
return mutex.lockAndRun(callback2);
})
.push(function () {
assertCounter(3);
})
.always(function () {
start();
});
});
test('lockAndRun prevent concurrent execution', function () {
var mutex = new Mutex(),
counter = 0;
stop();
expect(9);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback1() {
assertCounter(0);
return new RSVP.Queue()
.push(function () {
return RSVP.delay(50);
})
.push(function () {
assertCounter(1);
return 'callback1 result';
});
}
function callback2() {
assertCounter(2);
return new RSVP.Queue()
.push(function () {
return RSVP.delay(50);
})
.push(function () {
assertCounter(3);
return 'callback2 result';
});
}
function callback3() {
assertCounter(4);
return 'callback3 result';
}
return new RSVP.Queue()
.push(function () {
return RSVP.all([
mutex.lockAndRun(callback1),
mutex.lockAndRun(callback2),
mutex.lockAndRun(callback3)
]);
})
.push(function (result_list) {
equal(result_list[0], 'callback1 result');
equal(result_list[1], 'callback2 result');
equal(result_list[2], 'callback3 result');
assertCounter(5);
})
.always(function () {
start();
});
});
test('lockAndRun handle concurrent exception', function () {
var mutex = new Mutex(),
counter = 0;
stop();
expect(4);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback1() {
assertCounter(0);
throw new Error('error in callback1');
}
function callback2() {
assertCounter(1);
throw new Error('error in callback2');
}
function callback3() {
assertCounter(2);
return 'callback3 result';
}
return new RSVP.Queue()
.push(function () {
return RSVP.all([
mutex.lockAndRun(callback1),
mutex.lockAndRun(callback2),
mutex.lockAndRun(callback3)
]);
})
.push(undefined, function (error) {
equal(error.message, 'error in callback1');
assertCounter(2);
})
.always(function () {
start();
});
});
test('lockAndRun cancel does not prevent next execution', function () {
var mutex = new Mutex(),
counter = 0;
stop();
expect(6);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback1() {
ok(false, 'Should not reach that code');
}
function callback2() {
assertCounter(1);
return 'callback2 result';
}
return new RSVP.Queue()
.push(function () {
var promise1 = mutex.lockAndRun(callback1);
return RSVP.all([
promise1
.then(function () {
ok(false, 'Should not reach that code');
}, function (error) {
assertCounter(0);
equal(error.message, 'Default Message');
return 'handler1 result';
}),
mutex.lockAndRun(callback2),
promise1.cancel('cancel callback1')
]);
})
.push(function (result_list) {
equal(result_list[0], 'handler1 result');
equal(result_list[1], 'callback2 result');
assertCounter(2);
})
.always(function () {
start();
});
});
test('lockAndRun cancel does not cancel previous execution', function () {
var mutex = new Mutex(),
counter = 0,
defer = RSVP.defer();
stop();
expect(8);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback2() {
ok(false, 'Should not reach that code');
}
function callback1() {
return new RSVP.Queue()
.push(function () {
return RSVP.delay(50);
})
.push(function () {
assertCounter(0);
defer.resolve();
return RSVP.delay(50);
})
.push(function () {
assertCounter(3);
return 'callback1 result';
});
}
return new RSVP.Queue()
.push(function () {
var promise1 = mutex.lockAndRun(callback1),
promise2 = mutex.lockAndRun(callback2);
return RSVP.all([
promise1,
promise2
.then(function () {
ok(false, 'Should not reach that code');
}, function (error) {
assertCounter(2);
equal(error.message, 'Default Message');
return 'handler2 result';
}),
defer.promise
.then(function () {
assertCounter(1);
promise2.cancel('cancel callback2');
})
]);
})
.push(function (result_list) {
equal(result_list[0], 'callback1 result');
equal(result_list[1], 'handler2 result');
assertCounter(4);
})
.always(function () {
start();
});
});
test('lockAndRun only wait for the callback', function () {
var mutex = new Mutex(),
counter = 0;
stop();
expect(4);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback1() {
assertCounter(0);
return 'callback1 result';
}
function callback2() {
assertCounter(1);
return 'callback2 result';
}
return new RSVP.Queue()
.push(function () {
return RSVP.any([
mutex.lockAndRun(callback1)
.push(function () {
return RSVP.delay(10000);
}),
mutex.lockAndRun(callback2)
]);
})
.push(function (result) {
equal(result, 'callback2 result');
assertCounter(2);
})
.always(function () {
start();
});
});
test('lockAndRun only wait for the error callback', function () {
var mutex = new Mutex(),
counter = 0;
stop();
expect(4);
function assertCounter(value) {
equal(counter, value);
counter += 1;
}
function callback1() {
assertCounter(0);
throw new Error('callback1 error');
}
function callback2() {
assertCounter(1);
return 'callback2 result';
}
return new RSVP.Queue()
.push(function () {
return RSVP.any([
mutex.lockAndRun(callback1)
.push(undefined, function () {
return RSVP.delay(10000);
}),
mutex.lockAndRun(callback2)
]);
})
.push(function (result) {
equal(result, 'callback2 result');
assertCounter(2);
})
.always(function () {
start();
});
});
}(renderJS.Mutex, QUnit));
\ No newline at end of file
......@@ -5891,6 +5891,8 @@
URI("../dist/renderjs-latest.js")
.absoluteTo(parent_path).toString(),
URI("renderjs_test.js")
.absoluteTo(parent_path).toString(),
URI("mutex_test.js")
.absoluteTo(parent_path).toString()
]);
equal(root_gadget.element.outerHTML, document.body.outerHTML);
......@@ -5914,6 +5916,8 @@
URI("../dist/renderjs-latest.js")
.absoluteTo(parent_path).toString(),
URI("renderjs_test.js")
.absoluteTo(parent_path).toString(),
URI("mutex_test.js")
.absoluteTo(parent_path).toString()
]);
html = root_gadget.constructor.__template_element.outerHTML;
......
Styling with Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!