modules/js/htdocs/component.js - tuscany-sca-cpp - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 /**
  * Client component wiring API, supporting JSON and ATOM bindings.
  */

 var JSONClient = {};

 /**
  * Construct an HTTPBindingClient.
  */
 function HTTPBindingClient(name, uri, domain) {
     this.name = name;
     this.domain = domain;
     this.uri = uri;
     this.apply = this.createApplyMethod();
 }

 /**
  * HTTPBindingClient implementation
  */

 /**
  * Run a function asynchronously.
  */
 HTTPBindingClient.delaying = false;
 HTTPBindingClient.delay = function(f) {
     if (HTTPBindingClient.delaying)
         return window.setTimeout(f, 0);
     else
         return f();
 };

 /**
  * Generate client proxy apply method.
  */
 HTTPBindingClient.prototype.createApplyMethod = function() {
     var fn = function() {
         var methodName = arguments[0];
         var args = [];
         for(var i = 1; i < arguments.length; i++)
             args[args.length] = arguments[i];

         var cb;
         if(typeof args[args.length - 1] == 'function')
             cb = args.pop();

         var req = HTTPBindingClient.makeJSONRequest(methodName, args, cb);
         return fn.client.jsonApply(req);
     };
     fn.client = this;
     return fn;
 };

 /**
  * JSON-RPC request counter.
  */
 HTTPBindingClient.jsonrpcID = 1;

 /**
  * Make a JSON-RPC request.
  */
 HTTPBindingClient.makeJSONRequest = function(methodName, args, cb) {
     var req = {};
     req.id = HTTPBindingClient.jsonrpcID++;
     if(cb)
         req.cb = cb;
     var obj = {};
     obj.id = req.id;
     obj.method = methodName;
     obj.params = args;
     req.data = JSON.stringify(obj);
     return req;
 };

 /**
  * Return the JSON result from an XMLHttpRequest.
  */
 HTTPBindingClient.jsonResult = function(http) {
     var obj = JSON.parse(http.responseText);
     return obj.result;
 };

 /**
  * Schedule async requests, limiting the number of concurrent running requests.
  */
 HTTPBindingClient.queuedRequests = [];
 HTTPBindingClient.runningRequests = [];
 HTTPBindingClient.concurrentRequests = 4;

 HTTPBindingClient.scheduleAsyncRequest = function(f, cancelable) {
     debug('component schedule async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);

     // Queue the request function
     var req = new Object();
     req.f = f;
     req.cancelable = cancelable;
     req.canceled = false;
     HTTPBindingClient.queuedRequests[HTTPBindingClient.queuedRequests.length] = req;

     // Execute any requests in the queue
     return HTTPBindingClient.runAsyncRequests();
 };

 HTTPBindingClient.forgetRequest = function(req) {
     req.http = undefined;

     // Remove a request from the list of running requests
     for (var i in HTTPBindingClient.runningRequests) {
         if (HTTPBindingClient.runningRequests[i] == req) {
             HTTPBindingClient.runningRequests.splice(i, 1);
             debug('forget async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
             return true;
         }
     }
     return false;
 };

 HTTPBindingClient.cancelRequests = function() {
     debug('component cancel async requests', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);

     // Cancel any cancelable in flight HTTP requests
     for (var i in HTTPBindingClient.queuedRequests) {
         var req = HTTPBindingClient.queuedRequests[i];
         if (req.cancelable)
             req.canceled = true;
     }
     for (var i in HTTPBindingClient.runningRequests) {
         var req = HTTPBindingClient.runningRequests[i];
         if (req.cancelable) {
             req.canceled = true;
             if (req.http) {
                 req.http.aborted = true;
                 req.http.abort();
                 req.http = undefined;
                 debug('component abort async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
             }
         }
     }

     // Flush the queue
     return HTTPBindingClient.runAsyncRequests();
 }

 HTTPBindingClient.runAsyncRequests = function() {
     // Stop now if we already have enough requests running or there's no request in the queue
     if(HTTPBindingClient.runningRequests.length >= HTTPBindingClient.concurrentRequests || HTTPBindingClient.queuedRequests.length == 0)
         return true;

     // Run the first request in the queue
     var req = HTTPBindingClient.queuedRequests.shift();
     if (!req.canceled) {
         HTTPBindingClient.runningRequests[HTTPBindingClient.runningRequests.length] = req;
         debug('component run async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
         if (req.canceled) {
             HTTPBindingClient.forgetRequest(req);
             debug('component canceled timed async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
             return false;
         }
         HTTPBindingClient.delay(function asyncRequest() {
             try {
                 req.http = new XMLHttpRequest();
                 req.http.aborted = false;
                 return req.f(req.http, function asyncRequestDone() {
                     // Execute any requests left in the queue
                     HTTPBindingClient.forgetRequest(req);
                     debug('component done async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
                     HTTPBindingClient.runAsyncRequests();
                     return true;
                 });
             } catch(e) {
                 // Execute any requests left in the queue
                 HTTPBindingClient.forgetRequest(req);
                 debug('component async request error', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length, 'error', e);
                 HTTPBindingClient.runAsyncRequests();
             }
             return false;
         });
     } else {
         debug('component canceled queued async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
     }

     // Execute any requests left in the queue
     HTTPBindingClient.runAsyncRequests();
 };

 /**
  * Get a cache item from local storage.
  */
 HTTPBindingClient.getCacheItem = function(k) {
     var ls = lstorage || localStorage;
     return ls.getItem('dc.d.' + k);
 };

 /**
  * Set a cache item in local storage.
  */
 HTTPBindingClient.setCacheItem = function(k, v) {
     if (v && v.length > 65535)
         return HTTPBindingClient.removeCacheItem(k);
     HTTPBindingClient.collectCacheItems();
     var ls = lstorage || localStorage;
     var s = ls.getItem('dc.size');
     var size = s? parseInt(s) : 0;
     var ov = ls.getItem('dc.d.' + k);
     var nsize = size - (ov? ov.length : 0) + (v? v.length : 0);
     if (nsize != size)
         ls.setItem('dc.size', nsize.toString());
     return ls.setItem('dc.d.' + k, v);
 };

 /**
 * Remove a cache item from local storage.
 */
 HTTPBindingClient.removeCacheItem = function(k) {
     var ls = lstorage || localStorage;
     var s = ls.getItem('dc.size');
     var size = s? parseInt(s) : 0;
     var ov = ls.getItem('dc.d.' + k);
     if (ov) {
         var nsize = size - ov.length;
         ls.setItem('dc.size', nsize.toString());
     }
     return ls.removeItem('dc.d.' + k);
 };

 /**
  * Keep local storage cache entries under 2MB.
  */
 HTTPBindingClient.maxCacheSize = /* 20000; */ 2097152;
 HTTPBindingClient.collectCacheSize = /* 10000; */ 1048576;
 HTTPBindingClient.collectCacheItems = function() {
     var ls = window.lstorage || localStorage;
     var nkeys = window.lstorage? function() { return ls.length(); } : function() { return ls.length; };

     // Get the current cache size
     var size = 0;
     var s = ls.getItem('dc.size');
     if(!s) {
         // Calculate and store initial cache size
         debug('component calculating cache size');
         var n = nkeys();
         for(var i = 0; i < n; i++) {
             var k = ls.key(i);
             if(!k || k.substr(0, 5) != 'dc.d.')
                 continue;
             var v = ls.getItem(k);
             if(!v)
                 continue;
             size += v.length;
         }
         ls.setItem('dc.size', size.toString());
     } else
         size = parseInt(s);

     // Nothing to do if it's below the max size
     debug('component cache size', size);
     if (size <= HTTPBindingClient.maxCacheSize)
         return false;

     // Collect random cache entries until we reach our min size
     debug('component collecting cache items');
     var keys = [];
     var n = nkeys();
     for(var i = 0; i < n; i++) {
         var k = ls.key(i);
         if(!k || k.substr(0, 5) != 'dc.d.')
             continue;
         keys[keys.length] = k;
     }
     while (keys.length != 0 && size >= HTTPBindingClient.collectCacheSize) {
         var r = Math.floor(keys.length * Math.random());
         if (r == keys.length)
             continue;
         var k = keys[r];
         var v = ls.getItem(k);
         debug('component collect cache item', k);
         ls.removeItem(k);
         keys.splice(r, 1);
         if (v)
             size = size - v.length;
     }

     // Store the new cache size
     debug('component updated cache size', size);
     ls.setItem('dc.size', size.toString());
     return true;
 };

 /**
  * Apply a function remotely using JSON-RPC.
  */
 HTTPBindingClient.prototype.jsonApply = function(req) {
     var hascb = req.cb? true : false;

     // Call asynchronously with a callback
     if(hascb) {
         var u = this.uri;
         return HTTPBindingClient.scheduleAsyncRequest(function jsonApplyRequest(http, done) {
             http.open('POST', u, true);
             http.setRequestHeader('Accept', '*/*');
             http.setRequestHeader('Content-Type', 'application/json-rpc');
             http.setRequestHeader('X-Cache-Control', 'no-cache');
             http.onreadystatechange = function() {
                 if(http.readyState == 4) {
                     // Pass the result or exception
                     if(http.status == 200) {
                         var res = HTTPBindingClient.jsonResult(http);
                         req.cb(res);
                     } if(!http.aborted) {
                         error('jsonApply error', 'status', http.status, http.statusText);
                         req.cb(undefined, new Error('' + http.status + ' ' + http.statusText));
                     }
                     return done();
                 }
             };

             // Send the request
             http.send(req.data);
             return req.id;
         }, false);
     }

     // Call synchronously and return the result or exception
     var http = new XMLHttpRequest();
     http.open('POST', this.uri, false);
     http.setRequestHeader('Accept', '*/*');
     http.setRequestHeader('Content-Type', 'application/json-rpc');
     http.setRequestHeader('X-Cache-Control', 'no-cache');
     http.send(req.data);
     if(http.status == 200)
         return HTTPBindingClient.jsonResult(http);
     error('jsonApply error', 'status', http.status, http.statusText);
     throw new Error('' + http.status + ' ' + http.statusText);
 };


 /**
  * REST GET method.
  */
 HTTPBindingClient.prototype.get = function(id, cb, mode) {
     var u = id? (this.uri? this.uri + '/' + id : id) : this.uri;
     var hascb = cb? true : false;

     // Get from local storage first
     var item;
     if(mode != 'remote') {
         item = HTTPBindingClient.getCacheItem(u);
         if(item && item != '') {
             if(!hascb)
                 return item;

             // Pass local result to callback
             cb(item);
         }
     }

     // Call asynchronously with a callback
     if(hascb) {
         return HTTPBindingClient.scheduleAsyncRequest(function getRequest(http, done) {
             http.open('GET', u, true);
             http.setRequestHeader('Accept', '*/*');
             http.setRequestHeader('X-Cache-Control', 'no-cache');
             http.onreadystatechange = function() {
                 if(http.readyState == 4) {

                     // Pass result if different from local result
                     //debug('readystate', http.readyState, 'status', http.status, 'headers', http.getAllResponseHeaders());
                     if(http.status == 200) {
                         var ct = http.getResponseHeader('Content-Type');
                         if(http.responseText == '' || !ct || ct == '') {

                             // Report empty response
                             error('get received empty response', 'url', u);
                             cb(undefined, new Error('500 No-Content'));
                             return done();

                         } else if(!item || http.responseText != item) {

                             // Store retrieved entry in local storage
                             //debug('received response', 'url', u, 'response', http.responseText);
                             if(http.responseText != null)
                                 HTTPBindingClient.setCacheItem(u, http.responseText);
                             cb(http.responseText);
                             return done();
                         }
                     } else if (http.status == 403) {

                         // Redirect to login page
                         error('get received 403 response', 'url', u);
                         var le = new Error('' + http.status + ' ' + http.statusText);
                         if(window.onloginredirect)
                             window.onloginredirect(le);
                         cb(undefined, le);
                         return done();

                     } else if(!http.aborted) {

                         // Pass exception if we didn't have a local result
                         error('get received error', 'url', u, 'status', http.status, http.statusText);
                         if(!item) {
                             cb(undefined, new Error('' + http.status + ' ' + http.statusText));
                             return done();
                         }
                     }
                     return done();
                 }
             };

             // Send the request
             http.send(null);
             return true;
         }, true);
     }

     // Call synchronously and return the result or exception
     var http = new XMLHttpRequest();
     http.open('GET', u, false);
     http.setRequestHeader('Accept', '*/*');
     http.setRequestHeader('X-Cache-Control', 'no-cache');
     http.send(null);
     if(http.status == 200) {
         var ct = http.getResponseHeader('Content-Type');
         if(http.responseText == '' || !ct || ct == '') {
             // Report empty response
             error('get received empty response', 'url', u);
             throw new Error('500 No Content');
         }
         return http.responseText;
     }
     if(http.status == 403) {
         // Redirect to login page
         error('get received 403 response', 'url', u);
         var le = new Error('' + http.status + ' ' + http.statusText);
         if(window.onloginredirect)
             window.onloginredirect(le);
         throw le;
     }
     error('get received error', 'url', u, 'status', http.status, http.statusText);
     throw new Error('' + http.status + ' ' + http.statusText);
 };

 /**
  * REST POST method.
  */
 HTTPBindingClient.prototype.post = function (entry, cb) {
     var hascb = cb? true : false;

     // Call asynchronously with a callback
     if(hascb) {
         var u = this.uri;
         return HTTPBindingClient.scheduleAsyncRequest(function postRequest(http, done) {
             http.open('POST', u, true);
             http.setRequestHeader('Accept', '*/*');
             http.setRequestHeader('Content-Type', 'application/atom+xml');
             http.setRequestHeader('X-Cache-Control', 'no-cache');
             http.onreadystatechange = function() {
                 if(http.readyState == 4) {
                     if(http.status == 201) {

                         // Successful result
                         cb(http.responseText);
                     }
                     else {
                         // Report status code as an exception
                         cb(undefined, new Error('' + http.status + ' ' + http.statusText));
                     }
                     return done();
                 }
             };
             // Send the request
             http.send(entry);
             return true;
         }, false);
     }

     // Call synchronously
     var http = new XMLHttpRequest();
     var hascb = cb? true : false;
     http.open('POST', this.uri, false);
     http.setRequestHeader('Accept', '*/*');
     http.setRequestHeader('Content-Type', 'application/atom+xml');
     http.setRequestHeader('X-Cache-Control', 'no-cache');
     http.send(entry);
     if(http.status == 201)
         return http.responseText;

     // Return status code as an exception
     throw new Error('' + http.status + ' ' + http.statusText);
 };

 /**
  * REST PUT method.
  */
 HTTPBindingClient.prototype.put = function(id, entry, cb, mode) {
     var u = id? (this.uri? this.uri + '/' + id : id) : this.uri;
     var hascb = cb? true : false;

     // Update local storage
     var oentry;
     if(mode != 'remote') {
         oentry = HTTPBindingClient.getCacheItem(u);
         HTTPBindingClient.setCacheItem(u, entry);
     }

     // Call asynchronously with a callback
     if(hascb) {
         return HTTPBindingClient.scheduleAsyncRequest(function putRequest(http, done) {
             http.open('PUT', u, true);
             http.setRequestHeader('Accept', '*/*');
             http.setRequestHeader('Content-Type', 'application/atom+xml');
             http.setRequestHeader('X-Cache-Control', 'no-cache');
             http.onreadystatechange = function() {
                 if(http.readyState == 4) {
                     if(http.status == 200) {

                         // Successful result
                         cb();

                     } else {
                         if(http.status == 404) {

                             // Undo local storage update
                             if(mode != 'remote') {
                                 if(oentry)
                                     HTTPBindingClient.setCacheItem(u, oentry);
                                 else
                                     HTTPBindingClient.removeCacheItem(u);
                             }
                         }

                         // Report status code as an exception
                         cb(new Error('' + http.status + ' ' + http.statusText));
                     }
                     return done();
                 }
             };

             // Send the request
             http.send(entry);
             return true;
         }, false);
     }

     // Call synchronously
     var http = new XMLHttpRequest();
     http.open('PUT', u, false);
     http.setRequestHeader('Accept', '*/*');
     http.setRequestHeader('Content-Type', 'application/atom+xml');
     http.setRequestHeader('X-Cache-Control', 'no-cache');
     http.send(entry);
     if(http.status == 200)
         return true;
     if(http.status == 404) {
         // Undo local storage update
         if(mode != 'remote') {
             if(oentry)
                 HTTPBindingClient.setCacheItem(u, oentry);
             else
                 HTTPBindingClient.removeCacheItem(u);
         }
     }

     // Return status code as an exception
     throw new Error('' + http.status + ' ' + http.statusText);
 };

 /**
  * REST DELETE method.
  */
 HTTPBindingClient.prototype.del = function(id, cb, mode) {
     var u = id? (this.uri? this.uri + '/' + id : id) : this.uri;
     var hascb = cb? true : false;

     // Update local storage
     var ls = window.lstorage || localStorage;
     if(mode != 'remote')
         HTTPBindingClient.removeCacheItem(u);

     // Call asynchronously with a callback
     if(hascb) {
         return HTTPBindingClient.scheduleAsyncRequest(function delRequest(http, done) {
             http.open('DELETE', u, true);
             http.setRequestHeader('Accept', '*/*');
             http.setRequestHeader('X-Cache-Control', 'no-cache');
             http.onreadystatechange = function() {
                 if(http.readyState == 4) {
                     if(http.status == 200) {

                         // Successful result
                         cb();
                     }
                     else {
                         // Report status code as an exception
                         cb(new Error('' + http.status + ' ' + http.statusText));
                     }
                     return done();
                 }
             };

             // Send the request
             http.send(null);
             return true;
         }, false);
     }

     // Call synchronously
     var http = new XMLHttpRequest();
     http.open('DELETE', u, false);
     http.setRequestHeader('Accept', '*/*');
     http.setRequestHeader('X-Cache-Control', 'no-cache');
     http.send(null);
     if(http.status == 200)
         return true;

     // Report status code as an exception
     throw new Error('' + http.status + ' ' + http.statusText);
 };

 /**
  * Public API.
  */

 var sca = {};

 /**
  * Return an HTTP client proxy.
  */
 sca.httpClient = function(name, uri, domain) {
     return new HTTPBindingClient(name, uri, domain);
 };

 /**
  * Return a component proxy.
  */
 sca.component = function(name, domain) {
     if(!domain)
         return new HTTPBindingClient(name, '/c/' + name, domain);
     return new HTTPBindingClient(name, '/' + domain + '/c/' + name, domain);
 };

 /**
  * Return a reference proxy.
  */
 sca.reference = function(comp, rname) {
     if(!comp.domain)
         return new HTTPBindingClient(comp.name + '/' + rname, '/r/' + comp.name + '/' + rname, comp.domain);
     return new HTTPBindingClient(comp.name + '/' + rname, '/' + comp.domain + '/r/' + comp.name + '/' + rname, comp.domain);
 };

 /**
  * Add proxy functions to a reference proxy.
  */
 sca.defun = function(ref) {
     function defapply(name) {
         return function() {
             var args = [];
             args[0] = name;
             for(var i = 0; i < arguments.length; i++)
                 args[i + 1] = arguments[i];
             return this.apply.apply(this, args);
         };
     }

     for(var f = 1; f < arguments.length; f++) {
         var fn = arguments[f];
         ref[fn]= defapply(fn);
     }
     return ref;
 };
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	/**
	* Client component wiring API, supporting JSON and ATOM bindings.
	*/

	var JSONClient = {};

	/**
	* Construct an HTTPBindingClient.
	*/
	function HTTPBindingClient(name, uri, domain) {
	this.name = name;
	this.domain = domain;
	this.uri = uri;
	this.apply = this.createApplyMethod();
	}

	/**
	* HTTPBindingClient implementation
	*/

	/**
	* Run a function asynchronously.
	*/
	HTTPBindingClient.delaying = false;
	HTTPBindingClient.delay = function(f) {
	if (HTTPBindingClient.delaying)
	return window.setTimeout(f, 0);
	else
	return f();
	};

	/**
	* Generate client proxy apply method.
	*/
	HTTPBindingClient.prototype.createApplyMethod = function() {
	var fn = function() {
	var methodName = arguments[0];
	var args = [];
	for(var i = 1; i < arguments.length; i++)
	args[args.length] = arguments[i];

	var cb;
	if(typeof args[args.length - 1] == 'function')
	cb = args.pop();

	var req = HTTPBindingClient.makeJSONRequest(methodName, args, cb);
	return fn.client.jsonApply(req);
	};
	fn.client = this;
	return fn;
	};

	/**
	* JSON-RPC request counter.
	*/
	HTTPBindingClient.jsonrpcID = 1;

	/**
	* Make a JSON-RPC request.
	*/
	HTTPBindingClient.makeJSONRequest = function(methodName, args, cb) {
	var req = {};
	req.id = HTTPBindingClient.jsonrpcID++;
	if(cb)
	req.cb = cb;
	var obj = {};
	obj.id = req.id;
	obj.method = methodName;
	obj.params = args;
	req.data = JSON.stringify(obj);
	return req;
	};

	/**
	* Return the JSON result from an XMLHttpRequest.
	*/
	HTTPBindingClient.jsonResult = function(http) {
	var obj = JSON.parse(http.responseText);
	return obj.result;
	};

	/**
	* Schedule async requests, limiting the number of concurrent running requests.
	*/
	HTTPBindingClient.queuedRequests = [];
	HTTPBindingClient.runningRequests = [];
	HTTPBindingClient.concurrentRequests = 4;

	HTTPBindingClient.scheduleAsyncRequest = function(f, cancelable) {
	debug('component schedule async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);

	// Queue the request function
	var req = new Object();
	req.f = f;
	req.cancelable = cancelable;
	req.canceled = false;
	HTTPBindingClient.queuedRequests[HTTPBindingClient.queuedRequests.length] = req;

	// Execute any requests in the queue
	return HTTPBindingClient.runAsyncRequests();
	};

	HTTPBindingClient.forgetRequest = function(req) {
	req.http = undefined;

	// Remove a request from the list of running requests
	for (var i in HTTPBindingClient.runningRequests) {
	if (HTTPBindingClient.runningRequests[i] == req) {
	HTTPBindingClient.runningRequests.splice(i, 1);
	debug('forget async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
	return true;
	}
	}
	return false;
	};

	HTTPBindingClient.cancelRequests = function() {
	debug('component cancel async requests', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);

	// Cancel any cancelable in flight HTTP requests
	for (var i in HTTPBindingClient.queuedRequests) {
	var req = HTTPBindingClient.queuedRequests[i];
	if (req.cancelable)
	req.canceled = true;
	}
	for (var i in HTTPBindingClient.runningRequests) {
	var req = HTTPBindingClient.runningRequests[i];
	if (req.cancelable) {
	req.canceled = true;
	if (req.http) {
	req.http.aborted = true;
	req.http.abort();
	req.http = undefined;
	debug('component abort async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
	}
	}
	}

	// Flush the queue
	return HTTPBindingClient.runAsyncRequests();
	}

	HTTPBindingClient.runAsyncRequests = function() {
	// Stop now if we already have enough requests running or there's no request in the queue
	if(HTTPBindingClient.runningRequests.length >= HTTPBindingClient.concurrentRequests \|\| HTTPBindingClient.queuedRequests.length == 0)
	return true;

	// Run the first request in the queue
	var req = HTTPBindingClient.queuedRequests.shift();
	if (!req.canceled) {
	HTTPBindingClient.runningRequests[HTTPBindingClient.runningRequests.length] = req;
	debug('component run async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
	if (req.canceled) {
	HTTPBindingClient.forgetRequest(req);
	debug('component canceled timed async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
	return false;
	}
	HTTPBindingClient.delay(function asyncRequest() {
	try {
	req.http = new XMLHttpRequest();
	req.http.aborted = false;
	return req.f(req.http, function asyncRequestDone() {
	// Execute any requests left in the queue
	HTTPBindingClient.forgetRequest(req);
	debug('component done async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
	HTTPBindingClient.runAsyncRequests();
	return true;
	});
	} catch(e) {
	// Execute any requests left in the queue
	HTTPBindingClient.forgetRequest(req);
	debug('component async request error', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length, 'error', e);
	HTTPBindingClient.runAsyncRequests();
	}
	return false;
	});
	} else {
	debug('component canceled queued async request', 'running', HTTPBindingClient.runningRequests.length, 'queued', HTTPBindingClient.queuedRequests.length);
	}

	// Execute any requests left in the queue
	HTTPBindingClient.runAsyncRequests();
	};

	/**
	* Get a cache item from local storage.
	*/
	HTTPBindingClient.getCacheItem = function(k) {
	var ls = lstorage \|\| localStorage;
	return ls.getItem('dc.d.' + k);
	};

	/**
	* Set a cache item in local storage.
	*/
	HTTPBindingClient.setCacheItem = function(k, v) {
	if (v && v.length > 65535)
	return HTTPBindingClient.removeCacheItem(k);
	HTTPBindingClient.collectCacheItems();
	var ls = lstorage \|\| localStorage;
	var s = ls.getItem('dc.size');
	var size = s? parseInt(s) : 0;
	var ov = ls.getItem('dc.d.' + k);
	var nsize = size - (ov? ov.length : 0) + (v? v.length : 0);
	if (nsize != size)
	ls.setItem('dc.size', nsize.toString());
	return ls.setItem('dc.d.' + k, v);
	};

	/**
	* Remove a cache item from local storage.
	*/
	HTTPBindingClient.removeCacheItem = function(k) {
	var ls = lstorage \|\| localStorage;
	var s = ls.getItem('dc.size');
	var size = s? parseInt(s) : 0;
	var ov = ls.getItem('dc.d.' + k);
	if (ov) {
	var nsize = size - ov.length;
	ls.setItem('dc.size', nsize.toString());
	}
	return ls.removeItem('dc.d.' + k);
	};

	/**
	* Keep local storage cache entries under 2MB.
	*/
	HTTPBindingClient.maxCacheSize = /* 20000; */ 2097152;
	HTTPBindingClient.collectCacheSize = /* 10000; */ 1048576;
	HTTPBindingClient.collectCacheItems = function() {
	var ls = window.lstorage \|\| localStorage;
	var nkeys = window.lstorage? function() { return ls.length(); } : function() { return ls.length; };

	// Get the current cache size
	var size = 0;
	var s = ls.getItem('dc.size');
	if(!s) {
	// Calculate and store initial cache size
	debug('component calculating cache size');
	var n = nkeys();
	for(var i = 0; i < n; i++) {
	var k = ls.key(i);
	if(!k \|\| k.substr(0, 5) != 'dc.d.')
	continue;
	var v = ls.getItem(k);
	if(!v)
	continue;
	size += v.length;
	}
	ls.setItem('dc.size', size.toString());
	} else
	size = parseInt(s);

	// Nothing to do if it's below the max size
	debug('component cache size', size);
	if (size <= HTTPBindingClient.maxCacheSize)
	return false;

	// Collect random cache entries until we reach our min size
	debug('component collecting cache items');
	var keys = [];
	var n = nkeys();
	for(var i = 0; i < n; i++) {
	var k = ls.key(i);
	if(!k \|\| k.substr(0, 5) != 'dc.d.')
	continue;
	keys[keys.length] = k;
	}
	while (keys.length != 0 && size >= HTTPBindingClient.collectCacheSize) {
	var r = Math.floor(keys.length * Math.random());
	if (r == keys.length)
	continue;
	var k = keys[r];
	var v = ls.getItem(k);
	debug('component collect cache item', k);
	ls.removeItem(k);
	keys.splice(r, 1);
	if (v)
	size = size - v.length;
	}

	// Store the new cache size
	debug('component updated cache size', size);
	ls.setItem('dc.size', size.toString());
	return true;
	};

	/**
	* Apply a function remotely using JSON-RPC.
	*/
	HTTPBindingClient.prototype.jsonApply = function(req) {
	var hascb = req.cb? true : false;

	// Call asynchronously with a callback
	if(hascb) {
	var u = this.uri;
	return HTTPBindingClient.scheduleAsyncRequest(function jsonApplyRequest(http, done) {
	http.open('POST', u, true);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('Content-Type', 'application/json-rpc');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.onreadystatechange = function() {
	if(http.readyState == 4) {
	// Pass the result or exception
	if(http.status == 200) {
	var res = HTTPBindingClient.jsonResult(http);
	req.cb(res);
	} if(!http.aborted) {
	error('jsonApply error', 'status', http.status, http.statusText);
	req.cb(undefined, new Error('' + http.status + ' ' + http.statusText));
	}
	return done();
	}
	};

	// Send the request
	http.send(req.data);
	return req.id;
	}, false);
	}

	// Call synchronously and return the result or exception
	var http = new XMLHttpRequest();
	http.open('POST', this.uri, false);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('Content-Type', 'application/json-rpc');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.send(req.data);
	if(http.status == 200)
	return HTTPBindingClient.jsonResult(http);
	error('jsonApply error', 'status', http.status, http.statusText);
	throw new Error('' + http.status + ' ' + http.statusText);
	};


	/**
	* REST GET method.
	*/
	HTTPBindingClient.prototype.get = function(id, cb, mode) {
	var u = id? (this.uri? this.uri + '/' + id : id) : this.uri;
	var hascb = cb? true : false;

	// Get from local storage first
	var item;
	if(mode != 'remote') {
	item = HTTPBindingClient.getCacheItem(u);
	if(item && item != '') {
	if(!hascb)
	return item;

	// Pass local result to callback
	cb(item);
	}
	}

	// Call asynchronously with a callback
	if(hascb) {
	return HTTPBindingClient.scheduleAsyncRequest(function getRequest(http, done) {
	http.open('GET', u, true);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.onreadystatechange = function() {
	if(http.readyState == 4) {

	// Pass result if different from local result
	//debug('readystate', http.readyState, 'status', http.status, 'headers', http.getAllResponseHeaders());
	if(http.status == 200) {
	var ct = http.getResponseHeader('Content-Type');
	if(http.responseText == '' \|\| !ct \|\| ct == '') {

	// Report empty response
	error('get received empty response', 'url', u);
	cb(undefined, new Error('500 No-Content'));
	return done();

	} else if(!item \|\| http.responseText != item) {

	// Store retrieved entry in local storage
	//debug('received response', 'url', u, 'response', http.responseText);
	if(http.responseText != null)
	HTTPBindingClient.setCacheItem(u, http.responseText);
	cb(http.responseText);
	return done();
	}
	} else if (http.status == 403) {

	// Redirect to login page
	error('get received 403 response', 'url', u);
	var le = new Error('' + http.status + ' ' + http.statusText);
	if(window.onloginredirect)
	window.onloginredirect(le);
	cb(undefined, le);
	return done();

	} else if(!http.aborted) {

	// Pass exception if we didn't have a local result
	error('get received error', 'url', u, 'status', http.status, http.statusText);
	if(!item) {
	cb(undefined, new Error('' + http.status + ' ' + http.statusText));
	return done();
	}
	}
	return done();
	}
	};

	// Send the request
	http.send(null);
	return true;
	}, true);
	}

	// Call synchronously and return the result or exception
	var http = new XMLHttpRequest();
	http.open('GET', u, false);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.send(null);
	if(http.status == 200) {
	var ct = http.getResponseHeader('Content-Type');
	if(http.responseText == '' \|\| !ct \|\| ct == '') {
	// Report empty response
	error('get received empty response', 'url', u);
	throw new Error('500 No Content');
	}
	return http.responseText;
	}
	if(http.status == 403) {
	// Redirect to login page
	error('get received 403 response', 'url', u);
	var le = new Error('' + http.status + ' ' + http.statusText);
	if(window.onloginredirect)
	window.onloginredirect(le);
	throw le;
	}
	error('get received error', 'url', u, 'status', http.status, http.statusText);
	throw new Error('' + http.status + ' ' + http.statusText);
	};

	/**
	* REST POST method.
	*/
	HTTPBindingClient.prototype.post = function (entry, cb) {
	var hascb = cb? true : false;

	// Call asynchronously with a callback
	if(hascb) {
	var u = this.uri;
	return HTTPBindingClient.scheduleAsyncRequest(function postRequest(http, done) {
	http.open('POST', u, true);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('Content-Type', 'application/atom+xml');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.onreadystatechange = function() {
	if(http.readyState == 4) {
	if(http.status == 201) {

	// Successful result
	cb(http.responseText);
	}
	else {
	// Report status code as an exception
	cb(undefined, new Error('' + http.status + ' ' + http.statusText));
	}
	return done();
	}
	};
	// Send the request
	http.send(entry);
	return true;
	}, false);
	}

	// Call synchronously
	var http = new XMLHttpRequest();
	var hascb = cb? true : false;
	http.open('POST', this.uri, false);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('Content-Type', 'application/atom+xml');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.send(entry);
	if(http.status == 201)
	return http.responseText;

	// Return status code as an exception
	throw new Error('' + http.status + ' ' + http.statusText);
	};

	/**
	* REST PUT method.
	*/
	HTTPBindingClient.prototype.put = function(id, entry, cb, mode) {
	var u = id? (this.uri? this.uri + '/' + id : id) : this.uri;
	var hascb = cb? true : false;

	// Update local storage
	var oentry;
	if(mode != 'remote') {
	oentry = HTTPBindingClient.getCacheItem(u);
	HTTPBindingClient.setCacheItem(u, entry);
	}

	// Call asynchronously with a callback
	if(hascb) {
	return HTTPBindingClient.scheduleAsyncRequest(function putRequest(http, done) {
	http.open('PUT', u, true);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('Content-Type', 'application/atom+xml');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.onreadystatechange = function() {
	if(http.readyState == 4) {
	if(http.status == 200) {

	// Successful result
	cb();

	} else {
	if(http.status == 404) {

	// Undo local storage update
	if(mode != 'remote') {
	if(oentry)
	HTTPBindingClient.setCacheItem(u, oentry);
	else
	HTTPBindingClient.removeCacheItem(u);
	}
	}

	// Report status code as an exception
	cb(new Error('' + http.status + ' ' + http.statusText));
	}
	return done();
	}
	};

	// Send the request
	http.send(entry);
	return true;
	}, false);
	}

	// Call synchronously
	var http = new XMLHttpRequest();
	http.open('PUT', u, false);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('Content-Type', 'application/atom+xml');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.send(entry);
	if(http.status == 200)
	return true;
	if(http.status == 404) {
	// Undo local storage update
	if(mode != 'remote') {
	if(oentry)
	HTTPBindingClient.setCacheItem(u, oentry);
	else
	HTTPBindingClient.removeCacheItem(u);
	}
	}

	// Return status code as an exception
	throw new Error('' + http.status + ' ' + http.statusText);
	};

	/**
	* REST DELETE method.
	*/
	HTTPBindingClient.prototype.del = function(id, cb, mode) {
	var u = id? (this.uri? this.uri + '/' + id : id) : this.uri;
	var hascb = cb? true : false;

	// Update local storage
	var ls = window.lstorage \|\| localStorage;
	if(mode != 'remote')
	HTTPBindingClient.removeCacheItem(u);

	// Call asynchronously with a callback
	if(hascb) {
	return HTTPBindingClient.scheduleAsyncRequest(function delRequest(http, done) {
	http.open('DELETE', u, true);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.onreadystatechange = function() {
	if(http.readyState == 4) {
	if(http.status == 200) {

	// Successful result
	cb();
	}
	else {
	// Report status code as an exception
	cb(new Error('' + http.status + ' ' + http.statusText));
	}
	return done();
	}
	};

	// Send the request
	http.send(null);
	return true;
	}, false);
	}

	// Call synchronously
	var http = new XMLHttpRequest();
	http.open('DELETE', u, false);
	http.setRequestHeader('Accept', '/');
	http.setRequestHeader('X-Cache-Control', 'no-cache');
	http.send(null);
	if(http.status == 200)
	return true;

	// Report status code as an exception
	throw new Error('' + http.status + ' ' + http.statusText);
	};

	/**
	* Public API.
	*/

	var sca = {};

	/**
	* Return an HTTP client proxy.
	*/
	sca.httpClient = function(name, uri, domain) {
	return new HTTPBindingClient(name, uri, domain);
	};

	/**
	* Return a component proxy.
	*/
	sca.component = function(name, domain) {
	if(!domain)
	return new HTTPBindingClient(name, '/c/' + name, domain);
	return new HTTPBindingClient(name, '/' + domain + '/c/' + name, domain);
	};

	/**
	* Return a reference proxy.
	*/
	sca.reference = function(comp, rname) {
	if(!comp.domain)
	return new HTTPBindingClient(comp.name + '/' + rname, '/r/' + comp.name + '/' + rname, comp.domain);
	return new HTTPBindingClient(comp.name + '/' + rname, '/' + comp.domain + '/r/' + comp.name + '/' + rname, comp.domain);
	};

	/**
	* Add proxy functions to a reference proxy.
	*/
	sca.defun = function(ref) {
	function defapply(name) {
	return function() {
	var args = [];
	args[0] = name;
	for(var i = 0; i < arguments.length; i++)
	args[i + 1] = arguments[i];
	return this.apply.apply(this, args);
	};
	}

	for(var f = 1; f < arguments.length; f++) {
	var fn = arguments[f];
	ref[fn]= defapply(fn);
	}
	return ref;
	};